Português:Recursos

Visão Geral
O outro tipo de node no site.xml é o Asset. Assets pertencem às Páginas, e são arquivos externos associados à página a que pertencem. Usando Assets, o Gaia torna mais fácil o gerenciamento e o acesso a arquivos externos.

Assets de AS2 e AS3

 * NetStreamAsset - arquivos flv ou m4a
 * XMLAsset       - arquivos XML
 * SoundAsset     - arquivos mp3 ou wav
 * StyleSheetAsset - arquivos css

AS3 Assets
Estes assets refletem a hierarquia do DisplayObject AS3.
 * DisplayObjectAsset - Esta é a classe base para assets DisplayObject
 * BitmapAsset       - Imagens carregam como BitmapAssets por padrão (png, jpg, gif, etc.)
 * BitmapSpriteAsset	 - Este é um BitmapAsset que está contido em um Sprite para interatividade.
 * SpriteAsset       - Este asset está incluso para refletir a hierarquia do AS3 DisplayObject.
 * MovieClipAsset    - Por padrão, swfs vão carregar como MovieClipAssets.
 * TextAsset         - Para arquivos .txt e também a classe base para XMLAsset, StyleSheetAsset e JSONAsset
 * JSONAsset         - Para arquivos .json
 * ByteArrayAsset   - For loading raw bytes

AS2 Assets

 * MovieClipAsset - Qualquer coisa que carregue nativamente dentro de um MovieClip (swf, png, jpg, gif, etc.)
 * SoundClipAsset - Swf externo contendo um som embedado(para loops perfeitos)



Como usar Assets
Como padrão, Assets carregam com uma Página como parte do processo de preloading. Este comportamento pode ser ignorado em favor de uma base de assets, se você quiser (veja abaixo).

*** NOTA IMPORTANTE SOBRE O ACESSO DE ASSETS***

O objeto assets não está disponível em uma Página até que transitionIn seja chamada. Isso acontece porque o actionscript no primeiro frame de uma Página carregada é executado antes de que o objeto assets seja associado à Pagina, e muito menos tenha carregado os assets. Espere até que transitionIn seja chamada antes de tentar acessar qualquer asset.

Aqui está um exemplo rápido sobre como os assets são usados.

       

Neste exemplo, a página home tem quatro assets com os ids myMusic, myCopy, myImage e mySWF. Assets se tornam disponíveis para seus page swfs em uma propriedade chamada "assets" no document class da página ou na root timeline do swf da sua página.

O acesso aos assets é feito diretamente por suas ids e a maioria dos métodos nativos desse tipo de Flash asset estão disponíveis diretamente no asset, via Proxy design pattern.

Os Assets no Gaia refletem as classes asset do Flash.

'''Nota: Assets de imagem e swf tem visible = false quando são carregados e posicionados em 0,0. Se você quer que a imagem ou swf apareça no stage, é necessário definir visible = true.'''



MovieClipAsset
Você pode acessar um MovieClipAsset diretamente usando a maioria dos métodos e propriedades de MovieClip nativos do Flash.

Veja um exemplo de sintaxe. Perceba que você pode acessar o asset exatamente como faria com qualquer outro MovieClip.

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

AS3 não requer casting, mas se você quiser escrever no modo strict por code hints e performance, faça cast dos assets para sua interface.

MovieClipAssets usam IMovieClip, images usam IBitmap, sprites usam ISprite, e todos eles são herdados de IDisplayObject. Também é importante notar que a propriedade parent retorna o parent do loader, não do conteúdo.

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); // retorna o parent do loader, não o loader.content // // AS3 também funciona sem casting // assets.mySWF.gotoAndStop(5); assets.myImage.scaleX = 0.5; trace(assets.myImage.parent); // BitmapSpriteAsset.parent retorna o parent do Sprite em que está aninhado.

Em AS3, se é importante manter os arquivos leves, use apenas a interface mais próxima de IAsset que tenha os métodos que você precisa. Por exemplo, se você precisa apenas definir x e y, use IDisplayObject.

Definindo como alvo a timeline dos MovieClipAssets
Se você tem um asset swf e quer definir como target algo em sua document class ou sua timeline, como custom methods, properties, MovieClips, etc., você precisa definir como target a class/timeline diretamente - e pode fazer isso usando a propriedade content, que retorna um MovieClip.

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

Em AS3, você pode fazer cast de um MovieClipAsset como IMovieClip ou não.

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

O mesmo vale para os assets de Página (PageAsset herda a classe MovieClipAsset).

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

ou

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

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



BitmapAsset (somente AS3)
BitmapAsset herda DisplayObjectAsset. Em AS3, qualquer asset de imagem no site.xml - como jpg, gif, ou png - será carregado como BitmapAsset.

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



BitmapSpriteAsset (somente AS3)
Esta é uma versão do BitmapAsset em que você pode adicionar interatividade, pois BitmapSpriteAssets estão dentro de um Sprite container, e o asset fornece um proxy aos métodos de Sprite. Configure como type="sprite" no asset node para transformar um BitmapAsset em um BitmapSpriteAsset.

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



SpriteAsset (somente AS3)
SpriteAsset herda a classe DisplayObjectAsset. SpriteAsset é fornecida por paridade com a estrutura hierárquica do AS3 e não é um tipo de asset configurável. A interface ISprite é usada para manter baixo o tamanho do arquivo caso você não precise dos métodos em IMovieClip.

container
SpriteAsset tem uma propriedade chamada container que tem como alvo o loader de MovieClipAssets e o Sprite container criado para BitmapSpriteAssets. Você vai geralmente usar IBitmapSprite (que herda a classe ISprite).

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



SoundAsset
Um SoundAsset tem os mesmos métodos nativos do objeto Sound no Flash.

Por exemplo, se você quisesse iniciar a execução do mp3 asset com id "myMusic", você poderia usar a seguinte sintaxe na timeline principal do seu clip da página.

AS2 assets.myMusic.start; assets.myMusic.start(4, 5); // se você quiser que inicie em 4 segundos e entre em loop por 5 vezes

AS3 usa a interface ISound.

AS3 ISound(assets.myMusic).play; ISound(assets.myMusic).play(4, 5); // se você quiser que inicie em 4 segundos e entre em loop por 5 vezes

Em AS2, Sound Assets estão configuradas para evento por padrão. Configure o atributo streaming no asset node como "true", para Sound Assets que você quer rodar em streaming. Você também deve definir preload="false" a maioria das vezes, para audio streaming.

Em AS3, não existem eventos de som carregados, então o atributo "streaming" não é usado - todos os Sound Assets são tratados como streaming. Se você definir preload="true", o arquivo de som inteiro será pré-carregado como parte da Página, e não vai rodar até que você diga.

Finalmente, Gaia corrige a limitação nativa do AS2, de não ser apto a fazer loop de sons em streaming, e pertmite que você faça isso definindo o valor dos loops. Leia mais sobre esta funcionalidade na seção Carregamento de Assets sob Demanda abaixo.

SoundAssets tem três métodos auxiliares para tornar as coisas mais simples.

pause
pause(flag:Boolean) Use true para pausar e false (ou nada) para continuar a execução do ponto em que parou.

fadeTo
fadeTo(value:Number, duration:Number, [onComplete:Function]) // AS2 fadeTo(value:Number, duration:Number, onComplete:Function = null) // AS3 Value é o volume para o qual você quer dar fade, duração é o número de segundos do fade, e você tem a opção de passar uma função a ser chamada quando o fade estiver completo.

panTo
panTo(value:Number, duration:Number, [onComplete:Function]) // AS2 panTo(value:Number, duration:Number, onComplete:Function = null) // AS3 Value é o valor de pan para o qual você quer dar o efeito de panning (-100 a 100 em AS2, -1 a 1 em AS3), duração é o número de segundos, e você pode passar uma função que será chamada quando o pan estiver completo.



SoundClipAsset (somente AS2)
Um SoundClipAsset é quase idêntico a um SoundAsset, e tem mais dos mesmos métodos nativosque o Sound Asset. SoundClipAssets são usados principalmente para arquivos mp3 em que você quer um loop perfeito.

Para criar um SoundClipAsset para o Gaia, primeiro você deve criar um novo arquivo Flash e importar seu arquivo de áudio. Defina uma ID para o áudio e ponha o seguinte código na timeline:

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

No site.xml, você precisa configurar o atributo type do asset para "sound". Exemplo:



Isso é tudo que você precisa, e o Gaia vai fazer o resto.

SoundClipAssets se comportam como SoundAssets, com a exceção de que eles não podem ser configurados como streaming. Apesar isso, você pode utilizar exatamente como Sound Assets. Você também pode adicioná-los a SoundGroups.

<br style="clear:both" />

NetStreamAsset
NetStreamAssets têm todos os métodos da classe NetStream disponíveis. Um NetStreamAsset também tem a propriedade "ns" que é a referência à própria instância do NetStream.

Em AS3, NetStreamAssets usa a interface INetStream.

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

Tanto no AS2 como no AS3, NetStreamAssets têm duas propriedades e um método.

duration
get duration:Number Retorna a duração de um NetStreamAsset carregado, extraído de metaData.

metaData
get metaData:Object Retorna o objeto metaData de um NetStreamAsset carregado.

attach
attach(video:Video) Este método auxiliar permite que você passe uma instância de vídeo para attach, e o Gaia faz o attaching do NetStream para o Video.

Somente no AS3, os NetStreamAssets tem quatro propriedades/métodos adicionais.

volume (somente AS3)
get volume:Number set volume(value:Number):void Esta propriedade setter acessa o volume no NetStreamAsset, um floating point value de 0 a 1.

pan (somente AS3)
get pan:Number set pan(value:Number):void Esta propriedade getter/setter acessa o pan no NetStreamAsset, um floating point value de -1 a 1.

fadeTo (somente AS3)
fadeTo(value:Number, duration:Number, onComplete:Function = null) Value é o volume para o qual você quer o fade, duration é o número de segundos para o fade, e você tem como opção passar uma função a ser chamada quando o fade estiver completo.

panTo (somente AS3)
panTo(value:Number, duration:Number, onComplete:Function = null) Value é o valor do pan para o qual você quer um pan to (-100 a 100 em AS2, -1 a 1 em AS3), duration é o número de segundos, e você pode passar uma função a ser chamada quando o pan estiver completo.

<br style="clear:both" />

NetStreamAssetEvent
NetStreamAsset também dispara eventos para o client "events" incluindo onMetaData e onCuePoint. Você pode adicionar um listener para estes eventos ao NetStreamAsset, e o Evento passa a propriedade "info" para uso.

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

Para adicionar o listener ao evento onMetaData, o NetStreamAsset deve estar definido como preload="false", de outra maneira, a metadata já estará disponível no momento em que você pode acessar o asset.

Estes são todos os eventos do NetStreamAsset para os quais você pode adicionar listeners. Consulte a documentação do Actionscript NetStream para mais informações sobre estes eventos. AS3 e AS2 * NetStreamAssetEvent.METADATA * NetStreamAssetEvent.CUEPOINT

somente AS3 * NetStreamAssetEvent.IMAGE_DATA * NetStreamAssetEvent.TEXT_DATA * NetStreamAssetEvent.XMP_DATA

somente AS2 * NetStreamAssetEvent.STATUS

<br style="clear:both" />

XMLAsset
Em AS2, os assets XML tem duas maneiras de acessá-los. Você pode acessar o xml puro na propriedade xml ou como um objeto XML2AS Actionscript na propriedade obj.

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

No AS3, o XML é armazenado na propriedade xml, e você pode usar a sintaxe E4X. AS3 usa a interface IXml.

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

<br style="clear:both" />

StyleSheetAsset
StyleSheetAsset é usado para arquivos .css. Ele contém métodos de proxy para a classe StyleSheet, tem uma propriedade "style" para a instância de StyleSheet, e um método auxiliar, transformStyle, que combina dois métodos nativos de StyleSheet em um único, que retorna um TextFormat.

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

AS3 uses the IStyleSheet interface.

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

<br style="clear:both" />

TextAsset (somente AS3)
TextAsset é usado para arquivos .txt, e também é a classe base para StyleSheetAsset, JSONAsset e XMLAsset. Utiliza a interface IText e tem uma propriedade "text" para o texto puro.

AS3 usa a interface IText.

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

<br style="clear:both" />

JSONAsset (somente AS3)
JSONAsset herda a classe TextAsset e utiliza a interface IJson. Possui uma propriedade "json" que retorna um objeto JSON desserializado, usando a classe com.serialization.json.JSON.

IJson(assets.myJson).json;

ByteArrayAsset (somente AS3)
ByteArrayAsset carrega dados de bytes, que estão disponíveis na propriedade pública "data", que retorna o ByteArray. Um possível uso é carregar os bytes de um arquivo para criar múltiplas instâncias dele, como um Bitmap ou arquivo swf.

IByteArray(assets.myByteArray).data;

<br style="clear:both" />

DisplayObjectAsset (somente AS3)
DisplayObjectAsset herda a classe AbstractAsset, sendo o asset base para SpriteAsset (e consequentemente, MovieClipAsset), BitmapAsset e BitmapSpriteAsset.

<br style="clear:both" />

Carregamento de Assets sob Demanda
No site.xml, ao definir o atributo preload como "false", assets podem ser configurados para que não seja feito o preload com a página, e sim o carregamento por demanda. Para carregar assets on demand, utilize o método load. Você pode carregar por demanda qualquer quantidade de assets de uma só vez, e Gaia automaticamente os enfileira para carregá-los em dois por vez (o número máximo de HTTP requests simultâneos).

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

Em AS3, use a classe de interface apropriada.

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

Sound e NetStream Assets
Assets de Sound e NetStream iniciam imediatamente o streaming quando load é chamado. Se o Sound é um som de evento ou um SoundClipAsset, irá carregar primeiro e executar imediatamente.

load
Sound Assets aceitam dois parâmetros no método load, assim como o método Sound.start.

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

Se o SoundAsset não for streaming, irá carregar o arquivo de som inteiro e então executá-lo. No caso do streaming, irá executar o aruqivo imediatamente. Diferentemente do método (AS2) nativo loadSound, você pode ter o loop de arquivos de áudio em streaming, passando o número de loops que você quer. Por exemplo, este código irá iniciar o streaming de um sound asset e executar em loop por 999 vezes:

assets.myStreamingMusic.load(0, 999);

loadWithoutPlaying
Sound Assets também possuem um método para carregar o arquivo sem executar.

SoundAsset.loadWithoutPlaying;

<br style="clear:both" />

Outros tipos de Assets
Assets de imagem, swf, e xml vão carregar como fazem normalmente, com assets de imagem e swf sendo invisíveis no carregamento.

<br style="clear:both" />

Atributo Progress
Definindo o atributo progress como "true" no site.xml, você pode usar o preloader para mostrar o progresso do carregamento dos assets (isso não funciona para assets de NetStream ou som em streaming). Utilize "false" para não mostrar o progresso. O carregador de asset usa o preloader do site por padrão, mas este comportamento pode ser alterado durante a execução. Leia a documentação do Preloader e API para mais informações.

<br style="clear:both" />

Como Saber Quando um Asset Terminou o Carregamento
Se você quer saber quando um asset já está carregado, associe um listener AssetEvent.ASSET_COMPLETE ao asset. Certifique-se de remover o event listener quando terminar!

AS3

// substitua este IAsset import com qualquer asset interface específica que você esteja usando 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); // accessa seu asset OU event.target, que é também seu 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); // accessa seu asset OU event.target, que é também seu asset }

<br style="clear:both" />

Redefinindo o Objeto Parent do DisplayObjectAssets (somente AS3)
Se você quer colocar um BitmapAsset ou MovieClipAsset dentro de um MovieClip ou Sprite que você criou, espere até que transitionIn seja chamado e use a propriedade loader. myContainer.addChild(assets.myAsset.loader);

Se você quer mudar o parent de um BitmapSpriteAsset ou MovieClipAsset, use a propriedade container. myContainer.addChild(assets.myAsset.container);

<br style="clear:both" />

Outros Usos Para os Assets
Outra forma de utilizar assets é fazer preload e cache dos assets que você quer carregar manualmente. Simplesmente use a propriedade src do asset.

Um exemplo de uso é para sound assets que você quer que permaneçam depois que a página foi embora.

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" />

Accessando Assets nas Outras Páginas
Se você está dentro da timeline de uma página e quer acessar assets em outra página carregada no branch, você tem duas opções.

O caminho recomendado é usar o método API, getPage.

Gaia.api.getPage(branch).assets

sobre o qual você pode ler mais na seção API da documentação.

A outra maneira é acessar as propriedades do parent ou children da página, como:

page.getParent.assets OU page.children.somePageID.assets

<br style="clear:both" />

Preloader Asset
Você pode usar um MovieClipAsset como preloader do site. Na maior parte do tempo, você vai preferir definir depth="preloader" para carregá-lo no nível (depth) correto. É melhor fazer dele um asset de uma page que não irá descarregar (a página index, por exemplo). Se seu MovieClipAsset descarregar, o PreloadController irá reverter usando o preloader padrão do site. Certifique-se de que o MovieClipAsset seja carregado antes de que você ignore o preloader com este asset. Você pode ler mais sobre o assunto na documentação do Preloader.

<br style="clear:both" />

Assets Externos Dinâmicos
Esta é uma técnica avançada e você deve estar completamente familiarizado com o funcionamento dos assets no Gaia antes de usá-la.

Isso torna a criação de galerias de imagem com o Gaia muito mais simples, e permite o uso do AssetLoader ou do mecanismo de preloading do Gaia para listas dinâmicas de assets.

Uma prática recomendada é ter seu arquivo xml com assets como um asset da página index (usando indexFirst="true", veja exemplo abaixo), e chamar addAssets dentro do método transitionIn do index, na página em que você quer adicionar os assets. Você também pode usar addAssets em uma página que já está carregada.

Você pode adicionar os assets sob demanda (preload="false") ou, se quiser carregá-los junto com a página, defina preload="true".

Para usar addAssets, passe uma lista de asset nodes válids e uma reference ao PageAsset ao que você quer adicionar. Gaia vai avisá-lo se você tentar adicionar um asset que já existe em uma página então tenha certeza de que você usa IDs únicos para seus assets externos e não adicione os mesmos assets várias vezes. Adicionar assets em uma página usando addAssets é permanente e não temporário.

Como Utilizar Assets Externos
Gaia.api.addAssets(nodes:XMLList, page:IPageAsset):void // AS3 Gaia.api.addAssets(nodes:Array, page:PageAsset):Void // AS2

Aqui vai um exemplo de como isso funciona:

Exemplo site.xml
<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" />

Como você pode ver, a página index tem um XMLAsset, homeAssets, e indexFirst está definido como true. Isso quer dizer que a página index e o xml serão carregados antes de que o Gaiatente carregar o branch da página home.

<br style="clear:both" />

Exemplo homeAssets.xml
<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" />

Exemplo IndexPage.as
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" />

Explicação
O código acima irá adicionar todos os assets no arquivo homeAssets.xml da Página "home" antes que ela carregue, e irá carregá-los previamente com a página, desde que esses assets sejam adicionados antes que o branch "index/nav/home" seja carregado.

Se você não precisa carregar os assets com a página, use preload="false" em cada nodes de asset externo e você pode carregá-los na classe HomePage, se preferir.

Note que os nodes não precisam ser nomeados como "asset". Você pode ter muitas páginas como asset nodes em um único arquivo xml externo. Apenas passe a lista de nodes que você quer ao método API addAssets e a página a que eles pertencem, e o Gaia irá repetir naquela lista.

<br style="clear:both" />

Atualizar Bytes do Arquivo
Se você quer que o Painel do Gaia atualize o atributo "bytes" para assets externos, você precisa definir assets="true" no asset xml para que o painel o atualize.

<br style="clear:both" />

Mais Informações sobre Assets
Para ver todos os métodos disponíveis aos assets, cheque seus arquivos de classe individuais em com.gaiaframework.assets package. A maioria dos métodos nativos - se não todos - está disponível diretamente.

Em AS3, certifique-se de ver as classes de interface de asset individual, no com.gaiaframework.api pacote.

Você deve utilizar estas interfaces quando fizer casting de assets que você acessa, para manter o tamanho dos arquivos consideravelmente menor.

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
Todos os assets (incluindo Páginas) tem uma propriedade node. Ela contém o xml node da página ou asset no site.xml. Por se tratar de um XML, você pode colocar atributos personalizados na sua página ou asset nodes, além de custom child nodes que não são nodes ou. Em AS3, node é um XML que pode ser acessado via E4X. Em AS2, é um objeto XML2AS.