Statikus változókat használnak C++-ban például az ún. referenciaszámlálásra (ugyan kicsit kilépünk az ActionScript 3 problémaköréből, de ez a példa ideális, hogy megértsük a dolog lényegét). A refszámlálás lényege, hogy számon szeretnénk tartani az adott osztályunkból hány példány létezik jelen pillanatban. Ezt ugye egy statikus változóval nagyon egyszerűen megoldhatjuk (máshogy nem is igen lehetséges), hiszen csak annyi a dolgunk, hogy a konstruktorban növeljük (++staticvar), ill. a destruktorban csökkentsük (–staticvar). Megjegyzem, hogy sajnos ez az eljárás nem alkalmazható as-ben, mert nincs destruktorunk, maximum az összes példányosítás számát tudnánk ilyen módon nyomonkövetni.

Most nézzünk egy példát actionscript-ben. Tegyük fel, hogy nem létezik a math könyvtár, és nem tudjuk lekérdezni a Pi értékét, viszont gyakran számolunk vele a programunkba. Ezért létrehozunk egy statikus változót pi néven, minek hanyag módon csak a 2 tizedesjegyű 3,14-et adjuk értékül. Viszont innentől kezdve kényelmesen tudjuk használni, és nem kerül bele minden példányba feleslegesen.

Sajnos ez még nem egészen biztonságos, hiszen ezt az értéket lehetőségünk van még megváltoztatni, ami nem igazán lenne nyerő. Ilyen esetekben jön jól számunkra a konstans statikus változó. Actionscriptben Leggyakrabban így használatosak a statikus adattagok. Ennek leginkább az az oka, hogy ha véletlenül az egyik példányban megváltoztatjuk az értékét, akkor az az összes többi példányt érinti, hiszen ez a változó az osztályhoz tartozik. Persze mindig vannak kivételek, én például a hóesés effekt progiban, használok 2 static változót, amik nem konstansok. A két változó az ablak magasságát, ill. szélességét tartalmazza. Ezek a tulajdonságok miden hópehelynél megegyeznek, viszont nem akartam, hogy mind hordozza őket, felesleges. A konstansság pedig azért nem játszik, mert nem tudom, milyen értékkel fogják inicializálni, és inicializálólista híján nem tudunk konstansnak értéket adni, de deklaráláskor. Persze, emiatt a kis rugalmasságért cserébe számolni kell azzal az esettel, amikor valaki minden példányt más értékekkel veszünk fel, és ilyenkor statikus változó lévén mindig felülíródik, az össze példány tulajdonsága. Hát igen, bár ez a valóságban nem valószínű, de abban az esetben, ha hülyebiztos programot szeretnénk írni, akkor ilyen esetekre is gondolnunk kell.

Van még egy nagyon hasznos tulajdonsága az ilyen típusú változóknak. Ez a kód simán lefut azelőtt is, hogy létrehoznánk egy új objektumot:

var x:Number=className.pi;

Hiszen a pi nem egy példányváltozó, ezért bármikor lekérdezhetem az értékét. Az elérésszabályzókra azonban itt is figyelni kell. A fenti kód csak akkor lesz helyes, ha a pi definíciója ez:

public static const pi:Number  = 3.14;

Gondolom, ezek után nem árulok el nagy titkot, ha azt mondom, hogy a math könyvtár PI-je is így van megírva, azzal a különbséggel, hogy ott kicsit pontosabban ábrázolják az értékét (3.141592653589793).

Most ejtsünk néhány szót a statikus függvényekről. Ki lehet jelenteni, hogy használatuk nem olyan gyakori, mint fent említett társának, de szerepe ettől még igen fontos. Az elv ugyan az, létrehozunk egy függvényt, azzal a különbséggel, hogy az osztályunkhoz tartozik és nem egy adott objektumhoz. Ugyan úgy adhatunk neki visszatérésiértéket, paramétereket, és még természetesen az elérhetőségét is szabályozhatjuk. Viszont két dologban eltér átlagos társaitól:

• Nem használhatjuk a this kulcsszót. gondoljunk bele, ez teljesen logikus, hisz nem egy objektum része.
• Statikus függvény nem érheti el saját osztálya változóit, ill. függvényeit (fordítva természetesen semmi gond nincs).

És hogy hol használjuk ezeket? Vegyünk megint egy példát a math osztályból : abs(). Az abs függvény visszaadja egy szám abszolút értékét. Most nézzük, hogyan van definiálva:

public static function abs(val:Number):Number

Végeredményben egy teljesen hétköznapi függvényről beszélünk, azzal az eltéréssel, hogy ezt meghívhatjuk abban az esetben is, ha nincs ilyen objektumunk (adott esetben math).

var x:Number=math.abs(-2);

Mint láttuk érdemes használni a statikus változókat/függvényeket, mert megkönnyíthetik az életünket. Ezek után még annyit érdemes megjegyezni, hogy sok olyan osztály létezik melyekből soha nem jönnek létre példányok, csak és kizárólag statikus tagokkal dolgozik, jó példa az itt is annyiszor emlegetett math class.

Sok ingyenes alkalmazás van az AppStore-ban, de sajnos a legtöbb selejt. Azonban ez a kis apró iPhone program annak ellenére, hogy ingyen van, egy remek kis referencia as3-hoz (ezenkívül még helyet kapott: Adobe AIR 1.5, Adobe Flex 3.2 és Flash Player 10 API referencia is), ami végeredményben megegyezik az adobe oldalán találhatóval. Viszont van 2 nagy előnye: sokkal kényelmesebb a használata, mint ha safariban böngésznénk a hivatalos verziót, ill. nem kell hozzá internet kapcsolat. Nagyon hasznos tud lenni, ha csak meg szeretnénk nézni valami apróságot. Én például gyakran használom arra, hogy ha beugrik egy ötlet, akkor megnézem, hogy milyen lehetőségeket kínál erre a nyelv.

Ezenfelül nem sokat tudok még hozzá fűzni, keveset tud, de azt stabilan. Aki kedvet kapott hozzá, és rendelkezik egy iPhone-nal (2.2-es OS, vagy nagyobb) az itt letöltheti ingyenesen.

Karácsony alkalmával a fenti kis hóesés effekttel készültem. Ezt a kódot nem fogom teljes egészében bemutatni, csak bizonyos részleteire hívom fel majd a figyelmet. Részletek a tovább után.

Legelsőnek nézzük a kódot:

package {
	import flash.filters.BlurFilter;
	import flash.filters.BitmapFilterQuality;
	import flash.display.MovieClip;
	import flash.events.*;

	public class SnowFlake extends MovieClip {
		private static var Width:int;
		private static var Height:int;
		private var speedVari:int=Math.random()*10;
		private var speed:int=Math.random()*5;
		private var wind:int;

		function SnowFlake(w:uint,h:uint) {
			Width=w;
			Height=h;
			setSpeed(speed);
			createFlake();
			moveFlake();
		}

		private function setSpeed(n:uint):void {
			speed=n*speedVari;
		}

		private function moveFlake():void {
			this.addEventListener(Event.ENTER_FRAME,everyFrame);
		}

		private function everyFrame(evt:Event):void {
			x+=wind;
			y+=speed;
			if (x<0||x>Width||y>Height) {
				createFlake();
			}
		}

		private function createFlake():void {
			getWind();
			x=Math.random()*Width;
			y=Math.random()*Height*-1;
			var blur:BlurFilter=new BlurFilter(wind,speed/2,BitmapFilterQuality.HIGH);
			filters=[blur];
			if (speedVari>speed/2) {
				scaleX=scaleY=.6;
			}
		}

		private function getWind():void {
			wind=Math.random()*3;
			var windDirection:int=Math.random()*10;
			if (windDirection<5) {
				wind*=-1;
			}
		}
	}
}

//példányosítás
function flakes():void {
	var flake:SnowFlake=new SnowFlake(420,450);
	addChild(flake);
}

var numofFlakes:uint=150;

for (var i:uint=0; i<numofFlakes; ++i) {
	flakes();
}

Úgy gondolom a példányosításban semmi érdekes, vagy meglepő nincs szóval azt skippelem.

Az első, amire felhívnám a figyelmet, az az hogy a MovieClip osztályból származatom a SnowFlake-et. Tehát rendelkezni fogok az összes olyan tulajdonággal, amivel az MovieClippek (x – y koordináták, filterek, stb.) az öröklődés részleteit majd egy későbbi postban részletesen kitárgyaljuk, most csak az a fontos, hogy lássuk honnan is származnak azok az X-ek és Y-ok és a többi általunk nem definiált adattag és tagfüggvény.

Most nézzük meg a konstruktor paramétereit. Két integert vár: szélesség, magasság. Ez a két változó azért elengedhetetlen kis programunk számára, mert így képesek vagyunk figyelni, hogy mikor fújta ki a „szél” az ablakból kis hópelyheinket, ill. mikor estek le a „földre”.

A moveFlake() függvényben használom a this kulcsszót, ezzel mindig az aktuális objektumra tudunk hivatkozni. Az esetek nagy többségében a this nyugodtan elhagyható, mert a fordító kikövetkezteti, hogy mi mit is szeretnénk. Én is így tettem, hisz rengeteg helyre kiírhattam volna (pl.: this.x, this.scaleX), de mivel a programozók lusták, ezt gyakran elhagyjuk, az eseményfigyelő hozzáadásakor is csak a példa kedvéért tüntettem fel.

Többször is használom a Math.random() statikus függvényt, amit véletlen x számot generál nekünk, ahol 0 <= x < 1. Ha mondjuk 0 és 9 között szeretnénk számokat kapni, akkor csak fel kell szoroznunk a random számot 10-zel, bár gondolom ez természetes. Viszont arra érdemes figyelni, hogy lebegőpontos számot ad vissza a random függvény, tehát ha egész számokat szeretnénk kapni, akkor vagy kerekítünk (round() ), vagy felveszünk egy int típusú változót és ebben az esetben a kerekítés automatikus (valójában típuskonverzió megy végbe) én is ezt az utat választottam. A Math osztályban található az összes matematika függvény és néhány nevezetesebb állandó pl.: pi, sin, cos, sqrt.

És végül még érdemes megemlíteni a filtert, amit használok. Mint említettem a MovieClipből származtattam, tehát képes vagyok szűrőket hozzáadni a hópelyhekhez. A BlurFilter-t használom ezzel szimulálva a pelyhek sebességét. 3 paramétert vár: x irányú elmosás mértéke, y irányú elmosás mértéke, végül az elmosódás minősége, vagy megadhatjuk hányszor alkalmazza az adott filtert.

Használok statikus változókat, illetve a cikkben is említettem statikus függvényeket, de ez egy kimerítőbb téma, ezért ezt egy külön postban taglalom majd részletesen.

Még egyszer mindenkinek nagyon boldog karácsonyt kívánok.

source

Először nézzük, meg miként is történik egy eseményhívás.

Az események kezelésére ún. eseményfigyelőket használunk, amik technikai értelemben egyszerű függvények, melyek az események bekövetkezését követően futnak le. Amikor ez megtörténik, akkor az Actionscript az összes olyan eseményfigyelőt értesíti, amelyik be volt jegyezve az adott eseményez. Eseményindításkor mindig létrejön egy objektum, ami az eseményről tartalmaz információkat (leütött billentyű, egér pozíciója, stb.), ez az objektum, az Event osztályhoz vagy annak valamilyen leszármazottjához tartozik. Ahhoz, hogy valóban figyelni is tudjuk az eseményeket, egy objektumhoz hozzá kell rendelni az esemény típusát, ill. az eseményfigyelőnket, amit EventDispatcher osztályban található addEventListener() függvény segítségével tudunk megtenni. Mindezek után nézzük meg hogyan is néz ki a gyakorlatban.

A szemléletesség kedvéért maradjunk az előző postokból már megismert kattintás eseménynél.

//tegyük fel, hogy korábban, már hozzáadtuk a btn nevű objektumot a stagehez
btn.addEventListener(MouseEvent.CLICK,klikk);

function klikk(evt:MouseEvent):void {
	trace("X: "+evt.localX + "\nY: "+evt.localY);
}
//egy lehetséges kimenet:
//X: 11
//Y: 20

Legelsőnek hozzárendelem a btn nevű célobjektumhoz a CLICK eseményt és klikk eseményfigyelőt. Alatta pedig megvalósítom klikk függvényt. Figyeljük, meg hogy ezeknek a speciális függvényeknek mindig kötelezően át kell venniük egy paramétert, különben fordítási hibát kapunk. Ez a paraméter nem más, mint a korábban már említett eseményobjektum, ami tartalmazza az eseménnyel kapcsolatos információkat. A függvény törzsében csak kiíratom az átvett objektum x és y paramétereit, amiket az egér aktuális pozíciója határoz meg.

Érdemes megjegyezni, hogy az alábbi kód is teljesen helyes:

btn.addEventListener("click",klikk);

Ez azért lehetséges, mert az addEventListener() szignatúrája ez: addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void. Tehát, mint látjuk az adott event típusát stringként várja. Akkor hogy lehet az, hogy a MouseEvent.CLICK elnevezés nem okozott hibát? A magyarázat egyszerű MouseEvent.CLICK értéke valójában egy string. Ezt a megoldást, hogy karakterláncot adunk át nem szokás használni, mert nem egyértelmű, hogy mit szeretnénk, rontja a kód olvashatóságát, tehát kerüljük. Mint látjuk addEventListener() több paramétere van, mint amennyit én most itt ismertetek, de ezek csak feleslegesen elbonyolítanák a példákat.

Most hogy tudunk eseményeket bejegyezni, azt is meg kéne nézni miként tudjuk azokat eltávolítani, ha már szükségtelenné váltak. A removeEventListener() fog nekünk ebben segíteni, ami szinétn az EventDispatcher osztályban kapott helyet.

//tegyük fel, hogy korábban, már hozzáadtuk a btn nevű objektumot a stagehez
btn.addEventListener(MouseEvent.CLICK,klikk);

function klikk(evt:MouseEvent):void {
	trace("X: "+evt.localX + "\nY: "+evt.localY);
	btn.removeEventListener(MouseEvent.CLICK,klikk);
}

Ha lefuttatjuk az alábbi kis kódot, azt tapasztaljuk, hogy az első kattintás után nem írja ki a cursorunk helyét, és ez teljesen rendjét is van, hiszen eltávolítottuk a figyelőnket a klikk-ben. Fontos, hogy mindig távolítsuk el a már nem használt listenerekt, hisz erőforrásaink nem végesek, és feleslegesen ne terheljük meg a futtatókörnyezetet.

Most nézzünk meg az Event osztály néhány típusát, melyek bármely más eseményben (pl.: MouseEvent) is elérhetőek, hiszen az Eventből származnak.

type: A kiváltó esemény típusa.

btn.addEventListener(MouseEvent.CLICK,klikk);

function klikk(evt:MouseEvent):void {
	trace(evt.type);
}

//kimenet:
//click

currentTaret: Az az objektum, amihez hozzáadtuk az eseményfigyelőnket.

target: Visszaadja, hogy honnan származik az esemény.

A target és a currentTraget fogalma gyakran egybeesik, például a fenti példánknál is. De vannak esetek, amikor nem ilyen egyértelmű, hogy melyiknek mi is a tartalma. Nézzük meg az alábbi kódot:

addCircle();
btn.addEventListener(MouseEvent.CLICK,klikk);

function klikk(evt:MouseEvent):void {
	if (evt.target!=evt.currentTarget) {
		Sprite(evt.target).x=Sprite(evt.target).x+30;
	}
}
function addCircle():void {
	var circle:Sprite=new Sprite  ;
	circle.graphics.beginFill(0x000000);
	circle.graphics.drawCircle(1,50,25);
	circle.buttonMode=true;
	btn.addChild(circle);
}

Aki nem teljesen érti, az addCircle() függvényt, az ne bánkódjon, nincs rá szükség a példa megértéséhez, csak egy kört rajzol ki és hozzáadja a már eddig is létező btn-hez. Fontos, hogy nem a színpadhoz adjuk hozzá, hanem a btn-hez (ha hivatkozni akarnánk rá így tehetnénk: btn.circle)! A klikk törzsében ezúttal csak annyit történik, hogy  abban az esetben, amikor a célobjektum nem egyezik meg a kiváltóval, akkor azt az objektumot, amelytől származik az esemény eltolom 30-cal. Még érdemes megemlíteni a típus konverziót amikor az evt nevű MouseEvent típusú objektumot átalakítom Sprite típusúvá a biztonságos típushasználat miatt. Nézzük meg működés közben:

Abban az esetben, ha a téglalapra kattintunk, akkor megegyezik a target és a currentTarget, tehát nem történik semmi. Viszont, amikor a körre kattintunk, akkor már közel sem azonos a kettő tartalma, tehát eltolódik a kör. Kicsit talán erőltettet a példa, de remélem siketült megérteni mi a két fogalom között a különbség.

Még egy apró gondolta a végére. Ha egy azonos objektumhoz hozzáadunk egy azonos típusú eseményt, csak másik eseményfigyelővel, akkor szekvenciálisan az az fentről lefelé hajtódik végre.

btn.addEventListener(MouseEvent.CLICK,klikk1);
btn.addEventListener(MouseEvent.CLICK,klikk2);

function klikk1(evt:MouseEvent):void {
	trace("Hello");
}

function klikk2(evt:MouseEvent):void {
	trace("World");
}
//kimenet:
//Hello
//World

Van egyéb lehetőségünk is a hívási sorrend befolyásolására, de azt majd máskor.

• Flash Player verziófrissítés
• Biztonsági frissítések
• Bug fixek

Mind az SDK és a futtatókörnyezet is letölthető. A Release notesból többet is megtudhatjuk, illetve a fejlesztők blogjára is érdemes rápillantani.

Ezt fogjuk megvalósítani:

Első körben nézzük meg, hogyan tudunk, saját menüt készíteni, ill. miként tudjuk az alapértelmezett elemek manipulálni.

var myMenu:ContextMenu = new ContextMenu();
myMenu.hideBuiltInItems();
contextMenu = myMenu;

Az első sorban csak létrehozzuk a saját menünket. A másodikban letiltjuk az össze alapértelmezett elemet (zoom, quality, print, stb.). Az utolsóban, pedig betöltjük az általunk létrehozott menüt. A hideBuiltInItems() elég kényelmes megoldás abban az esetben, ha minden ki szeretnénk iktatni, de mi van, ha mégis meg szeretnénk tartani 1-2 alap menüelemet. Szerencsére ezeket egyesével is lehetőségünk van paraméterezni.

myMenu.builtInItems.forwardAndBack = false;
myMenu.builtInItems.loop = false;
myMenu.builtInItems.play = true;
myMenu.builtInItems.print = true;
myMenu.builtInItems.quality = false;
myMenu.builtInItems.rewind = false;
myMenu.builtInItems.save = false;
myMenu.builtInItems.zoom = false;

Érdemes megjegyezni, hogy bizonyos elemek, mint pl.: Settings vagy az About, semmilyen módon nem távolíthatók el a listából.

Ezek után nézzük, meg hogyan tudunk saját listaelemeket hozzáadni újonnan készített menünkhöz.

var myMenu:ContextMenu = new ContextMenu();
myMenu.hideBuiltInItems();

var myText = new ContextMenuItem("Hello World");

myMenu.customItems.push(myText);
contextMenu = myMenu;

A ContextMenuItem-mel tudunk létrehozni egy új elemet, stringet vár paraméterül, ez fog megjelenni a menüben. A push utasítással tudjuk beletenni a menüelemet a ContextMenu-be.

Több menuitemet így tudunk hozzáadni:

var myMenu:ContextMenu = new ContextMenu();
myMenu.hideBuiltInItems();

var myText = new ContextMenuItem("Hello World");
var mail = new ContextMenuItem("mail@domain.com");
var copyr = new ContextMenuItem("Minden jog...");
myMenu.customItems.push(myText,mail,copyr);
contextMenu = myMenu;

Semmi érdekes nincs a kódba, csak annyit érdemes megjegyezni, hogy amilyen sorrendben felsoroljuk a pushban az itemeket, olyas sorrendben fognak megjelenni a menüben.

Most nézzük meg, hogyan tudjuk a menüelemeket testreszabni:

• enabled – kattinthatóság (kiszürkül)
• separatorBefore – kis elválasztójelek közé kerül az elem
• visible – láthatóság (megjelenik a listában vagy sem)
• caption – felüldefiniálja a konstruktorban megadott nevet

A caption kivételével, ami stringet, mindegyik logikai értéket vár.

var myText=new ContextMenuItem("Hello World");
var mail=new ContextMenuItem("mail@domain.com");
var copyr=new ContextMenuItem("Minden jog...");

myText.enabled=false;
myText.separatorBefore=true;
mail.caption="e-mail";
copyr.visible=false

Az eddigi ismereteinkkel már képesek vagyunk minden ízében konfigolni a menünket, de sajnos az általunk felvett elemek idáig statikusak, hiába kattint a felhasználó bármelyikre, semmi nem fog történni. Tegyünk ez ellen!

var myMenu:ContextMenu = new ContextMenu();
myMenu.hideBuiltInItems();

var myText=new ContextMenuItem("ActionScript.hu");
var mail=new ContextMenuItem("mail@domain.com");

myText.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT,navigate);

function navigate(evt:ContextMenuEvent) {
	navigateToURL(new URLRequest("http://www.actionscript.hu/"),"_blank");
}

function navigate(evt:ContextMenuEvent) {
	navigateToURL(new URLRequest("http://www.actionscript.hu/"),"_blank");
}

myMenu.customItems.push(mail,myText);
contextMenu=myMenu;

A myText nevű menuitemhez hozzáadunk egy eseményfigyelőt. Abban az esetben, ha kattintunk a myText-re akkor lefuttatja navigate függvényünket, ami egy régebbi postban (Egyszerű linkek as3-ban) taglalt módon megnyit egy oldalt.

Legvégül pedig a teljes kód, ami egy kis ötlet add arra, hogy miként is lehet a menü segítségével vezérelni a mozinkat.

var myMenu:ContextMenu = new ContextMenu();
myMenu.hideBuiltInItems();

var myText=new ContextMenuItem("ActionScript.hu");
var mail=new ContextMenuItem("mail@domain.com");
var showCircle=new ContextMenuItem("Kör megjelenítése");
var hideCircle=new ContextMenuItem("Kör elrejtése");
myText.separatorBefore=true;
showCircle.enabled=false;

myText.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT,navigate);
showCircle.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT,showC);
hideCircle.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT,hideC);

function navigate(evt:ContextMenuEvent) {
	navigateToURL(new URLRequest("http://www.actionscript.hu/"),"_blank");
}

function showC(evt:ContextMenuEvent) {
	circle.visible=true;
	hideCircle.enabled=true;
	showCircle.enabled=false;
}

function hideC(evt:ContextMenuEvent) {
	circle.visible=false;
	hideCircle.enabled=false;
	showCircle.enabled=true;
}

myMenu.customItems.push(mail,myText,showCircle,hideCircle);
contextMenu=myMenu;

Feleslegesnek érzem kivesézni a kódot, hiszen csak az itt bemutatott eszközöket használom fel. Innentől már mindenki fantáziájára bízom a továbbiakat.

source

Én úgy gondolom, hogy ez az egyik nagyon erős ok, amiért az Apple nem hajlandó engedélyezni a flash tartalmakat a telefonon (kivétel persze a beépített YouTube program, de ez semmi másra nem jó). Ez nem meglepő hiszen, az Apple nem a telefoneladásokból szakítja a legnagyobbat, hanem az App Store-ból. Telefont csak egyszer veszel, viszont alkalmazásokat folyamatosan töltögeted és vásárolgatod. Eddig is voltak/lesznek lehetőségek, hogy ingyenesen jussunk fizetős alkalmazáshoz, de ezek, mint tudjuk illegálisak. Én személy szerint nem fűzök hozzá sok reményt, hogy valaha is lesz flash player az iPhone-ban, de azért érdekes eljátszani a gondolattal.

Valószínűleg ezt az Adobe is kezdi belátni, és ezért a „hegy megy Mohamedhez” elv alapján a Flash CS5 már képes lesz ipába fordítani, tehát ha megírunk valamit actionscriptben, az onnantól kezdve jó eséllyel megy a telefonunkon is. Meglátjuk, hogy sikerül majd ezt rendesen megoldani, de egyenlőre biztató dolgokat halhatunk a projektről.

Végeredményben én nagyon meg vagyok elégedve a készülékkel, nem véletlenül mozgat a flash+iphone kérdés ennyire. Egy szó, mint száz, emiatt a blogon is vissza fog köszönni néha –néha ez a téma.

[UPDATE: Mivel az imeem.com megszűnt (beépült a MySpacebe), és ezzel a stream szolgáltatás is megszűnt, ezért kénytelen voltam egy YouTubos videót beszúrni.]

A tovább után megtaláljátok a dalszöveget.

Jonathan Coulton – Code Monkey

Code Monkey get up get coffee
Code Monkey go to job
Have boring meeting with boring manager Rob
Rob say Code Monkey very diligent
But his output stink
His code not functional or elegant
What do Code Monkey think
Code Monkey think maybe manager oughta write goddamn login page himself
Code Monkey not say it out loud
Code Monkey not crazy just proud

Code Monkey like Fritos
Code Monkey like Tab and Mountain Dew
Code Monkey very simple man
With big warm fuzzy secret heart
Code Monkey like you
Code Monkey like you

Code Monkey hang around at front desk
Tell you sweater look nice
Code Monkey offer buy you soda
Bring you cup bring you ice
You say no thank you for the soda ’cause
Soda make you fat
Anyway you busy with the telephone
No time for chat

Code Monkey have long walk back to cubicle
He sit down pretend to work
Code Monkey not thinking so straight
Code Monkey not feeling so great

Code Monkey like Fritos
Code Monkey like Tab and Mountain Dew
Code Monkey very simple man
With big warm fuzzy secret heart
Code Monkey like you
Code Monkey like you a lot

Code Monkey have every reason
To get out this place
Code Monkey just keep on working
To see your soft pretty face
Much rather wake up eat a coffee cake
Take bath, take nap
This job fulfilling in creative way
Such a load of crap
Code Monkey think someday he have everything even pretty girl like you
Code Monkey just waiting for now
Code Monkey say someday, somehow

Code Monkey like Fritos
Code Monkey like Tab and Mountain Dew
Code Monkey very simple man
With big warm fuzzy secret heart
Code Monkey like you
Code Monkey like you

Ezt fogjuk elkészíteni:

Nagyon egyszerű dolgunk van, mert az as3 biztosít nekünk erre egy külön utasítást: navigateToURL(). A referenciában ezt olvashatjuk róla:  navigateToURL(request:URLRequest, window:String = null) :void. Tehát meg kell adnunk egy URLRequest típusú változót, és valamilyen stringet, illetve nem tér vissza semmivel a függvényünk, tehát egy eljárás. De mi is az az URLRequest? Ez az objektum végeredményben egy külső erőforrás helyt írja le. Az hogy milyen hálózati protokollokat (http, https, ftb, stb.) használhatunk oprendszer függő, tehát figyeljünk, mit használunk, mert elképzelhető, hogy egyes helyeken ez hibához vezet. Esetünkben ez nem probléma, mert http-t fogunk használni. Nézzünk is akkor egy példát.

//elérési út konstruktornak átadva
var url:URLRequest=new URLRequest("http://www.actionscript.hu/");

A konstruktor egy egyszerű stringet vár. Tehát akár ezt is megtehetjük:

var str:String="http://www.actionscript.hu/";
var url:URLRequest=new URLRequest(str);

Nem csak abszolút, hanem relatív eléréseket is megadhatunk, ill. nem muszáj a konstruktorban megadnunk az elérési utat.

var url:URLRequest = new URLRequest()
url.url="blog/pic/dog.jpg"

Az alábbi kódrészletből jól látszik, hogy URLRequest osztálynak van egy public, string típusú „url” adattagja, amit az elérési utat tartalmazza.

Ezek után nézzük a navigateToURL-t működés közben:

var url:URLRequest=new URLRequest("http://www.actionscript.hu/");
navigateToURL(url,"_blank");

Semmi váratlan dolgot nem tapasztalunk. Egyetlen érdekes dolog van, a második string paraméterrel tudjuk megmondani, hogy a link hol nyíljon meg, adott esetben _blank (új ablakban). Négy lehetőség közül választhatunk: _self, _blank, _parent, _top.

Megadhatjuk az előbbi kódot így is:

//
navigateToURL(new URLRequest("http://www.actionscript.hu/"), "_blank");

Viszont ebben az esetben nem tudunk hivatkozni a későbbiekben az elérési utunkra. Ha mostani állapotában lefordítanánk a kódunkat semmi nem történne. Szükségünk van egy eseményre, aminek hatására lefut a navigateToURL. Ez az esemény mi esetünkben, egy gombkattintás lesz.

Hát első körben csináljunk egy gombot. Ehhez csináljunk egy új fla-t, majd keressük meg a Window menüben a Components és Components Inspector ablakokat. Components ablakból egyszerűen húzzuk a stagere a Button komponenst.

Ezután jelöljük ki, és a Components Inspector ablakban megjelenik néhány paraméter, minket csak a label érdekel, ez határozz meg, hogy milyen felirat jelenik meg a gombon. Megjegyzem, hogy az itt megtalálható összes paraméter actionscriptből is konfigurálható, és mi ezt az utat fogjuk választani a példánkban. Ha ezzel megvagyunk, van még egy fontos dolgunk, el kell látnunk egy egyedi azonosítóval a gombunkat, hogy később a kódból tudjunk rá hivatkozni.

Nem kell mást tennünk, mint kijelölni a gombot és a Properties panelen adni neki egy egyedi nevet, esetünkben ez a btn.

Ezek után nincs más dolgunk, mint hozzárendelni egy eseményt.

btn.addEventListener(MouseEvent.CLICK,navigate);

Most nem szeretnék kitérni a listenerekre, egy későbbi postban, majd részletesebben tárgyaljuk őket. Nekünk most ebből csak az a fontos, hogy a gombunkra kattintunk, az kivált egy eseményt, aminek hatására lefut a navigate függvény.

Mindezek ismeretében lássuk egyben a kódot:

btn.label="ActionScript.hu";
var url:URLRequest=new URLRequest("http://www.actionscript.hu/");

btn.addEventListener(MouseEvent.CLICK,navigate);

function navigate(evt:MouseEvent):void {
	navigateToURL(url,"_blank");
}

Egyetlen egy újdonság tűnhet fel az 1. sorban. Itt egyszerűen csak beállítom a gomb feliratát, ha esetleg a Components Inspector-ban beállítottunk volna már valamilyen értéket a labelnek, akkor ez felüldefiniálja azt.

Ha nem framere szeretnénk írni ezt a kódot, hanem packagebe szeretnénk használni az itt megismert osztályokat, akkor itt találjuk őket: flash.net.navigateToURL; flash.net.URLRequest;

source