Upload
alex-augusto
View
20
Download
0
Embed Size (px)
Citation preview
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.
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ções de 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 do botã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 de
software 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ão mais 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 do XML 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.