Italiano:Assetti

Panoramica
L'altro tipo di nodo nel file site.xml sono gli Asset. Gli Assets appartengono alle pagine e sono file esterni, i quali sono associati con la paginaa cui appartengono. Usando gli Assets, Gaia rende più semplice la gestione e l'accesso ai file esterni.

Assets AS2 e AS3

 * NetStreamAsset - file flv o m4a
 * XMLAsset       - file XML
 * SoundAsset     - file mp3 o wav
 * StyleSheetAsset - file css

Assets AS3
Questo riflette l'albero di ereditarietà della classe DisplayObject in AS3.
 * DisplayObjectAsset - Questa è la classe base per gli assets DisplayObject.
 * BitmapAsset       - Le immagini verranno caricate come BitmapAssets come opzione predefinita (png, jpg, gif, etc.)
 * BitmapSpriteAsset - Questo Asset è una classe BitmapAsset inserita dentro una Sprite per l'interattività.
 * SpriteAsset       - Questa è inclusa per riflettere l'albero di ereditarietà della classe DisplayObject.
 * MovieClipAsset    - Come opzione predefinita, i file swf verranno caricati come MovieClipAssets.
 * TextAsset         - Per i file .txt e anche come classe base per XMLAsset, StyleSheetAsset e JSONAsset
 * JSONAsset         - Per i file.json
 * ByteArrayAsset   - For loading raw bytes

Assets AS2

 * MovieClipAsset - Qualunque file che venga caricato nativamente dentro a un MovieClip (swf, png, jpg, gif, etc.)
 * SoundClipAsset - Swf con suono incluso (per loop perfetti)



Come usare gli Assets
Come opzione predefinita, gli Assets vengono caricati assieme alla Pagina come parte del processo di precaricamento. Questo comportamento può essere modificato singolarmente per ogni asset, se preferisci (vedi sotto).

*** NOTA IMPORTANTE RIGUARDANTE L'ACCESSO AGLI ASSETS ***

Gli oggetti degli assets non sono disponibili in una Pagina fino a che non viene chiamato il metodo transitionIn. Questo avviene perchè l'pactionscript sul primo frame di una Pagina caricata viene eseguito prima che l'oggetto dell'asset venga assignato alla Pagina, come qualunque asset caricato. Aspetta che il metodo tansitionIn venga chiamato prima di provare ad accedere a qualunque assets.

Qui di seguito una piccola dimostrazione di come si usano gli assets.

       

In questo esempio, la Pagina home contiene quattro assets con id myMusic, myCopy, myImage e mySWF. Gli Assets sono resi disponibili all'interno delle pagine swf attraverso una proprietà "assets" disponibile nella document class o nella timeline principale delle tue pagine swf.

Puoi accedere agli assets direttamente utilizzando i loro id e la maggior parte dei metodi relativi ad essi sono disponibili direttamente sull'asset, attraverso il design pattern Proxy.

Gli Assets in Gaia reflettono le classi degli asset in Flash.

'''Nota: le Immagini e gli swf quando vengono caricati hanno come opzione prefedefinita visible = false e sono posizionati a 0,0. Se vuoi che le immagini o gli swf vengano visualizzati sullo stage, devi impostare la loro proprietà visible = true.'''



MovieClipAsset
Puoi accedere un MovieClipAsset direttamente usando molti metodi e proprietà native della classe MovieClip.

Di seguito alcuni esempi di sintassi. Nota che puoi accedere all'asset esattamente come qualunque altro MovieClip.

AS2 assets.myImage._x = 50; assets.myImage._y = 100; assets.myImage._visible = true; trace(assets.myImage._parent);  // restituisce il _parent del MovieClip // assets.mySWF.gotoAndPlay(10); assets.mySWF.onRelease = function {};

AS3 non richiede il casting, ma se vuoi strict typing per ottimizzare il codice, cast l'assets alla loro interfaccia. MovieClipAssets usa IMovieClip, le immagini usano IBitmap, le sprite usano ISprite, e tutti ereditano proprietà e metodi della classe IDisplayObject. E' inoltre importante notare che la proprietà parent restituisce il parent del loader, non del contenuto.

AS3 IDisplayObject(assets.myImage).x = 50; IDisplayObject(assets.myImage).y = 100; IDisplayObject(assets.myImage).visible = true; // IMovieClip(assets.mySWF).gotoAndPlay(10); trace(IMovieClip(assets.mySWF).parent); // restituisce il parent del loader, con del contenuto // // AS3 funziona anche senza casting // assets.mySWF.gotoAndStop(5); assets.myImage.scaleX = 0.5; trace(assets.myImage.parent); // BitmapSpriteAsset.parent restituisce il parent della Sprite in cui è nidificato.

In AS3, se la piccola dimensione del file è importante, usa solo l'interfaccia più simile a IAsset che ha i metodi che ti servono. Per esempio, se hai bisogno solo di settare x e y, usa IDisplayObject.

Puntare alla timeline di un MovieClipAssets
Se hai un swf e vuoi puntare qualcosa nella sua document class o nella sua timeline, e.s. metodi personalizzati, proprietà, MovieClips., etc., hai bisogno di puntare direttamente alla sua classe/timeline e puoi farlo usando la proprietà "content", che restituisce un MovieClip.

AS2 assets.mySWF.content.someMethod assets.mySWF.content.someMovieClip._x = 10;

In AS3, puoi cast un MovieClipAsset come IMovieClip.

AS3 assets.mySWF.content.someMethod; IMovieClip(assets.mySWF).content.someMovieClip.x = 10;

La stessa cosa avviene per le Pagine (PageAsset estende MovieClipAsset).

AS2 Gaia.api.getPage("index/nav").content.someMovieClip._visible = true;

oppure

_global.Gaia.getPage("index/nav").content.someMovieClip._visible = true;

AS3 Gaia.api.getPage("index/nav").content.someMovieClip.visible = true;



BitmapAsset (solo AS3)
BitmapAsset estende DisplayObjectAsset. In AS3, qualunque immagine nel file site.xml, come jpg, gif, o png, sarà caricata utilizzando BitmapAssets.

import com.gaiaframework.api.IBitmap; import flash.display.BitmapData; // IBitmap(assets.myBitmap).x = 50; var myBitmapData:BitmapData = IBitmap(assets.myImage).bitmapData;



BitmapSpriteAsset (solo AS3)
Questa è una versione di BitmapAsset alla quale puoi aggiungere interattività perchè BitmapSpriteAssets sono racchiusi all'interno di contenitori Sprite, e gli asset forniscono un proxy ai metodi della classe Sprite. Imposta la proprietà type="sprite" nel nodo dell'asset per convertire una BitmapAsset in una BitmapSpriteAsset.

import com.gaiaframework.api.IBitmapSprite; // IBitmapSprite(assets.myBitmap).buttonMode = true; IBitmapSprite(assets.myBitmap).addEventListener(MouseEvent.CLICK, onClickBitmap);



SpriteAsset (solo AS3)
SpriteAsset estende DisplayObjectAsset. SpriteAsset è fornito per parity con l'albero di ereditarietà di AS3 e non è un tipo di asset impostabile. L'interfaccia ISprite è usata per mantenere le dimensioni del file piccole ne non hai bisogno dei metodi presenti nella classe IMovieClip.

container
SpriteAsset ha una proprietà chiamata container che punta al loader di MovieClipAssets e il container Sprite creato per BitmapSpriteAssets. Generalmente userai IBitmapSprite (che estende ISprite).

import com.gaiaframework.api.IBitmapSprite // TweenLite.to(IBitmapSprite(assets.myBitmap).container, 2, {alpha:0});



SoundAsset
Un SoundAsset ha gli stessi metodi nativi dell'oggetto Sound di Flash.

Per esempio se vuoi aggiungere un mp3 asset con l'id "myMusic" per suonare, userai la seguente sintassi sulla root timeline del tuo clip pagina.

AS2 assets.myMusic.start; assets.myMusic.start(4, 5); // if you wanted it to start 4 seconds in and loop 5 times

AS3 usa l'interfaccia ISound.

AS3 ISound(assets.myMusic).play; ISound(assets.myMusic).play(4, 5); // if you wanted it to start 4 seconds in and loop 5 times

In AS2, i Sound Assets sono impostati come evento di base. Impostare l'asttributo "streaming" nel nodo asset a "true" per i Sound Assets che desiderate mandare in play come streaming audio. Dovreste impostare anche preload="false" la maggior parte delle volte per l'uso in streaming audio.

In AS3, non ci sono eventi suono, quindi l'attributo streaming non è usato e tutti i Sound Assets sono gestiti come streaming. Se impostate preload="true", verrà precaricato l'intero suono come parte della pagina, e non suonerà finché non gli direte di farlo.

Infine, Gaia risolve la limitazione nativa di AS2 che non le permetteva di fare un loop del suono in streaming e o consente settando il valore di loops. Approfondite riguardo a questa funzionalità in nella sezione Assets caricati su richiesta più sotto.

SoundAssets ha tre convenienti metodi helper.

pause
pause(flag:Boolean) Passa true o pause e false (o niente) ad unpause e inizia a riprodurre dall'ultima posizione.

fadeTo
fadeTo(value:Number, duration:Number, [onComplete:Function]) // AS2 fadeTo(value:Number, duration:Number, onComplete:Function = null) // AS3 Value is the volume you want to fade to, duration is the number of seconds for the fade, and you can optionally pass a function to be called when the fade is complete.

panTo
panTo(value:Number, duration:Number, [onComplete:Function]) // AS2 panTo(value:Number, duration:Number, onComplete:Function = null) // AS3 Value is the pan value you want to pan to (-100 to 100 in AS2, -1 to 1 in AS3), duration is the number of seconds for the pan, and you can optionally pass a function to be called when the pan is complete.



SoundClipAsset (AS2 only)
A SoundClipAsset is nearly identical to a SoundAsset, and has most of the same native methods as the Sound Asset. SoundClipAssets are primarily used for mp3 files which you need to be perfectly looped.

To create a SoundClipAsset for Gaia, first, you create a new Flash file and import your audio file. Give your audio file any linkage ID you like and put the following code in the timeline.

sound = new Sound(this); sound.attachSound("YOUR_LINKAGE_ID");

In your site.xml, you will need to set the asset type attribute to "sound". Example:



That's all you need to do and Gaia does the rest.

SoundClipAssets behave just like SoundAssets with the exception that they cannot be set to streaming. Other than that, you access them exactly the same as normal Sound Assets. You can add them to SoundGroups, as well.

<br style="clear:both" />

NetStreamAsset
NetStreamAssets have all of the methods available to the NetStream class available to them. A NetStreamAsset also has a property "ns" which is the reference to the NetStream instance itself.

In AS3, NetStreamAssets use the INetStream interface.

INetStream(assets.myFLV).play; INetStream(assets.myFLV).attach(video);

In both AS2 and AS3, NetStreamAssets have two convenience properties and one method.

duration
get duration:Number Returns the duration of a loaded NetStreamAsset, extracted from the metaData.

metaData
get metaData:Object Returns the metaData object of a loaded NetStreamAsset.

attach
attach(video:Video) This helper method lets you pass a video instance to attach and Gaia handles attaching the NetStream to the Video.

In AS3 only, NetStreamAssets have four additional convenience properties/methods.

volume (AS3 only)
get volume:Number set volume(value:Number):void This setter property accesses the volume on the NetStreamAsset, a floating point value from 0 to 1.

pan (AS3 only)
get pan:Number set pan(value:Number):void This getter/setter property accesses the pan on the NetStreamAsset, a floating point value from -1 to 1.

fadeTo (AS3 only)
fadeTo(value:Number, duration:Number, onComplete:Function = null) Value is the volume you want to fade to, duration is the number of seconds for the fade, and you can optionally pass a function to be called when the fade is complete.

panTo (AS3 only)
panTo(value:Number, duration:Number, onComplete:Function = null) Value is the pan value you want to pan to (-100 to 100 in AS2, -1 to 1 in AS3), duration is the number of seconds for the pan, and you can optionally pass a function to be called when the pan is complete.

<br style="clear:both" />

NetStreamAssetEvent
NetStreamAsset also dispatches events for the client "events" including onMetaData and onCuePoint. You can add a listener for these events to the NetStreamAsset, and the Event passes the "info" property for your use.

// AS3 INetStream(assets.myFLV).addEventListener(NetStreamAssetEvent.METADATA, onMetaData); // AS2 assets.myFLV.addEventListener(NetStreamAssetEvent.METADATA, Delegate.create(this, onMetaData));

To listen to the onMetaData event, the NetStreamAsset must be set to preload="false", otherwise, the metadata will already be available by the time you can access the asset.

These are all the NetStreamAsset events you can listen for. Consult the Actionscript NetStream documentation for more information about these events.

AS3 and AS2 * NetStreamAssetEvent.METADATA * NetStreamAssetEvent.CUEPOINT

AS3 only * NetStreamAssetEvent.IMAGE_DATA * NetStreamAssetEvent.TEXT_DATA * NetStreamAssetEvent.XMP_DATA

AS2 only * NetStreamAssetEvent.STATUS

<br style="clear:both" />

XMLAsset
In AS2, hai due diversi modi per accedere ad un XML asset. Puoi ottenere l'xml grezzo tramite la proprietà "xml" oppure puoi ottenere un oggetto actionscript XML2AS accedendo alla proprietà "obj".

AS2 assets.myCopy.xml.firstChild.firstChild.attributes.id; assets.myCopy.obj.site[0].page[0].attributes.id;

In AS3, l'XML è immagazzinato nella proprietà "xml", e puoi utilizzare la sintassi E4X per analizzare i nodi. AS3 utilizza l'interfaccia IXml.

AS3 var myXML:XML = IXml(assets.myCopy).xml; trace(myXML.child[0].anotherChild[0].@someAttribute);

<br style="clear:both" />

StyleSheetAsset
StyleSheetAsset è per i file .css. Esso contiene metodi proxy per la classe StyleSheet, ed ha una proprietà "style" che contiene l'istanza StyleSheet, e un metodo helper, transformStyle, che combina due metodi nativi StyleSheet in uno, che restituisce un TextFormat.

transformStyle
myFormat:TextFormat = assets.myStyle.transformStyle(styleName);

AS3 utilizza l'interfaccia IStyleSheet.

myFormat:TextFormat = IStyleSheet(assets.myStyle).transformStyle(styleName);

<br style="clear:both" />

TextAsset (solo AS3)
TextAsset è per i file .txt, ed è anche la classe base per StyleSheetAsset, JSONAsset e XMLAsset. Essa utilizza l'interfaccia IText e ha una proprietà "text" che contiene testo grezzo.

AS3 utilizza l'interfaccia IText.

var str:String = IText(assets.myFLV).text;

<br style="clear:both" />

JSONAsset (solo AS3)
JSONAsset estende la classe TextAsset ed usa l'interfaccia IJson. Essa ha una proprietà "json" la quale restituisce un oggetto deserializzato di tipo JSON utilizzando la classe com.serialization.json.JSON.

IJson(assets.myJson).json;

ByteArrayAsset (solo AS3)
ByteArrayAsset loads in raw byte data, which is avaiable in the public property "data" which returns the ByteArray. One use for this is if you want to load in the raw bytes of a file to create multiple instances of it, such as a Bitmap or swf file.

IByteArray(assets.myByteArray).data;

<br style="clear:both" />

DisplayObjectAsset (solo AS3)
DisplayObjectAsset estende la classe AbstractAsset ed è l'asset di base per gli SpriteAsset (così come per i MovieClipAsset), BitmapAsset e BitmapSpriteAsset.

<br style="clear:both" />

Assets caricati su richiesta
In the site.xml, by setting the preload attribute to "false", assets can be set to not preload with a page and instead be loaded on demand. To load assets on demand, you use the load method. You can load on demand any number of assets at once, and Gaia will automatically queue them to load two at a time (the maximum number of simultaneous HTTP requests).

assets.mySWF.load; assets.myMusic.load;

In AS3, use the appropriate interface class.

IMovieClip(assets.mySWF).load; ISound(assets.myMusic).load;

Sound And NetStream Assets
Sound and NetStream assets will immediately start streaming when load is called on them. If the Sound is an event sound or a SoundClipAsset, it will load first and immediately play.

load
Sound Assets accept two parameters on the load method, just like the Sound.start method.

SoundAsset.load(startTime:Number, loops:Number);

If the SoundAsset is not streaming, it will load the entire sound file and then play it. If it is streaming, it will play it immediately. Unlike the (AS2) native loadSound method, you can loop streaming audio files by passing the number of loops you want. For example, this code will start streaming a sound asset and loop it 999 times:

assets.myStreamingMusic.load(0, 999);

loadWithoutPlaying
Sound Assets also have a method to load without playing.

SoundAsset.loadWithoutPlaying;

<br style="clear:both" />

Altri tipi di asset
Immagini, swf, e xml assets saranno caricati come fanno normalmente, ovvero le immagini e gli swf assets una volta caricati saranno invisibili.

<br style="clear:both" />

Progress Attribute
By setting the progress attribute to "true" in the site.xml, you can use the preloader to display the loading progress of the asset (this does not work for NetStream or streaming sound assets), set it to "false" to not show progress. The asset loader uses the site preloader by default, but this behavior can be changed at runtime. Read the Preloader and API documentation for more information.

<br style="clear:both" />

Come sapere quando un Asset ha completato il caricamento
Se vuoi sapere quando un asset ha finito il caricamento, associa un listener per l'evento AssetEvent.ASSET_COMPLETE all'asset. Assicurati di rimuovere il listener quando hai fatto!

AS3

// replace this IAsset import with whatever specific asset interface you're using import com.gaiaframework.events.AssetEvent; import com.gaiaframework.api.IAsset; // var myAsset:IAsset = Gaia.api.getPage("index").assets.mySWF; myAsset.addEventListener(AssetEvent.ASSET_COMPLETE, onAssetLoaded, false, 0, true); myAsset.load; // private function onAssetLoaded(event:AssetEvent):void {    myAsset.removeEventListener(AssetEvent.ASSET_COMPLETE, onAssetLoaded); // access your asset OR event.target, which is also your asset }

AS2

import com.gaiaframework.assets.AbstractAsset; import com.gaiaframework.events.AssetEvent; import mx.utils.Delegate; // var myAsset:AbstractAsset = Gaia.api.getPage("index").assets.mySWF; var completeDelegate:Function = Delegate.create(this, onAssetLoaded); myAsset.addEventListener(AssetEvent.ASSET_COMPLETE, completeDelegate); myAsset.load; // private function onAssetLoaded(event:AssetEvent):Void {    myAsset.removeEventListener(AssetEvent.ASSET_COMPLETE, completeDelegate); // access your asset OR event.target, which is also your asset }

<br style="clear:both" />

Rimparentare DisplayObjectAssets (AS3 Only)
Se vuoi inserire un BitmapAsset o un MovieClipAsset dentro un MovieClip o ad una Sprite che hai creato, aspetta fino a che transitionIn è stato chiamato e usa la proprietà loader. myContainer.addChild(assets.myAsset.loader);

Se vuoi rimparentare un BitmapSpriteAsset o un MovieClipAsset, usa la proprietà container. myContainer.addChild(assets.myAsset.container);

<br style="clear:both" />

Altri usi per gli Assets
Un altro modo per utilizzare gli assets è di precaricare e memorizzare in cache gli asset che vuoi caricare da solo manualmente. Utilizza semplicemente la proprietà src dell'asset.

Un esempio d'uso è per gli assets di tipo sound che vuoi che continuino a riprodurre dopo che la pagina è cambiata.

AS2 var mc:MovieClip = _root.createEmptyMovieClip("MC_Music", _root.getNextHighestDepth); _root.music = new Sound(mc); _root.music.loadSound(assets.myMusic.src); _root.music.onLoad = function {    _root.music.start; };

<br style="clear:both" />

Accedere ad Assets su altre pagine
Se sei all'interno di una pagina e vuoi accedere agli assets di un'altra pagina caricata dello stesso ramo, hai due opzioni.

L'opzione raccomandata è di utilizzare il metodo dell'API, getPage.

Gaia.api.getPage(branch).assets

di cui potete avere maggiori informazioni leggendo la sezione API della documentazione.

L'altra opzione è di accedere alla proprietà parent o children della pagina, per esempio:

page.getParent.assets OPPURE page.children.somePageID.assets

<br style="clear:both" />

Preloader Asset
You can use a MovieClipAsset as a preloader for the site. Most of the time, you'll want to set its depth="preloader" to load it into the right depth. It's best to make this an asset of a page that will not unload (e.g. the index page). If your MovieClipAsset unloads, the PreloadController will revert to using the default site preloader. Make sure that the MovieClipAsset is loaded before you override the preloader with this asset. You can read more about this in the Preloader documentation.

<br style="clear:both" />

Assets Dinamici Esterni
Questa è una tecnica avanzata a dovreste essere completamente familiarizzati sul funzionamento di Gaia prima di usarla.

Potete creare file xml di tipo asset ad una pagina dinamicamente in runtime usando Gaia API method addAssets. Tutto quello che dovete fare è assicurarsi che il nodo che si passa abbia i minimi attributi richiesti che sono id e src. Questo rende la creazione di gallerie di immagini con Gaia più semplici e permette di usare l'assetLoader o il motore di preloading di Gaya per liste dinamiche di assets.

Una pratica raccomandata è quella di avere il vostro file xml con gli assets come asset caricato nella pagina index (usando indexFirst = "true", vedi esempio qui sotto) e richiamare addAssets nella metodo transitionIn della pagina Index nella pagina in cui vorrete che l'asset sia caricato. E' possibile addAssets ad una pagina che è già caricata.

Potete aggiungere gli assets su-richiesta (preload="false") oppure, se li volete precaricare con la pagina impostate preload="true".

Per usare addAssets, passare una lista di nodi assets validi e un riferimento al PageAsset a cui volete aggiungerli. Gaia vi avvertirà se tenterete di aggiungere un asset che esiste già in una pagina, quindi assicuratevi di usare un unico ID per i vostri asset esterni e non aggiungete gli stessi assets più di una volta. L'aggiunta di assets alla pagina usando addAssets è permanente, non temporaneo.

Come utilizzare Assets esterni
Gaia.api.addAssets(nodes:XMLList, page:IPageAsset):void // AS3 Gaia.api.addAssets(nodes:Array, page:PageAsset):Void // AS2

Di seguito un esempio di come funziona:

File site.xml di esempio
<site title="Gaia Scaffold Site: %PAGE%" menu="true" indexFirst="true"> <page id="index" src="index.swf"> <asset id="homeAssets" src="homeAssets.xml"/> <page id="nav" src="nav.swf" depth="top"> <page id="home" title="Home" src="home.swf" menu="true" />

Come puoi vedere, la pagina index ha un XMLAsset, homeAssets, e la proprietà indexFirst è impostata a true. Questo perchè la pagina index e i file xml verranno caricati prima che Gaia provi a caricare il ramo home page.

<br style="clear:both" />

File homeAssets.xml di esempio
<asset id="asset1" src="image1.jpg"/> <asset id="asset2" src="image2.jpg"/> <asset id="asset3" src="image3.jpg"/> <asset id="asset4" src="image4.jpg"/>

<br style="clear:both" />

File IndexPage.as di esempio
AS3 override public function transitionIn:void {   super.transitionIn; var assetNodes:XMLList = IXml(assets.homeAssets).xml.asset; var homePage:IPageAsset = Gaia.api.getPage("index/nav/home"); Gaia.api.addAssets(assetNodes, homePage); TweenLite.to(this, 0.3, {alpha:1, onComplete:transitionInComplete}); }

AS2 public function transitionIn:Void {   super.transitionIn; var assetNodes:Array = assets.homeAssets.obj.assets[0].asset; var homePage:PageAsset = Gaia.api.getPage("index/nav/home"); Gaia.api.addAssets(assetNodes, homePage); TweenLite.to(this, 0.3, {_alpha:100, onComplete:Delegate.create(this, transitionInComplete)}); }

<br style="clear:both" />

Explanation
The above code will add all the assets in the homeAssets.xml file to the "home" Page before it loads, and will preload them with the page since these assets are being added before the "index/nav/home" branch is loaded.

If you do not need to preload the assets with the page, set preload="false" in each of your external asset nodes and you can load them yourself in the HomePage class, if you like.

Note that the nodes themselves do not need to be named "asset". You could have many pages of asset nodes in a single external xml file. Just pass the list of nodes you want to the addAssets API method and the page they belong to and Gaia will iterate through that list.

<br style="clear:both" />

Aggiornare le dimensioni dei file
Se vuoi che il pannello di Gaia aggiorni la proprietà "bytes" per i file esterni, devi impostare assets="true" sui file xml che vuoi che il pannello aggiorni.

<br style="clear:both" />

Maggiori informazioni Assets
Per vedere tutti i metodi disponibili per gli assets, dai un'occhiata alle classi nella pagina della documentazione com.gaiaframework.assets package. La maggior parte dei metodi nativi, se non tutti, sono disponibili direttamente.

In AS3, assicurati di dare un'occhiata alle interfacce disponibili per ogni asset nella pagina della documentazione com.gaiaframework.api package.

Dovresti usare queste inerfacce quando casting assets ai quali accedi per mantenere le dimensioni del file considerevolmente piccole.

AS3 import com.gaiaframework.api.ISound; var myMusic:ISound = assets.myMusic as ISound; myMusic.play;

import com.gaiaframework.api.INetStream; var myVideo:INetStream = assets.myVideo as INetStream; myVideo.play;

node
Tutti gli assets (incluse le pagine Pages) hanno una proprietà node. Essa contiene il nodo xml della pagina o dell'asset nel file site.xml. Essendo XML, puoi utilizzare attributi personalizzati sul nodo della pagina o degli asset, e puoi usare nodi figli personalizzati che non siano nodi o. In AS3 puoi accedere all'XML del nodo utilizzando E4X. In AS2, il nodo è un oggetto XML2AS.