FlashAS3

Prévia do material em texto

1 
 
 
 
 
 
Flash AS3 
básico 
 
 
 
 
Desenvolvida exclusivamente para o Apostilando.com por 
Marcos Paulo Furlan 
2 
 
ÍNDICE 
ÍNDICE .......................................................................................................................................... 2 
INTRODUÇÃO AO ACTIONSCRIPT......................... ................................................................... 3 
A interface do Flash ........................................................................................ 3 
O PAINEL ACTIONS .................................. .................................................................................. 5 
ACTIONSCRIPT 3 ........................................................................................................................ 7 
Iniciando o AS3 no Flash ................................................................................ 8 
Variáveis ....................................................................................................... 12 
Funções ........................................................................................................ 13 
Propriedades ................................................................................................ 15 
Métodos ........................................................................................................ 18 
Explorando a dot syntax ............................................................................... 27 
URLS E HIPERLINKS ................................. ............................................................................... 33 
ORIENTAÇÃO A OBJETOS COM AS3 ...................... ............................................................... 34 
Conceitos .................................................................................................. 35 
Pacotes ..................................................................................................... 35 
Classes ..................................................................................................... 40 
Propriedades da Classe ............................................................................ 43 
Métodos .................................................................................................... 46 
Método de Construtor................................................................................ 48 
Encapsulamento ....................................................................................... 50 
Operadores ................................................................................................... 50 
Loops ........................................................................................................ 54 
CARREGAMENTO DE ARQUIVOS SWF EXTERNOS ............. ................................................ 56 
Display Object ............................................................................................... 57 
COMPONENTE LIGHTBOX ............................... ........................................................................ 60 
Galeria de fotos com XML ............................................................................ 66 
FLASH MOBILE....................................... ................................................................................... 72 
 
3 
 
INTRODUÇÃO AO ACTIONSCRIPT 
O objetivo dessa apostila é ensinar alguns dos recursos avançados do Flash. 
Quando se fala em “alguns”, pode-se pensar que serão vistos recursos de 
forma superficial, mas com certeza esse não será o caso. O Flash vem através 
de suas versões se aprimorando cada vez mais como ferramenta de criação e 
desenvolvimento para web e aplicações ricas. A partir da versão CS3, trouxe 
junto com ela um amadurecimento de sua linguagem de programação o 
ACTIONSCRIPT para a versão 3 que está estruturada como uma linguagem 
madura e utilizando recursos que somente eram comuns a linguagens como 
JAVA, C E C#. 
Em nossa apostila vamos estudar o flash de forma programável utilizando o 
actionscript 3. 
A interface do Flash 
Ao iniciarmos o Flash ele vai apresentar uma tela com as opções que podemos 
trabalhar com o Flash. 
Na coluna da esquerda temos os arquivos criados mais recentemente. NA 
coluna do meio podemos criar um novo arquivo do Flash. Aqui nessa coluna 
temos a primeira grande mudança, podemos começar nosso projeto focando 
em actionscript3, ou actionscript2. 
Na coluna da direita temos alguns modelos de projeto de arquivos Flash. Isto 
pode mudar um pouco de versão para versão, em nosso curso trabalharemos 
com as versões CS4 e CS5, mas quem utiliza a versão CS3, conseguira 
reproduzir todos os exemplos facilmente. Para quem ainda utiliza a versão 
2004 e 8, não será possível reproduzir os exemplos de actionScript 3. 
 
4 
 
Tela de abertura CS3 
 
Tela de abertura CS4 
5 
 
Tela de abertura CS5 
 
Action Script é a linguagem de programação utilizada no Flash e que possibilita 
que você possa adicionar interatividade complexa, controle de execução e 
exibição de dados num documento Flash. 
O PAINEL ACTIONS 
Para podermos aplicar os códigos action Script em nosso projeto é necessário 
utilizarmos o painel actions. Você pode chamar o painel actions através do 
menu, window actions, ou através da tecla de atalho F9 – opção recomendada. 
6 
 
O painel Actions divide-se em duas partes, na esquerda temos uma biblioteca 
de ações. Você pode observar que no topo temos o nível de action script que 
estamos utilizando e na direita temos a janela de código. 
Na parte superior da parte direita do painel de ações temos alguns botões, 
vamos ver os principais: 
 Permite adicionar ações de acordo com a sua necessidade. 
 
 Permite localizar uma palavra dentro do código 
 Insert a target path – Permite adicionar ao código um objeto ou variável 
criada. 
7 
 Verificador de sintaxe – verifica se existe algum erro de sintaxe do 
código. Caso ocorra algum erro ele dará um erro e o mesmo será mostrado 
na barra Compiler erros no rodapé do Flash 
 
 É um habito correto, ao se desenvolver qualquer código sempre trabalhar 
com endentação de níveis, deixando assim o código mais organizado, mas cós 
você não o tenha feito durante a digitação dos códigos, você pode usar esse 
botão para reorganizar o código para você. 
 Permitem adicionar comentários de bloco (/* texto do comentário */), 
comentário de linha (// texto do comentário) e remover os comentários. Todos 
os nossos códigos terão comentários. Esse é um bom costume de ser ter ao 
criar seus códigos, pois torna fácil o entendimento do que se está fazendo. 
 Esse botão liga / desliga o assistente de código do Flash. Em 
nosso curso vamos trabalhar com ele praticamente desligado. Vamos nós 
mesmos digitar os nossos códigos. 
 
ACTIONSCRIPT 3 
Uma das principais diferenças entre o Actionscript 3.0 e as versões anteriores, 
é que antes existiam diversas opções de onde colocar os códigos - por 
exemplo: timelines, movieclips, botões, arquivos de Actionscript externo e 
classes. Enquanto que o Actionscript 3.0 é totalmente baseado em classes, 
onde os códigos são colocados em métodos (funções) da classe. 
Nesta versão foram introduzidos novos recursos: 
• Verificação de tipos em tempo de compilação e de execução: os tipos 
são agora preservados em tempo de execução. O Flash Player faz 
verificação de tipos no momento da execução. Estas informações de tipo 
também são utilizadas na máquina virtual para melhorar desempenho e 
8 
reduzir uso de memória. 
• Exceções em tempo de execução: Erros em tempo de execução 
disponibilizam estado da pilha ("stack traces") com indicação de arquivo 
fonte e número de linhas, como em java, para rápida identificação de 
onde o erro foi gerado. 
• Separação do sistema de herança de classes do sistema de herança de 
prototipação utilizado na versão anterior: Vários recursos que antes 
eram disponibilizados por funçõesde biblioteca foram incluídos na 
linguagem. 
• Classes seladas: o comportamento padrão é que as classes não podem 
ser estendidas em tempo de execução, melhorando a alocação de 
memória e mantendo a aplicação mais segura. Classes dinâmicas 
podem ser utilizadas se definidas com o modificador dynamic. 
• Suporte a pacotes (package), como em Java, namespaces. 
• Métodos com Closure: as closures nos métodos guardam o estado dos 
objetos da qual originaram. 
• A API do flash player foi reorganizada em packages 
• Sistema unificado de tratamento de eventos baseado no Document 
Object Model. 
• Integração do ECMAScript para XML (chamada E4X). A antiga API, da 
versão 2.0, ainda existente. 
• Acesso direto à lista de componentes do Flash em tempo de execução, 
permitindo controle completo em ActionScript. 
• Implementação da especificação do ECMAScript (quarta edição). 
• Expressões regulares: suporte nativo à expressões regulares. 
• Novos tipos primitivos numéricos: int (com sinal) e uint (sem sinal), 
ambos com 32 bits. 
Iniciando o AS3 no Flash 
O primeiro cuidado ao se trabalhar com AS3 no Flash é ao abrir um projeto, 
escolher a opção Flash File (ActionScript 3). 
9 
 
Não é possível no mesmo arquivo Flash trabalhar com AS2 e AS3. 
Vamos a um exemplo inicial básico. Insira um objeto qualquer no palco de seu 
filme. 
Crie uma nova camada e nomeie-a como AS. 
 
10 
Clique no primeiro frame da camada AS e pressione F9 para chamar o painel 
de ações. 
Na esquerda do painel de ações, já é possível observar que a quantidade de 
opções aumentou e muito em relação ao AS2. 
 
ActionsScript 2 
11 
 
ActionScript 3 
Vamos então testar nosso primeiro AS3. Para não perder o costume adicione a 
seguinte action: 
Trace(“Olá Mundo!); 
Lembrando sempre que por se tratar de um string dentro do trace coloque-a 
entre aspas, caso contrário será apresentada uma tela de erro. 
Depois pressione CTRL+ENTER e observe a janela de output. 
 
Caso queira colocar comentários em seus códigos pode seguir a mesma lógica 
do As. 
//comentário de uma linha 
/* comentário de bloco 
Utilize este comentário quando o mesmo for longo*/ 
12 
Variáveis 
Uma variável é um objeto capaz de reter e representar um valor ou expressão. 
Enquanto as variáveis só existem em tempo de execução, elas são associadas 
a “nomes” chamados identificadores, durante o tempo de desenvolvimento. 
As variáveis primitivas são: String, Number, int, uint, Boolean, void e Undefined. 
As variaveis complexas são: Array, Date, Error, Function, RegExp, XML e 
XMLList. 
No AS2 , muitas vezes não era necessário dizer ao Flash que tipo de variável 
estávamos usando, esta passa a ser uma obrigação no AS3 
Ao digitar a chamada var, definir o nome da mesma e pressionar dois pontos(:), 
o Flash já trás todas as possíveis opções de preenchimento 
 
Vamos definir a primeira variável como um String 
var boneco:String=”Flash”. 
Depois adicione outras variáveis como no exemplo abaixo 
 
13 
 
Funções 
Função é basicamente um código usado para uma série de execuções. 
Aproveitando do exemplo anterior monte a seguinte função: 
 
function bonequinho (){ 
//cria a variável do tipo Number e faz o calculo 
 var carga:Number=(calculo+calculo); 
 //testa a função 
 trace(carga); 
} 
//chama a função 
bonequinho() 
Observe que foi necessário após o fechamento das chaves chamar a função. 
Podemos também fazer nossos cálculos na chamada da função. 
Veja o exemplo: 
 
14 
//criando a função e atribuindo argumentos 
function calcular(item1,item2){ 
 var somar:Number=item1+item2; 
 trace(somar); 
} 
calcular(4,5) 
calcular(6,8) 
calcular(calculo,calculo) 
Outra forma de se mostrar os valores de uma função seria; 
 
//criando a função e atribuindo argumentos 
function calcular(item1,item2){ 
 var somar:Number=item1+item2; 
 return somar; 
} 
trace(calcular(4,5)); 
trace(calcular(6,8)); 
trace(calcular(calculo,calculo)); 
 
Eu posso forçar a função a somente trabalhar com um tipo de argumento. 
Adicione a sua função o seguinte. 
15 
 
 
Propriedades 
Através das propriedades, podemos alterar, as dimensões, visibilidade, 
posicionamento de nossos objetos. 
Inicie um novo arquivo Flash e importe alguns elementos dentro do palco na 
camada principal, renomeie a camada para objetos, depois crie uma nova 
camada chamada AS. 
Converta seus objetos para Movie Clips e instancie-os. 
 
Acrescente as seguintes ações. 
16 
 
Observe que no AS2, para atribuir as propriedades a um objeto, usava-se um 
underline: _width. No AS3 não é mais utilizado. 
Para o CS5 vamos criar uma função que modifica suas propriedades. 
17 
 
Pode-se alterar também o fade de vários objetos de uma única vez. 
 
Observe que na função foi definido o argumento fade do tipo Number, e como 
18 
ele não possui um valor, atribui-se :void ao final, isto permite o retorno vazio da 
função. 
 
Métodos 
Métodos são funções que fazem parte de uma definição de classe. Depois que 
uma ocorrência da classe é criada, um método é ligado a essa ocorrência. Ao 
contrário de uma função declarada fora de uma classe, um método não pode 
ser usado à parte da ocorrência à qual ele está anexado. 
Os métodos são definidos usando a palavra-chave function. Assim como em 
qualquer propriedade de classe, você pode aplicar atributos de propriedade de 
classe a métodos, incluindo um espaço para nome privado, protegido, público, 
interno, estático ou personalizado. 
 
Inicie um novo arquivo AS3. 
Crie uma camada AS e nomeie uma camada objetos. 
Na camada objetos adicione uma imagem, três botões e uma animação 
qualquer. 
 
19 
 
 
Instancie os elementos de seu filme. A animação quadrado_mc para a imagem 
será boneco_mc, os botões serão verde_btn, cinza_btn e red_btn. 
Se você chamar o painel de ações e depois ir até flash.display, Movie Clip abrir 
20 
Methods, você terá as seguintes opções: 
 
Vamos usar um método que já existia no AS 2 o gotoAndStop. 
No seu painel de ações adicione. 
quadrado_mc.gotoAndStop(20); 
Ao pressionar CTRL+ENTER, ele vai rodar a animação até o quadro 20 e para 
a mesma. 
Vamos acrescentar ações aos nossos botões, pelo painel de ações as 
possibilidade de ações nos botões estão mais abaixo na categoria Simples 
Button. 
21 
 
Vamos adicionar ações em nossos botões, para isso no painel de actions, abra 
a pastinha events. 
 
Então no painel de ações adicione: 
//cria a função para clicar no botão e cria a variá vel do tipo Evento 
//adicione void para não haver retorno 
function clicar(evt:Event):void{ 
 trace("o botão verde foi clicado") 
 
} 
Até o momento ela não faz nada, é preciso acrescentar o método 
addEventListener. 
22 
 
 
 
Desta forma vai aparecer no painel output a frase dentro de sua função. 
Caso queira mudar a função para que seja possível detectar qual botão foi 
clicado. 
Mude a função da seguinte forma: 
23 
 
 
O código fica da seguinte forma: 
//cria a função para clicar no botão e cria a variá vel do tipo Evento 
//adicione void para não haver retorno 
function clicar(evt:Event):void{ 
 trace("o botão "+evt.target.name +" foi clicado") 
} 
//Adicionando o Método addEventListener 
//Adicionado o evento MouseEvent 
//O seu método CLICK 
//e a função a ser chamada "clicar" 
verde_btn.addEventListener(MouseEvent.CLICK,clicar) ; 
cinza_btn.addEventListener(MouseEvent.CLICK,clicar) ; 
red_btn.addEventListener(MouseEvent.CLICK,clicar); 
 
Vamos adicionar ao nosso código uma nova função para que o botão verde 
controle a animação dos quadrados. 
24 
 
Vamos acrescentar que ao clicar no botão cinza ele diminua a dimensão da 
imagem. 
 
//função para mudar as dimensões da imagem 
function imagem(evt:Event):void{ 
 //faz com a dimensão de boneco diminua em 10% em c ada clique 
 boneco_mc.scaleX=boneco_mc.scaleX-.1; 
 boneco_mc.scaleY=boneco_mc.scaleY-.1; 
} 
//Evento no clique dobotão 
cinza_btn.addEventListener(MouseEvent.CLICK,imagem) ; 
 
Vamos trabalhar agora com textos dentro deste nosso exemplo. 
As opções de scripts para textos estão em flash.text . 
25 
 
Vamos então criar uma caixa de texto dinâmico e instanciar ela como texto_txt. 
 
Vamos acrescentar então uma ação ao botão vermelho para escrever dentro 
de nossa caixa de texto. 
Primeiro cria função que permite escrever dentro da caixa de texto. 
//cria a função para escrever dentro da caixa de te xto 
function caixatxt(evt:Event):void{ 
 //escrevendo na caixa de texto. 
 texto_txt.text="Adobe Master Suite CS5"; 
} 
26 
Vamos acrescentar mais uma linha onde ele redimensione a caixa de texto 
conforme o conteúdo a ser adicionado. 
Este recurso é a propriedade autoSize . 
 
Se você clicar na propriedade e no canto superior direito do painel de ações 
clicar no ponto de interrogação, abre-se a janela de ajuda do Flash, mostrando 
a utilização da ação. 
 
Vamos usar a propriedade 
Ela aumenta a dimensão da caixa a partir da esquerda. 
//cria a função para escrever dentro da caixa de te xto 
27 
function caixatxt(evt:Event):void{ 
 //escrevendo na caixa de texto. 
 texto_txt.text="Adobe Master Suite CS5"; 
 //Ajustando o tamanho da caixa de texto conforme o conteúdo 
 texto_txt.autoSize=TextFieldAutoSize.LEFT; 
} 
Para finalizar, abaixo de nossa função, vamos fazer a chamada para o botão. 
//escrevendo na caixa de texto 
red_btn.addEventListener(MouseEvent.CLICK,caixatxt) ; 
 
 
 
Explorando a dot syntax 
No ActionScript, você usa um ponto ( . ) operador (sintaxe de ponto) para 
acessar propriedades ou métodos que pertencem a um objeto ou uma instância 
no Palco. Você também pode usar o operador ponto para identificar o caminho 
de destino para uma instância (por exemplo, um clipe de filme), variável, função 
ou objeto. 
Abra o arquivo relógio.fla que está dentro de nosso DVD. 
Nossos botões já estão instanciados como play_btn e stop_btn, o retângulo 
de cima está instanciado como painel_mc e o debaixo como painelbx_btn 
Crie uma camada de ações em seu filme. 
No primeiro frame desta camada adicione uma ação stop(); para que o filme 
fique parado no primeiro frame. 
O botão, Inicio como o próprio nome diz tem como objetivo que ao ser clicado 
inicie o relógio. Então na sua camada de ações coloque o seguinte: 
28 
 
Isso faz com que ao ser clicado o botão inicio dispara a Timeline. 
Processo simples, mas extremamente importante. 
Vamos adicionar também a função para parar a Timeline. 
 
A função é semelhante, mas ao invés de play(), usa-se stop(), é necessário 
também mudar o nome da função a ser criada e colocar este nome na 
chamada da função. 
Abra a bilioteca de símbolos e observe que ali temos um símbolo chamado 
relógios. Arraste uma instância dele para o palco na camada relógios. 
 
Instancie ele como nvrelogio_mc 
A ação que fizemos da um play na Timeline. Vamos adicionar as funções 
existentes uma ação que de play e stop no relógio que é um Movie Clip. 
Vamos alterar nossas ações da seguinte forma. 
29 
 
Para parar o processo é muito semelhante 
 
Pela biblioteca de símbolos, arraste o botão reiniciar para o palco na camada 
de botões. 
Instancie ele como reiniciar_btn. 
O objetivo deste botão é que ele volte ao primeiro frame da Timeline e do MC 
relógio e pare. 
 
Adicione a seguinte ação: 
 
Como o objetivo deste capítulo é trabalhar a sintaxe de pontos, dê um duplo 
clique no painel de baixo, na camada clock adicione mais uma instância do MC 
relógios e diminua seu tamanho para ficar dentro do retângulo. 
Instancie ele também com o nome de nvrelogio_mc. 
30 
 
Ao testar o filme e clicar nos botões de iniciar, parar e reiniciar, este relógio 
mesmo tendo o mesmo nome de instância que a versão maior não obedece 
aos comandos. Isto ocorre porque ele embora tenha o mesmo nome de 
instância. Para que ele receba os comandos é preciso dizer ao Flash qual o 
caminho do MC. 
Então este nvrelogio_mc está dentro do Movie Clip painelbx_mc , será 
necessário mostrar este caminho ao Flash. 
Então vamos alterar nossas ações da seguinte forma. 
31 
 
Selecione os três botões na timeline principal, recorte-os, de um duplo clique 
no MC painel e cole-os dentro deixando conforma a imagem. 
 
Será necessário então alterar o código actionscript, pois agora os botões estão 
dentro de um Movie clip. 
32 
 
Será necessário repetir o mesmo comando para as demais funções. 
O código completo ficou da seguinte forma. 
stop(); 
//cria função para iniciar o relógio 
function iniciar(evt:Event):void{ 
 play(); 
 //inicia o movimento no MC relogio 
 nvrelogio_mc.play(); 
 //inicia o MC que esta dentro do MC painelbx_mc 
 painelbx_mc.nvrelogio_mc.play(); 
} 
//adiciona função ao botão play_btn 
painel_mc.play_btn.addEventListener(MouseEvent.CLIC K,iniciar); 
 
//cria função para parar o relógio 
function parar(evt:Event):void{ 
 stop(); 
 //para o movimento do MC relógio 
 nvrelogio_mc.stop(); 
 //inicia o MC que esta dentro do MC painelbx_mc 
 painelbx_mc.nvrelogio_mc.stop(); 
} 
//adiciona função ao botão play_btn 
painel_mc.stop_btn.addEventListener(MouseEvent.CLIC K,parar); 
 
33 
//cria função para reiniciar a animação parada 
function reiniciar(evt:Event):void{ 
 //retorna ao frame da timeline principal 
 gotoAndStop(1); 
 //retorna ao frame do MC 
 nvrelogio_mc.gotoAndStop(1); 
 //reinicia o MC que esta dentro do MC painelbx_mc 
 painelbx_mc.nvrelogio_mc.gotoAndStop(1); 
} 
//adiciona a função reiniciar ao botão 
painel_mc.reiniciar_btn.addEventListener(MouseEvent .CLICK,reiniciar); 
 
URLS E HIPERLINKS 
Uma das maiores mudanças em relação ao acrionscript 2 foi como chamar 
uma URL. 
No As2 bastava getURL( http://www.apostilando.com,””) ;. Agora no AS3 a 
coisa ficou um pouco mais complicada. Ficaria da seguinte forma: 
Em um novo filme do Flash com AS3, crie um Movie Clip e o instancie como 
“botao_mc”. 
Depois crie uma nova camada de ações e adicione o seguinte código: 
//cria o evento de clicar no botão e chama a função 
botao_mc.addEventListener(MouseEvent.CLICK, minhaUR L); 
//cria a função 
function minhaURL(event: MouseEvent) { 
 //cria a variável de requisição da URL e define o link 
var request:URLRequest = new 
URLRequest("http://www.apostilando.com"); 
// como deve ser a navegação 
navigateToURL(request,"_blank"); 
} 
Caso você queira abrir a URL durante a navegação pela Timeline, você pode 
usar: 
34 
//importa as classes de navegação 
import flash.net.URLRequest; 
import flash.net.navigateToURL; 
/* 
 * Navega para página definida em url. 
* @param String url Caminho da página. 
 * @return void 
 */ 
function gotoURL(url:String):void 
{ 
 // Objeto URLRequest. 
 var rURL:URLRequest = new URLRequest(url); 
 // Navega para a url do objeto URLRequest. 
 navigateToURL(rURL, '_blank'); 
} 
gotoURL("http://www.apostilando.com"); 
 
ORIENTAÇÃO A OBJETOS COM AS3 
Até o momento em nosso curso de AS3 vimos algumas situações essenciais 
para trabalhar com AS3 no Flash, porém não foi visto nada que não poderia ser 
feito de forma mais fácil com AS2, então você pode estar se perguntando, que 
vantagem se tem em utilizar o AS3 para chegar ao mesmo resultado AS2, 
sendo que da mais trabalho. A principal vantagem de se utilizar o AS3 é que 
ele permite um código mais correto e melhor estruturado respeitando normas e 
regras de codificação. 
Ele está mais Orientado a Objetos e a partir deste capítulo vamos entender um 
pouco mais como o Flash se comporta. É um capitulo de nosso curso bem 
teórico, mas que lhe dará todo um suporte para exemplos reais de Flash com 
AS3 e Flex / Flash Builder. 
A orientação a objetos, também conhecida como Programação 
35 
Orientada a Objetos (POO), ou ainda em inglês Object-Oriented Programming 
(OOP) é um paradigma de análise, projeto e programação de sistemas desoftware baseado na composição e interação entre diversas unidades de 
software chamadas de objetos. Para saber mais 
(http://pt.wikipedia.org/wiki/Orientação_a_objetos.) 
Conceitos 
O Flash trabalha com vários conceitos, alguns inclusive já vistos, mas que são 
de extrema importância. 
Tipo de Dados : O tipo de informação que uma variável pode armazenar. 
Ocorrência : Um objeto real criado em um programa 
Classes Incorporadas : São classes existentes dentro do AS3, todas derivam 
da classe Object. 
Hierarquia de Classes : A estrutura de várias classes relacionadas, 
especificando as classes que herdam funcionalidade de outras classes. 
Exemplos de variáveis: 
 
Pacotes 
Pacotes (packages) é um conjunto de classes. Na verdade, é uma pasta, a 
parte do conjunto. Então, a grosso modo, um pacote é uma pasta com um 
monte de classes dentro. 
Crie um arquivo AS3 e salve-o com o nome de pacote . 
Inicie agora um arquivo Actionscript File. 
36 
 
Observe que este arquivo é muito semelhante a janela de actions, pois esta é a 
sua função, a inserção de scripts que serão posteriormente chamados dentro 
do filme principal. 
Vamos criar um exemplo simples para teste 
Dentro de seu arquivo de actionscript digite: 
 
Salve seu arquivo como Externa. O arquivo será salvo com a extensão AS. 
Sempre salve seu arquivo com o nome de sua função, classe, etc. 
Ainda precisamos adicionar ao código que ele poderá ser acessado em 
qualquer nível do código. Então antes de function acrescente public . 
37 
 
Como ele é um elemento público, é necessário acrescentar ele dentro de 
pacotes para que possa ser acessado. Altere o seu código da seguinte forma. 
 
Observe que no exemplo eu não adicionei um nome ao pacote (package), por 
se tratar de um exemplo simples, esta foi minha opção, porém mais a frente 
vamos trabalhar com nomes de pacotes para evitar assim códigos confusos. 
Retorne agora ao seu arquivo Flash e para chamarmos a função que está em 
nosso arquivo Actionscript basta colocar no painel de ações: Externa(); 
 
Observe no painel de Output que ele carrega a String que temos em nossa 
função. 
Crie um novo arquivo ActionScript file e nele vamos criar um novo pacote com 
uma variável do tipo Number. 
38 
 
Observe no exemplo acima que eu dei um nome para meu pacote, então ao 
salvar este exemplo, o mesmo deverá estar dentro de uma pasta chamada 
variáveis. Ao salvar o arquivo então, crie antes uma pasta variáveis e salve seu 
arquivo dentro dela. 
 
Observe também que o nome do arquivo deve ser o mesmo de sua variável. 
Para que este pacote consiga ser mostrado no arquivo do Flash precisamos 
importar o mesmo para dentro do nosso arquivo. Volte ao seu arquivo Flash e 
no painel de ações digite. 
39 
 
Pressione CTRL+ENTER para ver o resultado na janela de Output. 
Um cuidado importante ao se trabalhar com nomes de arquivos, 
variáveis, funções etc. no Flash é que ele é Case Sensitive, ou seja, ele 
diferencia maiúsculas de minúsculas, se você adicionar um nome de função 
com inicial maiúscula mantenha no nome de seu arquivo AS e também na 
chamada da função. 
Quando você ter muitos arquivos As em um único pacote, e precisar trabalhar 
com eles no mesmo arquivo, você pode usar : import nomedopacote.*; 
Vamos a outro exemplo. 
 
Crie um novo arquivo AS e adicione o seguinte código 
 
Para salvar seu arquivo AS, será necessário criar a estrutura de pastas para 
podermos acessar ao arquivo. 
40 
 
Vamos chamar o pacote dentro de nosso filme. 
 
Pressione CTRL+ENTER e veja o resultado na janela de Output. 
Classes 
Classe é o fundamento da programação orientada a objetos. Elas oferecem um 
modo simples e organizado para organizar métodos e atributos. Podemos dizer 
que, sem classes, não há OOP. 
Elas armazenam informações sobre os tipos de dados que um objeto pode 
manter e os comportamentos que um objeto pode exibir. O caminho da pasta 
do arquivo que contém a classe deve obedecer a hierarquia dos pacotes. Cada 
41 
arquivo poderá ter apenas uma classe pública. 
Vamos entender melhor como funcionam as classes, crie um novo arquivo AS3 
Salve seu arquivo e inicie um novo arquivo ActionScript File (Menu File, New). 
 
Vamos inicialmente criar o nosso pacote. 
 
Vamos gora criar a nossa classe publica 
42 
 
 
Vamos salvar nosso arquivo. Deve-se obrigatoriamente respeitar a estrutura de 
pastas de nosso pacote. 
 
No seu arquivo Flash, vamos importar a classe criada, mesmo que ela não 
contenha nada. 
Abra o painel de ações e digite: 
43 
 
Observe que é necessário importar todo o caminho de nosso pacote e chamar 
a classe criada. Para criar um objeto desta classe acrescente ao código 
 
Desta forma através da variável, poderemos manipular a nossa classe. 
Propriedades da Classe 
São os membros de uma classe declarados em seu corpo como variáveis ou 
constantes, ou membros definidos por métodos como getter ou setter. 
A declaração de uma propriedade é feita declarando uma variável ou 
constante. As propriedades de ocorrência de uma classe serão acessadas 
através do operador ponto. 
Dentro da construção de nossa classe. Adicione a ela as variáveis 
 
Salve seu arquivo e vamos agora para nosso arquivo Flash 
Vamos agora adicionar valores as nossas variáveis. 
44 
 
Vamos testar se a classe está sendo carregada corretamente. 
 
 
Podemos aplicar as nossas classes modificadores de acesso para as 
propriedades. 
Eles podem ser: 
Internal: Visivel dentro do mesmo pacote 
Private: Visivel para referências na mesma classe 
Protected: Para a mesma classe e para classes derivadas 
Public: Todos e lugares 
Static: Especifica que uma propriedade pertence à classe, e não às suas 
45 
ocorrências. 
Exemplos: 
 
private var Nomedavariavel:String; 
static var Nomedavariavel2:Number; 
public var Nomedavariavel3:Boolean; 
 
Vamos criar em nossa classe uma variável estática. Abra seu arquivo de classe 
e adicione a seguinte linha de código. 
 
Porém para que eu possa acessar esta variável no meu exemplo FLA, ela 
precisa também ser publica, então adicione ao seu código: 
46 
 
Vamos ao Flash, e vamos adicionar valores a esta variável estática. 
 
Você pode observar que atribuímos o valor a classe e não a variável criada. 
Métodos 
São funções que fazem parte de uma definição de classe. Depois que uma 
ocorrência da classe é criada, um método é ligado a essa ocorrência. Ao 
contrário de uma função declarada fora de uma classe, um método não pode 
ser usado à parte da ocorrência à qual ele está anexado. 
 
47 
Declarando um método: 
function Metodo( ):void{ 
... 
} 
Vamos criar então um função publica em nossa classe. Retorne ao seu arquivo 
AS e adicione as seguintes linhas de comando. 
 
Para executar o método no arquivo FLA, abra o painel de ações de nosso 
exemplo e adicione. 
 
48 
 
 
Método de Construtor 
Os métodos de construtor, às vezes chamados simplesmente de construtores, 
são funções que compartilham o mesmo nome da classe na qual eles são 
definidos. Qualquer código incluído em um método de construtor é executado 
todas as vezes que uma ocorrência da classe é criada com a palavra-chave 
new. 
Os métodos de construtor podem ser apenas públicos, mas o uso do atributo 
public é opcional. Você não pode usar nenhum dos outros especificadores de 
controle de acesso, inclusive private, protected ou internal, em um construtor. 
Você também não pode usar um espaço para nomes definido pelo usuário com 
um método de construtor. 
Abra seu arquivo AS e vamos criar nosso método construtor, lembre-se apenas 
que ele deve ter sempre o mesmo nome da classe. 
49 
 
Com isto podemos alterar o código em nosso arquivo FLA. 
Abra seu código e comente as seguintes linhas 
 
Os valores desta parte serão passados então como parâmetros. 
50 
 
Com isto eu poderia retirar o comando public de minhas variáveis no arquivo 
AS, por uma questãomais correta eu poderia substituir public por internal. 
Encapsulamento 
Encapsulamento, é o que torna sistemas com Orientação a Objetos flexíveis, 
adaptáveis, com partes independentes. 
A idéia consiste em dividir o sistema no maior número de partes possíveis e 
que cada uma dessas partes sejam isoladas e de certa forma independentes. 
Operadores 
Operadores são elementos dentro de linguagens de programação para 
manipular dados. 
O ActionScript 3.0 possui uma série de operadores, eu vou citar os principais: 
 
Operadores de Acesso 
. ponto 
O operador ponto é utilizado para acessar caminhos, objetos, propriedades, 
métodos e eventos. 
É de longe o operador mais utilizado no ActionScript, pois sempre que 
queremos disparar alguma ação a um objeto ou programar um evento, 
51 
utilizamos o operador ponto freqüentemente. 
Exemplos: 
 // Acesso a propriedade x do objeto instanciado como mBTN 
 mBTN.x=400; 
 // Acesso ao texto_txt, que está dentro de botao1, que está dentro de menu 
 menu.botao1.texto_txt; 
 
[] colchetes 
O operador colchetes tem 2 utilidades principais: 
* Acessar elementos dentro de um Array (Array é um tipo de dado que permite 
vários valores dentro de uma mesma variável, esses valores são identificados 
por sua posição numérica) 
// Declaração de um Array com nomes 
var nomes:Array=new Array(“Danilo Santana”, “Fábio Ricotta”, “Juliano 
Haussen”); 
// Resgate da posição 1 >> Fábio Ricotta pois os índices começam do 0 
nomes[1]; 
* Acessar objetos dinâmicos quando há uma expressão a ser resolvida ou o 
objeto é criado dentro de um laço por exemplo 
 
// Declara a variável contador valendo 0 
var contador:uint=0; 
// Acessa o botao0 dentro do escopo atual 
this["botao"+contador]; 
 
Operador de Atribuição 
= igual 
O operador igual atribui um valor a uma variável, ou então define a herança do 
objeto. 
Exemplo: 
// Declara uma variável nome 
var nome:String; 
52 
// Atribui valor a variável 
nome=”Danilo Santana”; 
// Declara uma variável carregador 
var carregador:Loader; 
// Define a herança com a classe Loader 
carregador= new Loader(); 
 
Operadores Matemáticos 
+ mais 
O operador mais serve para somar valores numéricos ou concatenar strings. 
Exemplo: 
// Soma 2 com 2. Tipos numéricos, retorno 4 
2+2; 
// Concatena 2 com 2. Tipo string, retorno “22” 
“2″+”2″; 
 
- menos 
O operador menos serve para subtrair valores de expressões matemáticas. 
Exemplo: 
// Declara a variável valor 
var valor:uint=50; 
// Subtrai 15 de valor. Retorna 35 
valor – 15; 
 
++ incremento 
O operador incremento aumenta o valor da variável em 1 a cada execução. 
Exemplo: 
// Declara a variável contador 
var contador:uint=0; 
// Incrementa a variável em 1. Retorna 1 
contador ++; 
// Incrementa a variável em 1. Retorna 2, já que já foi incrementado 1 
53 
contador ++; 
 
+= auto incremento 
O operador auto incremento, incrementa a variável de acordo com o valor 
passado. 
Exemplo: 
// Declara a variável temperatura 
var temperatura:int=-10; 
// Auto incrementa a variável com 40. Retorno 30 
temperatura += 40; 
 
Operadores de Comparação 
== é igual 
O operador é igual compara se um valor é igual a outro, não confundir com o 
operador de atribuição que é um igual simples. 
Exemplo: 
// Compara se 10 é igual a 20. Retorno falso 
10 == 20 
 
!= diferente 
O Operador diferente também compara valores mas retorna verdadeiro se a 
comparação retornar diferença nos valores. 
Exemplo: 
// Compara se 10 é diferente a 20. Retorno verdadeiro 
10 != 20 
> maior que 
O operador maior que compara dois valores e retorna verdadeiro ou falso. 
Exemplo: 
// Declara uma variável contagem e uma passadas 
var contagem:uint = 0; 
var passadas:uint = 1; 
// Compara se passadas é maior que contagem. Retorno verdadeiro 
54 
passadas > contagem; 
Loops 
Loops são estruturas de código que podem executar um bloco de ações 
repetidas vezes de maneira automatizada e em um curto espaço de tempo. 
 
Vamos aos principais tipos de loops no Flash. 
Estrutura de Repetição FOR 
Seguramente o tipo de loop mais utilizado, pois tem uma sintaxe e um controle 
muito facilitados. 
O FOR executa um bloco de ações de acordo com uma expressão a ser 
resolvida para definir quantas vezes esse bloco de ações será executado. 
Sintaxe 
for (inicio; limite; incremento) 
{ 
bloco de ações a serem executadas. 
} 
 
Nós utilizamos muito o FOR para criação de tarefas automáticas e que 
exigiriam códigos muito repetitivos. 
Exemplo 
for (var i:uin = 0; i < 5; i ++) 
{ 
trace (i); 
} 
Fazendo a leitura de interpretação desse código nós temos o seguinte: 
Cria uma variável uint valendo 0, com incremento de 1 em 1 (i++) e enquanto 
essa variável for menor que 5 executa o escopo, executa o que estiver dentro 
das chaves. 
No caso um trace de i. 
O método trace exibe no painel output o valor de i a cada execução do for 
enquanto a condição de limite for verdadeira. 
O retorno desse código é : 0, 1, 2, 3, 4 
55 
0 porque o primeiro valor de i é 0 de acordo com a minha declaração, e até 4 
porque quando i vale 5 ele não é menor que 5, ele seria menor igual, o que não 
é o caso. 
Então de forma resumida esse é o papel do FOR executar um bloco de código 
de acordo com uma expressão de limite. 
 
Estrutura de Repetição While 
O loop while trabalha com uma expressão simples sem possuir o incremento a 
variável dentro de sua declaração 
Sintaxe 
while (limite) 
{ 
bloco de ações 
} 
Exemplo 
// Declara a variável contador 
var contador:uint = 0; 
// Enquanto contador for menor que 5 executa o bloco de ações 
while (contador < 5) 
{ 
trace (contador); 
// Depois de exibir o contador atual, incrementa seu valor em 1 
contador ++; 
} 
 
Estrutura de Repetição Do While 
O loop do while também trabalhar com uma expressão simples de limite porém 
independentemente se a expressão for verdadeira o bloco de código sempre 
vai ser executado pelo menos uma vez. 
Sintaxe 
do 
{ 
56 
bloco de ações 
}while (limite) 
Exemplo 
// Declara a variável contador 
var contador:uint = 0; 
// Executa uma vez o bloco de código 
do 
{ 
trace (contador) 
// Avalia a expressão de limite e caso ela seja verdadeira executa o bloco de 
código novamente. 
} while (contador < 5) 
 
Em linhas gerais não há muito diferença entre os loops no que diz respeito a 
velocidade de execução ou consumo de processamento, então a escolha de 
qual utilizar beira a preferência pessoal do desenvolvedor. 
Com isso terminamos a parte teórica de nosso estudo do AS3, embora seja 
uma parte “chata” é de extrema importância para se entender os próximos 
exemplos do curso de AS3 e do módulo de Flash Builder (antigo Flex). 
CARREGAMENTO DE ARQUIVOS SWF EXTERNOS 
Com o As3 não é mais possível carregar um arquivo externo com LoadMovie. 
Crie um arquivo qualquer e salve-o como “carregado”. Pressione 
CTRL+ENTER para gerar o SWF. 
Crie um novo documento. Crie uma nova camada de nomeie ela para AS. 
Adicione o seguinte código. 
// cria uma instância do Loader 
var carregador:Loader = new Loader(); 
// armazena na variável “arquivo” o nome do swf ext erno a ser carregado 
var arquivo:String = "carregado.swf"; 
// cria uma instância do URLRequest, que carregará o swf armazenado na 
variável "arquivo" 
var requisicao:URLRequest = new URLRequest(arquivo) ; 
57 
// define onde o swf externo será carregado 
carregador.x = 0; 
carregador.y = 0; 
// Carrega o swf solicitado 
carregador.load(requisicao); 
// Inclui o swf carregado no Stage 
this.addChild(carregador); 
 
Salve o seu arquivo e pressione CTRL+ENTER para testar o carregamento. 
 
Display Object 
Crie um novo arquivo fla e nomeie-o como desejar. No campo Document class 
do painel Properties, digite exemplo (vamos definir essa classe a seguir, 
portanto, ignore a janela com mensagem de erro que surgirá). 
58 
 
Salve seu arquivo.Crie um arquivo as e nomeie-o como exemplo.as. Salve-o na mesma pasta em 
que salvou o arquivo fla, lembre-se que isso é necessário para que o arquivo 
FLA reconheça a classe. 
Adicione no seu arquivo AS o seguinte código: 
 
package 
{ 
 import flash.display.MovieClip; 
 public class exemplo extends MovieClip 
 { 
 // Não esqueça que o nome da classe e nome da fun ção deve 
ser o mesmo nome do nome do arquivo “.as”, neste ca so, “exemplo” 
 public var mc1:MovieClip = new MovieClip(); 
 public var mc2:MovieClip = new MovieClip(); 
 /* 
 Duas variáveis são definidas representando duas i nstâncias 
59 
da classe MovieClip. 
 A definição de variáveis antes da definição de fu nções as 
tornarão acessíveis para todas as funções dentro da classe. 
 Tornando-as públicas, também serão acessíveis atr avés de 
códigos externos à classe também. 
 Observa a sintaxe para a definição das variáveis: 
 var nome_variavel : tipo_variavel = valor; 
 mc1 e mc2 representarão dois MovieClips 
 */ 
 public function exemplo() 
 { 
 // Define a função principal da classe, Esta fun ção 
sempre será executada. 
 mc1.graphics.lineStyle(1); 
 mc1.graphics.beginFill(0xff0000); 
 mc1.graphics.drawCircle(100,100,50); 
 /* 
 Desenha um círculo (com borda preta, 1 px de 
espessura e preenchido com vermelho) 
 */ 
 this.addChild(mc1); 
 /* 
 addChild é um novo comando introduzido no AS3. 
 Objetos que serão mostrados agora são armazenado s 
em uma lista. 
 addChild incluirá novos objetos da lista. 
 O objeto inserido mais recentemente na lista é 
posicionado no topo da lista, ou seja é mostrado em primeiro plano. 
 Em outras palavras, você pode considera “Colocan do 
objetos no Stages.fla” é o MovieClip raiz (root) on de incluímos 
 o mc1 (círculo)no Display List deste MC (root) 
 */ 
60 
 mc2.graphics.lineStyle(1); 
 mc2.graphics.beginFill(0xffff00); 
 mc2.graphics.drawRect(100,100,150,100); 
 /* 
 Desenha um retângulo (borda preta, 1 px de espes sura 
e preenchido com amarelo) no MC mc2 e o inclui no D isplay List. 
 Quando for mostrado, o mc2 estará em primeiro pl ano, 
à frente do círculo. 
 */ 
 this.addChild(mc2); 
 } 
 } 
} 
 
 
COMPONENTE LIGHTBOX 
Lightbox é um gerenciador de imagem em CSS que permite a imagem abrir na 
tela sem precisar carrega uma nova pagina. É um pequeno script em javascript 
que cria este efeito quando se clica numa imagem que linka outra, por exemplo 
um thumbnail que é um link para a imagem em tamanho real, em que a 
segunda aparece sobreposta à página mostrada no browser. 
61 
Os exemplos mostrados aqui já estão sendo feitos com a versão CS5 do 
Flash, mas será possível que sejam feitos no Flash CS3 ou CS4, pois ambos 
dão suporte ao ActionScript 3. 
 
Vamos usar o componente FlashLightBox. É um componente que permite que 
o efeito LightBox presente em algumas páginas HTML possa ser usado em 
arquivo do Flash usando apenas ActionScript. 
 
 O componente está disponível no endereço: 
http://www.4shared.com/zip/nteCY14d/FlashLightBoxAS3.html 
 
Copie o arquivo para a seguinte pasta: 
Flash CS3 � C:/Arquivos de Programas/Adobe/Adobe Flash 
CS3/linguagem/Configuration/Components 
 
Flash CS4 / CS5 � C:/Arquivos de Programas/Adobe/Adobe Flash 
CS4/Common /Configuration/Components. 
Se o Flash já estiver sendo executado, feche-o e depois abra novamente. 
Clique no Menu Window, Components para ter acesso ao componente. 
62 
 
Arraste uma instância do componente para o palco e observe no painel 
Component Parameters. 
 
A personalização do Componente só será válida caso use as funções 
reservadas a um site feito inteiramente no Flash, caso seu site não seja 
totalmente em Flash e tiver que usar o JavaScript, a personalização terá que 
ser feita através do arquivo CSS do LightBox. 
No exemplo vamos carregar uma imagem, então faça uma miniatura da 
63 
imagem que será nosso botão para carregar a imagem maior. 
 
Após ter adicionado o Componente no palco e customizado ele através do 
painel Component Inspector, é necessário instanciar esse Componente. 
Instancie como light. Importe a imagem em miniatura, converta em Movie Clip e 
instancie como “img01_mc”. 
Crie uma nova camada chamada AS. Adicione o seguinte código. 
 
img01_mc.addEventListener(MouseEvent.CLICK, btPress ); 
function btPress(event:MouseEvent):void { 
light.carrega("pilulas.jpg", "Bem-Vindo ao Deserto do real"); 
} 
 
Para testar seu filme publique o mesmo e abra o HTML no navegador. 
64 
 
Podemos também fazer com carregue varias imagens. 
Adicione as demais miniaturas e instancie as mesmas. No exemplo mantive a 
seqüencia “img02_mc, img03_mc, img04_mc”. 
Para isso mude seu código para: 
 
var fotos:Array = ["pilulas.jpg", "ciber.jpg", 
"cibercultura2.jpg","cibercultura.jpg"]; 
var textos:Array = ["Bem-Vindo ao Deserto do Real", "Simulacros e 
Simulações", "O real e o imaginário", "Cidades Vigi adas"]; 
img01_mc.addEventListener(MouseEvent.CLICK, btPress ); 
function btPress(event:MouseEvent):void { 
 light.carregaMultiplos(fotos, textos, 1); 
} 
 
img02_mc.addEventListener(MouseEvent.CLICK, btPress 2); 
function btPress2(event:MouseEvent):void { 
65 
 light.carregaMultiplos(fotos, textos, 2); 
} 
 
img03_mc.addEventListener(MouseEvent.CLICK, btPress 3); 
function btPress3(event:MouseEvent):void { 
 light.carregaMultiplos(fotos, textos, 3); 
} 
 
img04_mc.addEventListener(MouseEvent.CLICK, btPress 4); 
function btPress4(event:MouseEvent):void { 
 light.carregaMultiplos(fotos, textos, 4); 
} 
 
66 
 
Galeria de fotos com XML 
Continuando nosso estudo vamos criar uma galeria que une um arquivo XML, 
com lightBox no Flash. 
Para nosso exemplo vou trabalhar com 6 imagens. Vamos também utilizar o 
componente LightBox que usamos no exemplo anterior. 
Inicialmente monte a seguinte estrutura XML, no seu editor de textos, ou editor 
HTML. Para o exemplo eu salvei o arquivo XML na mesma pasta das imagens. 
<?xml version="1.0" encoding="utf-8"?> 
<imagens> 
 <foto> 
 <imagem>001.jpg</imagem> 
 <texto>GT3 - Brasil</texto> 
 </foto> 
 <foto> 
 <imagem>002.jpg</imagem> 
 <texto>Lamborguini gallardo</texto> 
 </foto> 
 <foto> 
67 
 <imagem>003.jpg</imagem> 
 <texto>Porsche Carrera</texto> 
 </foto> 
 <foto> 
 <imagem>004.jpg</imagem> 
 <texto>Ford GT</texto> 
 </foto> 
 <foto> 
 <imagem>005.jpg</imagem> 
 <texto>Dodge Viper</texto> 
 </foto> 
 <foto> 
 <imagem>006.jpg</imagem> 
 <texto>Ferrari F430</texto> 
 </foto> 
 </imagens> 
Lembre-se apenas de dar o nome de sua imagem e a descrição. 
Inicie seu arquivo Flash. Para nosso exemplo criei um arquivo de 1024x768 
ActionScript 3 
Salve seu arquivo na mesma pasta de seu arquivo XML. Para nosso exemplo 
salvei como gt3.fla. 
Abra o painel componentes e arraste o componente FlashLightBox para o 
palco. 
68 
 
Intâncie-o como “flb” 
Vamos criar todo o conteúdo de nosso exemplo com AS3. 
Adicione o seguinte código: 
 
/* Alinha o arquivo para o canto superior esquerdo */ 
stage.align = StageAlign.TOP_LEFT; 
/* Desabilitamos o dimensionamento do arquivo */ 
stage.scaleMode = StageScaleMode.NO_SCALE; 
/* Variável que armazena o MovieClip selecionado */ 
var alvo:MovieClip; 
/* Variável que armazena a quantidade de itens do XML */ 
var total:Number = new Number(); 
/* Criamos uma instancia da Classe XML */ 
var xml:XML = new XML(); 
/* Criamos uma instancia da Classe URLLoader */ 
var arquivo:URLLoader = new URLLoader(); 
/* Carregamos o XML */ 
arquivo.load(new URLRequest("gt3.xml")); 
/* Adicionamos um event listener chamando a função arquivoOk */ 
arquivo.addEventListener(Event.COMPLETE, arquivoOk); 
/* Função chamada assim que o XML é carregado */ 
69 
function arquivoOk(event:Event):void { 
 /* Armazenamos os dados doXML na instancia da Classe XML */ 
 xml = new XML(event.target.data); 
 /* Armazenamos o total de itens */ 
 total = xml.foto.length(); 
 /* Chama a função carrega */ 
 carrega(); 
} 
/* Função que carrega as imagens */ 
function carrega() { 
 /* Criamos um laço para percorrer todos os itens do XML */ 
 for (var i=0; i<total; i++) { 
 /* Criamos um MovieClip */ 
 var mc:MovieClip = new MovieClip(); 
 /* Rotacionamos ele randomicamente */ 
 mc.rotation = Math.round(Math.random()*-30)+10; 
 /* Habilitamos o clique duplo do Mouse */ 
 mc.doubleClickEnabled = true; 
 /* Adicionamos um event listener para quando o mouse for clicado 
no MovieClip */ 
 mc.addEventListener(MouseEvent.MOUSE_DOWN, mcPress); 
 mc.addEventListener(MouseEvent.MOUSE_UP, mcRelease); 
 /* Adicionamos um event listener para o clique duplo */ 
 mc.addEventListener(MouseEvent.DOUBLE_CLICK, mcDoble); 
 /* Armazena o número do nó do XML */ 
 mc.id = i; 
 /* Criamos uma instancia da Classe DropShadowFilter */ 
 var sombra:DropShadowFilter = new DropShadowFilter(); 
 /* Modificamos o angulo da sombra */ 
 sombra.angle = 45; 
 /* Modificamos o blurX e blurY */ 
 sombra.blurX = 5; 
70 
 sombra.blurY = 5; 
 /* Modificamos a distancia */ 
 sombra.distance = 3; 
 /* Modificamos a intensidade da sombra */ 
 sombra.strength = 0.75; 
 /* Criamos um Array para armazenar os filtros utilizados */ 
 var filtro:Array = new Array(); 
 /* Adicionamos no Array a sobra criada */ 
 filtro.push(sombra); 
 /* Adiciona os filtros ao MovieClip */ 
 mc.filters = filtro; 
 /* Criamos uma instancia da Classe Loader */ 
 var loader:Loader = new Loader(); 
 /* Desabilitamos o mouse */ 
 loader.mouseEnabled = false; 
 /* Carregamos a imagem */ 
 loader.load(new URLRequest(xml.foto[i].imagem)); 
 /* Modificamos o tamanho da imagem randomicamente */ 
 loader.scaleX = (Math.random()*0.2)+0.6; 
 loader.scaleY = loader.scaleX; 
 /* Modificamos a posição da imagem */ 
 loader.x = 10; 
 loader.y = 10; 
 /* Adicionamos um event listener para saber quando terminou de 
carregar a imagem */ 
 loader.contentLoaderInfo.addEventListener(Event.COMPLETE, 
loaderOk); 
 /* Adiciona a imagem ao MovieClip criado */ 
 mc.addChild(loader); 
 /* Adiciona o MovieClip ao palco */ 
 addChild(mc); 
 } 
71 
} 
/* Função chamada quando a imagem termina de ser carregada */ 
function loaderOk(event:Event):void { 
 /* Criamos uma referencia para a imagem */ 
 var loader:Loader = event.target.loader; 
 /* Criamos uma referencia ao MovieClip */ 
 var mc:MovieClip = MovieClip(loader.parent); 
 /* Definimos a cor de fundo da borda */ 
 mc.graphics.beginFill(0xFFFFFF, 1); 
 /* Começamos a desenhar a borda no MovieClip de acordo com o 
tamanho da imagem */ 
 mc.graphics.lineTo(0, 0); 
 mc.graphics.lineTo(0, loader.height+20); 
 mc.graphics.lineTo(loader.width+20, loader.height+20); 
 mc.graphics.lineTo(loader.width+20, 0); 
 /* Termina de desenhar */ 
 mc.graphics.endFill(); 
 /* Modifica a posição do MovieClip de forma randômica */ 
 mc.x = Math.round(Math.random()*(stage.stageWidth-mc.width)); 
 mc.y = Math.round(Math.random()*(stage.stageHeight-mc.height)); 
} 
/* Função chamada quando clicamos duas vezes sobre a imagem */ 
function mcDoble(event:MouseEvent):void { 
 /* Chamamos a função carrega do Componente FlashLightBox */ 
 /* A função recebe o endereço da imagem e o texto para a legenda */ 
 flb.carrega(xml.foto[event.target.id].imagem, 
xml.foto[event.target.id].texto); 
} 
/* Função chamada quando clica com o mouse sobre o MovieClip */ 
function mcPress(event:MouseEvent):void { 
 /* Identificamos o alvo */ 
 alvo = MovieClip(event.target); 
72 
 /* Coloca o alvo a frente dos demais MovieClips */ 
 addChild(alvo); 
 /* Movimenta o MovieClip */ 
 alvo.startDrag(); 
} 
/* Função chamada quando soltamos o botão esquerdo do mouse */ 
function mcRelease(event:MouseEvent):void { 
 /* Paramos de movimentar o MovieClip */ 
 event.target.stopDrag(); 
} 
 
FLASH MOBILE 
Para finalizar nosso estudo no Flash vamos criar um exemplo simples de 
aplicação de Flash para tecnologia móbile. Já a algumas versões a Adobe deu 
a seus aplicativos a possibilidade de criar conteúdo para tecnologia móvel 
através do Aplicativo Device Central. 
73 
 
Como exemplo de criação vamos utilizar um exemplo criado por Paul Wyatt 
(Designer digital premiado e conceituado na Europa). 
Abra o exemplo “mobile_limpo.fla”, será nele que vamos trabalhar. 
Observe que na biblioteca de seu flash já estão os símbolos e imagens a 
serem utilizados. 
74 
 
Renomeie a camada atual para phone me, arraste para esta camada o botão 
callme_btn e a posicione nas coordenadas X:121 e Y: 243. Instancie como 
phone_btn. 
75 
 
Crie um quadro chave no frame 3 e no quadro 2 deixe como um quadro vazio. 
Crie as seguintes camadas. 
 
Para a camada meutrabalho arraste o botão work_btn e posicione nas 
coordenadas X: 121 e Y: 140. Instancie como work_btn. 
76 
 
Na camada marcos, acrescente o nome. 
Para estas duas camadas mantenha em branco no frame 2 e 3. 
Na camada teclas adicione duas caixas de texto. 
 
Crie um quadro chave no frame 2, e mude o texto do botão Quem Sou para 
Home. 
 
77 
Na camada Labels crie quadros chaves e pelo painel de propriedades da 
camada de nome a estes frames, o primeiro como: start, o segundo como work 
movie e o terceiro como about me. 
 
 
 
Na camada telas, no primeiro frame adicione a ação stop(); 
Insira um quadro chave no frame 2 e arraste para ele o Movie Clip para este 
frame posicione nas coordenadas X: 24,3 e Y:0,0. 
78 
 
Acrescente também neste frame uma ação stop(); 
No Frame 3 insira um quadro vazio e arraste o Movie Clip texto para este frame 
posicione nas coordenadas X:43,9 e Y:18,5. 
 
Na camada de ações no primeiro frame adicione ou copie do arquivo pronto: 
 
stop(); 
 
79 
_focusrect = false; 
 
fscommand2("SetSoftKeys", "Main", "Exit"); 
fscommand2("SetQuality", "high"); 
fscommand2("Fullscreen", "true"); 
 
if (selectedItem == null) { 
 Selection.setFocus(work_btn); 
} 
else { 
 Selection.setFocus(selectedItem) 
} 
 
work_btn.onPress = function() { 
 selectedItem = this; 
 gotoAndStop("work movie"); 
}; 
 
phone_btn.onPress = function() { 
 selectedItem = this; 
 getURL("tel: 00000000"); 
}; 
 
 
Key.removeListener(myListener); 
var myListener:Object = new Object(); 
myListener.onKeyDown = function() { 
var keyCode = Key.getCode(); 
if (keyCode == ExtendedKey.SOFT1) { 
 
gotoAndStop("about me"); 
} else if (keyCode == ExtendedKey.SOFT2) { 
80 
 
fscommand2("Quit"); 
} 
}; 
Key.addListener(myListener); 
 
Crie um quadro chave no frame 2 e adicione o seguinte código: 
Key.removeListener(myListener); 
var myListener:Object = new Object(); 
myListener.onKeyDown = function() { 
var keyCode = Key.getCode(); 
if (keyCode == ExtendedKey.SOFT1) { 
gotoAndStop("start"); 
} else if (keyCode == ExtendedKey.SOFT2) { 
fscommand2("Quit"); 
} 
}; 
Key.addListener(myListener); 
Crie um quadro chave no frame3 e adicione o seguinte código: 
Key.removeListener(myListener); 
var myListener:Object = new Object(); 
myListener.onKeyDown = function() { 
var keyCode = Key.getCode(); 
if (keyCode == ExtendedKey.SOFT1) { 
gotoAndStop("start"); 
} else if (keyCode == ExtendedKey.SOFT2) { 
fscommand2("Quit"); 
} 
}; 
Key.addListener(myListener); 
 
Clique no menu Control, Test Movie, in Device Central. 
81 
 
 
Com este exemplo finalizamos nosso estudo com AS3 dentro de Flash