Aprendendo ActionScript 2.0 no Flash

Transcrição

Aprendendo ActionScript 2.0 no Flash
Marcas comerciais
1 Step RoboPDF, ActiveEdit, ActiveTest, Authorware, Blue Sky Software, Blue Sky, Breeze, Breezo, Captivate, Central,
ColdFusion, Contribute, Database Explorer, Director, Dreamweaver, Fireworks, Flash, FlashCast, FlashHelp, Flash Lite,
FlashPaper, Flash Video Encoder, Flex, Flex Builder, Fontographer, FreeHand, Generator, HomeSite, JRun, MacRecorder,
Macromedia, MXML, RoboEngine, RoboHelp, RoboInfo, RoboPDF, Roundtrip, Roundtrip HTML, Shockwave, SoundEdit,
Studio MX, UltraDev e WebHelp são marcas comerciais registradas ou marcas comerciais da Macromedia, Inc. e podem estar
registradas nos Estados Unidos ou em outras jurisdições, inclusive internacionais. Outros nomes de produtos, logotipos, designs,
títulos, palavras ou frases mencionados nesta publicação podem ser marcas comerciais, marcas de serviço ou nomes comerciais da
Macromedia, Inc. ou de outras entidades e podem estar registrados em certas jurisdições, inclusive internacionais.
Informações de terceiros
Este guia contém links para sites da Web de terceiros que não estão sob o controle da Macromedia. Nesses casos, a Macromedia
não é responsável pelo conteúdo de nenhum site vinculado. Se acessar um dos sites da Web de terceiros mencionados neste guia,
você estará assumindo os riscos inerentes. A Macromedia oferece esses links apenas como uma conveniência, e a inclusão de um
link não significa que a Macromedia apóia ou aceita qualquer responsabilidade pelo conteúdo apresentado nos sites de terceiros.
Tecnologia de compactação e descompactação de voz licenciada da Nellymoser, Inc. (www.nellymoser.com).
Tecnologia Sorenson™ Spark™ de compactação e descompactação de vídeo licenciada da Sorenson
Media, Inc.
Navegador Opera ® Copyright © 1995-2002 Opera Software ASA e seus fornecedores. Todos os
direitos reservados.
O vídeo Macromedia Flash 8 possui tecnologia de vídeo On2 TrueMotion. © 1992-2005 On2 Technologies, Inc. Todos os
direitos reservados. http://www.on2.com.
Visual SourceSafe é uma marca comercial ou comercial registrada da Microsoft Corporation nos Estados Unidos e/ou em outros
países.
Copyright © 2005 Macromedia, Inc. Todos os direitos reservados. Este manual não pode ser copiado, fotocopiado,
reproduzido, traduzido ou convertido em nenhum formato eletrônico ou que possa ser lido por máquina, por inteiro ou
em parte, sem o consentimento prévio por escrito da Macromedia, Inc. Não obstante o precedente, o proprietário ou
usuário autorizado de uma cópia válida do software com que este manual foi fornecido pode imprimir uma cópia deste
manual a partir de uma versão eletrônica com a finalidade única de ele próprio ou um usuário autorizado aprender a usar
este software, desde que nenhuma parte deste manual seja impressa, reproduzida, distribuída, revendida ou transmitida
para qualquer outro fim, incluindo, sem limitação, fins comerciais, como vendas de cópias desta documentação ou
fornecimento de serviços de suporte pré-pagos.
Agradecimentos
Gerenciamento de projetos: Sheila McGinn
Criação do texto: Jen deHaan; Peter deHaan, Joey Lott
Editora geral: Rosana Francescato
Editora chefe: Lisa Stanziano
Edição: Linda Adler, Geta Carlson, Evelyn Eldridge, John Hammett, Mary Kraemer, Noreen Maher, Jessie Wood, Anne Szabla
Gerenciamento de produção: Patrice O’Neill, Kristin Conradi, Yuko Yagi
Projeto de mídia e produção: Adam Barnett, Aaron Begley, Paul Benkman. John Francis, Geeta Karmarkar, Masayo Noda,
Paul Rangel, Arena Reed, Mario Reynoso
Agradecimentos especiais a Jody Bleyle, Mary Burger, Lisa Friendly, Stephanie Gowin, Bonnie Loo, Mary Ann Walsh, Erick Vera,
aos testadores beta e a toda a equipe de engenharia e controle de qualidade do Flash e do Flash Player.
Primeira edição: Setembro de 2005
Macromedia, Inc.
601 Townsend St.
San Francisco, CA 94103
Conteúdo
Introdução. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Público-alvo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Requisitos de sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Atualizando arquivos XML para Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Sobre a documentação. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Recursos adicionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Capítulo 1: Novidades do ActionScript no Flash 8 . . . . . . . . . . . . 19
Novidades do ActionScript 2.0 e do Flash 8 . . . . . . . . . . . . . . . . . . . . . . 19
Alterações no modelo de segurança para arquivos SWF instalados
localmente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Capítulo 2: Escrevendo e editando o ActionScript 2.0 . . . . . . . . 31
Sobre o ActionScript e eventos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Organizando o código ActionScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Usando o painel Actions e a janela Script. . . . . . . . . . . . . . . . . . . . . . . . 36
Sobre o painel Actions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37
Sobre a janela Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Sobre a codificação no painel Actions e na janela Script . . . . . . . . . . 39
Sobre recursos do painel Actions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Sobre comportamentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Sobre as configurações de publicação do ActionScript . . . . . . . . . . . 66
Capítulo 3: Sobre o ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . 71
O que é ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .72
Sobre a opção entre o ActionScript 1.0 e o ActionScript 2.0 . . . . . . .73
Noções básicas do ActionScript e do Flash Player . . . . . . . . . . . . . . . .74
3
Capítulo 4: Dados e tipos de dados . . . . . . . . . . . . . . . . . . . . . . . . 75
Sobre dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Sobre tipos de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Sobre variáveis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Organizando dados em objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .114
Sobre a conversão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .116
Capítulo 5: Fundamentos da sintaxe e da linguagem . . . . . . . . 119
Sobre sintaxe, instruções e expressões . . . . . . . . . . . . . . . . . . . . . . . . . 120
Sobre sintaxe de ponto e caminhos de destino . . . . . . . . . . . . . . . . . . 124
Sobre pontuadores de linguagem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
Sobre constantes e palavras-chave . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Sobre instruções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
Sobre arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
Sobre operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
Capítulo 6: Funções e métodos . . . . . . . . . . . . . . . . . . . . . . . . . . 213
Sobre funções e métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
Noções básicas sobre métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .235
Capítulo 7: Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
Sobre a programação orientada a objeto e o Flash . . . . . . . . . . . . . 240
Criando arquivos de classes personalizados. . . . . . . . . . . . . . . . . . . . 249
Sobre como trabalhar com classes personalizadas em um
aplicativo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .252
Exemplo: Criando classes personalizadas. . . . . . . . . . . . . . . . . . . . . . . 278
Exemplo: Usando arquivos de classes personalizados no Flash . . . 291
Atribuindo uma classe a símbolos no Flash. . . . . . . . . . . . . . . . . . . . . 295
Compilando e exportando classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .296
Noções básicas sobre classes e escopo . . . . . . . . . . . . . . . . . . . . . . . 299
Sobre classes de nível superior e internas . . . . . . . . . . . . . . . . . . . . . . 302
Sobre como trabalhar com classes internas . . . . . . . . . . . . . . . . . . . . . 312
Capítulo 8: Herança . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
Sobre herança . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
Sobre a criação de subclasses no Flash . . . . . . . . . . . . . . . . . . . . . . . . 321
Usando o polimorfismo em um aplicativo . . . . . . . . . . . . . . . . . . . . . . . 327
4
Conteúdo
Capítulo 9: Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
Sobre interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .331
Criando interfaces como tipos de dados. . . . . . . . . . . . . . . . . . . . . . . . 337
Noções básicas sobre herança e interfaces . . . . . . . . . . . . . . . . . . . . . 339
Exemplo: Usando interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
Exemplo: Criando uma interface complexa . . . . . . . . . . . . . . . . . . . . . 342
Capítulo 10: Manipulando eventos . . . . . . . . . . . . . . . . . . . . . . . 347
Usando métodos manipuladores de eventos . . . . . . . . . . . . . . . . . . . . 348
Usando ouvintes de eventos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .351
Usando ouvintes de eventos com componentes . . . . . . . . . . . . . . . . 353
Usando manipuladores de eventos de botão e de clipe de filme. . . 355
Transmitindo eventos de instâncias de componentes . . . . . . . . . . . . 360
Criando clipes de filme com estados de botão . . . . . . . . . . . . . . . . . . .361
Escopo do manipulador de eventos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
Escopo da palavra-chave this . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365
Usando a classe Delegate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
Capítulo 11: Trabalhando com clipes de filme . . . . . . . . . . . . . . 369
Sobre o controle de clipes de filme com o ActionScript . . . . . . . . . . 370
Chamando vários métodos em um único clipe de filme. . . . . . . . . . . 372
Carregando e descarregando arquivos SWF . . . . . . . . . . . . . . . . . . . 373
Alterando a posição e a aparência de um clipe de filme . . . . . . . . . . 376
Arrastando clipes de filme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377
Criando clipes de filme durante a execução . . . . . . . . . . . . . . . . . . . . . 378
Adicionando parâmetros aos clipes de filme criados
dinamicamente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
Gerenciando profundidades do clipe de filme . . . . . . . . . . . . . . . . . . . 385
Sobre o armazenamento em cache e a rolagem de clipes
de filme com o ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
Usando clipes de filme como máscaras . . . . . . . . . . . . . . . . . . . . . . . . 397
Manipulando eventos de clipes de filme . . . . . . . . . . . . . . . . . . . . . . . . 399
Atribuindo uma classe a um símbolo de clipe de filme . . . . . . . . . . . . 399
Inicializando as propriedades de classe . . . . . . . . . . . . . . . . . . . . . . . . .401
Capítulo 12: Trabalhando com texto e seqüências
de caracteres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
Sobre campos de texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
Sobre o carregamento de texto e variáveis em campos de texto . . .415
Usando fontes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
Sobre a renderização de fontes e texto sem serrilhado. . . . . . . . . . . 430
Conteúdo
5
Sobre o layout e a formatação de texto . . . . . . . . . . . . . . . . . . . . . . . . 439
Formatando texto com estilos CSS . . . . . . . . . . . . . . . . . . . . . . . . . . . .447
Usando texto em formato HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
Exemplo: Criando texto de rolagem . . . . . . . . . . . . . . . . . . . . . . . . . . . .475
Sobre seqüências de caracteres e a classe String. . . . . . . . . . . . . . . . 477
Capítulo 13: Animação, filtros e desenhos . . . . . . . . . . . . . . . . . 497
Scripts de animação com o ActionScript 2.0 . . . . . . . . . . . . . . . . . . 498
Sobre cache de bitmap, rolagem e desempenho . . . . . . . . . . . . . . . 508
Sobre as classes Tween e TransitionManager . . . . . . . . . . . . . . . . . 509
Usando efeitos de filtro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .526
Trabalhando com filtros usando ActionScript . . . . . . . . . . . . . . . . . . .534
Manipulando efeitos de filtro com código . . . . . . . . . . . . . . . . . . . . . . .557
Criando bitmaps com a classe BitmapData . . . . . . . . . . . . . . . . . . . . . 561
Modos de mistura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .564
Sobre a ordem de operação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567
Desenhando com o ActionScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567
Noções básicas sobre dimensionamento e guias de trecho . . . . . . .583
Capítulo 14: Criando interação com o ActionScript . . . . . . . . . 589
Sobre eventos e interação. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590
Controlando a reprodução de arquivos SWF . . . . . . . . . . . . . . . . . . . 590
Criando interatividade e efeitos visuais. . . . . . . . . . . . . . . . . . . . . . . . . 593
Criando vinculações de dados durante a execução com
o ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .607
Desconstruindo um script de exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . 616
Capítulo 15: Trabalhando com imagens, som e vídeo . . . . . . . . 619
Sobre o carregamento e o trabalho com mídia externa . . . . . . . . . . 620
Carregando arquivos SWF e de imagem externos . . . . . . . . . . . . . . . 621
Sobre o carregamento e o uso de arquivos MP3 externos . . . . . . . .626
Atribuindo vinculação a recursos da biblioteca. . . . . . . . . . . . . . . . . . . 631
Sobre o uso de vídeo FLV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .632
Sobre a criação de animações do progresso para arquivos
de mídia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .654
6
Conteúdo
Capítulo 16: Trabalhando com dados externos . . . . . . . . . . . . . 663
Enviando e carregando variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 664
Usando HTTP para conectar a scripts do servidor . . . . . . . . . . . . . . . 668
Sobre upload e download de arquivos . . . . . . . . . . . . . . . . . . . . . . . . . 674
Sobre XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 683
Enviando mensagens para o Flash Player e a partir deste . . . . . . . . 692
Sobre a API External . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 696
Capítulo 17: Noções básicas de segurança . . . . . . . . . . . . . . . . 707
Sobre compatibilidade com os modelos de segurança
anteriores do Flash Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 708
Sobre segurança do arquivo local e o Flash Player . . . . . . . . . . . . . . 709
Sobre domínios, segurança entre domínios e arquivos SWF . . . . . 727
Arquivos de diretivas de servidor para autorizar o acesso a dados. 736
Acesso de protocolo HTTP para HTTPS entre arquivos SWF . . . . . 741
Capítulo 18: Depurando aplicativos . . . . . . . . . . . . . . . . . . . . . . 745
Depurando scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 745
Usando o painel Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 759
Capítulo 19: Melhores práticas e convenções de codificação
para ActionScript 2.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .767
Convenções de atribuição de nome . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Usando de comentários no código. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Convenções de codificação do ActionScript . . . . . . . . . . . . . . . . . . . .
Otimização do ActionScript e do Flash Player . . . . . . . . . . . . . . . . . .
Formatando a sintaxe do ActionScript . . . . . . . . . . . . . . . . . . . . . . . . .
769
779
782
798
799
Apêndice A: Mensagens de erro . . . . . . . . . . . . . . . . . . . . . . . . . 809
Apêndice B: Operadores Flash 4 obsoletos . . . . . . . . . . . . . . . . 815
Apêndice C: Teclas do teclado e valores de códigos
de teclas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 817
Apêndice D: Criando scripts para versões anteriores do Flash
Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 825
Sobre a especificação de versões anteriores do Flash Player . . . . 825
Usando o Flash 8 para criar conteúdo para o Flash Player 4 . . . . . 826
Conteúdo
7
Apêndice E: Programação orientada a objeto com
o ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 829
Sobre o ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 830
Criando um objeto personalizado no ActionScript 1.0 . . . . . . . . . . . . 831
Atribuindo métodos a um objeto personalizado no
ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .832
Definindo métodos manipuladores de eventos no
ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .834
Criando herança no ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . .836
Adicionando propriedades getter/setter a objetos no
ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 837
Usando as propriedades do objeto Function no ActionScript 1.0 . .838
Apêndice F: Terminologia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 841
Índice. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 851
8
Conteúdo
Introdução
O Macromedia Flash Basic 8 e o Macromedia Flash Professional 8 são as ferramentas de
criação padrão profissionais para a produção de experiências de grande impacto na Web. O
ActionScript é a linguagem utilizada para adicionar interatividade aos aplicativos Flash, sejam
os aplicativos arquivos SWF animados simples ou aplicativos de Internet avançados mais
complexos. Para usar o Flash, não é necessário o ActionScript, mas, se você desejar fornecer
interatividade básica ou complexa com o usuário, trabalhar com objetos diferentes daqueles
contidos no Flash (como botões e clipes de filme) ou então transformar um arquivo SWF em
uma experiência de usuário mais eficiente, deverá usar o ActionScript.
Para obter mais informações, consulte os tópicos a seguir:
Público-alvo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Atualizando arquivos XML para Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Requisitos de sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Sobre a documentação. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Recursos adicionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Público-alvo
Este manual pressupõe que você já tenha instalado o Flash Basic 8 ou o Flash Professional 8 e
saiba como usar a interface de usuário.É preciso que saiba posicionar objetos no Stage e
manipulá-los no ambiente de criação do Flash. Se já tiver usado uma linguagem de criação, o
ActionScript lhe parecerá familiar. No entanto, se for iniciante em programação, saiba que os
fundamentos do ActionScript são fáceis de aprender. Você pode começar com comandos
simples e criar mais complexidade com o tempo. Pode adicionar muita interatividade aos seus
arquivos sem precisar aprender (ou escrever) muito código.
Requisitos de sistema
O ActionScript 2.0 não tem qualquer requisito de sistema além do Flash 8 .
9
Este manual pressupõe que você esteja utilizando as configurações de publicação padrão para
os arquivos do Flash: Flash Player 8 e ActionScript 2.0. Se você alterar qualquer uma dessas
configurações, as explicações e exemplos de código apresentados na documentação poderão
não funcionar corretamente. Caso desenvolva aplicativos para versões anteriores do Flash
Player, consulte o Apêndice D, “Criando scripts para versões anteriores do Flash Player”, na
página 825.
Atualizando arquivos XML para Flash
É importante que estejam sempre instalados os arquivos XML para Flash mais recentes. A
Macromedia algumas vezes apresenta recursos em versões com ponto (versões menores) do
Flash Player. Quando uma versão dessas se encontrar disponível, atualize sua versão do Flash
para obter os arquivos XML mais recentes. Caso contrário, o compilador do Flash 8 poderá
gerar erros caso você use novas propriedades ou métodos indisponíveis na versão do Flash
Player que veio com a instalação do Flash.
Por exemplo, o Flash Player 7 (7.0.19.0) continha um novo método para o objeto System ,
System.security.loadPolicyFile. Para acessar esse método, use o instalador Player
Updater (Atualizador de player) para atualizar todos os players instalados com o Flash. Caso
contrário, o compilador do Flash exibirá erros.
Lembre-se de que é possível instalar um Player Updater que seja de uma ou mais versões
maiores mais recentes que a sua do Flash. Fazendo isso, obterá os arquivos XML necessários,
mas não deverá receber mensagens de erro do compilador quando publicar versões mais
antigas do Flash Player. Algumas vezes, novos métodos ou propriedades encontram-se
disponíveis para versões mais antigas, e ter os arquivos XML mais recentes minimiza os erros
de compilação quando você tenta acessar métodos ou propriedades mais antigos.
Sobre a documentação
Este manual oferece uma visão geral da sintaxe do ActionScript e informações sobre como usálo quando trabalhar com diferentes tipos de objetos. Para obter detalhes sobre a sintaxe e o uso
de cada elemento da linguagem, consulte o ActionScript 2.0 Language Reference.
Para obter mais informações, consulte os seguintes tópicos:
■
“Visão geral do manual Aprendendo ActionScript 2.0” na página 11
■
“Sobre os arquivos de exemplo” na página 15
■
“Termos usados neste documento” na página 13
■
“Copiar e colar código” na página 13
10
Introdução
Visão geral do manual Aprendendo ActionScript 2.0
A lista a seguir resume o conteúdo deste manual:
■
O Capítulo 1, “Novidades do ActionScript no Flash 8,” descreve recursos que são novos
no ActionScript, alterações no compilador e no depurador e o novo modelo de
programação para a linguagem ActionScript 2.0.
■
O Capítulo 2, “Escrevendo e editando o ActionScript 2.0,” descreve recursos do editor do
ActionScript dentro do Flash que facilitam a escrita de código.
■
O Capítulo 3, “Sobre o ActionScript,” descreve o que é a linguagem ActionScript e
detalha como escolher qual versão utilizar.
■
O Capítulo 4, “Dados e tipos de dados,” descreve a terminologia e os conceitos básicos
sobre dados, tipos de dados e variáveis. Esses conceitos serão usados em todo o manual.
■
O Capítulo 5, “Fundamentos da sintaxe e da linguagem,” descreve a terminologia e os
conceitos básicos da linguagem ActionScript. Esses conceitos serão usados em todo o
manual.
■
O Capítulo 6, “Funções e métodos,” descreve como escrever diferentes tipos de funções e
métodos e como usá-los no seu aplicativo.
■
O Capítulo 7, “Classes,” descreve como criar classes e objetos personalizados no
ActionScript. Esse capítulo também lista as classes internas do ActionScript e oferece uma
visão geral de como utilizá-las para acessar recursos avançados do ActionScript.
■
O Capítulo 8, “Herança,” descreve a herança na linguagem ActionScript e como estender
classes internas ou personalizadas.
■
O Capítulo 9, “Interfaces,” descreve como criar interfaces e trabalhar com elas no
ActionScript.
■
O Capítulo 10, “Manipulando eventos,” descreve várias formas de manipular eventos:
métodos manipuladores de eventos, ouvintes de eventos e manipuladores de eventos de
botão e de clipe de filme.
■
O Capítulo 11, “Trabalhando com clipes de filme,” descreve clipes de filme e o
AcionScript que você pode usar para crontrolá-los.
■
O Capítulo 12, “Trabalhando com texto e seqüências de caracteres,” descreve os diferentes
modos como você pode controlar o texto e as seqüências de caracteres no Flash e inclui
informações sobre formatação de texto e o FlashType (renderização de texto avançada,
como texto sem serrilhado).
■
O Capítulo 13, “Animação, filtros e desenhos,” descreve como criar animação e imagens
baseadas em código, adicionar filtros a objetos e desenhar usando o ActionScript.
11
■
O Capítulo 14, “Criando interação com o ActionScript,” descreve alguns modos simples
de criar aplicativos mais interativos, incluindo o controle quando os arquivos SWF são
executados e a criação de ponteiros personalizados e de controles de som.
■
O Capítulo 15, “Trabalhando com imagens, som e vídeo,” descreve como importar
arquivos de mídia externos, como imagens de bitmap, arquivos MP3, arquivos Flash
Video (FLV) e outros arquivos SWF, nos aplicativos Flash. Esse capítulo também oferece
uma visão geral de como trabalhar com o vídeo nos aplicativos e como criar animações
para o carregamento da barra de progresso.
■
O Capítulo 16, “Trabalhando com dados externos,” descreve como processar dados de
fontes externas usando scripts de servidor ou de cliente nos aplicativos. Esse capítulo
descreve como integrar os dados com os aplicativos.
■
O Capítulo 17, “Noções básicas de segurança,” explica a segurança no Flash Player, na
medida em que se relaciona com o trabalho com arquivos SWF localmente no disco
rígido. Esse capítulo também explica questões de segurança entre domínios e como
carregar dados de servidores ou através de domínios.
■
O Capítulo 18, “Depurando aplicativos,” descreve o depurador do ActionScript dentro do
Flash, que facilita a escrita de aplicativos.
■
O Capítulo 19, “Melhores práticas e convenções de codificação para ActionScript 2.0,”
explica as melhores práticas para usar o Flash e para escrever o ActionScript. Esse capítulo
também lista convenções de codificação padronizadas, como variáveis de atribuição de
nome e outras convenções.
■
O Apêndice A, “Mensagens de erro,” lista as mensagens de erro que o compilador do Flash
pode gerar.
■
O Apêndice B, “Operadores Flash 4 obsoletos,” lista todos os operadores obsoletos do
Flash 4 e sua associatividade.
■
O Apêndice C, “Teclas do teclado e valores de códigos de teclas,” lista todas as teclas de
um teclado padrão e os valores de códigos de teclas ASCII correspondentes usados para
identificar as teclas no ActionScript.
■
O Apêndice D, “Criando scripts para versões anteriores do Flash Player,” fornece diretrizes
para ajudá-lo a criar scripts sintaticamente corretos para a versão do Flash Player desejada.
■
O Apêndice E, “Programação orientada a objeto com o ActionScript 1.0,” fornece
informações sobre o uso do modelo de objeto ActionScript 1.0 para escrver scripts.
■
O Apêndice F, “Terminologia,” lista a terminologia comumente usada ao trabalhar com a
linguagem ActionScript e fornece descrições para os termos.
Este manual explica como usar a linguagem ActionScript. Para obter informações sobre os
elementos de linguagem propriamente ditos, consulte o ActionScript 2.0 Language Reference.
12
Introdução
Convenções tipográficas
Este manual usa as seguintes convenções tipográficas:
■
Fonte Code indica
código do ActionScript.
■
Fonte Code negrito, normalmente em um procedimento, indica código que você
precisa modificar ou adicionar a um código já adicionado ao arquivo FLA. Em alguns
casos, pode ser usado para realçar o código a ser observado.
■
Texto em negrito indica dados que você precisa digitar na interface de usuário, como
nome de arquivo ou nome de instância.
■
Texto em itálico indica um novo termo definido no texto que se segue. Em um caminho de
arquivo, pode indicar um valor que deve ser substituído (por exemplo, por um nome de
diretório no seu próprio disco rígido).
Termos usados neste documento
Os seguintes termos são usados neste manual:
■
Você refere-se ao desenvolvedor que escreve um script ou aplicativo.
■
O usuário refere-se à pessoa que executará os scripts e aplicativos.
■
Tempo de compilação é o momento em que você publica, exporta, testa ou depura o
documento.
■
Tempo de execução é o momento em que o script é executado no Flash Player.
Termos do ActionScript como método e objeto são definidos no Apêndice F, “Terminologia”,
na página 841.
Copiar e colar código
Quando você colar o ActionScript do painel Help (Ajuda) para o FLA ou o arquivo do
ActionScript, preste atenção aos caracteres especiais. São caracteres especiais as aspas especiais
(também chamadas de aspas curvas ou aspas inglesas). Esses caracteres não são interpretados
pelo editor do ActionScript, então o código lança um erro quando você tenta compilá-lo no
Flash.
13
Você pode identificar se os caracteres de aspas são especiais quando eles não são codificados
por cores de forma correta. Ou seja, se nenhuma seqüência de caracteres mudar de cor no
editor de cores, será preciso substituir os caracteres especiais por caracteres de aspas retas
comuns. Se você digitar um caractere de aspa simples ou dupla diretamente no editor do
ActionScript, sempre digitará um caractere de aspa reta. O compilador (quando você testa ou
publica um arquivo SWF) lança um erro e permite que você saiba que há um tipo errado
(marcas de aspas especiais ou curvas) de caracteres no seu código.
N OT A
Você também pode encontrar aspas especiais se colar o ActionScript de outros locais,
como de uma página da Web ou um documento do Microsoft Word.
Cuidado com quebras de linha ao copiar e colar código. Ao colar o seu código de alguns
locais, a linha de código poderá se quebrar em um local inapropriado. Certifique-se de que a
codificação de cores da sua sintaxe esteja correta no editor do ActionScript se achar que as
quebras de linha representam um problema. Compare o código do painel Actions (Ações)
com o do painel Help para ver se correspondem. Procure ativar o Word Wrap (quebra
automática de linha) no editor do ActionScript para ajudar a solucionar quebras de linha
excedentes no código (selecione View (Exibir) > Word Wrap (quebra automática de linha) na
janela Script ou Word Wrap no menu pop-up do painel Actions.)
Recursos adicionais
Além deste manual sobre o ActionScript, existem outros sobre outros tópicos do Flash, como
componentes e o Macromedia Flash Lite. Você pode acessar cada manual no painel Help
(Help > Flash Help (Ajuda do Flash)), exibindo o sumário padrão. Clique no botão Clear
(Limpar) para ver os manuais disponíveis; para obter mais informações, consulte “Onde
encontrar documentação sobre outros assuntos” na página 17.
Para obter mais informações sobre outros recursos disponíveis, consulte os seguintes tópicos:
■
“Sobre os arquivos de exemplo” na página 15
■
“Onde encontrar arquivos PDF ou documentação impressa” na página 15
■
“Sobre o LiveDocs” na página 16
■
“Recursos on-line adicionais” na página 17
■
“Onde encontrar documentação sobre outros assuntos” na página 17
14
Introdução
Sobre os arquivos de exemplo
Há vários arquivos de exemplo baseados no ActionScript que são instalados com o Flash. Esses
arquivos de exemplo mostram como o código funciona em um arquivo FLA; geralmente
servem como uma ferramenta de aprendizado bem útil. Os capítulos deste manual muitas
vezes fazem referência a esses arquivos, mas recomendamos que você consulte também a pasta
de arquivos de exemplo do seu disco rígido.
Os arquivos de exemplo incluem arquivos FLA de aplicativo que usam funções comuns do
Flash instaladas com ele. Esses aplicativos foram projetados para apresentar aos novos
desenvolvedores do Flash as capacidades dos aplicativos Flash assim como para mostrar aos
desenvolvedores avançados como funcionam os recursos do Flash no contexto.
Você pode encontrar os arquivos de origem de exemplo com foco no ActionScript na pasta
Samples (Exemplos) do disco rígido.
■
No Windows, navegue até a unidade de inicialização\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\.
■
No Macintosh, navegue até Macintosh HD/Applications/Macromedia Flash 8/Samples
and Tutorials/Samples/ActionScript/.
Você verá como são úteis os seguintes arquivos de exemplo com foco em componentes, pois
eles contêm vários códigos ActionScript. Eles também podem ser encontrados na pasta
Samples do disco rígido:
■
8\Samples and Tutorials\Samples\Components\.
■
and Tutorials/Samples/Components/.
Você também pode encontrar arquivos de exemplo adicionais para download na Internet. A
página da Web a seguir contém links e descrições de arquivos de exemplo adicionais:
www.macromedia.com/go/flash_samples/.
Onde encontrar arquivos PDF ou documentação
impressa
Caso prefira ler a documentação em formato impresso, as versões PDF de cada manual
encontram-se disponíveis para download. Vá até www.macromedia.com/support/
documentation/ e selecione o produto em que está interessado. Você pode exibir ou fazer o
download do PDF ou acessar o link da versão LiveDocs do manual.
Recursos adicionais
15
Muitas vezes você também pode adquirir a documentação impressa. Para obter informações
atualizadas, vá até o site de suporte da documentação e selecione Flash Basic 8 ou Flash
Professional 8.
Sobre o LiveDocs
Você pode acessar a documentação no site LiveDocs ou pelo painel Help. O site LiveDocs
contém todas as páginas de ajuda do Flash e pode conter comentários que esclareçam,
atualizem ou corrijam partes da documentação. Clique em View Comments (Exibir
comentários) em LiveDocs na parte inferior de uma página do painel Help para exibir a
página equivalente no site LiveDocs. Vá até http://livedocs.macromedia.com para ver uma
lista de toda a documentação disponível no formato LiveDocs.
Escritores técnicos monitoram o site LiveDocs. Uma das vantagens do LiveDocs é ver
comentários que esclarecem a documentação ou corrigir erros ou problemas que surgem após
o lançamento de um software. Não é no LiveDocs que você faz solicitações de ajuda, como
perguntas sobre seu código que não funciona, comentários sobre problemas com software ou
instalação ou perguntas sobre como criar algo com o Flash. Nele você fornece informações
sobre a documentação (por exemplo, você aponta uma frase ou parágrafo que requer
esclarecimento).
Quando você clica no botão para adicionar um comentário sobre o LiveDocs, há diversos
pontos sobre os tipos de comentários que são aceitáveis no sistema. Leia essas diretrizes
atentamente para que seu comentário não seja removido do site.
Se tiver alguma dúvida sobr eo Flash, faça sua pergunta nos fóruns da Web da Macromedia:
www.macromedia.com/support/forums/. Os fóruns da Web são o melhor local para fazer
perguntas, pois há vários funcionários da Macromedia lá, voluntários da equipe Macromedia,
gerentes e membros de grupos de usuário da Macromedia e até escritores técnicos que
monitoram esses fóruns.
Engenheiros não monitoram o sistema LiveDocs, mas a lista de tarefas do Flash. Se achar que
encontrou um erro (bug) no software ou se quiser solicitar um aprimoramento para o Flash,
preencha o formulário em www.macromedia.com/go/wish. Se você relatar o bug ou a
solicitação de aprimoramento no LiveDocs, eles não serão adicionados de forma oficial ao
banco de dados de bugs. Use o formulário apropriado se quiser que um engenheiro dê atenção
ao bug reportado ou à sua solicitação.
Lembre-se de dar atenção aos caracteres especiais e às quebras de linha quando colar da Web,
incluindo do LiveDocs. A Macromedia vem se esforçando para remover todos os caracteres
especiais dos exemplos de código, mas, se você tiver dificuldades para colar o código, consulte
“Copiar e colar código” na página 13.
16
Introdução
Recursos on-line adicionais
Existem vários recursos on-line que oferecem várias instruções, ajuda e orientação para
facilitar o uso do Macromedia Flash 8. Consulte com freqüência os seguintes sites para obter
atualizações:
O site The Macromedia Developer Center (www.macromedia.com/devnet) é atualizado
regularmente com as informações mais recentes sobre o Flash, além de oferecer
aconselhamentos de usuários experientes, tópicos avançados, exemplos, dicas, tutoriais
(incluindo tutoriais com várias partes) e outras atualizações. Visite com freqüência o site da
Web para saber das últimas novidades sobre o Flash e como obter o máximo do programa.
O site The Macromedia Flash Support Center (www.macromedia.com/support/flash)
fornece TechNotes (Notas Técnicas), atualizações de documentação e links para recursos
adicionais na comunidade Flash.
O site The Macromedia Weblogs (http://weblogs.macromedia.com) fornece uma lista dos
weblogs (também chamados de blogs) de funcionários e da comunidade Macromedia .
Os fóruns da Web da Macromedia (http://webforums.macromedia.com) oferecem vários
fóruns para perguntas específicas sobre o Flash, seus aplicativos ou a linguagem ActionScript.
Os fóruns são monitorados por voluntários da equipe Macromedia e muitas vezes são visitados
por funcionários de lá também. Se não souber a quem recorrer ou como resolver um
problema, comece por um fórum do Flash.
O site The Macromedia Community (www.macromedia.com/community) hospeda
regularmente Macrochats, uma série de apresentações ao vivo sobre uma variedade de tópicos
feitas por funcionários ou membros da comunidade Macromedia. Consulte regulamente o site
à procura de atualizações e para registrar-se nos Macrochats.
Onde encontrar documentação sobre outros
assuntos
Os manuais a seguir oferecem informações adicionais sobre assuntos comumente associados
ao ActionScript 2.0:
■
Para obter informações sobre os elementos que compõem a linguagem ActionScript,
consulte o ActionScript 2.0 Language Reference.
■
Para obter informações sobre como trabalhar no ambiente de criação do Flash, consulte o
How to Use Help (Como usar a Ajuda).
■
Para obter informações sobre como trabalhar com componentes, consulte o Using
Components (Usando componentes).
Recursos adicionais
17
18
Introdução
CAPÍTULO 1
1
Novidades do ActionScript
no Flash 8
O Macromedia Flash Basic 8 e o Macromedia Flash Professional 8 oferecem vários
aprimoramentos que facilitam a criação de scripts mais eficientes com uso da linguagem
ActionScript. Os novos recursos, analisados neste capítulo, incluem novos elementos de
linguagem (consulte “Acréscimos à linguagem ActionScript” na página 22), ferramentas de
edição aprimoradas (consulte “Alterações de edição do ActionScript” na página 28), alterações
no modelo de segurança e outros aprimoramentos do ActionScript relacionados à ferramenta
de criação.
Novidades do ActionScript 2.0 e do Flash 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Alterações no modelo de segurança para arquivos SWF instalados localmente . 29
Novidades do ActionScript 2.0 e do
Flash 8
A linguagem ActionScript cresceu e desenvolveu-se desde sua introdução, há vários anos. Com
cada nova versão do Flash, mais palavras-chave, objetos, métodos e outros elementos foram
adicionados à linguagem. Existem também aprimoramentos do ActionScript relacionados aos
ambientes de criação do Flash 8. O Flash Basic 8 e o Flash Professional 8 introduzem vários
novos elementos de linguagem para recursos expressivos, como filtros e modos de mistura,
além do desenvolvimento de aplicativos, como integração do JavaScript (ExternalInterface) e
entrada e saída de arquivo (FileReference e FileReferenceList).
Esta seção fornece uma visão geral dos elementos e classes da linguagem ActionScript que são
novos ou foram alterados no Flash 8 e aprimoramentos do ActionScript relacionados à
ferramenta de criação. Para obter uma lista de adições específicas ao ActionScript 2.0, consulte
“Acréscimos à linguagem ActionScript” na página 22. Para usar qualquer dos novos elementos
da linguagem nos seus scripts, tenha em mente o Flash Player 8 (o padrão) quando publicar
seus documentos.
19
Os recursos a seguir foram adicionados ao Flash Basic 8 e ao Flash Professional 8 (a menos que
explicitado de forma diferente):
■
Os aprimoramentos do editor do ActionScript permitem a exibição de caracteres ocultos
nos scripts. Para obter mais informações, consulte “Exibindo caracteres ocultos”
na página 57.
■
As opções de depuração agora encontram-se disponíveis na janela Script, assim como no
painel Actions, para arquivos do ActionScript.
■
O diretório Configuration que inclui arquivos XML e arquivos de classes está
reorganizado. Para obter detalhes, consulte “Arquivos de configuração instalados com o
Flash 8” na página 69.
■
É possível definir uma preferência para recarregar arquivos de script modificados ao
trabalhar em um aplicativo, o que ajuda a evitar o trabalho com versões mais antigas de
arquivos de script e a substituição de arquivos de script mais novos. Para obter mais
informações, consulte “Sobre as preferências do ActionScript” na página 44.
■
O recurso da janela Script encontra-se disponível no Flash Basic 8 e no Flash Professional
8. Isso significa que você pode criar um arquivo do ActionScript nos dois programas.
■
O Script Assist (Assistência de script), semelhante ao Normal Mode (Modo Normal) em
edições anteriores do Flash, ajuda você a codificar sem que precise ter noções de sintaxe.
Para obter mais informações sobre o Script Assist, consulte “Sobre o Script Assist”
na página 62.
■
É possível carregar novos tipos de arquivos de imagem durante a execução, o que inclui
imagens JPEG progressivas e arquivos GIF e PNG não-animados. Se você carregar um
arquivo animado, o primeiro quadro da animação será exibido.
■
É possível atribuir identificadores de vinculação a arquivos de bitmap e de som
armazenados na biblioteca (Library), o que significa que você pode anexar imagens ao
Stage ou trabalhar com esses recursos em bibliotecas compartilhadas.
■
O cache de bitmap permite o aumento do desempenho dos aplicativos durante a execução
por meio do cache de uma representação de bitmap de suas instâncias. Você pode usar o
ActionScript para acessar essa propriedade. Para obter mais informações, consulte “Sobre
cache de bitmap, rolagem e desempenho” na página 508.
20
Novidades do ActionScript no Flash 8
■
O dimensionamento em 9 trechos permite o dimensionamento de instâncias de clipe de
filme sem expansão dos traços que contornam o clipe de filme. Você pode usar o código
ActionScript para acessar esse recurso no Flash Basic 8 e no Flash Professional 8 ou na
ferramenta de criação do Flash 8. Para obter mais informações, consulte “Trabalhando
com dimensionamento de 9 trechos no ActionScript” na página 585. Para obter
informações sobre como acessar o dimensionamento em 9 trechos na ferramenta de
criação, consulte “Sobre dimensionamento em 9 trechos e símbolos de clipe de filme”
na página 91 em Usando o Flash.
■
Agora você pode adicionar informações de metadados para os arquivos FLA na caixa de
diálogo Publish Settings (Configurações de publicação). Pode adicionar um nome e uma
descrição ao arquivo FLA usando a caixa de diálogo para ajudar a aumentar a visibilidade
da pesquisa on-line.
■
O painel Strings (Seqüências de caracteres) está aprimorado e agora inclui suporte
multilinha no campo String e um arquivo de linguagem XML. Para obter mais
informações, consulte “Sobre o painel Strings” na página 479.
■
Um novo coletor de lixo faz parte do Flash Player, que usa um coletor incremental para
melhorar o desempenho.
■
O fluxo de trabalho para a criação de aplicativos acessíveis está aprimorado. No Flash
Player 8 não há mais necessidade de os desenvolvedores adicionarem todos os objetos ao
índice de tabulação para que o conteúdo seja lido corretamente por um leitor de tela. Para
obter mais informações sobre o índice de tabulação, consulte tabIndex
(Button.tabIndex property), tabIndex (MovieClip.tabIndex property) e
tabIndex (TextField.tabIndex property) em ActionScript 2.0 Language Reference.
■
O Flash Player aumentou a segurança dos arquivos locais; agora há mais segurança quando
os arquivos SWF são executados no disco rígido. Para obter informações sobre segurança
de arquivos locais, consulte “Sobre segurança do arquivo local e o Flash Player”
na página 709.
■
Usando o código ActionScript, você pode usar a API Drawing (API de desenho) para
controlar o estilo de linhas dos traços desenhados. Para obter informações sobre novos
estilos de linha, consulte “Usando estilos de linha” na página 574.
■
Usando o código ActionScript, você poderá usar a API Drawing para criar gradientes mais
complexos com os quais preencherá as formas. Para obter informações sobre
preenchimentos de gradiente, consulte “Usando preenchimentos de gradiente complexos”
na página 573.
■
Você pode usar o código ActionScript para aplicar muitos filtros a objetos no Stage (como
instâncias de clipe de filme). Para obter informações sobre filtros e o ActionScript,
consulte “Trabalhando com filtros usando ActionScript” na página 534.
Novidades do ActionScript 2.0 e do Flash 8
21
■
Para fazer o upload dos arquivos para um servidor, use as APIs FileReference e
FileReferenceList. Para obter mais informações, consulte “Sobre upload e download de
arquivos” na página 674.
■
Você pode usar o código ActionScript para acessar meios novos e avançados de aplicar e
manipular cores. Para obter mais informações, consulte “Definindo valores de cores”
na página 599 e ColorTransform (flash.geom.ColorTransform) em ActionScript 2.0
Language Reference.
■
Foram feitos diversos aprimoramentos no texto, incluindo novas opções, propriedades e
parâmetros nas classes TextField e TextFormat. Para obter mais informações, consulte
TextField e TextFormat em ActionScript 2.0 Language Reference.
■
Para acessar os recursos avançados de eliminação de serrilhado (FlashType), use o código
ActionScript. Para obter mais informações, consulte “Sobre a renderização de fontes e
texto sem serrilhado” na página 430.
■
Quando testar o aplicativo, você poderá excluir os arquivos ASO. Selecione Control
(Controlar) > Delete ASO files (Excluir arquivos ASO) ou Control > Delete ASO files e
Test Movie (Testar filme) na ferramenta de criação. Para obter informações, consulte
“Usando arquivos ASO” na página 298.
Para obter uma lista de classes, elementos de linguagem, métodos e propriedades específicas
adicionadas ao ActionScript 2.0 no Flash 8, consulte “Acréscimos à linguagem ActionScript”
na página 22.
Acréscimos à linguagem ActionScript
Esta seção lista acréscimos aos elementos e classes da linguagem ActionScript novos ou
alterados no Flash 8. As classes e os elementos de linguagem a seguir são novos acréscimos ao
Flash Player 8 ou passaram a ter suporte recentemente nesse programa.
As classes a seguir foram adicionadas ao ActionScript 2.0 no Flash 8:
■
A classe BevelFilter (do pacote flash.filters) permite a adição de efeitos de chanfro a
objetos.
■
A classe BitmapData (do pacote flash.display) permite a criação e a manipulação de
imagens de bitmap transparentes ou opacas dimensionadas arbitrariamente.
■
A classe BitmapFilter (do pacote flash.display) é uma classe base para efeitos de filtro.
■
A classe BlurFilter permite a aplicação de embaçamentos a objetos no Flash.
■
A classe ColorMatrixFilter (do pacote flash.filters) permite a aplicação de transformações a
cores ARGB e valores alfa.
■
A classe ColorTransform (do pacote flash.geom) permite o ajuste de valores de cores em
clipes de filme. A classe Color é obsoleta em relação a esta classe.
22
■
A classe ConvolutionFilter (do pacote flash.filters) permite a aplicação de efeitos de filtro
de torção de matriz.
■
A classe DisplacementMapFilter (do pacote flash.filters) permite o uso de valores em pixels
de um objeto BitmapData para o deslocamento de um objeto.
■
A classe DropShadowFilter (do pacote flash.filters) permite a adição de sombreamentos a
objetos.
■
A classe ExternalInterface (do pacote flash.external) permite que você se comunique
usando o ActionScript com o recipiente do Flash Player (o sistema que contém o
aplicativo Flash, como um navegador com JavaScript, ou o aplicativo desktop).
■
A classe FileReference (do pacote flash.net ) permite o upload e o download de arquivos
entre o computador do usuário e um servidor.
■
A classe FileReferenceList (do pacote flash.net) permite a seleção de um ou mais arquivos
para upload.
■
A classe GlowFilter (do pacote flash.filters) permite a adição de efeitos de brilho a objetos.
■
A classe GradientBevelFilter (do pacote flash.filters) permite a adição de chanfros
gradientes a objetos.
■
A classe GradientGlowFilter (do pacote flash.filters) permite a adição de efeitos de brilho
gradiente a objetos.
■
A classe IME (da classe System) permite a manipulação do IME (Input Method Editor,
Editor de método de entrada) do sistema operacional no Flash Player.
■
A classe Locale (do pacote mx.lang) permite o controle do modo de exibição de texto
multilíngüe em um arquivo SWF.
■
A classe Matrix (do pacote flash.geom) representa uma matriz de transformação que
determina como mapear pontos de um espaço de coordenada para o outro.
■
O objeto Point (do pacote flash.geom) representa um local em um sistema de coordenadas
bidimensional, onde x representa o eixo horizontal e y representa o eixo vertical.
■
A classe Rectangle (do pacote flash.geom) permite a criação e a modificação de objetos
Rectangle.
■
A classe TextRenderer (do pacote flash.text) oferece funcionalidade para fontes
incorporadas sem serrilhado.
■
A classe Transform (do pacote flash.geom) coleta dados sobre transformações de cores e
manipulações de coordenadas aplicadas a uma instância MovieClip.
N O TA
No Flash 8 foi adicionado suporte oficial para a classe AsBroadcaster.
23
Os novos elementos, métodos e funções da linguagem adicionados a classes existentes no
ActionScript incluem:
■
A função global showRedrawRegions permite que o player do depurador indique as
regiões da tela que estão sendo redesenhadas (ou seja, regiões problemáticas que estão
sendo atualizadas). A função faz o player mostrar o que foi redesenhado, mas não permite
que você controle as regiões de redesenho.
■
A propriedade blendMode da classe Button, que define o modo de mistura para a instância
do botão.
■
A propriedade cacheAsBitmap da classe Button, que permite o cache do objeto como
representação interna de bitmap da instância.
■
A propriedade filters da classe Button, que é um array indexado que contém cada
objeto filtro associado ao botão.
■
A propriedade scale9Grid da classe Button, que é a região retangular que define nove
regiões de dimensionamento para a instância.
■
A propriedade hasIME da classe System.capabilities, que indica se o sistema possui um
IME instalado.
■
A propriedade getUTCYear da classe Date, que retorna o ano dessa data, de acordo com a
hora universal.
■
A constante ALT da classe Key.
■
O método isAccessible() da classe Key retorna um valor booleano que indica se a
última tecla pressionada pode ser acessada por outros arquivos SWF, dependendo das
restrições de segurança.
■
O manipulador de eventos onHTTPStatus da classe LoadVars retorna o código de status
retornado do servidor (por exemplo, o valor 404 para página não encontrada). Para obter
mais informações, consulte onHTTPStatus (LoadVars.onHTTPStatus handler) em
ActionScript 2.0 Language Reference.
■
O método attachBitmap() da classe MovieClip, que anexa uma imagem de bitmap a um
clipe de filme. Para obter mais informações, consulte BitmapData
(flash.display.BitmapData) em ActionScript 2.0 Language Reference.
■
O método beginBitmapFill() da classe MovieClip, que preenche um clipe de filme com
uma imagem de bitmap.
■
Os parâmetros spreadMethod, interpolationMethod e focalPointRatio do método
beginGradientFill() da classe MovieClip. Esse método preenche uma área de desenho
com uma imagem de bitmap, e o bitmap pode ser repetido ou colocado lado a lado para
preencher a área.
24
■
A propriedade blendMode da classe MovieClip, que permite a definição do modo de
mistura para a instância.
■
A propriedade cacheAsBitmap da classe MovieClip, que permite o cache do objeto como
uma representação interna de bitmap da instância.
■
A propriedade filters da classe MovieClip, que é um array indexado que contém cada
objeto filtro associado no momento à instância.
■
O método getRect() da classe MovieClip, que retorna propriedades que são os valores de
coordenada mínimo e máximo da instância especificada.
■
O método lineGradientStyle() da classe MovieClip, que especifica um estilo de linha
gradiente que o Flash usa quando desenha um caminho.
■
Os parâmetros pixelHinting, noScale, capsStyle, jointStyle e miterLimit do
método lineStyle() da classe MovieClip. Esses parâmetros especificam tipos de estilos
de linha que você pode usar ao desenhar linhas.
■
A propriedade opaqueBackground da classe MovieClip, que define a cor de fundo opaca
(não transparente) do clipe de filme como a cor que o valor hexadecimal RGB especifica.
■
A propriedade scale9Grid da classe MovieClip, que é a região retangular que define nove
regiões de dimensionamento para a instância.
■
A propriedade scrollRect da classe MovieClip, que permite que você role rapidamente o
conteúdo do clipe de filme e que a janela exiba um conteúdo maior.
■
A propriedade transform da classe MovieClip, que permite configurações em relação aos
limites de matriz, transformação de cores e pixels de um clipe de filme. Para obter mais
informações, consulte Transform (flash.geom.Transform) em ActionScript 2.0
Language Reference.
■
O parâmetro status da classe MovieClipLoader. O manipulador de eventos
onLoadComplete retorna o código de status retornado do servidor (por exemplo, o valor
404 para página não encontrada). Para obter mais informações, consulte onLoadComplete
(MovieClipLoader.onLoadComplete event listener) em ActionScript 2.0 Language
Reference.
■
O manipulador de eventos onLoadError da classe MovieClipLoader é chamado quando
um arquivo carregado com MovieClipLoader.loadClip() não pode ser carregado.
■
O parâmetro secure do método SharedObject.getLocal() determina se o acesso a esse
objeto compartilhado se restringe a arquivos SWF transmitidos por uma conexão
HTTPS. Para obter mais informações, consulte getLocal (SharedObject.getLocal
method) em ActionScript 2.0 Language Reference.
■
A constante ID3 da classe Sound.
25
■
A propriedade sandboxType da classe System.security indica o tipo de sandbox de
segurança em que o arquivo SWF de chamada está operando. Para obter mais
informações, consulte sandboxType (security.sandboxType property) em
■
O método parse() da classe TextField.StyleSheet.
■
A propriedade antiAliasType da classe TextField, que define o tipo de eliminação de
serrilhado utilizada na instância TextField.
■
A propriedade filters da classe TextField, que é um array indexado que contém cada
objeto filtro associado no momento à instância TextField.
■
A propriedade gridFitType da classe TextField, que define o tipo de ajuste à grade usado
na instância. Para obter informações sobre ajuste à grade e TextField.gridFitType, consulte
gridFitType (TextField.gridFitType property) em ActionScript 2.0 Language
Reference.
■
A propriedade sharpness da classe TextField, que estabelece a definição das bordas de
glifo para a instância TextField. Se usar essa propriedade, terá de definir o método
antiAliasType() como avançado.
■
A propriedade thickness da classe TextField, que define a espessura das bordas de glifo
na instância TextField. Se usar essa propriedade, terá de definir o método
antiAliasType() como avançado.
■
O valor justify da propriedade align da classe TextFormat, que permite a justificação
de um parágrafo específico.
■
A propriedade indent da classe TextFormat, que permite o uso de valores negativos.
■
A propriedade kerning da classe TextFormat, que permite a ativação ou desativação do
kerning para o objeto TextFormat.
■
A propriedade leading da classe TextFormat, que permite o uso de entrelinhamento
negativo, ou seja, que o espaço entre as linhas seja inferior à altura do texto. Isso permite
que você coloque linhas de texto juntas nos aplicativos.
■
A propriedade letterSpacing da classe TextFormat, que permite a especificação da
quantidade de espaço distribuída uniformemente entre os caracteres.
■
A propriedade _alpha da classe Video, que é a quantidade especificada de transparência
para o objeto vídeo.
■
A propriedade _height da classe Video, que indica a altura da instância do vídeo.
■
A propriedade _name da classe Video, que indica o nome de instância do vídeo.
■
A propriedade _parent da classe Video, que indica a instância ou objeto de clipe de vídeo
que contém a instância do vídeo.
26
■
A propriedade _rotation da classe Video, que permite a definição do valor de rotação da
instância do vídeo em graus.
■
A propriedade _visible da classe Video, que permite a definição da visibilidade de uma
instância de vídeo.
■
A propriedade _width da classe Video, que permite a definição da largura da instância do
vídeo.
■
A propriedade _x da classe Video, que permite a definição da coordenada x da instância do
vídeo.
■
A propriedade _xmouse da classe Video, que permite a definição da coordenada x da
posição do ponteiro do mouse.
■
A propriedade _xscale da classe Video, que permite a definição do percentual de
dimensionamento horizontal da instância do vídeo.
■
A propriedade _y da classe Video, que permite a definição da coordenada y da instância do
vídeo.
■
A propriedade _ymouse da classe Video, quer permite a definição da coordenada y da
posição do ponteiro do mouse.
■
A propriedade _yscale da classe Video, que permite a definição do percentual de
dimensionamento vertical da instância do vídeo.
■
O manipulador de eventos onHTTPStatus da classe XML retorna o código de status
retornado do servidor (por exemplo, o valor 404 para página não encontrada). Para obter
mais informações, consulte onHTTPStatus (XML.onHTTPStatus handler) em
■
A propriedade localName da classe XMLNode, que retorna o nome completo do objeto
nó XML (incluindo o prefixo e o nome local).
■
A propriedade namespaceURI da classe XMLNode, que lê o URI do namespace para o
qual o prefixo do nó XML resolve. Para obter mais informações, consulte namespaceURI
(XMLNode.namespaceURI property) em ActionScript 2.0 Language Reference.
■
A propriedade prefix da classe XMLNode, que lê o prefixo do nome do nó.
■
O método getNamespaceForPrefix() da classe XMLNode, que retorna o URI do
namespace associado ao prefixo especificado para o nó.
■
O método getPrefixForNamespace da classe XMLNode, que retorna o prefixo associado
a um URI de namespace especificado para o nó.
27
Sobre elementos de linguagem obsoletos
Alguns elementos de linguagem estão obsoletos no Flash Player 8. Para obter uma lista dos
elementos de linguagem obsoletos e alternativas para uso no Flash Player 8, consulte as seções
a seguir do ActionScript 2.0 Language Reference:
■
Deprecated Class summary
■
Deprecated Function summary
■
Deprecated Property summary
■
Deprecated Operator summary
Alterações de edição do ActionScript
O editor do ActionScript no painel Actions e na janela Script foi atualizado de várias maneiras
para ficar mais eficiente e fácil de usar do que nas versões anteriores da ferramenta. Essas
alterações são resumidas nesta seção.
Agora você pode usar o menu pop-up
Options (Opções) dos painéis Script, Debugger (Depurador) e Output (Saída) para exibir ou
ocultar caracteres quando escrever arquivos de script no painel Actions ou na janela Script.
Para obter informações sobre esse recurso, consulte “Exibindo caracteres ocultos”
na página 57.
View hidden characters (Exibir caracteres ocultos)
Nas
versões anteriores do Flash, você podia trabalhar no painel Actions tanto no modo normal, em
que você preenchia opções e parâmetros para criar código, quanto no modo especialista, em
que você adicionava comandos diretamente ao painel Script. Essas opções não estavam
disponíveis no Flash MX 2004 e no Flash MX Professional 2004. No entanto, no Flash Basic
8 e no Flash Professional 8, você pode trabalhar no modo Script Assist, que é semelhante ao
modo normal e muito mais eficiente que ele. Para obter informações sobre o modo Script
Assist, consulte Capítulo 13, “Criando ActionScript com o Script Assist” em Usando o Flash.
Para ver um tutorial sobre o Script Assist, consulte o Capítulo 13, “Criando um evento
startDrag/stopDrag com o Script Assist” do manual Usando o Flash.
Script assist added to Actions panel (Script assist adicionado ao painel Actions)
28
Você pode recarregar os
arquivos de script modificados quando trabalhar em um aplicativo. É exibida uma mensagem
de aviso, solicitando o recarregamento dos arquivos de script modificados associados ao
aplicativo em que você está trabalhando. Esse recurso é especialmente vantajoso para equipes
que trabalham simultaneamente em aplicativos. Ele ajuda a evitar o trabalho com scripts
desatualizados ou que versões mais recentes de um script acabem sendo substituídas. Se um
arquivo de script tiver sido movido ou excluído, uma mensagem de aviso será exibida e
solicitará o salvamento dos arquivos conforme necessário. Para obter mais informações,
consulte “Sobre as preferências do ActionScript” na página 44.
Reload modified files (Recarregar arquivos modificados)
Alterações no modelo de segurança para
arquivos SWF instalados localmente
O Flash Player 8 possui um modelo de segurança novo e aperfeiçoado por meio do qual os
aplicativos Flash e os arquivos SWF de um computador local podem se comunicar com a
Internet e o sistema de arquivos local, em vez de serem executados de um servidor remoto da
Web. Ao desenvolver um aplicativo Flash, você precisa indicar se um arquivo SWF pode se
comunicar com uma rede ou com um sistema de arquivos local.
N OT A
Nesta descrição, um arquivo SWF local é um arquivo SWF instalado localmente no
computador de um usuário (e não disponibilizado a partir de um site) e não inclui
arquivos de projetor (EXE).
Nas versões anteriores do Flash Player, os arquivos SWF locais podiam interagir com outros
arquivos SWF e carregar dados de qualquer computador remoto ou local sem configurar
definições de segurança. No Flash Player 8, um arquivo SWF não pode fazer conexões com o
sistema de arquivos local e a rede (como a Internet) no mesmo aplicativo sem fazer uma
configuração de segurança. Isso é para sua segurança. Dessa forma, um arquivo SWF não pode
ler arquivos no seu disco rígido e depois enviar o conteúdo deles pela Internet.
A restrição de segurança afeta todo o conteúdo implantado localmente, seja um conteúdo
herdado (um arquivo FLA criado em uma versão anterior do Flash) ou criado no Flash 8.
Usando o Flash MX 2004 ou uma ferramenta de criação anterior, você pode testar um
aplicativo Flash que seja executado localmente e também acesse a Internet. No Flash Player 8,
esse aplicativo agora solicita permissão ao usuário para se comunicar com a Internet.
Alterações no modelo de segurança para arquivos SWF instalados localmente
29
Quando você testa um arquivo no disco rígido, são necessárias várias etapas para determinar se
ele é um documento local confiável (seguro) ou um documento potencialmente não-confiável
(sem segurança). Se você criar o arquivo no ambiente de criação do Flash (por exemplo,
quando selecionar Control > Test Movie), seu arquivo será considerado confiável, pois ele se
encontra no ambiente de teste.
No Flash Player 7 e anteriores, os arquivos SWF locais tinham permissões para acessar o
sistema de arquivos local e a rede. No Flash Player 8, os arquivos SWF locais podem ter três
níveis de permissão:
■
Access the local file system only (Acessar somente o sistema de arquivos local), o nível
padrão. O arquivo SWF local pode ser lido no sistema de arquivos local e em caminhos de
rede de convenção universal de atribuição de nomes (UNC, Universal Naming
Convention) e não pode se comunicar com a Internet.
■
Access the network only (Acessar somente a rede). O arquivo SWF local pode acessar
somente a rede (como a Internet) e não o sistema de arquivos local onde o arquivo SWF
está instalado.
■
Access to both the local file system and the network (Acessar o sistemas de arquivos local e
a rede). O arquivo SWF local pode ser lido no sistema de arquivos local onde o arquivo
está instalado, pode ser lido em qualquer servidor que lhe conceda permissão (e gravar
nele) e pode criar vários scripts para outros arquivos SWF na rede ou no sistema de
arquivos local que lhe conceda permissão.
Para obter mais detalhes sobre cada nível de permissão, consulte “Sobre segurança do arquivo
local e o Flash Player” na página 709.
Há também pequenas alterações em System.security.allowDomain e aprimoramentos em
System.security.allowInsecureDomain. Para obter mais informações sobre segurança de
arquivos locais, consulte o Capítulo 17, “Noções básicas de segurança.”
30
CAPÍTULO 2
2
Escrevendo e editando o
ActionScript 2.0
Ao escrever o código ActionScript no Macromedia Flash Basic 8 ou no Macromedia Flash
Professional 8, use o painel Actions (Ações) ou a janela Script. O painel Actions e a janela
Script contêm um editor de código completo (o editor do ActionScript) que inclui referências
de código e sinalização por cores, formatação de código, realce de sintaxe, verificação de
sintaxe, depuração, números de linha, quebra automática de linha e suporte a Unicode em
duas exibições diferentes. Para obter mais informações sobre o editor do ActionScript,
consulte “Usando o painel Actions e a janela Script” na página 36.
Use um dos dois métodos para escrever o código ActionScript no Flash. Você pode criar
scripts que façam parte de seu documento do Flash (ou seja, scripts incorporados ao arquivo
FLA) ou criar scripts externos (scripts ou classes armazenadas em arquivos externos). Não é
possível usar o painel Actions para criar scripts externos.
Use o editor do ActionScript no painel Actions ao criar scripts em um arquivo FLA. O painel
Actions contém o editor do ActionScript em um painel Script e ferramentas de suporte para
facilitar a criação de scripts. Essas ferramentas incluem a caixa de ferramentas Actions (Ações)
que oferece um acesso rápido aos elementos básicos da linguagem ActionScript; o navegador
Script que ajuda na navegação por todos os scripts do documento; e o modo Script Assist
(Assistência de script) que solicita os elementos necessários para a criação de scripts. Para obter
mais informações sobre o painel Actions, consulte “Sobre o painel Actions” na página 37. Para
obter mais informações sobre o Script Assist, consulte “Sobre o Script Assist” na página 62.
Quando precisar criar um script externo, use o editor do ActionScript na janela Script para
criar um novo arquivo do ActionScript. (Você também pode usar o seu editor de texto favorito
para criar um arquivo externo do AS.) Na janela Script, o editor do Action Script inclui
recursos de assistência a código, como referências de código e sinalização por cores, verificação
de sintaxe etc., da mesma forma que no painel Actions. Para obter mais informações sobre a
janela Script, consulte “Sobre a janela Script” na página 38.
31
O Flash oferece assistência adicional a scripts através de comportamentos. Os
comportamentos são funções predefinidas do ActionScript que você pode anexar a objetos no
documento do Flash sem precisar criar o código ActionScript. Para obter mais informações
sobre comportamentos, consulte “Sobre comportamentos” na página 65.
Para obter mais informações sobre como manipular eventos, consulte as seguintes seções:
Sobre o ActionScript e eventos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Organizando o código ActionScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Usando o painel Actions e a janela Script. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Sobre o painel Actions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Sobre a janela Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Sobre a codificação no painel Actions e na janela Script . . . . . . . . . . . . . . . . . . . . . . 39
Sobre recursos do painel Actions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Sobre comportamentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Sobre as configurações de publicação do ActionScript . . . . . . . . . . . . . . . . . . . . . . . 66
Sobre o ActionScript e eventos
No Macromedia Flash Basic 8 e no Macromedia Flash Professional 8, o código ActionScript é
executado quando ocorre um evento: por exemplo, quando um clipe de filme é carregado,
quando um quadro-chave é inserido na timeline ou quando o usuário clica em um botão. Os
eventos podem ser ativados pelo usuário ou pelo sistema. Os usuários clicam em botões do
mouse e pressionam teclas; o sistema ativa eventos quando condições específicas são atendidas
ou quando processos são concluídos (o arquivo SWF é carregado, a timeline alcança um
determinado quadro, um elemento gráfico conclui o download etc.).
Quando ocorre um evento, você cria um manipulador de eventos para responder ao evento com
uma ação. Compreender quando e onde ocorrerão os eventos o ajudará a determinar como e
onde você responderá a eles com uma ação e quais ferramentas do ActionScript utilizará em
cada caso. Para obter mais informações, consulte “Sobre a criação de scripts para manipular
eventos” na página 35.
Os eventos podem ser agrupados em várias categorias: eventos de mouse e teclado, que
ocorrem quando o usuário interage com seu aplicativo Flash através do mouse e do teclado;
eventos de clipe, que ocorrem em clipes de filme; e eventos de quadro, que ocorrem em
quadros na timeline.
Para obter informações sobre os tipos de scripts que podem ser criados para manipular
eventos, consulte “Sobre a criação de scripts para manipular eventos” na página 35.
32
Escrevendo e editando o ActionScript 2.0
Eventos de mouse e teclado
Quando o usuário interage com seu aplicativo ou arquivo SWF, ele ativa eventos de mouse e
teclado. Por exemplo, quando ele rola sobre um botão, ocorre o evento Button.onRollOver
ou on(rollOver); quando ele clica em um botão, o evento Button.onRelease é ativado; se
uma tecla do teclado for pressionada, o evento on(keyPress) ocorrerá. Você pode criar um
código em um quadro ou anexar scripts a uma instância para manipular esses eventos e
adicionar toda a interatividade desejada.
Eventos de clipe
Em um clipe de filme, você pode reagir a diversos eventos de clipe ativados quando o usuário
entra ou sai da cena ou interagir com a cena usando o mouse ou o teclado. Por exemplo, você
pode carregar uma imagem externa SWF ou JPG no clipe de filme quando o usuário entrar na
cena ou permitir que os movimentos do mouse do usuário reposicionem elementos na cena.
Eventos de quadro
Em uma timeline principal ou de clipe de filme, um evento de sistema ocorre quando a
reprodução entra em um quadro-chave — conhecido como evento de quadro. Os eventos de
quadro são úteis para ativar ações baseadas na passagem de tempo (que se movem pela
timeline) ou para interagir com elementos visíveis no momento no Stage. Quando você
adiciona um script a um quadro-chave, ele é executado quando o quadro-chave é alcançado
durante uma reprodução. Os script anexados a um quadro são chamados scripts de quadro.
Uma das utilizações mais comuns dos scripts de quadro é interromper a reprodução quando
um determinado quadro-chave é alcançado. Isso é feito com a função stop(). Selecione um
quadro-chave e adicione a função stop() como um elemento de script no painel Actions.
Ao interromper arquivo SWF em um quadro-chave específico, você precisará executar uma
ação. Você pode, por exemplo, usar um script de quadro para atualizar dinamicamente o valor
de um rótulo, gerenciar a interação dos elementos no Stage etc.
Sobre o ActionScript e eventos
33
Organizando o código ActionScript
É possível anexar scripts a quadros-chave e instâncias de objeto (clipes de filme, botões e
outros símbolos). Entretanto, se o seu código ActionScript for distribuído por vários quadroschave e instâncias de objeto, a depuração de seu aplicativo ficará muito mais difícil. Também
será difícil compartilhar o código com diferentes aplicativos Flash. Portanto, é importante que
você siga as práticas recomendadas de codificação ao criar o ActionScript no Flash.
Em vez de anexar scripts aos elementos, como quadros-chave, clipes de filme e botões,
responda aos eventos chamando as funções residentes em um local central. Um dos métodos
consiste em anexar o ActionScript incorporado ao primeiro ou ao segundo quadro da
timeline, sempre que possível, para que você não precise pesquisar o arquivo FLA a fim de
localizar todo o código. Uma prática comum envolve a criação de uma camada denominada
actions e a inclusão do código ActionScript nessa camada.
Ao anexar todos os scripts a elementos individuais, você incorpora todo o código ao arquivo
FLA. Se o compartilhamento de seu código com outros aplicativos do Flash for um requisito
importante para você, use a janela Script ou o seu editor de texto favorito para criar um
arquivo externo do ActionScript (AS).
A criação de um arquivo externo torna o seu código mais modular e bem organizado. À
medida que seu projeto for se desenvolvendo, essa conveniência terá cada vez mais utilidade
do que você imagina. Um arquivo externo ajudará na depuração e também no gerenciamento
do controle de origem caso você esteja trabalhando em um projeto junto com outros
desenvolvedores.
Para usar o código ActionScript contido em um arquivo externo do AS, crie um script no
arquivo FLA e use a instrução #include para acessar o código armazenado externamente,
como mostrado no exemplo a seguir:
#include "../core/Functions.as"
34
Também é possível usar o ActionScript 2.0 para criar classes personalizadas. Armazene as
classes personalizadas em arquivos externos do AS e use instruções import em um script para
exportar as classes para o arquivo SWF, em vez de usar instruções #include. Para obter mais
informações sobre como criar arquivos de classe, consulte “Criando arquivos de classes
personalizados” na página 249 e “Sobre a importação de arquivos de classes” na página 254
que tratam da importação desses arquivos. Você também pode usar componentes (clipes de
filme predefinidos) para compartilhar código e funcionalidade, como scripts e elementos de
UI.
NO T A
O código do ActionScript em arquivos externos é compilado em um arquivo SWF
quando você publica, exporta, testa ou depura um arquivo FLA. Portanto, se você fizer
qualquer alteração em um arquivo externo, será preciso salvá-lo e recompilar os
arquivos FLA que o utilizam.
Ao criar o ActionScript no Flash 8, use o painel Actions, a janela Script ou ambos. O uso do
painel Actions ou da janela Script é determinado pelo modo de resposta aos eventos, pelo
modo de organização do código e, principalmente, pelas práticas recomendadas de
codificação.
Para obter mais informações sobre convenções e práticas recomendadas de codificação,
consulte “Convenções de codificação do ActionScript” na página 782.
Outros problemas relacionados a fluxo de trabalho e organização de código deverão ser
considerados quando você usar comportamentos, que são funções predefinidas do
ActionScript (consulte “Sobre comportamentos” na página 65).
Sobre a criação de scripts para manipular eventos
A criação de código para eventos pode ser categorizada em dois grupos principais: eventos que
ocorrem na timeline (em quadros-chave) e eventos que ocorrem em instâncias de objeto
(clipes de filme, botões e componentes). A interatividade de seu aplicativo ou arquivo SWF
pode ser distribuída pelos vários elementos de seu projeto; você também pode optar por
adicionar scripts diretamente a esses elementos. Entretanto, a Macromedia recomenda a não
adição direta de scripts a esses elementos (quadros-chave e objetos). Nesse caso, você deve
responder aos eventos chamando as funções residentes em um local central, conforme descrito
em “Organizando o código ActionScript”.
Organizando o código ActionScript
35
Usando o painel Actions e a janela Script
Para criar scripts em um arquivo FLA, insira o ActionScript diretamente no painel Actions.
Para criar scripts externos a serem incluídos ou importados para o seu aplicativo, você pode
usar a janela Script (File [Arquivo] > New [Novo] e selecionar ActionScript File [Arquivo do
ActionScript]) ou o seu editor de texto preferido.
A utilização do painel Actions ou da janela Script equivale ao uso dos recursos do editor do
ActionScript para criar, formatar e editar o código. O painel Actions e a janela Script possuem
o painel Script (onde o código é digitado) e a caixa de ferramentas Actions. O painel Actions
oferece mais alguns recursos de assistência a código do que a janela Script. O Flash oferece
esses recursos no painel Actions por eles serem especialmente úteis no contexto de edição do
ActionScript em um arquivo FLA.
Para exibir o painel Actions, siga um destes procedimentos:
■
Selecione Window (Janela) > Actions (Ações).
■
Pressione F9.
Para exibir a janela Script, siga um destes procedimentos:
■
Para começar a escrever um novo script, selecione File (Arquivo) > New (Novo) e
ActionScript File (Arquivo do ActionScript).
■
Para abrir um script existente, selecione File > Open (Abrir) e abra um arquivo do AS.
■
Para editar um script já aberto, clique na guia do documento que exibe o nome do script.
Para obter mais informações, consulte os tópicos a seguir:
■
“Sobre o painel Actions” na página 37
■
“Sobre a janela Script” na página 38
36
Sobre o painel Actions
Use o painel Actions para criar o ActionScript em um documento do Flash (arquivo FLA). O
painel consiste em três painéis, e cada um deles oferece suporte à criação e ao gerenciamento
de scripts.
Actions (Ações), caixa
Navegador Script
de ferramentas
Script, painel
Menu pop-up
Caixa de ferramentas Actions Use esta caixa de ferramentas para pesquisar uma lista
categórica de elementos da linguagem ActionScript (funções, classes, tipos etc.) e, em
seguida, insira-os no painel Script. Para inserir um elemento de script no painel Script,
clique duas vezes nele ou arraste-o diretamente para esse painel. Você também pode
adicionar elementos de linguagem aos scripts usando o botão Add (+) (Adicionar)
localizado na barra de ferramentas do painel Actions. Para obter mais informações,
consulte “Sobre as barras de ferramentas do painel Actions e da janela Script”
na página 40.
Exibe uma lista hierárquica de elementos do Flash (clipes de filme,
quadros e botões) contendo scripts. Use o navegador Script para se mover rapidamente
entre todos os scripts do documento do Flash.
Navegador Script
Se você clicar em um item no navegador Script, o script associado a esse item aparecerá no
painel Script e a reprodução passará para essa posição na timeline. Se você clicar duas vezes
em um item do navegador Script, o script ficará preso (travado no lugar). Para obter mais
informações, consulte “Prendendo scripts no painel Actions” na página 63.
Sobre o painel Actions
37
No painel Script, você digita seu código. O painel fornece ferramentas
para a criação de scripts em um editor completo (o editor do ActionScript) que inclui
verificação e formatação de sintaxe, referências de código, sinalização por cores, depuração
e outros recursos que simplificam a criação. Para obter mais informações, consulte
“Usando o painel Actions e a janela Script” na página 36.
Painel Script
Para obter informações sobre cada botão da barra de ferramentas do painel Actions,
consulte “Sobre a codificação no painel Actions e na janela Script” na página 39. Para
obter mais informações sobre os recursos do painel Actions, consulte os seguintes tópicos:
■
“Sobre as barras de ferramentas do painel Actions e da janela Script” na página 40
■
“Sobre as opções de edição do ActionScript” na página 42
■
“Sobre as referências de código no Flash” na página 47
■
“Formatando código” na página 53
■
“Usando o realce de sintaxe” na página 54
■
“Usando números de linha e quebra automática de linha” na página 55
■
“Usando teclas de atalho de Escape” na página 56
■
“Exibindo caracteres ocultos” na página 57
■
“Usando a ferramenta Find” na página 58
■
“Verificando sintaxe e pontuação” na página 59
■
“Importando e exportando scripts” na página 60
Sobre a janela Script
Você pode criar e editar o ActionScript na janela Script ao criar um novo arquivo do
ActionScript, do Flash Communication ou do Flash JavaScript. Use a janela Script para criar e
editar arquivos de script externos. A janela oferece suporte à sinalização da sintaxe por cores, a
referências de código e a outras opções de editor.
Nessa janela, é possível criar um ActionScript externo, a comunicação do ActionScript e
arquivos do Flash JavaScript. Dependendo do tipo de arquivo de script externo criado, a caixa
de ferramentas Actions fornecerá uma lista completa dos elementos de linguagem disponíveis
para cada um deles.
Ao usar a janela Script, você perceberá que alguns dos outros recursos de assistência a código,
como o navegador Script, o modo Script Assist e os comportamentos, não estarão disponíveis.
Isso ocorre porque esses recursos são úteis apenas no contexto de criação de um documento do
Flash, e não de criação de um arquivo de script externo.
38
Você também observará que várias opções disponíveis no painel Actions não estão disponíveis
na janela Script. A janela Script oferece suporte às seguintes opções de editor: caixa de
ferramentas Actions, recursos localizar e substituir, verificação de sintaxe, formatação
automática, referências de código e opções de depuração (somente arquivos do ActionScript).
Além disso, ela oferece suporte à exibição de números de linha, caracteres ocultos e quebra
automática de linha.
Para exibir a janela Script:
1.
Selecione File (Arquivo) > New (Novo).
2.
Selecione o tipo de arquivo externo que deseja criar (arquivo do ActionScript, arquivo do
Flash Communication ou arquivo do Flash JavaScript).
É possível abrir vários arquivos externos ao mesmo tempo; os nomes dos arquivos são exibidos
em guias na parte superior da janela Script. Para obter mais informações sobre os recursos da
janela Script, consulte os seguintes tópicos:
■
■
■
■
■
■
■
■
■
■
■
Sobre a codificação no painel Actions e
na janela Script
O painel Script, local de edição do código, é o principal elemento do painel Actions e da
janela Script. O painel Actions e a janela Script oferecem recursos básicos de assistência a
código e de edição de script, como referências de código, sinalização por cores, formatação
automática etc.
Os recursos que ajudam na edição do código podem ser acessados na barra de ferramentas do
painel Actions ou da janela Script, através do sistema de menu e no próprio painel Script.
Sobre a codificação no painel Actions e na janela Script
39
Os tópicos a seguir apresentam os vários recursos do editor do ActionScript (painel Actions e
janela Script):
■
■
■
“Sobre as preferências do ActionScript” na página 44
■
■
■
■
■
■
■
■
■
Para obter os recursos específicos apenas do painel Actions, por exemplo, prender o script e
navegador Script, consulte “Sobre recursos do painel Actions” na página 62.
Sobre as barras de ferramentas do painel Actions e
da janela Script
As barras de ferramentas do painel Actions e da janela Script contêm links para os recursos de
assistência a código que ajudam a simplificar e agilizar a codificação no ActionScript. Elas
serão diferentes caso você utilize o editor do ActionScript no painel Actions ou no painel
Script. A imagem a seguir exibe os recursos localizados na barra de ferramentas do painel
Actions. As opções marcadas estão disponíveis apenas no painel Actions.
Add a new item to the script (Adicionar um novo item ao script)
Find (Localizar)
Menu pop-up*
Debug Options (Opções de depuração)*
Insert target path (Inserir caminho de destino)* Script Assist *
Show Code Hint (Mostrar referência de código)
Referência
Auto Format (Formatação automática)
Check Syntax (Verificar sintaxe)
* Somente no painel Actions
40
Os recursos localizados na barra de ferramentas serão discutidos em detalhes em “Usando o
painel Actions e a janela Script” na página 36. Veja a seguir um breve resumo dos botões
disponíveis nas barras de ferramentas do painel Actions e da janela Script.
NO TA
Algumas opções a seguir estão localizadas apenas no painel Actions. Esses recursos
estão marcados como Somente no painel Actions.
Add a new item to the script (Adicionar um novo item ao script) Exiba todos os
elementos de linguagem também existentes na caixa de ferramentas do ActionScript. A
seleção de um item na lista categorizada de elementos de linguagem adiciona-o ao script.
Find (Localizar) Localize e substitua qualquer texto no código ActionScript. Para obter
mais informações, consulte “Usando a ferramenta Find” na página 58.
Somente no painel Actions. Ajuda na
configuração de um caminho de destino relativo ou absoluto de uma ação no script. Para
obter mais informações, consulte “Inserindo caminhos de destino” na página 65.
Insert target path (Inserir caminho de destino)
Verifique erros na sintaxe do script atual. Os erros de
sintaxe são listados no painel Output (Saída). Para obter mais informações, consulte
“Verificando sintaxe e pontuação” na página 59.
Check Syntax (Verificar sintaxe)
Formate seu script para uma sintaxe de
codificação apropriada e para melhorar a legibilidade. Você pode definir as preferências de
formatação automática na caixa de diálogo Preferences (Preferências), disponível no menu
Edit (Editar) ou no menu pop-up do painel Actions. Para obter mais informações,
consulte “Formatando código” na página 53.
Auto Format (Formatação automática)
Se tiver desativado a referência de
código automática, você poderá usar o comando Show Code Hint para exibir
manualmente uma referência de código relativa à linha de código na qual estiver
trabalhando. Para obter mais informações, consulte “Sobre o Script Assist” na página 62.
Show Code Hint (Mostrar referência de código)
Debug Options (Opções de depuração) Defina e remova pontos de interrupção no
script, para que, ao depurar seu documento do Flash, você possa parar e, em seguida,
percorrer o script linha por linha. As opções de depuração agora estão disponíveis na janela
Script e também no painel Actions, mas somente para arquivos do ActionScript. Essa
opção está desativada para arquivos do ActionScript Communication e do Flash
JavaScript. Para obter mais informações sobre como depurar documentos do Flash,
consulte “Depurando scripts” na página 745. Para obter informações sobre como definir e
remover pontos de interrupção, consulte “Definindo e removendo pontos de interrupção”
na página 755.
41
Script Assist Somente no painel Actions. No modo Script Assist, você é solicitado a
inserir os elementos necessários à criação de scripts. Para obter mais informações, consulte
“Sobre o Script Assist” na página 62.
Exiba um tópico da Ajuda de referência para o elemento da
linguagem ActionScript selecionado no painel Script. Por exemplo, se você clicar em uma
instrução import e, em seguida, clicar em Reference, o tópico da Ajuda relativo à import
será exibido no painel Help (Ajuda).
Reference (Referência)
Menu pop-up Somente no painel Actions. Contém os vários comandos e preferências que
se aplicam ao painel Actions ou à janela Script. Por exemplo, você pode definir números
de linha e quebra automática de linha no editor do ActionScript; acessar as preferências do
ActionScript e importar ou exportar scripts. Para obter mais informações, consulte “Sobre
as opções de edição do ActionScript” na página 42.
Sobre as opções de edição do ActionScript
A janela Script e o painel Actions oferecem vários recursos de assistência a código —
ferramentas que facilitam bastante a criação e a manutenção de scripts. Essas opções de
ferramenta estão disponíveis na barra de ferramentas do painel Actions ou da janela Script e
no menu pop-up do painel Actions. Durante a edição do ActionScript na janela Script, essas
opções estarão disponíveis na barra de ferramentas e no sistema de menu do Flash.
O painel Actions oferece mais opções do que as disponíveis na janela Script. Isso ocorre
porque essas opções adicionais são úteis no contexto de criação do ActionScript incorporado a
um documento do Flash — e não na criação de arquivos externos do ActionScript. Para obter
informações sobre quais dessas opções estão disponíveis na janela Script, consulte “Sobre a
janela Script” na página 38.
As opções disponíveis na janela Script e no painel Actions são discutidas em “Sobre as barras
de ferramentas do painel Actions e da janela Script” na página 40.
As opções a seguir estão disponíveis no menu pop-up do painel Actions e em diversos menus
da janela Script.
N OT A
Algumas opções a seguir estão localizadas apenas no painel Actions. Esses recursos
estão marcados como Somente no painel Actions.
Reload code hints (Recarregar referências de código)
Somente no painel Actions. Se
personalizar o modo Script Assist criando métodos personalizados, você poderá recarregar
as referências de código sem reiniciar o Flash 8.
42
Pin script (Prender script) Somente no painel Actions. Prende (trava no lugar) o script
exibido no momento no painel Script. Para obter mais informações, consulte “Prendendo
scripts no painel Actions” na página 63.
Close script (Fechar script)
Somente no painel Actions. Fecha o script aberto no
momento.
Close all scripts (Fechar todos os scripts)
Somente no painel Actions. Fecha todos os
scripts abertos no momento.
Go to line (Ir para linha)
Localiza e realça a linha especificada no painel Script.
Find and replace (Localizar e substituir) Localiza e substitui qualquer texto contido
nos scripts do painel Script. Para obter mais informações, consulte “Usando a ferramenta
Find” na página 58.
Repete a ação de busca para a última seqüência de
caracteres de pesquisa digitada na ferramenta Find. Para obter mais informações, consulte
“Usando a ferramenta Find” na página 58.
Find again (Localizar novamente)
Import script (Importar script) Permite importar um arquivo de script (ActionScript)
para o painel Script. Para obter mais informações, consulte “Importar e exportar
preferências” na página 61.
Exporta o script atual para um arquivo externo do
ActionScript (AS). Para obter mais informações, consulte “Importar e exportar
preferências” na página 61.
Export script (Exportar script)
Insira rapidamente elementos de
linguagem e estruturas de sintaxe comuns nos scripts. Por exemplo, quando você
pressionar Esc+g+p no painel Script, a função gotoAndPlay() será inserida no script.
Quando você seleciona a opção Esc Shortcut Keys no menu pop-up do painel Actions,
todas as teclas de atalho disponíveis de Escape são exibidas na caixa de ferramentas
Actions. Para obter mais informações, consulte “Usando teclas de atalho de Escape”
na página 56.
Esc shortcut keys (Teclas de atalho de Esc)
Exiba os caracteres ocultos em seu script que
podem ser espaços, tabulações e quebras de linha. Para obter mais informações, consulte
“Exibindo caracteres ocultos” na página 57.
Hidden characters (Caracteres ocultos)
Exibe números de linha no painel Script. Para obter
mais informações, consulte “Usando números de linha e quebra automática de linha”
na página 55.
Line numbers (Números de linha)
Preferences (Preferências) Somente no painel Actions. Exibe a caixa de diálogo de
preferências do ActionScript. Para obter mais informações, consulte “Sobre as preferências
do ActionScript” na página 44.
43
Word wrap (Quebra automática de linha) Para quebrar as linhas do script que
excedem o tamanho atual da janela Script, selecione Word Wrap (Quebra automática de
linha) no menu pop-up do painel Actions. Quando você usar a janela Script, selecione
Word Wrap no menu View (Exibir). Para obter mais informações, consulte “Usando
números de linha e quebra automática de linha” na página 55.
Group Actions with (Agrupar ações com) Somente no painel Actions. Permite agrupar o
painel Actions (que inclui a caixa de ferramentas Actions e o navegador Script) com outros
painéis dentro do ambiente de criação do Flash.
O menu pop-up do painel Actions também inclui os comandos Print (Imprimir), Help
(Ajuda) e comandos de redimensionamento de painel.
Sobre as preferências do ActionScript
A edição de um código no painel Actions ou na janela Script permite definir e modificar um
único conjunto de preferências. Por exemplo, você pode controlar o recuo automático, as
referências de código e a sinalização por cores, além de vários outros recursos básicos de edição
de código.
Para acessar as preferências do ActionScript:
1.
Para acessar as preferências do ActionScript em um arquivo FLA através do painel Actions,
selecione Preferences (Preferências) no menu pop-up ou Edit (Editar) > Preferences
(Preferências) (Windows) ou Flash > Preferences (Macintosh) e clique em ActionScript na
lista Category (Categoria).
2.
Para acessar as preferências do ActionScript na janela Script, selecione Edit > Preferences e
clique em ActionScript (Windows) ou escolha Flash > Preferences e clique em ActionScript
(Macintosh).
44
A imagem a seguir mostra as configurações do ActionScript que podem ser alteradas no Flash
8.
Você pode definir as seguintes preferências:
Automatic indentation (Recuo automático)
Quando o recuo automático estiver ativado,
o texto digitado após um parêntese de abertura [(] ou uma chave de abertura ({) será recuado
automaticamente conforme a configuração Tab Size (Tamanho da tabulação) nas preferências
do ActionScript. Para obter mais informações, consulte “Formatando código” na página 53.
Tab size (Tamanho da tabulação) Especifica o número de caracteres segundo o qual a
linha será deslocada quando o recuo automático estiver ativado.
Permite referências de código no painel Script. Para
obter mais informações sobre como usar referências de código, consulte “Sobre as referências
de código no Flash” na página 47.
Code hints (Referências de código)
Delay (Atraso)
Especifica o atraso (em segundos) antes da exibição das referências de
código.
Font (Fonte)
Especifica a fonte usada no painel Script.
45
Executa uma
verificação para assegurar que a família de fontes selecionada possui os glifos necessários para
renderizar cada caractere. Caso não haja os glifos necessários, o Flash substituirá uma família
de fontes contendo os caracteres necessários. Para obter mais informações, consulte
“Formatando código” na página 53.
Use dynamic font mapping (Usar mapeamento dinâmico de fontes)
Especifica a codificação de caracteres usada quando você abre,
salva, importa e exporta arquivos do ActionScript. Para obter mais informações, consulte
“Importando e exportando scripts” na página 60.
Encoding (Codificação)
Permite que você selecione o
momento de exibição de avisos sobre a modificação, a movimentação ou a exclusão de um
arquivo de script. Selecione Always (Sempre), Never (Nunca) ou Prompt.
Reload modified files (Recarregar arquivos modificados)
■
Always (Sempre) Nenhum aviso é exibido quando uma alteração é detectada e o
arquivo é automaticamente recarregado.
■
Never (Nunca)
■
Prompt (Padrão) Um aviso é exibido quando uma alteração é detectada e você pode
optar por recarregar ou não o arquivo.
Nenhum aviso é exibido quando uma alteração é detectada e o arquivo
permanece no estado atual.
Quando você criar aplicativos que envolvam arquivos de script externos, esse recurso ajudará a
evitar a substituição de um script modificado por um membro da equipe desde a abertura do
aplicativo ou a publicação do aplicativo com versões antigas de scripts. Os avisos permitem
fechar automaticamente um script e reabrir a versão mais atual modificada.
Especifica as cores da sinalização por cores nos scripts.
Com o recurso de sinalização por cores ativado, é possível selecionar as cores para exibição no
painel Script.
Syntax colors (Cores da sintaxe)
Language (Idioma) Abre a caixa de diálogo ActionScript Settings (Configurações do
ActionScript). Para obter mais informações, consulte “Modificando o caminho de classe”
na página 68.
46
Sobre as referências de código no Flash
No painel Actions ou na janela Script, é possível usar vários recursos para ajudar na criação de
um código sintaticamente correto. As referências de código ajudam a criar um código com
rapidez e precisão. As referências de código incluem dicas de ferramenta contendo a sintaxe
correta e menus que permitem selecionar nomes de método e de propriedade. As seções a
seguir mostram como criar um código que utiliza esses recursos.
■
“Sobre a ativação de referências de código” na página 47
■
“Usando referências de código” na página 48
■
“Sobre a atribuição de tipo a objetos para ativar referências de código” na página 51
■
“Sobre o uso de sufixos para ativar referências de código” na página 51
■
“Sobre o uso de comentários para ativar referências de código” na página 53
Sobre a ativação de referências de código
Quando você trabalha no painel Actions ou na janela Script, o Flash pode detectar a ação que
está sendo inserida e exibir uma referência de código. Os dois estilos diferentes de referência de
código são uma dica de ferramenta que contém a sintaxe completa da ação e um menu pop-up
que lista possíveis nomes de método ou de propriedade (algumas vezes usado como uma
forma de conclusão do código). Um menu pop-up é exibido para parâmetros, propriedades e
eventos quando você usa a atribuição de tipo estrita ou nomeação para objetos, conforme
discutido no restante desta seção.
As referências de código algumas vezes serão exibidas se você clicar duas vezes em um item na
caixa de ferramentas Actions ou clicar em Add (+) na barra de ferramentas do painel Actions
ou da janela Script para adicionar ações ao painel Script. Para obter informações sobre como
usar referências de código quando elas aparecerem, consulte “Usando referências de código”
na página 48.
N OT A
A exibição das referências de código é ativada automaticamente para classes nativas
que não exigem a criação de uma instância da classe e a atribuição de nome a ele, como
Math, Key, Mouse etc.
Para assegurar a ativação das referências de código, é necessário que as opções de Code Hints
(Referências de código) estejam selecionadas na caixa de diálogo Preferences do ActionScript.
Para obter mais informações, consulte “Sobre o painel Actions” na página 37.
47
Usando referências de código
As referências de código são ativadas por padrão. Ao definir preferências, é possível desativar
referências de código ou determinar a rapidez com que elas são exibidas. Quando as
referências de código estão desativadas nas preferências, ainda é possível exibir uma referência
de código para um comando específico.
Para especificar configurações de referências de código automáticas, siga um
destes procedimentos:
■
No painel Actions ou na janela Script, selecione Edit > Preferences (Windows) ou Flash >
Preferences (Macintosh), clique em ActionScript na lista Category e ative ou desative
Code Hints.
■
No painel Actions, selecione Preferences no menu pop-up (na parte superior direita do
painel) e ative ou desative Code Hints nas preferências do ActionScript.
Se você ativar as referências de código, poderá também especificar um atraso, em segundos,
antes que elas apareçam. Por exemplo, se você não estiver familiarizado com o ActionScript,
poderá preferir não usar atrasos, para que as referências de código sempre apareçam
imediatamente. No entanto, se você geralmente souber o que quer digitar e só precisar das
referências de código ao usar elementos de linguagem desconhecidos, poderá especificar um
atraso para que elas não apareçam quando não desejar usá-las.
Para especificar um atraso para as referências de código:
1.
No painel Actions ou na janela Script, selecione Edit > Preferences (Windows) ou Flash >
Preferences (Macintosh) no menu principal.
2.
Clique em ActionScript na lista Category.
3.
Use o controle deslizante para selecionar o tempo de atraso.
Esse tempo é definido em segundos.
Para trabalhar com referências de código no estilo de dica de ferramenta:
1.
48
Para exibir a referência de código, digite um parêntese de abertura [(] após um elemento
que exija parênteses (por exemplo, após o nome de um método, um comando, como if ou
do..while etc.
A referência de código será exibida.
NO TA
2.
Se nenhuma referência de código for exibida, verifique se você não desativou Code
Hints nas preferências do ActionScript (Edit > Preferences (Windows) ou Flash >
Preferences (Macintosh)) e clique em ActionScript na lista Category). Para exibir
referências de código para uma variável ou um objeto criado, verifique se você
atribuiu nome à variável ou ao objeto corretamente (consulte “Sobre o uso de sufixos
para ativar referências de código” na página 51) ou se usou a atribuição de tipo
estrita para a variável ou o objeto (consulte “Sobre a atribuição de tipo a objetos para
ativar referências de código” na página 51).
Digite um valor para o parâmetro.
Se houver mais de um parâmetro, separe os valores por vírgulas. Para funções ou
instruções, por exemplo, for loop, separe os parâmetros por ponto-e-vírgula.
Os comandos superpostos (funções ou métodos que podem ser chamados com conjuntos
diferentes de parâmetros), como gotoAndPlay() ou for, exibem um indicador que
permite selecionar o parâmetro a ser definido. Clique nos pequenos botões de seta ou
pressione Control+seta para a esquerda e Control+seta para a direita para selecionar o
parâmetro.
3.
Para desconsiderar a referência de código, siga um destes procedimentos:
■
Digite um parêntese de fechamento [)].
■
Clique fora da instrução.
■
Pressione Escape.
Para trabalhar com referências de código no estilo de menu:
1.
Para exibir a referência de código, digite um ponto após o nome da variável ou objeto.
49
O menu de referências de código é exibido.
N OT A
Se nenhuma referência de código for exibida, verifique se você não desativou as
referências de código nas preferências do ActionScript (Edit > Preferences
(Windows) ou Flash > Preferences (Macintosh)) e clique em ActionScript na lista
Category). Para exibir referências de código para uma variável ou um objeto criado,
verifique se você atribuiu nome à variável ou ao objeto corretamente (consulte
“Sobre o uso de sufixos para ativar referências de código” na página 51) ou se usou
a atribuição de tipo estrita para a variável ou o objeto (consulte “Sobre a atribuição
de tipo a objetos para ativar referências de código” na página 51).
2.
Para percorrer as referências de código, use as teclas de seta para cima e de seta para baixo.
3.
Para selecionar um item no menu, pressione Enter ou Tab ou clique duas vezes no item.
4.
Para desconsiderar a referência de código, siga um destes procedimentos:
■
Selecione um dos itens de menu.
■
Clique acima ou abaixo da janela de menu.
■
Digite um parêntese de fechamento [)] se já tiver digitado um parêntese de abertura
[(].
■
Pressione Escape.
Para exibir manualmente uma referência de código:
1.
2.
50
Clique em um local no código onde é possível exibir as referências de código, como nos
seguintes locais:
■
Após o ponto (.) que segue uma instrução ou um comando, onde uma propriedade ou
um método deve ser digitado
■
Entre parênteses [()] em um nome de método
Siga um destes procedimentos:
■
Clique em Show Code Hint (Mostrar referência de código) na barra de ferramentas do
painel Actions ou da janela Script.
■
Pressione Control+Barra de espaços (Windows) ou Command+Barra de espaços
(Macintosh).
■
Se estiver trabalhando no painel Actions, selecione Show Code Hint no menu pop-up.
Sobre a atribuição de tipo a objetos para ativar referências de
código
Com o ActionScript 2.0, você pode usar a atribuição de tipo estrita para uma variável que tem
como base uma classe interna, como Button, Array etc. Nesse caso, o painel Script exibirá
referências de código para a variável. Por exemplo, suponha que você defina o seguinte código:
var names:Array = new Array();
names.
Assim que você digita o ponto (.), o Flash exibe uma lista de métodos e propriedades
disponíveis para objetos Array em um menu pop-up, porque você digitou a variável como se
fosse um array. Para obter mais informações sobre como atribuir tipos de dados, consulte
“Sobre a atribuição de tipos de dados e a atribuição estrita de tipos de dados” na página 85.
Para obter informações sobre como usar referências de código quando elas aparecerem,
consulte “Usando referências de código” na página 48.
Sobre o uso de sufixos para ativar referências de código
Se você usa o ActionScript 1 ou deseja exibir referências de código para objetos criados por
você sem atribuir um tipo estritamente a eles (consulte “Sobre a atribuição de tipo a objetos
para ativar referências de código” na página 51), adicione um sufixo especial ao nome de cada
objeto ao criá-lo. Por exemplo, os sufixos que ativam referências de código para a classe Array
e a classe Camera são, respectivamente, _array e _cam. Por exemplo, se digitar o seguinte
código
var my_array = new Array();
var my_cam = Camera.get();
você poderá digitar um dos elementos a seguir (o nome de variável seguido por um ponto):
my_array.
my_cam.
Referências de código serão exibidas para os objetos Array e Camera.
Para objetos que aparecem no Stage, use o sufixo na caixa de texto Instance Name (Nome de
instância) no inspetor Properties (Propriedades). Por exemplo, para exibir referências de
código de objetos MovieClip, use o inspetor Properties para atribuir nomes de instância com o
sufixo _mc a todos os objetos MovieClip. Assim, sempre que você digitar o nome da instância
seguido por um ponto, as referências de código aparecerão.
Embora não sejam necessários sufixos para ativar as referências de código quando você usar a
atribuição de tipo estrita a um objeto, usá-los de forma consistente ajudará a entender seu
código.
51
A tabela abaixo lista os sufixos necessários para o suporte a referências de código automáticas:
Tipo de objeto
Sufixo da variável
Array
_array
Button
_btn
Camera (Câmera)
_cam
Color
_color
ContextMenu
_cm
ContextMenuItem
_cmi
Date
_date
Error
_err
LoadVars
_lv
LocalConnection
_lc
Microphone (Microfone) _mic
MovieClip
_mc
MovieClipLoader
_mcl
PrintJob
_pj
NetConnection
_nc
NetStream
_ns
SharedObject
_so
Sound
_sound
String
_str
TextField
_txt
TextFormat
_fmt
Video
_video
XML
_xml
XMLNode
_xmlnode
XMLSocket
_xmlsocket
Para obter informações sobre como usar referências de código quando elas aparecerem,
consulte “Usando referências de código” na página 48.
52
Sobre o uso de comentários para ativar referências de código
Você também pode usar os comentários do ActionScript a fim de especificar a classe de um
objeto para referências de código. O exemplo a seguir informa ao ActionScript que a classe da
instância theObject é Object e assim por diante. Se você digitar mc e ponto após esses
comentários, serão exibidas as referências de código com a lista de métodos e propriedades de
MovieClip. Se você digitar theArray e ponto, será exibido um menu com uma lista de
métodos e propriedades de Array.
// Object theObject;
// Array theArray;
// MovieClip theMc;
Entretanto, a Macromedia recomenda que você utilize a atribuição estrita de tipos de dados
(consulte “Sobre a atribuição de tipo a objetos para ativar referências de código” na página 51)
ou sufixos (consulte “Sobre o uso de sufixos para ativar referências de código” na página 51)
em vez dessa técnica, porque eles ativam automaticamente as referências de código e tornam o
código mais compreensível. Para obter mais informações sobre como usar referências de
código, consulte “Usando referências de código” na página 48.
Formatando código
Você pode especificar configurações para determinar se o código será formatado e recuado
automática ou manualmente. Você também pode optar por usar o mapeamento dinâmico de
fontes, que assegura o uso de fontes corretas durante o trabalho com texto multilíngüe.
Para definir opções de formato:
1.
painel). Na caixa de diálogo Preferences, selecione Auto Format (Formatação automática).
Como alternativa, na janela Script, selecione Edit > Preferences (Windows) ou Flash >
Preferences (Macintosh). Na caixa de diálogo Preferences, selecione Auto Format.
2.
Selecione uma das opções de Auto Format.
Para verificar o efeito de cada seleção, observe o painel Preview (Visualizar).
Depois de definir as opções de Auto Format, as configurações serão aplicadas
automaticamente ao código que você escrever, e não ao código existente; você deverá aplicar
suas configurações manualmente ao código existente. Formate manualmente o código que foi
formatado com configurações diferentes, importado de outro editor etc.
53
Para formatar o código de acordo com as configurações de Auto Format, siga
um destes procedimentos:
■
Clique no botão Auto Format na barra de ferramentas do painel Actions ou da janela
Script.
■
No painel Actions, selecione Auto Format no menu pop-up.
■
Pressione Control+Shift+F (Windows) ou Command+Shift+F (Macintosh).
■
Na janela Script, selecione Tools (Ferramentas) > Auto Format (Formatação automática).
Para usar o mapeamento dinâmico de fontes:
■
Para ativar ou desativar o mapeamento dinâmico de fontes, marque ou desmarque Use
dynamic font mapping (Usar mapeamento dinâmico de fontes) na caixa de diálogo
Preferences.
Por padrão, o mapeamento dinâmico de fontes está desativado para melhorar o
desempenho durante a edição de scripts. Se estiver trabalhando com texto multilíngüe,
ative o mapeamento dinâmico de fontes para assegurar o uso das fontes corretas.
Para usar o recuo automático:
■
Para ativar ou desativar o recuo automático, marque ou desmarque Automatic indentation
(Recuo automático) na caixa de diálogo Preferences.
Quando o recuo automático estiver ativado, o texto digitado após um parêntese de
abertura [(] ou uma chave de abertura ({) será recuado automaticamente conforme a
configuração Tab Size (Tamanho da tabulação) nas preferências do ActionScript.
Nos scripts, selecione uma linha e pressione Tab para recuá-la. Para remover o recuo,
selecione a linha e pressione Shift+Tab.
Usando o realce de sintaxe
No ActionScript, assim como em qualquer linguagem, a sintaxe é a maneira como os
elementos são reunidos para terem significado. Se for usada uma sintaxe incorreta do
ActionScript, os scripts não funcionarão.
Quando você escreve scripts no Flash Basic 8 e no Flash Professional 8, os comandos não
suportados pela versão do exibidor especificado aparecerão em amarelo na caixa de
ferramentas Actions. Por exemplo, se a versão do arquivo SWF do Flash Player estiver definida
como Flash 7, o ActionScript que só é suportado pelo Flash Player 8 aparecerá em amarelo na
caixa de ferramentas Actions. (Para obter informações sobre como definir a versão do arquivo
SWF do Flash Player, consulte Capítulo 17, “Definindo opções de publicação para o formato
de arquivo SWF do Flash” em Using Flash (Usando o Flash).
54
Também é possível definir uma preferência para que o Flash destaque com cores partes dos
scripts enquanto você os escreve a fim de realçar erros de digitação. Por exemplo, imagine que
você definiu a preferência de sinalização da sintaxe por cores para que as palavras-chave
apareçam em azul-escuro. Ao criar o código, se você digitar var, a palavra var aparecerá em
azul. Entretanto, se, por engano, você digitar vae, a palavra vae continuará na cor preta,
indicando que houve erro de digitação. Para obter informações sobre palavras-chave, consulte
“Sobre palavras-chave” na página 146.
Para definir preferências de sinalização de sintaxe por cores enquanto digita,
siga um destes procedimentos:
■
Selecione Edit > Preferences (Windows) ou Flash > Preferences (Macintosh), clique em
ActionScript na lista Category e especifique as configurações Syntax coloring (Sinalização
de sintaxe por cores).
■
painel) e especifique as configurações Syntax coloring nas preferências do ActionScript.
■
Com o ponteiro do mouse focalizado no painel Script, pressione Control-U (Windows)
ou Command-U (Macintosh).
É possível alterar as configurações de cor para palavras-chave, comentários, identificadores e
seqüências de caracteres. Para obter informações sobre identificadores e seqüências de
caracteres, consulte “Terminologia” na página 841 e “Tipo de dados String” na página 83.
Para obter informações sobre comentários, consulte “Sobre comentários” na página 139.
Usando números de linha e quebra automática de
linha
Você pode optar por exibir números de linha e quebrar as linhas longas de código.
Geralmente, você dever ativar os números de linha e a quebra automática de linha para
facilitar a edição do código. Os números de linha facilitam a análise do código e a rolagem por
ele durante sua edição ou modificação. A quebra automática de linha ajuda a evitar a rolagem
horizontalmente por longas linhas de código (principalmente durante o trabalho no ambiente
de criação ou em baixas resoluções de tela).
Para ativar ou desativar números de linha, siga um destes procedimentos:
■
No painel Actions, selecione Line Numbers (Números de linha) no menu pop-up.
■
Na janela Script, selecione Tools > Line Numbers.
■
Pressione Control+Shift+L (Windows) ou Command+Shift+L (Macintosh).
55
Para ativar ou desativar a quebra automática de linha, siga um destes
procedimentos:
■
No painel Actions, selecione Word Wrap (Quebra automática de linha) no menu pop-up.
■
Na janela Script, selecione Tools > Word Wrap.
■
Pressione Control+Shift+W (Windows) ou Command+Shift+W (Macintosh).
Usando teclas de atalho de Escape
Você pode adicionar vários elementos a um script usando as teclas de atalho de Escape
(pressionando a tecla Escape e, em seguida, duas outras teclas).
NO T A
Esses atalhos são diferentes dos atalhos de teclado que iniciam determinados
comandos de menu.
Por exemplo, se você estiver trabalhando no painel Script e pressionar Escape+d+o, o código a
seguir será inserido no seu script:
do {
} while ();
O ponto de inserção é inserido imediatamente após a palavra while, para que você possa
começar a digitar sua condição. Da mesma forma, se você pressionar Escape+c+h, o código a
seguir será inserido no script, e o ponto de inserção será posicionado entre os parênteses [()],
para que você possa começar a digitar a condição:
catch () {
}
Para aprender (ou ser lembrado de) quais comandos possuem teclas de atalho de Escape,
exiba-os ao lado dos elementos na caixa de ferramentas do ActionScript.
56
Para exibir ou ocultar as teclas de atalho de Escape:
■
No menu pop-up do painel Actions, marque ou desmarque Esc Shortcut Keys (Teclas de
atalho de Esc).
As teclas de atalho de Escape são exibidas ao lado dos elementos na caixa de ferramentas
do ActionScript.
Exibindo caracteres ocultos
Quando você cria e formata o código do ActionScript, insere espaços, tabulações e quebras de
linha no script. Eles obviamente são úteis e necessários à organização visual do código.
Entretanto, o compilador do Flash gera erros quando encontra espaços de bytes duplos que
não fazem parte de um valor de seqüência de caracteres. A exibição de caracteres ocultos no
painel Script permite ver e remover esses espaços.
Os símbolos a seguir são usados para exibir cada caractere oculto:
espaço de um byte
.
espaço de bytes
duplos
l
tabulação
>>
quebra de linha
Para exibir caracteres ocultos, siga um destes procedimentos :
■
Selecione Hidden Characters (Caracteres ocultos) no menu pop-up.
■
Pressione Control+Shift+8 (Windows) ou Command+Shift+8 (Macintosh).
57
O painel Script terá esta aparência quando forem exibidos caracteres ocultos:
Usando a ferramenta Find
A ferramenta Find (Localizar) permite localizar e, opcionalmente, substituir uma seqüência de
caracteres nos scripts. Você pode substituir a primeira ocorrência, ou todas, do texto no script.
Também pode fazer a correspondência de maiúsculas e minúsculas do texto.
Para localizar um texto no script:
1.
Na barra de ferramentas do painel Actions ou da janela Script, selecione a ferramenta Find
ou pressione Control+F (Windows) ou Command+F (Macintosh).
2.
Digite a seqüência de caracteres de pesquisa que deseja localizar no script.
3.
Clique em Find Next (Localizar próximo).
Se o texto ou os caracteres estiverem presentes no script, as palavras ou os caracteres serão
realçados no painel Script.
Para localizar e substituir um texto no script:
1.
Na barra de ferramentas do painel Actions ou da janela Script, clique na ferramenta Find
ou pressione Control+F (Windows) ou Command+F (Macintosh).
2.
Digite a seqüência de caracteres de pesquisa que deseja localizar e substituir no script.
3.
Na caixa de texto Replace (Substituir), digite a nova seqüência de caracteres.
4.
Clique em Find Next.
Se a seqüência de caracteres estiver presente no script, ela será realçada.
58
5.
Clique em Replace (Substituir) para substituir a seqüência de caracteres ou em Replace All
(Substituir todos) para substituir todas as ocorrências da seqüência.
Após digitar uma seqüência de caracteres de pesquisa na ferramenta Find, você poderá repetir
a pesquisa selecionando Find Again (Localizar novamente) no menu pop-up.
Verificando sintaxe e pontuação
Para determinar se o código escrito tem o desempenho planejado, publique ou teste o arquivo.
Entretanto, você pode verificar rapidamente o código do ActionScript sem sair do arquivo
FLA. Os erros de sintaxe são listados no painel Output (Saída). Você também pode verificar se
um conjunto de parênteses, chaves ou colchetes em torno de um bloco de código está
equilibrado.
O script atual é verificado quando você verifica a sintaxe. Se o script atual chamar classes do
ActionScript 2.0, elas serão compiladas e sua sintaxe também será verificada. Outros scripts
possivelmente existentes no arquivo FLA não serão verificados.
Para verificar a sintaxe, siga um destes procedimentos:
■
Clique em Check Syntax (Verificar sintaxe) na barra de ferramentas do painel Actions ou
da janela Script.
■
No painel Actions, selecione Check Syntax no menu pop-up.
■
Selecione o painel Script (para que ele tenha o foco) e pressione Control+T (Windows) ou
Command+T (Macintosh).
N OT A
Se você clicar em Check Syntax em um arquivo de classe externo do ActionScript
2.0 na janela Script window, o caminho de classe global afetará esse processo.
Algumas vezes, você irá gerar erros — mesmo que o caminho de classe global esteja
definido corretamente — pelo fato de o compilador não saber que essa classe está
sendo compilada. Para obter mais informações sobre como compilar classes,
consulte “Compilando e exportando classes” na página 296.
Para verificar o equilíbrio da pontuação, siga um destes procedimentos:
■
Clique entre chaves ({}), colchetes ([]) ou parênteses (()) no script.
■
Pressione Control+' (aspas simples) no Windows ou Command+' (aspas simples) no
Macintosh para realçar o texto entre chaves, colchetes ou parênteses.
O realce ajuda a verificar se a pontuação de abertura possui a pontuação de fechamento
correspondente.
59
Importando e exportando scripts
Você pode importar um script para o painel Actions ou para a janela Script e exportar os
scripts para arquivos externos do ActionScript. Os dois procedimentos podem ser úteis para o
compartilhamento do código entre diferentes aplicativos Flash e várias equipes de
desenvolvimento.
Para importar um arquivo externo do AS:
■
Para importar um script externo para um script no qual esteja trabalhando no painel
Script, coloque o ponto de inserção no local em que deseja posicionar a primeira linha do
script externo e, em seguida, siga um destes procedimentos:
■
No painel Actions, selecione Import Script (Importar script) no menu pop-up ou
pressione Control+Shift+I (Windows) ou Command+Shift+I (Macintosh).
■
Na janela Script, selecione Import Script no menu File (Arquivo) ou pressione
Control+Shift+I (Windows) ou Command+Shift+I (Macintosh).
Você pode exportar um script do painel Actions. Quando a janela Script é usada, a exportação
é desnecessária já que você pode salvar o arquivo do AS.
Para exportar um script do painel Actions:
1.
Selecione o script para exportação e escolha Export Script (Exportar script) no menu popup ou pressione Control+Shift+X (Windows) ou Command+Shift+X (Macintosh).
A caixa de diálogo Save As (Salvar como) é exibida.
2.
Salve o arquivo do ActionScript (AS).
O Flash oferece suporte a vários formatos de codificação de caracteres diferentes (incluindo
Unicode) e você pode especificar o formato a ser usado ao importar e exportar scripts. Para
obter mais informações, consulte “Importando e exportando scripts” na página 60 e
“Importar e exportar preferências” na página 61.
60
Suporte a Unicode para ActionScript
O Flash 8 oferece suporte à codificação de texto Unicode para o ActionScript. Isso significa
que é possível incluir texto em diferentes idiomas em um arquivo do ActionScript. Por
exemplo, você pode incluir texto em inglês, japonês e francês no mesmo arquivo.
AT E N ÇÃ O
Quando você usa um aplicativo em um idioma que não está em inglês em um sistema em
inglês, o comando Test Movie (Testar filme) (consulte “Depurando scripts”
na página 745) falha quando qualquer parte do caminho do arquivo SWF possui
caracteres que não podem ser representados usando o esquema de codificação MBCS
(Multibyte Character Sets, conjuntos de caracteres de vários bytes). Por exemplo,
caminhos em japonês, que funcionam em um sistema em japonês, não funcionarão em
um sistema em inglês. Todas as áreas do aplicativo que usarem o exibidor externo
estarão sujeitas a esta limitação.
Importar e exportar preferências
Você pode definir as preferências do ActionScript para especificar o tipo de codificação a ser
usada na importação ou exportação de arquivos do ActionScript. Você pode selecionar UTF-8
Encoding (Codificação UTF-8) ou Default Encoding (Codificação padrão). UTF-8 é o
formato Unicode de 8 bits; Default Encoding é a forma de codificação suportada pelo idioma
utilizado por seu sistema, também chamada página de código tradicional.
Em geral, ao importar ou exportar arquivos do ActionScript em formato UTF-8, use a
preferência UTF-8. Se você estiver importando ou exportando arquivos na página de código
tradicional do sistema, deverá usar a preferência Default Encoding.
Se o texto dos scripts não tiver a aparência esperada quando você abrir ou importar um
arquivo, altere a preferência de codificação de importação. Se receber uma mensagem de aviso
ao exportar arquivos do ActionScript, você poderá alterar a preferência de codificação de
exportação ou desativar o aviso nas preferências do ActionScript.
Para selecionar opções de codificação de texto para importação ou
exportação de arquivos do ActionScript:
1.
Na caixa de diálogo Preferences (Edit > Preferences (Windows) ou Flash > Preferences
(Macintosh)), clique em ActionScript na lista Category.
2.
Em Editing Options (Opções de edição), siga uma ou ambas as instruções:
■
Em Open/Import (Abrir/importar), selecione UTF-8 Encoding para abrir ou
importar usando a codificação Unicode ou selecione Default Encoding para abrir ou
importar usando a forma de codificação do idioma usado no momento por seu
sistema.
61
■
Em Save/Export (Salvar/exportar), selecione UTF-8 Encoding para salvar ou exportar
usando a codificação Unicode ou selecione Default Encoding para salvar ou exportar
usando a forma de codificação de idioma usada no momento por seu sistema.
Para ativar ou desativar o aviso de codificação de exportação:
1.
No sistema de menu do Flash, selecione Edit > Preferences (Windows) ou Flash >
Preferences (Macintosh) e clique em Warnings (Avisos) na lista Category.
2.
Marque ou desmarque Warn on encoding conflicts when exporting ActionScript files
(Avisar em conflitos de codificação ao exportar arquivos do ActionScript).
Sobre recursos do painel Actions
Os recursos a seguir estão disponíveis apenas no painel Actions. Eles não estão disponíveis na
janela Script. Embora o painel Actions tenha todos os recursos da janela Script, essa janela é
usada para uma funcionalidade diferente. O painel Actions deve oferecer suporte a algumas
funcionalidades relacionadas ao arquivo FLA, que serão abordadas posteriormente nas
próximas seções. Para obter informações sobre os recursos disponíveis na janela Script e no
painel Actions, consulte as seções em “Sobre a codificação no painel Actions e na janela
Script” na página 39.
Para obter informações sobre os recursos disponíveis apenas no painel Actions, consulte estas
seções:
■
“Sobre o Script Assist” na página 62
■
“Prendendo scripts no painel Actions” na página 63
■
“Inserindo caminhos de destino” na página 65
Sobre o Script Assist
O Script Assist solicita a inserção dos elementos de um script, ajudando a adicionar mais
facilmente uma interatividade simples ao aplicativo ou arquivo do Flash SWF. O modo Script
Assist é ideal para usuários que não estão familiarizados com a escrita de seus próprios scripts
ou que simplesmente apreciam a conveniência oferecida pela ferramenta.
Usado em conjunto com o painel Actions, o Script Assist solicita a seleção de opções e a
inserção de parâmetros. Por exemplo, em vez de criar um novo script, você pode selecionar um
elemento de linguagem na caixa de ferramentas Actions (ou o comando Add (+) na barra de
ferramentas), arrastá-lo para o painel Script e usar o Script Assist para ajudar na conclusão do
script.
62
No exemplo a seguir, a função gotoAndPlay foi adicionada ao painel Script. O Script Assist
exibe todos os prompts necessários à utilização dessa função do ActionScript — neste caso, o
nome da cena, o tipo e o número do quadro.
Prendendo scripts no painel Actions
Se você não centralizar o código de um arquivo FLA em um local (discutido em
“Organizando o código ActionScript” na página 34) ou se estiver usando comportamentos
(consulte “Sobre comportamentos” na página 65), você poderá prender vários scripts no painel
Actions para facilitar a passagem por eles. Prender um script significa que você mantém o local
do código aberto no painel Actions e clica facilmente entre cada script aberto.
Na figura a seguir, o script associado ao local atual na timeline está no Frame (Quadro) 1 da
camada denominada Cleanup (Limpeza). (A guia na extremidade esquerda sempre segue sua
localização na timeline). Esse script também está preso (ele é mostrado na guia mais à direita).
Dois outros scripts estão presos: um no Frame 1 e o outro no Frame 15 da camada Intro
(Introdução). Você pode mover-se entre os scripts presos clicando nas guias ou usando atalhos
de teclado, como Control+Shift+. (ponto). Mover-se por scripts presos não altera sua posição
atual na timeline. Como você pode ver na figura a seguir, vários scripts estão abertos no painel
Actions e você pode clicar em cada guia para mover-se entre eles.
DICA
Se o conteúdo no painel Script não mudar para refletir o local selecionado na timeline, o
painel Script provavelmente estará exibindo um script preso. Clique na guia à esquerda
localizada na parte inferior esquerda do painel Script para exibir o ActionScript
associado ao seu local na timeline.
Para prender um script:
1.
Posicione o ponteiro do mouse na Timeline para que o script apareça em uma guia na parte
inferior esquerda do painel Script no painel Actions.
Sobre recursos do painel Actions
63
2.
■
Clique no ícone de tachinha à direita da guia.
■
Clique com o botão direito do mouse (Windows) ou, pressionando Control, clique
(Macintosh) na guia e selecione Pin Script (Prender script).
■
Selecione Pin Script (Prender script) no menu pop-up (na parte superior direita do
painel Actions).
■
Com o ponteiro do mouse focalizado no painel Script, pressione Control+= (sinal de
igual) no Windows ou Command+= no Macintosh.
Para liberar um ou mais scripts, siga um destes procedimentos:
■
Se um script preso aparecer em uma guia na parte inferior esquerda do painel Script no
painel Actions, clique no ícone de tachinha à direita da guia.
■
Clique com o botão direito (Windows) ou, pressionando Control, clique (Macintosh) em
uma guia e selecione Close Script (Fechar script) ou Close All Scripts (Fechar todos os
scripts).
■
Selecione Close Script (Fechar script) ou Close All Scripts (Fechar todos os scripts) no
menu pop-up (na parte superior direita do painel Actions).
■
Com o ponteiro do mouse focalizado no painel Script, pressione Control+- (sinal de
menos) no Windows ou Command+- no Macintosh.
Para usar atalhos de teclado com scripts presos:
■
64
É possível usar os seguintes atalhos de teclado para trabalhar com scripts presos:
Ação
tecla de atalho no
Windows
tecla de atalho no
Macintosh
Prender script
Control+= (sinal de igual)
Command+=
Liberar script
Control+- (sinal de menos)
Command+-
Mover o foco para a guia da
direita
Control+Shift+. (ponto)
Command+Shift+.
Mover o foco para a guia da
esquerda
Control+Shift+, (vírgula)
Command+Shift+,
Liberar todos os scripts
Control+Shift+- (menos)
Command+Shift+-
Inserindo caminhos de destino
Várias ações criadas no script afetarão clipes de filme, botões e outras instâncias de símbolos.
Para aplicar ações a instâncias em uma timeline, defina um caminho de destino — o endereço
da instância que você deseja especificar como destino. Você pode definir um caminho de
destino absoluto ou relativo.
A ferramenta Target Path (Caminho de destino), disponível no painel Actions, solicita que
você insira o caminho de destino da ação selecionada no script.
Para inserir um caminho de destino:
1.
Selecione e posicione o ponteiro em uma ação no script.
2.
Clique em Target Path na barra de ferramentas do painel Actions.
A caixa de diálogo Insert Target Path (Inserir caminho de destino) é exibida.
3.
■
Insira manualmente o caminho da instância de destino.
■
Selecione o destino na lista de destinos disponíveis.
4.
Selecione a opção de caminho Absolute (Absoluto) ou Relative (Relativo).
5.
Clique em OK.
O caminho é anexado à ação.
Sobre comportamentos
Os comportamentos são funções predefinidas do ActionScript que você pode anexar a objetos
no documento do Flash sem precisar criar o código ActionScript. Eles oferecem uma
funcionalidade predefinida do ActionScript, como navegação por quadros, carregamento de
arquivos SWF e JPEGs externos, controle da ordem de empilhamento dos clipes de filme,
além de uma funcionalidade que permite arrastar clipes de filme.
Os comportamentos podem ser usados de modo conveniente na criação do aplicativo Flash —
como uma forma de evitar a escrita do ActionScript ou, inversamente, como um meio de
aprender sobre o funcionamento do ActionScript em determinadas situações.
Sobre comportamentos
65
Eles somente estão disponíveis quando você trabalha em um documento do Flash, e não em
um arquivo de script externo. Em geral, você seleciona um objeto de ativação em seu
documento, um clipe de filme ou um botão, seleciona o botão Add (Adicionar) no painel
Behaviors (Comportamentos) para exibir os comportamentos disponíveis e, em seguida,
seleciona o comportamento desejado, como mostrado no exemplo a seguir:
O comportamento é adicionado ao objeto e exibido no painel Actions.
Sobre as configurações de publicação do
ActionScript
Você pode editar o ActionScript de duas maneiras. Você pode editar o ActionScript
incorporado a um documento do Flash usando o painel Actions. Você também pode editar o
ActionScript localizado em um arquivo de script separado, externo ao documento do Flash,
usando a janela Script. Como o painel Actions e a janela Script são basicamente duas exibições
diferentes que utilizam o mesmo editor do ActionScript, as configurações e as preferências do
ActionScript no Flash aplicam-se a ambos.
Edite as configurações de publicação do documento do Flash para alterar a versão do
ActionScript que será usada na publicação do documento. Você também pode definir o
caminho de classe do documento atual, ignorando o caminho de classe global do
ActionScript.
Para obter mais informações sobre como modificar as configurações de publicação do
ActionScript, consulte “Modificando as configurações de publicação do ActionScript”
na página 67. Para obter mais informações sobre como definir um caminho de classe em nível
de documento ou no nível global, consulte “Modificando o caminho de classe” na página 68.
66
Modificando as configurações de publicação do
ActionScript
Por padrão, quando você publica um documento do Flash, a versão do ActionScript é definida
como 2.0 e o caminho de classe é herdado da configuração do caminho de classe global. Se
precisar alterar a versão do ActionScript ou especificar um caminho de classe em nível de
documento, edite as configurações de publicação.
Para alterar a versão do ActionScript:
1.
Selecione File (Arquivo) > Publish Settings (Configurações de publicação) e clique na guia
Flash.
2.
Selecione a versão do ActionScript no menu pop-up.
O ActionScript 2.0 está selecionado por padrão. Se criar seus scripts no ActionScript 1.0,
em vez de no 2.0, altere essa configuração antes de publicar seu documento do Flash.
O compilador do ActionScript 2.0 compila todo o código ActionScript 1.0, exceto: a sintaxe
de barra (/) usada para indicar caminhos de clipes de filme (por exemplo, parentClip/
testMC:varName= "olá mundo") gera erros de compilação quando você seleciona o
ActionScript 2.0 como a versão do ActionScript. Para solucionar esse problema, reescreva o
código usando a notação de ponto (.), em vez de barras, ou selecione o compilador do
ActionScript 1.0.
Use o botão Settings (Configurações) (próximo ao menu pop-up da versão do ActionScript)
para modificar o caminho de classe em nível de documento. Para obter mais informações,
consulte “Modificando o caminho de classe” na página 68.
Sobre as configurações de publicação do ActionScript
67
Modificando o caminho de classe
Ao usar o ActionScript 2.0, você também pode definir um caminho de classe em nível de
documento. Isso será útil quando você criar suas próprias classes e desejar substituir o caminho
de classe global do ActionScript definido nas preferências do ActionScript.
A alteração do caminho de classe nas configurações de publicação somente será aplicada ao
arquivo do Flash atual.
Você pode usar a caixa de diálogo Preferences para modificar o caminho de classe global. Para
modificar a configuração do caminho de classe em nível de documento, use a caixa de diálogo
Publish Settings para o arquivo FLA. Em ambos os casos, você pode adicionar caminhos de
diretório absolutos (por exemplo, C:/my_classes) e caminhos de diretório relativos (por
exemplo, ../my_classes ou ".").
Para modificar o caminho de classe global:
1.
Selecione Edit > Preferences (Windows) ou Flash > Preferences (Macintosh) para abrir a
caixa de diálogo Preferences.
2.
Clique em ActionScript na lista Category e, em seguida, clique em ActionScript 2.0
Settings (Configurações do ActionScript 2.0).
3.
■
Para adicionar um diretório ao caminho de classe, clique em Browse to Path (Navegar
até caminho), navegue até o diretório que deseja adicionar e clique em OK.
Uma outra alternativa é clicar em Add New Path (+) (Adicionar novo caminho) para
adicionar uma nova linha à lista Classpath (Caminho de classe). Clique duas vezes na
nova linha, digite um caminho relativo ou absoluto e clique em OK.
■
Para editar um diretório de caminho de classe existente, selecione o caminho na lista
Classpath, clique em Browse to Path, navegue até o diretório que deseja adicionar e
clique em OK.
Ou então, clique duas vezes no caminho na lista Classpath, digite o caminho desejado
e clique em OK.
■
Para excluir um diretório do caminho de classe, selecione o caminho na lista Classpath
e clique em Remove from Path (Remover do caminho).
N OT A
68
Não exclua o caminho de classe global absoluto (consulte Caminhos de classe
globais e em nível de documento). O Flash utiliza esse caminho de classe para
acessar as classes internas. Se você acidentalmente excluir esse caminho de
classe, restabeleça-o adicionando $(LocalData)/Classes como um novo
caminho de classe.
Para modificar o caminho de classe em nível de documento:
1.
Selecione File > Publish Settings para abrir a caixa de diálogo Publish Settings.
2.
Clique na guia Flash.
3.
Clique em Settings próximo ao menu pop-up ActionScript Version (Versão do
ActionScript).
4.
■
Para adicionar um diretório ao caminho de classe, clique em Browse to Path, navegue
até o diretório que deseja adicionar e clique em OK.
Uma outra alternativa é clicar em Add New Path (+) para adicionar uma nova linha à
lista Classpath. Clique duas vezes na nova linha, digite um caminho relativo ou
absoluto e clique em OK.
■
Classpath, clique em Browse to Path, navegue até o diretório que deseja adicionar e
clique em OK.
Ou então, clique duas vezes no caminho na lista Classpath, digite o caminho desejado
e clique em OK.
■
Para excluir um diretório do caminho de classe, selecione o caminho na lista Classpath
e clique em Remove from Path.
Para obter mais informações sobre como definir e modificar caminhos de classe, consulte
“Sobre a definição e a modificação do caminho de classe” na página 255.
Arquivos de configuração instalados com o Flash 8
Quando você instala o Flash Basic 8 ou o Flash Professional 8, vários arquivos e pastas de
configuração relacionados ao ActionScript são incluídos no sistema. Você pode utilizar esses
arquivos para definir determinadas configurações no ambiente de criação. Como sempre,
modifique cuidadosamente e salve um backup dos arquivos alterados.
Pasta de classes do ActionScript
Contém todas as classes do ActionScript (arquivos do
AS) incluídas no Flash Professional 8 ou no Flash Basic 8. Caminhos típicos da pasta:
■
Windows: Hard Disk\Documents and Settings\usuario\Local Settings\Application
Data\Macromedia\Flash 8\idioma\Configuration\Classes.
■
Macintosh: Hard Disk/Users/usuario/Library/Application Support/Macromedia/Flash 8/
idioma/Configuration/Classes.
Sobre as configurações de publicação do ActionScript
69
A pasta Classes é organizada em pastas contendo diretórios com as classes do Flash Player
7 (FP7) e do Flash Player 8 (FP8). Ela também contém um diretório para o pacote (mx),
usado nos dois exibidores e em arquivos do ASO (aso). Para obter mais informações sobre
arquivos do ASO, consulte “Usando arquivos ASO” na página 298. Para obter mais
informações sobre a organização desse diretório, consulte o arquivo readme na pasta
Classes.
Pasta de inclusão de classes
Contém todos os arquivos de inclusão globais do
ActionScript e está localizada em:
■
Data\Macromedia\Flash 8\idioma\Configuration\Include.
■
idioma/Configuration/Include.
Arquivo de configuração ActionsPanel.xml
Inclui o arquivo de configuração das
referências do código ActionScript e está localizado em:
■
Data\Macromedia\Flash 8\idioma\Configuration\ActionsPanel\ActionScript_1_2.
■
idioma/Configuration/ActionsPanel/ActionScript_1_2.
É o arquivo de configuração para realce da
sintaxe por cores do código ActionScript, localizado em:
Arquivo de configuração AsColorSyntax.xml
■
Data\Macromedia\Flash 8\idioma\Configuration\ActionsPanel\.
■
idioma/Configuration/ActionsPanel.
70
CAPÍTULO 3
3
Sobre o ActionScript
Os recursos OOP (object-oriented programming, programação orientada a objeto) no
ActionScript 2.0 tem como base a proposta ECMAScript 4 desenvolvidas no momento pela
ECMA TC39-TG1 (consulte www.mozilla.org/js/language/es4/index.html). Como a
proposta ECMA-4 ainda não se tornou padrão e está em processo de alteração, o
ActionScript 2.0 baseia-se nessa especificação com menos rigidez.
O ActionScript 2.0 oferece suporte a todos os elementos padrão da linguagem ActionScript;
ele permite escrever scripts que atendem melhor aos padrões usados em outras linguagens
orientadas a objeto, como Java. O ActionScript 2.0 deve interessar principalmente a
desenvolvedores de Flash intermediários ou avançados autores de aplicativos que precisam da
implementação de classes e subclasses. O ActionScript 2.0 também permite que você declare o
tipo de objeto de uma variável ao criá-la (consulte “Sobre a atribuição de tipos de dados e a
atribuição estrita de tipos de dados” na página 85) e fornece erros de compilador bem
aprimorados (consulte Apêndice A, “Mensagens de erro”, na página 809).
As principais considerações sobre o ActionScript 2.0 incluem os seguintes pontos:
■
Scripts que usam o ActionScript 2.0 para definir classes ou interfaces devem ser
armazenados como arquivos de script externos, com uma única classe definida em cada
script, ou seja, classes e interfaces não podem ser definidas no painel Actions (Ações).
■
Você pode importar arquivos de classes individuais implicitamente (armazenando-os em
um local especificado por caminhos de pesquisa globais ou específicos de documentos e
depois utilizando-os em um script) ou explicitamente (usando o comando import). É
possível importar pacotes (coleções de arquivos de classe em um diretório) usando
caracteres curinga.
71
■
Os aplicativos desenvolvidos com o ActionScript 2.0 são suportados pelo Flash Player 6 e
versões posteriores.
A T E NÇ Ã O
A configuração padrão de publicação para os novos arquivos criados no Flash 8 é
ActionScript 2.0. Se você planeja modificar um arquivo FLA existente com
ActionScript 1.0 para usar a sintaxe do ActionScript 2.0, verifique se o arquivo
especifica ActionScript 2.0 em suas configurações de publicação. Caso contrário,
seu arquivo será compilado incorretamente, apesar de o Flash não gerar
necessariamente erros de compilador.
Para obter mais informações sobre como usar o ActionScript 2.0 para escrever programas
orientados a objeto no Flash, consulte o Capítulo 7, “Classes”, na página 239.
Embora a Macromedia recomende o uso do ActionScript 2.0, você pode continuar usando a
sintaxe do ActionScript 1.0, especialmente se estiver realizando um trabalho mais tradicional
do Flash, por exemplo, uma animação simples, que não requer a interação do usuário.
O que é ActionScript
Os principais recursos do ActionScript 2.0 incluem:
Modelo familiar OOP (Object-Oriented Programming, Programação orientada a
objeto) O recurso primário do ActionScript 2.0 é um modelo familiar para a criação de
programas orientados a objeto. O ActionScript 2.0 implementa vários conceitos e palavraschave orientados a objeto, como class, interface e packages, que parecerão familiares se você já
tiver programado com Java.
O modelo OOP fornecido pelo ActionScript 2.0 é uma “formalização sintática” do método de
encadeamento de protótipo usado em versões anteriores do Macromedia Flash para criar
objetos e estabelecer herança. Com o ActionScript 2.0, é possível criar classes personalizadas e
estender as classes internas do Flash.
O ActionScript 2.0 também permite especificar
explicitamente os tipos de dados para variáveis, parâmetros de função e tipos de retorno de
função. Por exemplo, o código a seguir declara uma variável chamada userName de tipo String
(um tipo de dados interno do ActionScript, ou classe).
Atribuição estrita de tipos de dados
var userName:String = "";
Avisos e erros do compilador Os dois recursos anteriores (modelo OOP e atribuição
estrita de tipos de dado) permitem que a ferramenta de criação e o compilador forneçam
mensagens de erro e avisos do compilador que ajudam a localizar falhas nos aplicativos de
forma mais rápida que anteriormente no Flash.
72
Ao usar o ActionScript 2.0, verifique se as configurações de publicação para o arquivo FLA
especificam ActionScript 2.0. Esse é o padrão para arquivos criados em Flash MX 2004 e
Flash 8. Entretanto, se você abrir um arquivo FLA antigo que usa ActionScript 1.0 e começar
a reescrevê-lo em ActionScript 2.0, altere suas configurações de publicação para
ActionScript 2.0. Caso contrário, seu arquivo FLA não será compilado corretamente e não
serão gerados erros.
Sobre a opção entre o ActionScript 1.0 e
o ActionScript 2.0
Ao iniciar um novo documento ou aplicativo no Flash, você deve decidir como organizará os
arquivos associados. Você pode usar classes em alguns projetos, por exemplo, ao criar
aplicativos ou arquivos FLA complexos, mas nem todos os documentos utilizam classes. Por
exemplo, vários exemplos pequenos na documentação não utilizam classes. O uso de classes
para armazenar funcionalidade não é a mais fácil ou melhor solução para aplicativos pequenos
ou arquivos FLA simples. Em geral, é mais eficiente incluir o ActionScript dentro do
documento. Nesse caso, tente colocar todo o código naTimeline, no menor número de
quadros possível, e evite incluir código em instâncias (como botões ou clipes de filme) de um
arquivo FLA.
Quando você cria um projeto pequeno, em geral é mais produtivo usar classes ou arquivos de
código externos para organizar o ActionScript, em vez de adicioná-lo ao arquivo FLA.
Algumas vezes, é mais fácil manter todo o código ActionScript no arquivo FLA, em vez de
inseri-lo em uma classe importada. Isso não significa que você deve usar necessariamente o
ActionScript 1.0. Você pode optar por incluir o código no arquivo FLA usando o ActionScript
2.0 com sua atribuição estrita de tipos de dados e seus novos métodos e propriedades. O
ActionScript 2.0 também oferece uma sintaxe que segue os padrões de outras linguagens de
programação, o que torna a linguagem mais fácil e valiosa para ser aprendida. Por exemplo,
você se sentirá familiarizado com o ActionScript caso tenha encontrado outra linguagem
baseada na mesma estrutura e padrões de sintaxe. Ou então, você poderá aplicar esse
conhecimento a outras linguagens a serem aprendidas no futuro. O ActionScript 2.0 permite
o uso de uma abordagem orientada a objeto para o desenvolvimento de aplicativos através de
um conjunto adicional de elementos de linguagem, que pode ser vantajoso para o
desenvolvimento de seu aplicativo.
Em alguns casos, não é possível escolher a versão do ActionScript a ser usada. Se estiver
criando um arquivo SWF destinado a uma versão antiga do Flash Player, por exemplo, um
aplicativo de dispositivo móvel, use o ActionScript 1.0, que é compatível com o Flash Player
no caso de vários dispositivos.
Sobre a opção entre o ActionScript 1.0 e o ActionScript 2.0
73
Independentemente da versão do ActionScript, lembre-se de seguir as práticas recomendadas.
Várias delas, como manter-se consistente com a distinção entre maiúsculas e minúsculas, usar
a conclusão de código, melhorar a legibilidade, evitar palavras-chave para nomes de instância e
manter uma convenção de nomeação consistente, aplicam-se às duas versões.
Se planeja atualizar o aplicativo em versões futuras do Flash ou torná-lo maior e mais
complexo, use o ActionScript 2.0 e classes para facilitar a atualização e a modificação do
aplicativo.
Noções básicas do ActionScript e do
Flash Player
Se você compilar um arquivo SWF que contenha o ActionScript 2.0 com configurações de
publicação definidas para o Flash Player 6 e o ActionScript 1.0, o código funcionará desde que
não use classes do ActionScript 2.0. Não há distinção entre maiúsculas e minúsculas no
código, somente no Flash Player. Portanto, se você compilar o arquivo SWF com
Configurações de Publicação definidas para o Flash Player 7 ou 8 e o ActionScript 1.0, o Flash
irá impor a distinção entre maiúsculas e minúsculas.
As anotações de tipos de dados (tipos de dados estritos) são impostas durante a compilação
para o Flash Player 7 e 8 quando você publica as configurações definidas para o ActionScript
2.0.
O ActionScript 2.0 realiza a compilação para o bytecode do ActionScript 1.0 na publicação de
aplicativos, portanto, você pode usar o Flash Player 6, 7, ou 8 ao trabalhar com o ActionScript
2.0.
74
CAPÍTULO 4
4
Dados e tipos de dados
Este capítulo é o primeiro de vários que descrevem e demonstram alguns dos conceitos
fundamentais do ActionScript. Você praticará algumas técnicas básicas de codificação para
aprender a criar aplicativos complexos. Neste capítulo, você também aprenderá a trabalhar
com dados em um arquivo FLA e verá os tipos de dados com os quais é possível trabalhar. No
próximo capítulo, Capítulo 5, “Fundamentos da sintaxe e da linguagem,” você descobrirá
como usar a sintaxe do ActionScript e instruções de formulário. Em seguida, o Capítulo 6,
“Funções e métodos” demonstra como usar funções e métodos na linguagem ActionScript.
Para obter mais informações sobre dados e tipos de dados, consulte estas seções:
Sobre dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Sobre tipos de dados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Sobre variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Organizando dados em objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .114
Sobre a conversão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .116
Sobre dados
Dados referem-se a números, seqüências de caracteres e outras informações que você pode
manipular no Flash. O uso de dados é geralmente essencial durante a criação de aplicativos ou
sites da Web. Você também pode usar dados ao criar gráficos avançados e animação gerada
com script e possivelmente terá de manipular os valores usados para controlar seus efeitos.
É possível definir dados em variáveis no Flash ou carregar dados de sites ou arquivos externos
usando XML, serviços da Web, classes internas do ActionScript etc. Você pode armazenar
dados em um banco de dados e representar as informações de diversas maneiras em um
arquivo SWF. Por exemplo, você pode exibir as informações em campos de texto ou
componentes ou exibir imagens em instâncias de clipe de filme.
Alguns dos tipos de dados mais comuns incluem seqüências de caracteres (como nomes e
partes de texto), números, objetos (como clipes de filme), valores booleanos (true e false)
etc. Neste capítulo, você também aprenderá sobre os tipos de dados do Flash e como usá-los.
75
Para obter informações sobre tipos de dados, consulte “Sobre tipos de dados” na página 76.
Para obter informações sobre variáveis, consulte “Sobre variáveis” na página 91.
Sobre tipos de dados
Um tipo de dados descreve um dado e os tipos de operações que podem ser executados nele. Os
dados são armazenados em uma variável. Você usa tipos de dados ao criar variáveis, instâncias
de objetos e definições de funções para atribuir o tipo de dados com o qual está trabalhando.
Ao criar um código ActionScript, você usa diversos tipos de dados.
O ActionScript 2.0 define vários tipos de dados comumente usados. Os tipos de dados
descrevem o tipo de valor que uma variável ou um elemento do ActionScript pode conter.
Uma variável atribuída a um tipo de dados pode armazenar somente um valor contido no
conjunto de valores desse tipo de dados. Para obter informações sobre variáveis, consulte
“Sobre variáveis” na página 91.
O ActionScript contém vários tipos de dados básicos que você provavelmente usará com
freqüência em seus aplicativos. Consulte a tabela em “Sobre tipos de dados primitivos e
complexos” na página 77 para obter mais informações.
O ActionScript também contém classes básicas, como Array e Date, que são consideradas
tipos de dados complexos ou de referência. Para obter mais informações sobre tipos de dados
complexos e de referência, consulte “Sobre tipos de dados primitivos e complexos”
na página 77. Além disso, todos os tipos de dados e classes são totalmente definidos em
ActionScript 2.0 Language Reference (Referência da linguagem ActionScript 2.0).
Você também pode criar classes personalizadas para seus aplicativos. Toda classe definida com
o uso de declarações de classe é considerada um tipo de dados. Para obter mais informações
sobre classes básicas e outras classes internas, consulte “Sobre classes de nível superior e
internas” na página 302. Para obter mais informações sobre como criar classes personalizadas,
consulte o Capítulo 7, “Classes”, na página 239.
No ActionScript 2.0, é possível atribuir tipos de dados a variáveis ao declará-las. Os tipos de
dados atribuídos podem ser qualquer um dos tipos básicos ou representar uma classe
personalizada criada por você. Para obter mais informações, consulte “Sobre a atribuição de
tipos de dados e a atribuição estrita de tipos de dados” na página 85.
Ao depurar scripts, talvez você precise determinar os tipos de dados de uma expressão ou
variável para entender seu comportamento. Isso pode ser feito com os operadores instanceof
e typeof (consulte “Sobre a determinação do tipo de dados” na página 90).
Você pode converter um tipo de dados em outro durante a execução usando uma das seguintes
funções de conversão: Array(), Boolean(), Number(), Object(), String().
76
Você pode localizar um arquivo de origem de exemplo, datatypes.fla, na pasta Samples do seu
disco rígido, que mostra como usar os tipos de dados em um aplicativo.
■
No Windows, navegue até unidade de inicialização\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\DataTypes.
■
No Macintosh, navegue até HD Macintosh/Applications/Macromedia Flash 8/Samples
and Tutorials/Samples/ActionScript/DataTypes.
Sobre tipos de dados primitivos e complexos
Os diversos valores de tipos de dados podem ser divididos em duas categorias principais:
primitivos ou complexos.
Um valor primitivo (ou tipo de dados primitivo) é um valor que o ActionScript armazena no
nível mais baixo de abstração; isso significa que as operações executadas em tipos de dados
primitivos geralmente são mais rápidas e eficientes do que as executadas em tipos de dados
complexos. Os seguintes tipos de dados definem um conjunto de um ou mais valores
primitivos: Boolean, null, Number, String e undefined.
Um valor complexo (ou tipo de dados complexo) é um valor que não é primitivo e faz
referência aos valores primitivos. Em geral, eles são chamados tipos de dados de referência. Os
valores complexos pertencem ao tipo de dados Object ou a um tipo que se baseia no tipo de
dados Object. Os tipos de dados que definem conjuntos de valores complexos incluem Array,
Date, Error, Function e XML. Para obter mais informações sobre esses tipos de dados
complexos, consulte as entradas correspondentes em ActionScript 2.0 Language Reference.
Em determinadas situações, as variáveis que contêm tipos de dados primitivos se comportam
de maneira diferente das que contêm tipos de dados complexos. Para obter mais informações,
consulte “Usando variáveis em um projeto” na página 111.
O ActionScript possui os seguintes tipos de dados básicos que você pode usar em seus
aplicativos:
Tipo de dados
Descrição
Boolean
Primitivo. O tipo de dados Boolean consiste em dois valores: true e
false. Nenhum outro valor é válido para variáveis desse tipo. O valor
padrão de uma variável Boolean declarada, mas não inicializada é
false. Para obter mais informações, consulte “Tipo de dados Boolean”
na página 79.
MovieClip
Complexo. O tipo de dados MovieClip permite controlar símbolos de
clipes de filme com os métodos da classe MovieClip. Para obter mais
informações, consulte “Tipo de dados MovieClip” na página 80.
77
Tipo de dados
Descrição
null
Primitivo. O tipo de dados null contém o valor null. Esse valor significa
nenhum valor — ou seja, uma falta de dados. Você pode atribuir o valor
null em inúmeras situações para indicar que não há um valor atribuído
a uma propriedade ou a uma variável. O tipo de dados null é o padrão de
todas as classes que definem tipos de dados complexos. Uma exceção
a essa regra é a classe Object, cujo padrão é undefined. Para obter mais
informações, consulte “Tipo de dados null” na página 81.
Number
Primitivo. Esse tipo de dados pode representar inteiros, inteiros sem
sinal e números de ponto flutuante. Para armazenar um número de
ponto flutuante, inclua um ponto decimal no número. Sem o ponto
decimal, o número é armazenado como um inteiro. O tipo de dados
Number pode armazenar desde um valor Number.MAX_VALUE (muito alto)
até Number.MIN_VALUE (muito baixo). Para obter mais informações,
consulte, ActionScript 2.0 Language Reference e “Tipo de dados
Number” na página 82.
Object
Complexo. O tipo de dados Object é definido pela classe Object. Essa
classe serve como base para todas as definições de classe do
ActionScript e permite organizar os objetos uns dentro dos outros
(objetos aninhados). Para obter mais informações, consulte “Tipo de
dados Object” na página 83.
String
Primitivo. O tipo de dados String representa uma seqüência de
caracteres de 16 bits que pode incluir letras, números e sinais de
pontuação. As seqüências de caracteres são armazenadas como
caracteres Unicode, usando o formato UTF-16. Uma operação em um
valor String retorna uma nova instância da seqüência de caracteres.
Para obter mais informações, consulte “Tipo de dados String”
na página 83.
undefined
Primitivo. O tipo de dados undefined contém um valor: undefined. Esse
é o valor padrão das instâncias da classe Object. Somente é possível
atribuir o valor undefined às variáveis pertencentes à classe Object. Para
obter mais informações, consulte “Tipo de dados undefined”
na página 85.
Void
Complexo. O tipo de dados Void contém somente um valor: void. Use
esse tipo de dados para designar funções que não retornam um valor.
Void é um tipo de dados complexo que faz referência ao tipo de dados
primitivo Void. Para obter mais informações, consulte “Tipo de dados
Void” na página 85.
78
■
■
Tipo de dados Boolean
Um valor booleano é true ou false. O ActionScript também converte os valores true e
false em 1 e 0 quando apropriado. Os valores booleanos são freqüentemente usados com
operadores lógicos em instruções do ActionScript que fazem comparações para controlar o
fluxo de um script.
O exemplo a seguir carrega um arquivo de texto em um arquivo SWF e exibe uma mensagem
no painel Output (Saída) caso o arquivo de texto não seja carregado corretamente ou os
parâmetros se ele for carregado com êxito. Consulte os comentários no exemplo de código
para obter mais detalhes.
var my_lv:LoadVars = new LoadVars();
//sucess é um valor booleano
my_lv.onLoad = function(sucess:Boolean) {
//se sucess for true, rastrear monthNames
if (sucess) {
trace(my_lv.monthNames);
//se sucess for false, rastrear uma mensagem
} else {
trace("unable to load text file");
}
};
my_lv.load("http://www.helpexamples.com/flash/params.txt");
O exemplo a seguir verifica se os usuários inserem valores em duas instâncias do componente
TextInput. Duas variáveis Boolean são criadas, userNameEntered e isPasswordCorrect e, se
ambas resultarem em true, uma mensagem de boas-vindas será atribuída à variável String
titleMessage.
// Adicionar dois componentes TextInput, um componente Label e um componente
Button no Stage.
// Atribuir um tipo de dados estrito às três instâncias do componente
var userName_ti:mx.controls.TextInput;
var password_ti:mx.controls.TextInput;
var submit_button:mx.controls.Button;
var welcome_lbl:mx.controls.Label;
//Ocultar o rótulo
welcome_lbl.visible = false;
79
// Criar um objeto ouvinte, que é usado com o componente Button.
// Quando o Button é clicado, procura um nome de usuário e uma senha.
var loadListener:Object = new Object();
btnListener.click = function(evt:Object) {
// Verifica se o usuário insere pelo menos um caractere nas instâncias do
componente TextInput
// e retorna um valor true/false booleano.
var userNameEntered:Boolean = (userName_ti.text.length > 0);
var isPasswordCorrect:Boolean = (password_ti.text == "vertigo");
if (userNameEntered && isPasswordCorrect) {
var titleMessage:String = "Welcome " + userName_ti.text + "!";
welcome_lbl.text = titleMessage;
//exibir o rótulo
welcome_lbl.visible = true;
}
};
submit_button.addEventListener("click", btnListener);
Para obter mais informações, consulte “Usando funções no Flash” na página 227 e “Sobre
operadores lógicos” na página 205.
Tipo de dados MovieClip
Clipes de filme são símbolos que podem reproduzir animações em um aplicativo Flash. Eles
são os únicos tipos de dados que fazem referência a elementos gráficos. O tipo de dados
MovieClip permite controlar símbolos de clipes de filme com os métodos da classe
MovieClip.
Os métodos da classe MovieClip não são chamados com um construtor. Você pode criar uma
instância de clipe de filme no Stage (Palco) ou dinamicamente. Em seguida, basta chamar os
métodos da classe MovieClip com o operador ponto (.).
O exemplo a seguir chama os métodos
e getURL() para instâncias diferentes de clipe de filme existentes no Stage:
Trabalhando com clipes de filme no Stage
startDrag()
my_mc.startDrag(true);
parent_mc.getURL("http://www.macromedia.com/support/" + product);
O segundo exemplo retorna a largura do clipe de filme chamado my_mc no Stage. A instância
especificada como destino deve ser um clipe de filme, e o valor retornado deve ser numérico.
function getMCWidth(target_mc:MovieClip):Number {
return target_mc._width;
}
trace(getMCWidth(my_mc));
80
Criando clipes de filme dinamicamente O uso do ActionScript para criar clipes de filme
dinamicamente é útil quando você não deseja criar manualmente clipes de filme no Stage ou
anexá-los a partir da biblioteca. Por exemplo, você pode criar uma galeria de imagens com um
grande número de miniaturas que deseja organizar no Stage. Com
MovieClip.createEmptyMovieClip() , é possível criar um aplicativo usando apenas o
ActionScript.
Para criar um clipe de filme dinamicamente, use MovieClip.createEmptyMovieClip(),
como mostra o seguinte exemplo:
// Cria um clipe de filme para armazenar o recipiente.
this.createEmptyMovieClip("image_mc", 9);
// Carrega uma imagem em image_mc.
image_mc.loadMovie("http://www.helpexamples.com/flash/images/image1.jpg");
O segundo exemplo cria um clipe de filme chamado square_mc que usa a API (Application
Programming Interface, Interface de programação de aplicativos) Drawing para desenhar um
retângulo. Os manipuladores de eventos e os métodos startDrag() e stopDrag() da classe
MovieClip são adicionados para tornar o retângulo arrastável.
this.createEmptyMovieClip("square_mc", 1);
square_mc.lineStyle(1, 0x000000, 100);
square_mc.beginFill(0xFF0000, 100);
square_mc.moveTo(100, 100);
square_mc.lineTo(200, 100);
square_mc.endFill();
square_mc.onPress = function() {
this.startDrag();
};
square_mc.onRelease = function() {
this.stopDrag();
};
Para obter mais informações, consulte Capítulo 11, “Trabalhando com clipes de filme”, na
página 369 e a entrada %{MovieClip}% em ActionScript 2.0 Language Reference.
Tipo de dados null
O tipo de dados null possui apenas um valor: null. Esse valor significa nenhum valor — ou
seja, uma falta de dados. Você pode atribuir o valor null em inúmeras situações para indicar
que ainda não há valor atribuído a uma propriedade ou a uma variável. Por exemplo, é
possível atribuir o valor null nas seguintes situações:
■
Para indicar que uma variável existe, mas ainda não recebeu um valor
■
Para indicar que uma variável existe, mas não contém mais um valor
81
■
Como resultado de uma função, para indicar que não havia valor disponível a ser
retornado pela função
■
Como parâmetro de uma função, para indicar a omissão de um parâmetro
Vários métodos e funções retornarão null se nenhum valor tiver sido definido. O exemplo a
seguir demonstra como usar null para testar se os campos de formulário têm foco de
formulário:
if (Selection.getFocus() == null) {
trace("no selection");
}
Tipo de dados Number
O tipo de dados Number é um número de dupla precisão e ponto flutuante. O valor mínimo
de um objeto Number é aproximadamente 5e-324, e o máximo é aproximadamente
1,79E+308.
É possível manipular números usando os operadores aritméticos de adição (+), subtração (-),
multiplicação (*), divisão (/), módulo (%), incremento (++) e decremento (--). Para obter
mais informações, consulte “Usando operadores numéricos” na página 198.
Também é possível usar métodos das classes internas Math e Number para manipular
números. Para obter mais informações sobre os métodos e as propriedades dessas classes,
consulte as entradas %{Math}% e %{Number}% em ActionScript 2.0 Language Reference.
O exemplo a seguir usa o método sqrt() (square root - raiz quadrada) da classe Math para
retornar a raiz quadrada do número 100:
Math.sqrt(100);
O exemplo a seguir retorna um inteiro aleatório entre 10 e 17 (inclusive):
var bottles:Number = 0;
bottles = 10 + Math.floor(Math.random() * 7);
trace("There are " + bottles + " bottles");
O exemplo a seguir localiza a porcentagem do clipe de filme intro_mc carregada e a
representa como um inteiro:
var percentLoaded:Number = Math.round((intro_mc.getBytesLoaded() /
intro_mc.getBytesTotal()) * 100);
82
Tipo de dados Object
Um objeto é uma coleção de propriedades. Uma propriedade é um atributo que descreve o
objeto. Por exemplo, a transparência de um objeto (como um clipe de filme) é um atributo
que descreve sua aparência. Portanto, _alpha (transparência) é uma propriedade. Cada
propriedade possui um nome e um valor. O valor de uma propriedade pode ser qualquer tipo
de dados do Flash, até mesmo o tipo de dados Object. Isso permite aninhar objetos, ou seja,
organizá-los uns dentro dos outros.
Para especificar os objetos e suas propriedades, use o operador ponto (.). Por exemplo, no
código a seguir, hoursWorked é uma propriedade de weeklyStats, que, por sua vez, é uma
propriedade de employee:
employee.weeklyStats.hoursWorked
O objeto MovieClip do ActionScript possui métodos que permitem controlar instâncias de
símbolos de clipes de filme no Stage. Este exemplo usa os métodos play() e nextFrame():
mcInstanceName.play();
mc2InstanceName.nextFrame();
Você também pode criar objetos personalizados para organizar informações em seu aplicativo
Flash. Para adicionar interatividade a um aplicativo com o ActionScript, você precisará de
muitas informações, por exemplo, o nome, a idade e o telefone do usuário; a velocidade de
uma bola; os nomes dos itens de um carrinho de compras; o número de quadros carregados;
ou a última tecla pressionada pelo usuário. A criação de objetos personalizados permite que
você organize essas informações em grupos, simplifique e reutilize scripts.
O código ActionScript apresentado a seguir mostra como usar objetos personalizados para
organizar informações. Ele cria um novo objeto chamado user e três propriedades, name, age
e phone, que são tipos de dados String e Numeric.
var user:Object = new Object();
user.name = "Irving";
user.age = 32;
user.phone = "555-1234";
Para obter mais informações, consulte “Exemplo: Criando classes personalizadas”
na página 278.
Tipo de dados String
Uma seqüência de caracteres é uma seqüência de letras, números e sinais de pontuação. Insira
seqüências de caracteres em instruções do ActionScript colocando-as entre aspas simples (') ou
duplas (").
83
Uma forma comum de usar o tipo String é atribuir uma seqüência de caracteres a uma
variável. Por exemplo, na instrução a seguir, "L7" é uma seqüência de caracteres atribuída à
variável favoriteBand_str:
var favoriteBand_str:String = "L7";
Você pode usar o operador de adição (+) para concatenar, ou unir, duas seqüências de
caracteres. O ActionScript trata os espaços no início ou no final de uma seqüência de
caracteres como uma parte literal dessa seqüência. A expressão a seguir inclui um espaço
depois da vírgula:
var greeting_str:String = "Welcome, " + firstName;
Para incluir aspas em uma seqüência de caracteres, coloque uma barra invertida (\) antes delas.
Isso é chamado escape de caractere. Há outros caracteres que só podem ser representados no
ActionScript por seqüências de escape especiais. A tabela a seguir lista todos os caracteres de
escape do ActionScript:
Seqüência de
escape
Caractere
\b
Caractere Backspace (ASCII 8)
\f
Caractere de alimentação de formulário (ASCII 12)
\n
Caractere de alimentação de linha (ASCII 10)
\r
Caractere de retorno de carro (ASCII 13)
\t
Caractere Tab (ASCII 9)
\"
Aspas duplas
\'
Aspas simples
\\
Barra invertida
\000 - \377
Um byte especificado em octal
\x00 - \xFF
Um byte especificado em hexadecimal
\u0000 - \uFFFF
Um caractere Unicode de 16 bits especificado em hexadecimal
Assim como em Java, as seqüências de caracteres são imutáveis no ActionScript. Qualquer
operação que modifique uma seqüência de caracteres retorna uma nova seqüência.
A classe String é uma classe interna do ActionScript. Para obter informações sobre os métodos
e as propriedades da classe String, consulte a entrada %{String}% em ActionScript 2.0
Language Reference.
84
Tipo de dados undefined
O tipo de dados undefined possui um valor, undefined, e é atribuído automaticamente a
uma variável à qual um valor não foi atribuído, tanto pelo seu código como pela interação do
usuário.
O valor undefined é atribuído automaticamente; diferentemente de null, um valor
undefined não é atribuído a uma variável ou a uma propriedade. Use o tipo de dados
undefined para verificar se uma variável está definida. Esse tipo de dados permite criar um
código que é executado somente quando o aplicativo está em execução, como mostra o
exemplo a seguir:
if (init == undefined) {
trace("initializing app");
init = true;
}
Se o aplicativo tiver vários quadros, o código não será executado uma segunda vez porque a
variável init não será mais undefined.
Tipo de dados Void
O tipo de dados Void possui um valor, void, usado em uma definição de função para indicar
que a função não retorna um valor, como mostra o exemplo a seguir:
//Cria uma função com o tipo de retorno Void
function displayFromURL(url:String):Void {}
Sobre a atribuição de tipos de dados e a atribuição
estrita de tipos de dados
No Flash, as variáveis são usadas para armazenar valores no código. Você pode declarar
explicitamente o tipo de objeto de uma variável ao criá-la; isso é chamado atribuição estrita de
tipos de dados.
Se você não definir explicitamente que um item armazena um número, uma seqüência de
caracteres ou outro tipo de dados, durante a execução, o Flash Player tentará determinar o tipo
de dados do item quando ele for atribuído. Se você atribuir um valor a uma variável, como no
exemplo a seguir, o Flash Player avaliará, durante a execução, o elemento à direita do operador
e determinará que ele é do tipo Number:
var x = 3;
85
Como x não foi declarado com a atribuição estrita de tipos de dados, o compilador não pode
determinar o tipo; para o compilador, a variável x pode ter qualquer tipo de valor. (Consulte
“Atribuindo um tipo de dados” na página 87.) Uma atribuição posterior pode alterar o tipo de
x; por exemplo, a instrução x = "hello" altera o tipo de x para String.
O ActionScript sempre converte automaticamente tipos de dados primitivos (como Boolean,
Number, String, null ou undefined) quando uma expressão exige a conversão e a atribuição
estrita de tipos de dados não é aplicada às variáveis.
A atribuição estrita de tipos de dados oferece vários benefícios durante a compilação. A
declaração de tipos de dados (atribuição estrita de tipos de dados) pode ajudar a evitar ou a
diagnosticar erros no código durante a compilação. Para declarar uma variável usando a
atribuição estrita de dados, use o seguinte formato:
var variableName:datatype;
NO T A
Algumas vezes, a atribuição estrita de tipos de dados é chamada atribuição forte de
tipos de dados a uma variável.
Como a incompatibilidade de tipos de dados gera erros do compilador, a atribuição estrita de
tipos de dados ajuda a identificar erros no código durante a compilação e evita a atribuição do
tipo de dados incorreto a uma variável existente. Durante a criação, a atribuição estrita de
tipos de dados ativa as referências de código no editor do ActionScript (mas ainda assim é
necessário usar sufixos de nomes de instância para elementos visuais).
A atribuição estrita de tipo de dados ajuda a garantir a não atribuição inadvertida de um tipo
incorreto de valor a uma variável. O Flash verifica se há erros de incompatibilidade de tipos
durante a compilação e exibirá uma mensagem de erro se você usar o tipo incorreto de valor.
Portanto, o uso da atribuição estrita também ajuda a impedir sua tentativa de acesso a
propriedades ou métodos que não façam parte do tipo de um objeto. A atribuição estrita de
tipos de dados significa que o editor do ActionScript mostra automaticamente as referências
de código dos objetos.
Para obter mais informações sobre como criar variáveis, consulte “Sobre variáveis”
na página 91. Para obter informações sobre como atribuir nomes a variáveis, consulte “Sobre a
atribuição de nomes a variáveis” na página 96. Para obter mais informações sobre como
atribuir tipos de dados e os tipos que podem ser atribuídos, consulte “Atribuindo um tipo de
dados” na página 87.
86
■
■
Atribuindo um tipo de dados
Atribua tipos de dados sempre que definir uma variável, quer você a declare usando a palavrachave var, crie um argumento de função, defina o tipo de retorno da função ou defina uma
variável para ser usada em um loop for ou for..in. Para atribuir um tipo de dados, use a
sintaxe pós-dois-pontos, a qual indica que, após o nome da variável, são acrescentados doispontos e o tipo de dados:
var my_mc:MovieClip;
Há vários tipos de dados possíveis, incluindo desde tipos nativos, como Number, String e
Boolean, ou classes internas fornecidas com o Flash Player 8, como BitmapData e
FileReference, ou até mesmo classes personalizadas criadas por você ou outros
desenvolvedores. Os tipos mais comuns de dados que precisam ser especificados são os
internos, como Number, String, Boolean, Array ou Object, que são mostrados nos exemplos
de código apresentados a seguir.
Para atribuir um tipo de dados específico a um item, defina seu tipo usando a palavra-chave
var e a sintaxe pós-dois-pontos, como no exemplo a seguir:
// Atribuição estrita de tipo de dados a uma variável ou a um objeto
var myNum:Number = 7;
var birthday:Date = new Date();
//Atribuição estrita de tipo de dados de parâmetros
function welcome(firstName:String, age:Number) {
}
// Atribuição estrita de tipo de dados de parâmetro e valor de retorno
function square(myNum:Number):Number {
var squared:Number = myNum * myNum;
return squared;
}
87
Você pode declarar o tipo de dados de objetos com base em classes internas (Button, Date
etc.), bem como em classes e interfaces criadas por você. No exemplo a seguir, se houver um
arquivo Student.as no qual define a classe Student, você poderá especificar que os objetos que
criar sejam do tipo Student:
var myStudent:Student = new Student();
Neste exemplo, suponha que você defina o seguinte código:
// no arquivo de classe Student.as
class Student {
public var status:Boolean; // propriedade dos objetos Student
}
// no arquivo FLA
var studentMaryLago:Student = new Student();
studentMaryLago.status = "enrolled"; /* Tipos incompatíveis em uma
instrução de atribuição: String encontrado onde Boolean é necessário. */
Quando o Flash compila esse script, um erro de tipos incompatíveis é gerado porque o
arquivo SWF espera um valor booleano.
Se criar uma função que não tenha um tipo de retorno, você poderá especificar o tipo de
retorno Void para essa função. Ou, se criar um atalho para uma função, você poderá atribuir o
tipo de dados Function à nova variável. Veja no exemplo a seguir como especificar o tipo
Function ou Void para objetos:
function sayHello(name_str:String):Void {
trace("Hello, " + name_str);
}
sayHello("world"); // Olá, mundo
var greeting:Function = sayHello;
greeting("Augustus"); // Olá, Augustus
Outra vantagem da atribuição estrita de tipos de dados é que o Flash exibe automaticamente
referências de código para objetos internos quando o tipo de dados é atribuído a eles
estritamente. Para obter mais informações, consulte “Sobre a atribuição de tipos de dados e a
atribuição estrita de tipos de dados” na página 85.
Como os arquivos publicados com o ActionScript 1.0 não respeitam as atribuições estritas de
tipos de dados durante a compilação, a atribuição do tipo incorreto de valor a uma variável à
qual um tipo foi atribuído estritamente não gera um erro do compilador.
var myNum:String = "abc";
myNum = 12;
/* Não há erro no ActionScript 1.0, mas há um erro de tipos incompatíveis no
ActionScript 2.0 */
88
A razão disso é que, quando você publica um arquivo no ActionScript 1.0, o Flash interpreta
uma instrução, por exemplo, var myNum:String = "abc" como sintaxe de barra, e não
como atribuição estrita de tipo. (O ActionScript 2.0 não aceita sintaxe de barra.) Esse
comportamento pode resultar na atribuição de um objeto do tipo incorreto a uma variável,
fazendo com que o compilador permita chamadas de método ilegais e que referências a
propriedades não definidas sejam passadas sem serem relatadas.
Os arquivos publicados com o ActionScript 2.0 podem usar opcionalmente a atribuição de
tipos de dados. Portanto, se você implementar a atribuição estrita de tipos de dados em seu
código, defina suas configurações de publicação para o ActionScript 2.0. Você pode especificar
as configurações de publicação e definir em que versão do ActionScript deseja publicar seus
arquivos modificando essas configurações no menu principal, em File (Arquivo) > Publish
Settings (Configurações de publicação), ou clicando no botão Settings (Configurações) no
inspetor Properties (Propriedades) (certifique-se de que não haja instâncias selecionadas). Para
usar uma versão específica do ActionScript ou do Flash Player, selecione a guia Flash na caixa
de diálogo Publish Settings e escolha uma opção no menu pop-up de versões do ActionScript.
Para obter informações sobre verificação de tipo, consulte “Sobre a verificação de tipo”
na página 89.
Sobre a verificação de tipo
A verificação de tipo consiste em examinar se o tipo de uma variável e de uma expressão são
compatíveis. Portanto, o Flash verifica se o tipo especificado para uma variável corresponde
ao(s) valor(es) atribuído(s) a ela. Para obter mais informações sobre tipos estritos de dados e
atribuição de tipos de dados, consulte “Sobre a atribuição de tipos de dados e a atribuição
estrita de tipos de dados” na página 85 e “Atribuindo um tipo de dados” na página 87.
A verificação de tipo pode ocorrer durante a compilação ou a execução. Se você usar a
atribuição estrita de tipos de dados, a verificação de tipo ocorrerá durante a compilação.
Como o ActionScript é uma linguagem com atribuição dinâmica de tipos, o ActionScript
também pode realizar a verificação de tipo durante a execução.
Por exemplo, o código a seguir não especifica o tipo de dados do parâmetro xParam. Durante
a execução, você usa o parâmetro para armazenar um valor do tipo Number e outro do tipo
String. Em seguida, a função dynamicTest() usa o operador typeof para testar se o
parâmetro é do tipo String ou Number.
function dynamicTest(xParam) {
if (typeof(xParam) == "string") {
var myStr:String = xParam;
trace("String: " + myStr);
} else if (typeof(xParam) == "number") {
var myNum:Number = xParam;
89
trace("Number: " + myNum);
}
}
dynamicTest(100);
dynamicTest("one hundred");
Não é necessário adicionar explicitamente informações de tipo de dados ao ActionScript. O
compilador do ActionScript permite que você use propriedades e chame métodos não
existentes durante a compilação. Dessa maneira, é possível criar propriedades ou atribuir
métodos dinamicamente durante a execução.
Um exemplo da flexibilidade oferecida pela verificação dinâmica de tipo envolve o uso de
propriedades e métodos não conhecidos durante a compilação. Como o código é menos
restritivo, isso poderá ser vantajoso em algumas situações de codificação. Por exemplo, o
código a seguir cria uma função chamada runtimeTest() que chama um método e retorna
uma propriedade, ambos desconhecidos para o compilador. O código não gerará um erro
durante a compilação, mas, se a propriedade ou o método não estiver acessível durante a
execução, ocorrerá um erro durante a execução.
function runtimeTest(myParam) {
myParam.someMethod();
return myParam.someProperty;
}
Sobre a determinação do tipo de dados
Ao testar e depurar seus programas, você pode detectar problemas que parecem estar
relacionados aos tipos de dados de itens diferentes. Ou, se você usar variáveis não associadas
explicitamente a um tipo de dados, talvez seja útil saber o tipo de dados de determinada
variável. Com o ActionScript, é possível determinar o tipo de dados de um item. Você pode
usar o operador typeof para retornar informações sobre os dados.
Use o operador typeof para obter os tipos de dados, mas lembre-se de que ele não retorna
informações sobre a classe à qual uma instância pertence.
O exemplo a seguir mostra como usar o operador typeof para retornar o tipo de objeto que
está sendo rastreado:
// Criar uma nova instância da classe LoadVars.
/* O operador typeof não especifica a classe, ele especifica apenas que
my_lv é um objeto*/
var typeResult:String = typeof(my_lv);
trace(typeResult); // objeto
90
Neste exemplo, você cria uma nova variável String chamada myName e converte-a no tipo de
dados Number:
var myName:String = new String("17");
trace(myName instanceof String); // true
var myNumber:Number = new Number(myName);
trace(myNumber instanceof Number); // true
Para obter mais informações sobre esses operadores, consulte %{operador typeof}% e
%{operador instanceof}% em ActionScript 2.0 Language Reference. Para obter mais
informações sobre testes e depuração, consulte o Capítulo 18, “Depurando aplicativos”, na
página 745 Para obter mais informações sobre herança e interfaces, consulte o Capítulo 8,
“Herança”, na página 319. Para obter mais informações sobre classes, consulte o Capítulo 7,
“Classes”, na página 239.
Sobre variáveis
Uma variável é um recipiente que contém informações. O código a seguir mostra a aparência
de uma variável no ActionScript:
var myVariable:Number = 10;
Essa variável contém um valor numérico. O uso de :Number no código anterior atribui o tipo
de valor que a variável contém, denominado atribuição de tipos de dados. Para obter mais
informações sobre como atribuir tipos de dados, consulte “Sobre a atribuição de tipos de
dados e a atribuição estrita de tipos de dados” na página 85 e “Atribuindo um tipo de dados”
na página 87.
O recipiente (representado pelo nome da variável) é sempre o mesmo em todo o ActionScript,
mas o conteúdo (o valor) pode mudar. Você pode alterar o valor de uma variável em um script
quantas vezes desejar. Ao alterar o valor de uma variável durante a reprodução do arquivo
SWF, você poderá registrar e salvar informações sobre as atividades do usuário, gravar valores
que mudam à medida que o arquivo SWF é reproduzido ou avaliar se uma condição é true
ou false. Talvez a variável precise ser atualizada continuamente durante a reprodução do
arquivo SWF, como, por exemplo, quando o placar de um jogador muda em um jogo do
Flash. As variáveis são essenciais quando você cria e trata da interação com o usuário em um
arquivo SWF.
Sobre variáveis
91
É recomendável atribuir um valor a uma variável ao declará-la pela primeira vez. A atribuição
de um valor inicial é chamada inicialização da variável e ocorre geralmente no Frame 1
(Quadro 1) da Timeline (Linha de tempo) ou em uma classe carregada quando a reprodução
do arquivo SWF inicia. Há diversos tipos de variáveis, que são afetados pelo escopo. Para obter
mais informações sobre os diversos tipos de variáveis e escopo, consulte “Sobre variáveis e
escopo” na página 101.
D IC A
A inicialização de uma variável facilita o controle e a comparação de seu valor durante a
reprodução do arquivo SWF.
N OT A
O Flash Player 7 e versões posteriores avaliam as variáveis não inicializadas de maneira
diferente do Flash Player 6 e versões anteriores. Se tiver criado scripts para o Flash
Player 6 e planejar criar ou portar scripts para o Flash Player 7 ou versões posteriores,
você deverá compreender essas diferenças a fim de evitar um comportamento
inesperado.
As variáveis podem conter diversos tipos de dados; para obter mais informações, consulte
“Sobre tipos de dados” na página 76. O tipo de dados que uma variável contém afeta a forma
como o valor da variável é alterado quando atribuído em um script.
Os tipos mais comuns de informações que podem ser armazenados em uma variável são um
URL (tipo String), um nome de usuário (tipo String), o resultado de uma operação
matemática (tipo Number), o número de vezes que um evento ocorreu (tipo Number) ou se o
usuário clicou em determinado botão (tipo Boolean). Cada arquivo SWF e instância de um
objeto (como um clipe de filme) tem um conjunto de variáveis, sendo que cada variável possui
um valor, independentemente das variáveis de outros arquivos SWF ou clipes de filme.
Para exibir o valor de uma variável, use a instrução trace() a fim de enviar o valor para o
painel Output. Em seguida, o valor será exibido no painel Output quando você testar o
arquivo SWF no ambiente de teste. Por exemplo, trace(hoursWorked) envia o valor da
variável hoursWorked para o painel Output no ambiente de teste. Também é possível verificar
e definir os valores da variável no Debugger (Depurador), no ambiente de teste.
Para obter mais informações sobre variáveis, consulte os tópicos a seguir:
■
“Sobre a declaração de variáveis” na página 93
■
“Sobre a atribuição de valores” na página 93
■
“Sobre a atribuição de nomes a variáveis” na página 96
■
“Usando variáveis em um aplicativo” na página 97
■
“Sobre variáveis e escopo” na página 101
■
“Sobre valores padrão” na página 93
■
“Sobre operadores e variáveis” na página 96
92
■
“Sobre o carregamento de variáveis” na página 106
■
“Usando variáveis em um projeto” na página 111
Sobre a declaração de variáveis
Você pode declarar variáveis em um quadro da timeline, diretamente em um objeto ou em um
arquivo de classe externo.
Para definir variáveis, use a palavra-chave var e siga as convenções de atribuição de nomes de
variáveis. Você pode declarar uma variável chamada firstName, como mostra o exemplo a
seguir:
var firstName:String;
Ao declarar uma variável, você atribui um tipo de dados a ela. Nesse caso, o tipo de dados
String é atribuído à variável firstName. Para obter mais informações sobre como atribuir
tipos de dados, consulte “Sobre a atribuição de tipos de dados e a atribuição estrita de tipos de
dados” na página 85.
Sobre valores padrão
Um valor padrão é o valor que uma variável contém antes de seu valor ser definido. A variável
é inicializada quando você define o seu valor pela primeira vez. Se você declarar uma variável,
mas não definir o seu valor, ela será considerada uma variável não inicializada. O valor padrão
de uma variável não inicializada é undefined. Para obter mais informações sobre como criar e
usar variáveis, consulte “Sobre variáveis” na página 91.
Sobre a atribuição de valores
Você pode definir um valor como o conteúdo atual de uma variável. O valor poderá consistir
em seqüências de caracteres, números, arrays, objetos, XML, datas ou até mesmo classes
personalizadas criadas por você. Lembre-se de que, no Flash, as variáveis são declaradas com a
palavra-chave var. Ao declarar a variável, você também atribui um tipo de dados a ela. Você
também pode atribuir um valor a uma variável, desde que ele corresponda ao tipo de dados
atribuído à variável.
O exemplo a seguir mostra como criar uma variável chamada catName:
var catName:String;
Sobre variáveis
93
Após declarar a variável, você poderá atribuir um valor a ela. Após a linha anterior do
ActionScript, insira esta linha:
catName = "Pirate Eye";
NO T A
Como Pirate Eye é uma seqüência de caracteres, o valor precisa estar entre aspas
retas.
Esse exemplo atribui o valor Pirate Eye à variável catName. Ao declarar uma variável, você
também pode atribuir um valor a ela, em vez de atribuí-lo posteriormente (como nos
exemplos anteriores). Você poderia definir a variável catName ao declará-la, como no seguinte
exemplo:
var catName:String = "Pirate Eye";
Se desejar exibir o valor da variável catName no ambiente de teste, você poderá usar a
instrução trace(). Essa instrução envia o valor para o painel Output. Você pode rastrear o
valor da variável catName e verificar que o valor real não inclui as aspas, usando o seguinte
ActionScript:
var catName:String = "Pirate Eye";
trace(catName); // Pirate Eye
Lembre-se de que o valor atribuído deve corresponder ao tipo de dados atribuído a ele (nesse
caso, String). Se você posteriormente tentar atribuir um número à variável catName, como
catName = 10, o seguinte erro será exibido no painel Output durante o teste do arquivo
SWF:
Type mismatch in assignment statement: found Number where String is
required.
Esse erro informa que você tentou definir o tipo incorreto de dados para uma variável
especificada.
Quando um valor numérico é atribuído a uma variável, as aspas não são necessárias, como
mostra o código a seguir:
var numWrinkles:Number = 55;
Se desejar alterar o valor de numWrinkles posteriormente no código, você poderá atribuir um
novo valor usando o seguinte ActionScript:
numWrinkles = 60;
Ao reatribuir um valor a uma variável existente, você não precisa usar a palavra-chave var ou
definir o tipo de dados da variável (nesse caso, :Number).
Se o valor for numérico ou booleano (true ou false), ele não usará aspas retas. Exemplos de
valores numéricos e booleanos são mostrados no trecho de código a seguir:
94
var age:Number = 38;
var married:Boolean = true;
var hasChildren:Boolean = false;
No exemplo anterior, a variável age contém um valor inteiro (não-decimal), embora você
também possa usar um valor decimal ou de ponto flutuante, como 38,4. As variáveis
booleanas (como married ou hasChildren) têm somente dois valores possíveis, true ou
false.
Se você desejar criar um array e atribuir valores a ele, o formato será ligeiramente diferente,
como mostra o código a seguir:
var childrenArr:Array = new Array("Pylon", "Smithers", "Gil");
Há uma sintaxe alternativa (abreviada) para criar um array com os operadores de acesso de
array, que usam colchetes ([]). Você pode reescrever o exemplo anterior da seguinte maneira:
var childrenArr:Array = ["Pylon", "Smithers", "Gil"];
Para obter mais informações sobre como criar arrays e os operadores de acesso de array,
consulte “Sobre arrays” na página 172 e “Sobre uso da sintaxe de ponto para referenciar uma
instância” na página 125.
De maneira semelhante, você pode criar um novo objeto chamado myObj. Há dois métodos
para criar um novo objeto. O primeiro (e mais longo) método para codificar um array é
apresentado a seguir:
var myObj:Object = new Object();
myObj.firstName = "Steve";
myObj.age = 50;
myObj.childrenArr = new Array("Mike", "Robbie", "Chip");
O segundo e (mais curto) método para codificar o array myObj é o seguinte:
var myObj:Object = {firstName:"Steve", age:50, childrenArr:["Mike",
"Robbie", "Chip"]};
Como você pode observar nesse exemplo, o uso do método mais curto pode poupar muito
tempo e digitação, especialmente quando você define instâncias de objetos. É importante estar
familiarizado com essa sintaxe alternativa, pois você a encontrará se trabalhar em equipes ou
quando trabalhar com código ActionScript de terceiros encontrado, por exemplo, na Internet
ou em manuais.
N OT A
Nem todas as variáveis precisam ser definidas explicitamente. O Flash cria algumas
variáveis automaticamente. Por exemplo, para encontrar as dimensões do Stage, você
poderia usar os valores destas duas variáveis predefinidas: Stage.width e
Stage.height.
Sobre variáveis
95
Sobre operadores e variáveis
Talvez você não entenda os símbolos matemáticos contidos em seu código. Esses símbolos são
chamados operadores no ActionScript. Os operadores calculam um novo valor a partir de um
ou mais valores e são usados para atribuir um valor a uma variável no código. Use o operador
de igualdade (=) para atribuir um valor a uma variável:
var username:String = "Gus";
Outro exemplo é o operador de adição (+), que adiciona dois ou mais valores numéricos para
produzir um novo valor. Se você usar o operador + em dois ou mais valores de seqüência de
caracteres, as seqüências serão concatenadas. Os valores manipulados pelos operadores são
denominados operandos.
Ao atribuir um valor, use um operador a fim de definir um valor para uma variável. Por
exemplo, o script a seguir usa o operador de atribuição para atribuir o valor 7 à variável
numChildren:
var numChildren:Number = 7;
Se desejar alterar o valor da variável numChildren, use o seguinte código:
numChildren = 8;
NO TA
Não é necessário usar var, pois a variável foi definida anteriormente.
Para obter mais informações sobre como usar operadores no ActionScript, consulte “Sobre
operadores” na página 185.
Sobre a atribuição de nomes a variáveis
Tenha cautela ao nomear variáveis, pois, embora elas possam ter praticamente qualquer nome,
algumas regras devem ser observadas. O nome de uma variável deve seguir estas regras:
■
Uma variável deve ser um identificador.
N O TA
Um identificador é um nome de variável, propriedade, objeto, função ou método. O
primeiro caractere do identificador deve ser uma letra, um sublinhado (_) ou um
cifrão ($). Os caracteres subseqüentes podem ser uma letra, um número, um
sublinhado ou um cifrão.
■
Uma variável não pode ser uma palavra-chave nem um literal do ActionScript, como
true, false, null ou undefined. Para obter mais informações sobre literais, consulte
“Sobre literais” na página 138.
■
As variáveis devem ser exclusivas em seu escopo (consulte “Sobre variáveis e escopo”
na página 101).
96
■
As variáveis não devem ser um elemento da linguagem ActionScript, como um nome de
classe.
Se você não seguir as regras ao atribuir um nome a uma variável, poderão ocorrer erros de
sintaxe ou resultados inesperados. No exemplo a seguir, se você atribuir o nome new a uma
variável e testar o seu documento, o Flash gerará um erro do compilador:
// Este código funciona como esperado.
var helloStr:String = new String();
trace(helloStr.length); // 0
// Mas, se você atribuir a uma variável o mesmo nome de uma classe
interna...
var new:String = "hello"; // erro: identificador esperado
var helloStr:String = new String();
trace(helloStr.length); // indefinido
O editor do ActionScript oferece suporte a referências de código para classes internas e
variáveis que tenham como base essas classes. Se desejar que o Flash forneça referências de
código para um tipo de objeto específico atribuído a uma variável, você poderá atribuir um
tipo estrito a ela. As referências de código fornecem uma sintaxe no estilo de dica de
ferramenta e um menu pop-up que o ajuda a criar o código rapidamente.
Por exemplo, digite o seguinte código:
var members:Array = new Array();
members.
Assim que você digita o ponto (.) no painel Actions (Ações), o Flash exibe uma lista de
métodos e propriedades disponíveis para objetos Array.
Para obter as convenções de codificação recomendadas para a atribuição de nomes a variáveis,
consulte “Atribuição de nome a variáveis” na página 772.
Usando variáveis em um aplicativo
Nesta seção, você usará variáveis em trechos curtos de código ActionScript. É necessário
declarar e inicializar uma variável em um script antes de usá-la em uma expressão. As
expressões são combinações de operandos e operadores que representam um valor. Por
exemplo, na expressão i+2, i e 2 são operandos, e + é um operador.
Se você não inicializar uma variável antes de usá-la em uma expressão, a variável não ficará
indefinida e poderá gerar resultados inesperados. Para obter mais informações sobre como
criar expressões, consulte o Capítulo 5, “Fundamentos da sintaxe e da linguagem”, na
página 119.
Se você usar uma variável indefinida, como no exemplo a seguir, o valor da variável no Flash
Player 7 e versões posteriores será NaN, e o script poderá produzir resultados indesejados:
Sobre variáveis
97
trace(squared); // NaN
No exemplo a seguir, a instrução que declara e inicializa a variável myNum vem em primeiro
lugar; portanto, squared pode ser substituído por um valor:
trace(squared); // 36
Um comportamento semelhante ocorre quando você passa uma variável não definida para um
método ou uma função, como mostrado a seguir.
Para comparar a passagem de variáveis indefinidas e definidas para uma
função:
1.
Arraste um componente Button do painel Components (Componentes) até o Stage
(Palco).
2.
Abra o inspetor Properties (Propriedades) e digite bad_button na caixa de texto Instance
Name (Nome da instância).
3.
Digite o seguinte código no Frame 1 da Timeline.
// Não funciona
function badClickListener(evt:Object):Void {
getURL(targetUrl);
var targetUrl:String = "http://www.macromedia.com";
}
bad_button.addEventListener("click", badClickListener);
4.
Selecione Control (Controlar) > Test Movie (Testar filme) e observe que o botão não
funciona (ele não abre a página da Web).
5.
Arraste outro componente Button até o Stage. Selecione o botão.
6.
Abra o inspetor Properties e digite good_button na caixa de texto Instance Name.
7.
Adicione o seguinte ActionScript ao Frame 1 da Timeline (após o ActionScript adicionado
anteriormente):
// Funciona
function goodClickListener(evt:Object):Void {
var targetUrl:String = "http://www.macromedia.com";
getURL(targetUrl);
}
good_button.addEventListener("click", goodClickListener);
8.
Selecione Control > Test Movie e clique no segundo botão adicionado ao Stage.
Esse botão abre a página da Web corretamente.
98
O tipo de dados que uma variável contém afeta como e quando o seu valor será alterado. Os
tipos de dados primitivos, como Strings e Numbers, são passados por valor; isso significa que é
usado o valor atual da variável, em vez de uma referência a esse valor. Array e Object são
exemplos de tipos de dados complexos.
No exemplo a seguir, você definirá myNum como 15 e copiará o valor para otherNum. Quando
você altera myNum para 30 (na linha 3 do código), o valor de otherNum permanece igual a 15
porque otherNum não procura o seu valor em myNum. A variável otherNum contém o valor de
myNum recebido (na linha 2 do código).
Para usar variáveis no ActionScript:
1.
Crie um novo documento do Flash e salve-o como var_example.fla.
2.
Selecione o Frame 1 da Timeline e digite o código a seguir no painel Actions:
var otherNum:Number = myNum;
myNum = 30;
trace(myNum); // 30
trace(otherNum); // 15
Quando você altera myNum para 30 (na linha 3 do código), o valor de otherNum permanece
igual a 15 porque otherNum não procura o seu valor em myNum. A variável otherNum
contém o valor de myNum recebido (na linha 2 do código).
3.
Selecione Control > Test Movie para que os valores sejam exibidos no painel Output.
4.
Agora adicione o seguinte ActionScript após o código adicionado na etapa 2:
function sqr(myNum:Number):Number {
myNum *= myNum;
return myNum;
}
var inValue:Number = 3;
var outValue:Number = sqr(inValue);
trace(inValue); // 3
trace(outValue); // 9
Nesse código, a variável inValue contém um valor primitivo, 3; portanto, o valor é
passado para a função sqr(), e o valor retornado é 9. O valor da variável inValue não é
alterado, embora o valor de myNum seja alterado na função.
5.
Selecione Control > Test Movie para que os valores sejam exibidos no painel Output.
O tipo de dados Object pode conter uma quantidade tão grande de informações complexas
que uma variável com esse tipo não armazenará o valor real, mas uma referência a esse valor.
Essa referência é semelhante a um alias que aponta para o conteúdo da variável. Quando a
variável precisa saber seu valor, a referência solicita o conteúdo e responde sem transferir o
valor para a variável.
Sobre variáveis
99
Para obter informações sobre como passar uma variável por referência, consulte “Passando
uma variável por referência” na página 100.
Passando uma variável por referência
Como os tipos de dados Array e Object armazenam uma referência a um valor, em vez de
conterem seu valor real, tenha cautela ao trabalhar com arrays e objetos.
O exemplo a seguir mostra como passar um objeto por referência. Ao criar uma cópia do
array, você cria, na verdade, apenas uma cópia da referência (ou alias) ao conteúdo do array.
Ao editar o conteúdo do segundo array, você modifica o conteúdo do primeiro e do segundo
arrays, pois ambos apontam para o mesmo valor.
Para passar um objeto por referência:
1.
Selecione File (Arquivo) > New (Novo), escolha Flash Document (Documento do Flash)
para criar um novo arquivo FLA e salve-o como copybyref.fla.
2.
Selecione o Frame 1 da Timeline e digite o código a seguir no painel Actions:
var myArray:Array = new Array("tom", "josie");
var newArray:Array = myArray;
myArray[1] = "jack";
trace(myArray); // tom,jack
trace(newArray); // tom,jack
3.
Selecione Control (Controlar) > Test Movie (Testar filme) para testar o ActionScript.
Esse ActionScript cria um objeto Array chamado myArray com dois elementos. Crie a
variável newArray e passe uma referência para myArray. Quando você altera o segundo
elemento de myArray para jack, ele afeta todas as variáveis que contêm uma referência a
ele. A instrução trace() envia tom,jack para o painel Output.
N OT A
O Flash usa um índice que inicia em zero, ou seja, 0 é o primeiro item do array, 1 é o
segundo e assim por diante.
No exemplo a seguir, myArray contém um objeto Array, portanto, o array é passado para a
função zeroArray() por referência. A função zeroArray() aceita um objeto Array como
parâmetro e define todos os elementos desse array como 0. Ela pode modificar o array porque
ele é passado por referência.
Para passar um array por referência:
1.
100
Selecione File > New, escolha Flash Document para criar um novo arquivo FLA e salve-o
como arraybyref.fla.
2.
Adicione o seguinte ActionScript ao Frame 1 da Timeline:
function zeroArray (theArr:Array):Void {
var i:Number;
for (i = 0; i < theArr.length; i++) {
theArr[i] = 0;
}
}
var myArr:Array = new Array();
myArr[0] = 1;
myArr[1] = 2;
myArr[2] = 3;
trace(myArr); // 1,2,3
zeroArray(myArr);
3.
Selecione Control > Test Movie para testar o ActionScript.
A primeira instrução trace() desse ActionScript exibe o conteúdo original do array
myArray (1,2,3). Depois que você chama a função zeroArray() e passa uma referência
ao array myArray, cada um dos valores do array é substituído e definido como zero. A
instrução trace() subseqüente exibe o novo conteúdo do array myArray (0,0,0). Como
o array é passado por referência, e não por valor, não é necessário retornar o seu conteúdo
atualizado a partir da função zeroArray().
Para obter mais informações sobre arrays, consulte “Sobre arrays” na página 172.
Sobre variáveis e escopo
O escopo de uma variável refere-se à área na qual a variável é conhecida (definida) e na qual
pode ser referenciada. A variável poderá ser conhecida em uma timeline ou em uma função
específica, ou poderá ser conhecida globalmente em todo o aplicativo. Para obter mais
informações sobre escopo, consulte “Sobre escopo e referência” na página 130.
A compreensão do escopo das variáveis é importante durante o desenvolvimento de aplicativos
Flash com o ActionScript. Além de indicar quando e onde é possível fazer referência a
variáveis, o escopo especifica por quanto tempo determinada variável existirá em um
aplicativo. Quando as variáveis são definidas no corpo de uma função, elas deixam de existir
assim que a função especificada é encerrada. Se tentar fazer referência a objetos no escopo
incorreto ou a variáveis expiradas, você receberá erros nos documentos do Flash, os quais
levarão a um comportamento inesperado ou à interrupção de uma funcionalidade.
Há três tipos de escopos de variável no ActionScript:
■
Variáveis globais e funções estão disponíveis para cada timeline e escopo do documento.
Portanto, uma variável global é definida em todas as áreas do código.
Sobre variáveis
101
■
Variáveis de Timeline estão disponíveis para qualquer script nessa timeline.
■
Variáveis locais estão disponíveis no corpo da função em que são declaradas (delineado por
chaves). Portanto, as variáveis locais são definidas somente em parte do código.
Para obter diretrizes sobre o uso de escopo e variáveis, consulte o Capítulo 5, “Sobre escopo e
referência”, na página 130.
N OT A
As classes do ActionScript 2.0 criadas por você oferecem suporte a escopos públicos,
privados e estáticos de variáveis. Para obter mais informações, consulte “Sobre
membros de classe” na página 265 e “Controlando o acesso de membros em classes”
na página 288.
Não é possível usar a atribuição estrita de dados para variáveis globais. Para obter informações
e uma solução alternativa, consulte “Variáveis globais” na página 102.
Variáveis globais
As variáveis globais e as funções estão visíveis para cada timeline e escopo do documento. Para
declarar (ou criar) uma variável com escopo global, use o identificador _global antes do
nome da variável e não use a sintaxe var =. Por exemplo, o código a seguir cria a variável
global myName:
var _global.myName = "George"; // Sintaxe incorreta para a variável global
_global.myName = "George"; // Sintaxe correta para a variável global
Entretanto, se inicializar uma variável local com o mesmo nome de uma variável global, você
não terá acesso à variável global enquanto estiver no escopo da variável local, como mostra o
exemplo a seguir:
_global.counter = 100; // Declara a variável global
trace(counter); // Acessa a variável global e exibe 100
function count():Void {
for (var counter:Number = 0; counter <= 2; counter++) { // Variável local
trace(counter); // Acessa a variável local e exibe de 0 a 2
}
}
count();
trace(counter); // Acessa a variável global e exibe 100
Esse exemplo mostra simplesmente que a variável global não é acessada no escopo da função
count(). Entretanto, você poderá acessar a variável de escopo global se adicionar a ela o
prefixo _global. Por exemplo, você poderia acessá-la se adicionasse o prefixo _global ao
contador, como no seguinte código:
trace(_global.counter);
102
Você não poderá atribuir tipos de dados estritos às variáveis criadas no escopo _global, pois
precisará usar a palavra-chave var ao atribuir um tipo de dados. Por exemplo, isto não seria
possível:
_global.foo:String = "foo"; //erro de sintaxe
var _global.foo:String = "foo"; //erro de sintaxe
O recurso de segurança sandbox do Flash Player versão 7 e versões posteriores impõe restrições
ao acesso de variáveis globais em arquivos SWF carregados a partir de domínios de segurança
separados. Para obter mais informações, consulte Capítulo 17, “Noções básicas de segurança”,
na página 707.
Variáveis de Timeline
As variáveis de Timeline estão disponíveis para qualquer script nessa timeline. Para declarar
variáveis de timeline, use a instrução var e inicialize-as em qualquer quadro da timeline. A
variável está disponível para esse quadro e para todos os quadros subseqüentes, como no
exemplo apresentado a seguir.
Para usar variáveis de timeline em um documento:
1.
Crie um novo documento do Flash e atribua o nome timelinevar.fla a ele.
2.
var myNum:Number = 15; /* inicializada no Frame 1 e, portanto, disponível
para todos os quadros */
3.
Selecione o Frame 20 da Timeline.
4.
Selecione Insert (Inserir) > Timeline > Blank Keyframe (Quadro-chave em branco).
5.
Com o novo quadro-chave selecionado, digite o seguinte ActionScript no painel Actions:
trace(myNum);
6.
Selecione Control > Test Movie para testar o novo documento.
O valor 15 é exibido no painel Output após aproximadamente um segundo. Como os
documentos do Flash executam um loop, por padrão, o valor 15 é exibido continuamente
no painel Output toda vez que a reprodução alcança o Frame 20 da Timeline. Para
interromper a ação de loop, adicione stop(); após a instrução trace().
É necessário declarar uma variável de timeline antes de tentar acessá-la em um script. Por
exemplo, se você colocar o código var myNum:Number = 15; em Frame 20, todos os scripts
anexados a um quadro anterior a esse não poderão acessar myNum e serão indefinidos em vez de
conterem o valor 15.
Sobre variáveis
103
Variáveis locais
Ao usar a instrução var em um bloco de função, você declara variáveis locais. Quando uma
variável local é declarada em um bloco de função (também chamado definição de função), ela é
definida no escopo desse bloco e expira no final dele. Portanto, a variável local existe somente
nessa função.
Por exemplo, se você declarar uma variável chamada myStr em uma função localScope, essa
variável não estará disponível fora da função.
function localScope():Void {
var myStr:String = "local";
}
localScope();
trace(myStr); // Indefinida, porque myStr não está definida globalmente
Se o nome usado para a variável local já estiver declarado como uma variável de timeline, a
definição local terá precedência sobre a definição da timeline enquanto a variável local estiver
no escopo. A variável de timeline ainda existirá for a da função. Por exemplo, o código a seguir
cria uma variável de seqüência de caracteres timeline chamada str1 e, em seguida, cria uma
variável local de mesmo nome na função scopeTest(). A instrução trace contida na função
gera a definição local da variável, mas a instrução trace fora da função gera a definição da
variável na timeline.
var str1:String = "Timeline";
function scopeTest():Void {
var str1:String = "Local";
trace(str1); // Local
}
scopeTest();
trace(str1); // Timeline
No próximo exemplo, observe que certas variáveis existem apenas enquanto determinada
função existir e poderão gerar erros se você tentar fazer referência a elas fora do escopo dessa
função.
Para usar variáveis locais em um aplicativo:
1.
Crie um novo documento do Flash.
2.
Abra o painel Actions (Window (Janela) > Actions (Ações)) e adicione o seguinte
ActionScript ao Frame 1 da Timeline:
function sayHello(nameStr:String):Void {
var greetingStr:String = "Hello, " + nameStr;
trace(greetingStr);
}
sayHello("world"); // Olá, mundo
trace(nameStr); // indefinido
trace(greetingStr); // indefinido
104
3.
Selecione Control > Test Movie para testar o documento.
O Flash exibe a seqüência de caracteres “Olá, mundo” no painel Output e indefinido
para os valores de nameStr e greetingStr porque as variáveis não estão mais disponíveis
no escopo atual. Somente é possível fazer referência a nameStr e greetingStr na
execução da função sayHello. Quando a função encerrar, as variáveis deixarão de existir.
As variáveis i e j são geralmente usadas como contadores de loop. No exemplo a seguir, i é
usada como uma variável local; ela só existe dentro da função initArray():
function initArray(arrayLength:Number):Void {
var i:Number;
for(i = 0; i < arrayLength; i++) {
myArr[i] = i + 1;
}
}
trace(myArr); // 
initArray(3);
trace(i); // indefinido
N OT A
A sintaxe a seguir também costuma ser usada para um loop for: for (var i:Number =
0; i < arrayLength; i++) {...}.
Esse exemplo exibe undefined no ambiente de teste do Flash porque a variável i não está
definida na timeline principal. Ela existe somente na função initArray().
Você pode usar variáveis locais para ajudar a evitar conflitos de nome, que podem gerar
resultados inesperados em seu aplicativo. Por exemplo, se usar age como uma variável local,
você poderá usá-la para armazenar a idade de uma pessoa em um contexto e a idade do filho
de uma pessoa em outro contexto. Nesse caso, não há conflito porque as variáveis são usadas
em escopos separados.
É recomendável usar variáveis locais no corpo de uma função para que a função possa atuar
como um código independente. Uma variável local só pode ser alterada em seu próprio bloco
de código. Se uma expressão em uma função usar uma variável global, um código ou eventos
externos à função poderão alterar seu valor, o que alteraria a função.
Você pode atribuir um tipo de dados a uma variável local ao declará-la. Isso ajuda a evitar a
atribuição do tipo de dados incorreto a uma variável existente. Para obter mais informações,
consulte “Sobre a atribuição de tipos de dados e a atribuição estrita de tipos de dados”
na página 85.
Sobre variáveis
105
Sobre o carregamento de variáveis
Nas seções a seguir, você carregará variáveis do servidor de diferentes maneiras ou em um
documento a partir de uma seqüência de caracteres de URL ou de FlashVars (você pode usar
FlashVars a fim de passar variáveis para o Flash) em seu código HTML. Essas práticas
demonstram que há várias maneiras de usar variáveis fora de um arquivo SWF.
Para obter mais informações sobre como carregar variáveis (como pares de nome/valor),
consulte o Capítulo 16, “Trabalhando com dados externos”, na página 663.
Você poderá usar variáveis de diferentes maneiras em um arquivo SWF, dependendo de suas
necessidades. Para obter mais informações, consulte os seguintes tópicos:
■
“Usando variáveis a partir do URL” na página 106
■
“Usando FlashVars em um aplicativo” na página 109
■
“Carregando variáveis a partir de um servidor” na página 110
Usando variáveis a partir do URL
Ao desenvolver um aplicativo ou um exemplo simples no Flash, você poderá passar valores de
uma página HTML para o documento do Flash. Os valores passados algumas vezes são
conhecidos como seqüência de caracteres de consulta ou variáveis codificadas em URL. As
variáveis de URL são úteis quando você deseja criar um menu no Flash, por exemplo. Você
pode inicializar o menu para mostrar a navegação correta por padrão. Você também pode criar
um visualizador de imagens no Flash e definir uma imagem padrão para exibição no site da
Web.
Para usar variáveis de URL em um documento:
1.
Crie um documento do Flash e atribua o nome urlvariables.fla a ele.
2.
Selecione File (Arquivo) > Save As (Salvar como) e salve o documento na área de trabalho.
3.
Selecione o Frame 1 da Timeline e adicione o seguinte código ao painel Actions:
this.createTextField("myTxt", 100, 0, 0, 100, 20);
myTxt.autoSize = "left";
myTxt.text = _level0.myURL;
4.
Selecione Control > Test Movie para testar o arquivo SWF no Flash Player.
O campo de texto exibe undefined. Para ter certeza de que as variáveis estão definidas
corretamente antes de continuar, verifique a existência das variáveis no Flash. Para isso,
verifique se elas estão indefinidas.
106
5.
Para verificar se a variável está definida, modifique o ActionScript adicionado ao painel
Actions na etapa 3 de acordo com o código a seguir. Adicione o código que aparece em
negrito:
if (_level0.myURL == undefined) {
myTxt.text = "myURL is not defined";
} else {
}
Quando você publica o documento do Flash, um documento HTML é criado por padrão
no mesmo diretório do arquivo SWF. Se um arquivo HTML não tiver sido criado,
selecione File (Arquivo) > Publish settings (Configurações de publicação) e, em seguida,
HTML na guia Formats (Formatos). Em seguida, publique o documento novamente.
O código a seguir demonstra o HTML do documento responsável por incorporar um
documento do Flash em uma página HTML. Examine esse HTML para entender como
as variáveis de URL funcionam na etapa a seguir (na qual você adicionará um código para
essas variáveis).
<object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000"
codebase="http://fpdownload.macromedia.com/pub/shockwave/cabs/flash/
swflash.cab#version=8,0,0,0" width="550" height="400"
id="urlvariables" align="middle">
<param name="allowScriptAccess" value="sameDomain" />
<param name="movie" value="urlvariables.swf" />
<param name="quality" value="high" />
<param name="bgcolor" value="#ffffff" />
<embed src="urlvariables.swf" quality="high" bgcolor="#ffffff"
width="550" height="400" name="urlvariables" align="middle"
allowScriptAccess="sameDomain" type="application/x-shockwave-flash"
pluginspage="http://www.macromedia.com/go/getflashplayer" />
</object>
6.
Para passar variáveis do documento HTML gerado para o documento do Flash, você pode
passá-las após o caminho e o nome do arquivo (urlvariables.swf). Adicione o texto em
negrito ao arquivo HTML gerado na área de trabalho.
<param name="movie" value="urlvariables.swf?myURL=http://
weblogs.macromedia.com" />
Sobre variáveis
107
<embed src="urlvariables.swf?myURL=http://weblogs.macromedia.com"
quality="high" bgcolor="#ffffff" width="550" height="400"
name="urlvariables" align="middle" allowScriptAccess="sameDomain"
type="application/x-shockwave-flash" pluginspage="http://
www.macromedia.com/go/getflashplayer" />
</object>
7.
Se desejar passar diversas variáveis para o Flash, separe os pares de nome/valor com um E
comercial (&). Localize o seguinte código da etapa 6:
?myURL=http://weblogs.macromedia.com
Substitua-o por este texto:
?myURL=http://weblogs.macromedia.com&myTitle=Macromedia+News+Aggregator
Lembre-se de que é necessário efetuar as mesmas alterações nas marcas object e embed
para manter a consistência entre todos os navegadores. Observe que as palavras estão
separadas pelos sinais +. As palavras são separadas dessa maneira porque os valores são
codificados em URL e o sinal + representa um único espaço em branco.
N OT A
Para obter uma lista de caracteres especiais comuns codificados em URL, consulte
a Flash TechNote (Nota técnica do Flash), URL Encoding: Reading special
characters from a text file (Codificação de URL: Lendo caracteres especiais em um
arquivo de texto).
Como o E comercial (&) serve como delimitador para diversos pares de nome/valor, se os
valores passados contiverem esse caractere, poderão ocorrer resultados inesperados. Em
virtude da natureza dos pares de nome/valor e da análise, se os valores a seguir forem
passados para o Flash,
my.swf?name=Ben+&+Jerry&flavor=Half+Baked
ele criará as seguintes variáveis (e valores) no escopo raiz:
'name': 'Ben ' (note space at end of value)
' Jerry': '' (note space at beginning of variable name and an empty
value)
'flavor': 'Half Baked'
Para evitar isso, use o E comercial (&) como um caractere de escape no par de nome/valor
com seu equivalente codificado em URL (%26).
8.
Abra o documento urlvariables.html e localize o seguinte código:
?myURL=http://weblogs.macromedia.com&myTitle=Macromedia+News+Aggregator
Substitua-o por este código:
?myURL=Ben+%26+Jerry&flavor=Half+Baked
108
9.
Salve o HTML revisado e teste o documento do Flash novamente.
Observe que o Flash criou os seguintes pares de nome/valor.
'name': 'Ben & Jerry'
'flavor': 'Half Baked'
NO T A
Todos os navegadores aceitarão seqüências de caracteres de até 64K (65535
bytes). FlashVars deve ser atribuída nas marcas object e embed para que funcione
em todos os navegadores.
Usando FlashVars em um aplicativo
Usar FlashVars para passar variáveis para o Flash é semelhante a usar o URL para passar
variáveis no código HTML. Com FlashVars, em vez de serem passadas após o nome do
arquivo, as variáveis são passadas em uma marca param separada, bem como na marca embed.
Para usar FlashVars em um documento:
1.
Crie um novo documento do Flash e atribua o nome myflashvars.fla a ele.
2.
Selecione File > Publish Settings, verifique se HTML está selecionado e clique em OK para
fechar a caixa de diálogo.
3.
Adicione o seguinte ActionScript ao Frame 1 da Timeline principal:
if (_level0.myURL == undefined) {
myTxt.text = "myURL is not defined";
} else {
}
NO T A
Por padrão, o código HTML é publicado no mesmo local que myflashvars.fla.
4.
Selecione File (Arquivo) > Publish (Publicar) para publicar os arquivos SWF e HTML.
5.
Abra o diretório que contém os arquivos publicados (onde você salvou myflashvars.fla no
disco rígido) e abra o documento HTML (myflashvars.html, por padrão) em um editor
HTML, como o Dreamweaver ou o Bloco de Notas.
6.
Adicione o código que aparece em negrito abaixo, para que o documento HTML
corresponda ao seguinte:
swflash.cab#version=8,0,0,0" width="550" height="400" id="myflashvars"
align="middle">
Sobre variáveis
109
<param name="movie" value="myflashvars.swf" />
<param name="FlashVars" value="myURL=http://weblogs.macromedia.com/">
<embed src="myflashvars.swf" FlashVars="myURL=http://
weblogs.macromedia.com/" quality="high" bgcolor="#ffffff" width="550"
height="400" name="myflashvars" align="middle"
</object>
Esse código passa uma única variável chamada myURL, que contém a seqüência de
caracteres
http://weblogs.macromedia.com. Quando o arquivo SWF é carregado, uma
propriedade chamada myURL é criada no escopo _level0. Uma das vantagens de usar
FlashVars ou passar variáveis no URL é que elas ficam imediatamente disponíveis no Flash
quando o arquivo SWF é carregado. Isso significa que não é preciso criar funções para
verificar se o carregamento das variáveis foi concluído; esse procedimento seria necessário
se elas fossem carregadas com LoadVars ou XML.
7.
Salve as alterações no documento HTML e feche-o.
8.
Clique duas vezes em myflashvars.html para testar o aplicativo.
O texto http://weblogs.macromedia.com, uma variável do arquivo HTML, é exibido
no arquivo SWF.
N OT A
Todos os navegadores aceitarão seqüências de caracteres de até 64K (65.535
bytes). FlashVars deve ser atribuída nas marcas object e embed para que funcione
em todos os navegadores.
Carregando variáveis a partir de um servidor
Há várias maneiras de carregar variáveis no Flash a partir de origens externas (como arquivos
de texto, documentos XML etc.). Para obter mais informações sobre como carregar variáveis,
incluindo pares de nome/valor, consulte o Capítulo 16, “Trabalhando com dados externos”,
na página 663.
No Flash, é possível carregar facilmente variáveis usando a classe LoadVars, como mostra este
exemplo.
110
Para carregar variáveis de um servidor:
1.
2.
Selecione o Frame 1 da Timeline e adicione o seguinte ActionScript ao painel Actions:
my_lv.onLoad = function(success:Boolean):Void {
if (success) {
trace(this.dayNames); // Domingo,Segunda-feira,Terça-feira,...
} else {
trace("Error");
}
}
my_lv.load("http://www.helpexamples.com/flash/params.txt");
Esse código carrega um arquivo de texto de um servidor remoto e analisa seus pares de
nome/valor.
DICA
3.
Faça download ou exiba o arquivo de texto (http://www.helpexamples.com/flash/
params.txt) em um navegador se desejar saber como as variáveis são formatadas.
Se o arquivo for carregado com êxito, o evento complete será chamado e o painel Output
exibirá o valor de dayNames. Se não for possível fazer o download do arquivo de texto, o
argumento success será definido como false e o painel Output exibirá o texto Error.
Usando variáveis em um projeto
Quando você cria animações ou aplicativos com o Flash, em algumas situações não será
preciso usar nenhum tipo de variável em seu projeto. Por exemplo, se criar um sistema de
login, você talvez precise de variáveis para determinar se o nome de usuário e a senha são
válidos ou se foram preenchidos.
Para obter mais informações sobre como carregar variáveis (como pares de nome/valor),
consulte o Capítulo 16, “Trabalhando com dados externos”, na página 663.
No exemplo a seguir, você usará variáveis para armazenar o caminho de uma imagem que está
sendo carregada com a classe Loader, uma variável para a instância dessa classe e algumas
funções que são chamadas dependendo do carregamento bem ou não sucedido do arquivo.
Sobre variáveis
111
Para usar variáveis em um projeto:
1.
Crie um novo documento do Flash e salve-o como imgloader.fla.
2.
Selecione o Frame 1 da Timeline e adicione o seguinte ActionScript ao painel Actions:
/* Especifique a imagem padrão se um valor não tiver sido passado com
FlashVars. */
var imgUrl:String = "http://www.helpexamples.com/flash/images/
image1.jpg";
if (_level0.imgURL != undefined) {
// Se a imagem tiver sido especificada, substitua o valor padrão.
imgUrl = _level0.imgURL;
}
this.createEmptyMovieClip("img_mc", 10);
var mclListener:Object = new Object();
mclListener.onLoadInit = function(target_mc:MovieClip):Void {
target_mc._x = (Stage.width - target_mc._width) / 2;
target_mc._y = (Stage.height - target_mc._height) / 2;
}
mclListener.onLoadError = function(target_mc:MovieClip):Void {
target_mc.createTextField("error_txt", 1, 0, 0, 100, 20);
target_mc.error_txt.autoSize = "left";
target_mc.error_txt.text = "Error downloading specified image;\n\t" +
target_mc._url;
}
var myMCL:MovieClipLoader = new MovieClipLoader();
myMCL.addListener(mclListener);
myMCL.loadClip(imgUrl, img_mc);
A primeira linha do código especifica a imagem a ser carregada dinamicamente no
documento do Flash. Em seguida, verifique se um novo valor de imgURL foi especificado
usando FlashVars ou variáveis codificadas em URL. Se um novo valor tiver sido
especificado, o URL da imagem padrão será substituído pelo novo valor. Para obter
informações sobre como usar variáveis de URL, consulte “Usando variáveis a partir do
URL” na página 106. Para obter informações sobre FlashVars, consulte “Usando
FlashVars em um aplicativo” na página 109.
As linhas de código seguintes definem a instância MovieClip e um objeto ouvinte para a
instância MovieClipLoader futura. O objeto ouvinte de MovieClipLoader define dois
manipuladores de eventos, onLoadInit e onLoadError. Os manipuladores serão
chamados quando a imagem for carregada e inicializada com êxito no Stage ou se a
imagem não for carregada. Em seguida, crie a instância MovieClipLoader e usa o método
addListener() para adicionar o objeto ouvinte definido anteriormente para
MovieClipLoader. Finalmente, é feito o download da imagem que será ativada quando
você chamar o método MovieClipLoader.loadClip(), que especifica o arquivo de
imagem a ser carregado e o clipe de filme de destino no qual a imagem será carregada.
112
3.
Como você está testando o documento do Flash na ferramenta de criação, nenhum valor
de imgUrl será passado por FlashVars ou no URL e, portanto, a imagem padrão será
exibida.
4.
Salve o documento do Flash e selecione File (Arquivo) > Publish (Publicar) para publicar
o arquivo como um documento SWF e HTML.
NO T A
Verifique se Flash e HTML estão selecionados na caixa de diálogo Publish Settings.
Selecione File > Publish Settings e clique na guia Formats. Em seguida, selecione as
duas opções.
5.
Se testar o documento na ferramenta do Flash (selecione Control > Test Movie) ou em um
navegador local (File > Publish Preview (Visualizar publicação) > HTML), você verá que a
imagem é centralizada vertical e horizontalmente no Stage.
6.
Edite o documento HTML gerado em um editor (como Dreamweaver ou Bloco de Notas)
e modifique o HTML padrão de acordo com o seguinte texto:
<param name="movie" value="urlvariables.swf" />
<param name="FlashVars" value="imgURL=http://www.helpexamples.com/flash/
images/image2.jpg">
<embed src="urlvariables.swf" quality="high" FlashVars="imgURL=http://
www.helpexamples.com/flash/images/image2.jpg" bgcolor="#ffffff"
width="550" height="400" name="urlvariables" align="middle"
</object>
7.
Teste o documento HTML para ver as alterações. Uma imagem especificada no código
HTML é exibida no arquivo SWF.
Para modificar esse exemplo e usar suas próprias imagens, altere o valor de FlashVars (a
seqüência de caracteres entre aspas).
Sobre variáveis
113
Organizando dados em objetos
Você já deve estar familiarizado com os objetos que coloca no Stage. Por exemplo, pode existir
um objeto MovieClip no Stage, o qual contém outros clipes de filme. Os campos de texto, os
clipes de filme e os botões são geralmente chamados objetos quando colocados no Stage.
No ActionScript, os objetos são coleções de propriedades e métodos. Cada objeto tem seu
próprio nome e é uma instância de determinada classe. Os objetos internos pertencem a
classes predefinidas no ActionScript. Por exemplo, a classe interna Date fornece informações
do relógio do sistema no computador do usuário. A classe interna LoadVars pode ser usada
para carregar variáveis em um arquivo SWF.
Também é possível criar objetos e classes com o ActionScript. Você pode criar um objeto para
armazenar uma coleção de dados, como o nome, o endereço e o telefone de uma pessoa.
Também pode criar um objeto para armazenar informações sobre as cores de uma imagem. A
organização de dados em objetos pode ajudar a manter seus documentos do Flash mais
organizados. Para obter informações gerais sobre como criar uma classe personalizada para
armazenar uma coleção de métodos e propriedades, consulte “Criando arquivos de classes
personalizados” na página 249. Para obter informações detalhadas sobre classes internas e
personalizadas, consulte o Capítulo 7, “Classes”, na página 239.
Há várias maneiras de criar um objeto no ActionScript. O próximo exemplo cria objetos
simples de duas maneiras diferentes e, em seguida, executa um loop no conteúdo desses
objetos.
Para criar objetos simples no Flash:
1.
Crie um novo documento do Flash e salve-o como simpleObjects.fla.
2.
Selecione o Frame 1 da Timeline e digite o seguinte ActionScript no painel Actions:
// O primeiro método
var firstObj:Object = new Object();
firstObj.firstVar = "hello world";
firstObj.secondVar = 28;
firstObj.thirdVar = new Date(1980, 0, 1); // 1º de janeiro de 1980
Esse código, que é um dos métodos usados para criar um objeto simples, cria uma nova
instância do objeto e define algumas propriedades dele.
3.
Agora digite o seguinte ActionScript após o código inserido na etapa 2.
// O segundo método
var secondObj:Object = {firstVar:"hello world", secondVar:28,
thirdVar:new Date(1980, 0, 1)};
114
Este é outro método para criar um objeto. Os dois objetos são equivalentes. O código
acima cria um novo objeto e inicializa algumas propriedades usando a notação abreviada
do objeto.
4.
Para executar um loop em cada um dos objetos anteriores e exibir o seu conteúdo, adicione
o seguinte ActionScript ao Frame 1 da Timeline (após o código já inserido):
var i:String;
for (i in firstObj) {
trace(i + ": " + firstObj[i]);
}
5.
Selecione Control > Test Movie e o seguinte texto será exibido no painel Output:
firstVar: hello world
secondVar: 28
thirdVar: Tue Jan 1 00:00:00 GMT-0800 1980
Você também pode usar arrays para criar objetos. Em vez de ter uma série de variáveis como
firstname1, firstname2 e firstname3 para representar uma coleção de variáveis, é possível
criar um array de objetos para representar os mesmos dados. Essa técnica é demonstrada a
seguir.
Para usar um array para criar um objeto:
1.
Crie um novo documento do Flash e salve-o como arrayObject.fla.
2.
Selecione o Frame 1 da Timeline e digite o seguinte ActionScript no painel Actions:
var usersArr:Array = new Array();
usersArr.push({firstname:"George"});
usersArr.push({firstname:"John"});
usersArr.push({firstname:"Thomas"});
A vantagem de organizar variáveis em arrays e objetos é que é muito mais fácil executar um
loop nas variáveis e ver os valores, como mostra a etapa a seguir.
3.
Digite o seguinte código após o ActionScript adicionado na etapa 2.
var i:Number;
for (i = 0; i < usersArr.length; i++) {
trace(usersArr[i].firstname); // George, John, Thomas
}
4.
Selecione Control > Test Movie e o seguinte texto será exibido no painel Output:
George
John
Thomas
Organizando dados em objetos
115
O exemplo a seguir representa outro loop executado em objetos. Neste exemplo, é criado um
objeto e um loop é executado nele com for..in, e cada propriedade é exibida no painel
Output:
var myObj:Object = {var1:"One", var2:"Two", var3:18, var4:1987};
var i:String;
for (i in myObj) {
trace(i + ": " + myObj[i]);
}
//gera a seguinte saída:
/*
var1: One
var2: Two
var3: 18
var4: 1987
*/
Para obter informações sobre como criar loops, consulte o Capítulo 5, “Usando os loops for”,
na página 166. Para obter informações sobre loops for...in, consulte “Usando os loops for..in”
na página 167. Para obter mais informações sobre objetos, consulte o Capítulo 7, “Classes”,
na página 239.
Sobre a conversão
O ActionScript 2.0 permite que você converta um tipo de dados em outro. A conversão de
um objeto em um tipo diferente consiste em converter o valor armazenado no objeto ou na
variável em outro tipo.
Os resultados da conversão de tipos variam de acordo com os tipos de dados envolvidos. Para
converter um objeto em um tipo diferente, coloque o nome do objeto entre parênteses (()) e
preceda-o com o nome do novo tipo. Por exemplo, o código a seguir converte um valor
booleano em um inteiro.
var myBoolean:Boolean = true;
var myNumber:Number = Number(myBoolean);
Para obter mais informações sobre a conversão, consulte os seguintes tópicos:
■
116
“Sobre a conversão de objetos” na página 117
Sobre a conversão de objetos
A sintaxe usada na conversão é type(item), onde você deseja que o compilador se comporte
como se o tipo de dados do item fosse type. A conversão é basicamente uma chamada de
função, que retornará null se a conversão falhar durante a execução (isso ocorre nos arquivos
publicados no Flash Player 7 ou versões posteriores; os arquivos publicados no Flash Player 6
não oferecem suporte a falhas de conversão durante a execução). Se a conversão for bem
sucedida, o retorno da chamada de função será o objeto original. Entretanto, o compilador
não é capaz de determinar se uma conversão falhará durante a execução e não gerará erros
durante a compilação nesses casos.
O código a seguir mostra um exemplo:
// Both the Cat and Dog classes are subclasses of the Animal class
function bark(myAnimal:Animal) {
var foo:Dog = Dog(myAnimal);
foo.bark();
}
var curAnimal:Animal = new Dog();
bark(curAnimal); // Funcionará
curAnimal = new Cat();
bark(curAnimal); // Não funcionará
Nesse exemplo, você declarou ao compilador que foo é um objeto Dog e, portanto, o
compilador pressupõe que foo.bark(); é uma instrução legal. Entretanto, o compilador não
sabe que a conversão falhará (ou seja, que você tentou converter um objeto Cat em um tipo
Animal), portanto, nenhum erro ocorrerá durante a compilação. Entretanto, se você incluir
uma verificação no script para garantir que a conversão tenha êxito, poderão ocorrer erros
durante a execução, como mostra este exemplo.
function bark(myAnimal:Animal) {
var foo:Dog = Dog(myAnimal);
if (foo) {
foo.bark();
}
}
Você pode converter uma expressão em uma interface. Se a expressão for um objeto que
implemente a interface ou tenha uma classe base que implemente a interface, a conversão terá
êxito. Caso contrário, ela falhará.
N O TA
A conversão em null ou undefined retornará undefined.
Sobre a conversão
117
Não é possível substituir tipos de dados primitivos que têm uma função de conversão global
correspondente por um operador de conversão de mesmo nome. Isso ocorre porque as funções
de conversão globais têm precedência sobre os operadores de conversão. Por exemplo, não é
possível converter em Array porque a função de conversão Array() tem precedência sobre o
operador de conversão.
Esse exemplo define duas variáveis de seqüência de caracteres (firstNum e secondNum), que
são adicionadas juntas. O resultado inicial é que os números são concatenados em vez de
serem adicionados, pois são do tipo de dados String. A segunda instrução trace converte os
dois números no tipo de dados Number antes de executar a adição que gera o resultado
adequado. A conversão de dados é importante ao trabalhar com dados carregados por meio de
XML ou FlashVars, como mostra o seguinte exemplo:
var firstNum:String = "17";
var secondNum:String = "29";
trace(firstNum + secondNum); // 1729
trace(Number(firstNum) + Number(secondNum)); // 46
Para obter mais informações sobre as funções de conversão de dados, consulte a entrada de
cada função de conversão em ActionScript 2.0 Language Reference: %{função Array}%,
%{função Boolean}%, %{função Number}%, %{função Object}% e %{função String}%.
118
CAPÍTULO 5
5
Fundamentos da sintaxe e da
linguagem
A função da sintaxe e das instruções do ActionScript é semelhante à função das palavras nas
frases, que podem ser agrupadas para formar os parágrafos. O ActionScript pode ser tão
simples quanto isso. Por exemplo, na língua portuguesa, um ponto encerra uma frase. No
ActionScript, um ponto-e-vírgula encerra uma instrução. Na linguagem ActionScript, é
possível digitar uma ação stop() para interromper o loop da reprodução de uma instância de
clipe de filme ou de um arquivo SWF. É possível também escrever milhares de linhas de
código para potencializar uma aplicação bancária interativa. Como você pode ver, o
ActionScript pode realizar tarefas muito simples ou tarefas muito complexas.
O Capítulo 4, “Dados e tipos de dados,” explicou como a linguagem ActionScript usa os
dados e como é possível formatá-los no código. Este capítulo demonstrará como formar as
instruções no ActionScript usando a sintaxe. Ele contém pequenos trechos de código e alguns
exemplos para demonstrar os conceitos fundamentais da linguagem. Os próximos capítulos
apresentarão exemplos de código mais longos e cada vez mais complexos que complementarão
e facilitarão os fundamentos aprendidos neste capítulo.
As regras gerais descritas nesta seção aplicam-se a toda a linguagem ActionScript. A maioria
dos termos do ActionScript também tem requisitos individuais. Para obter as regras de um
termo específico, consulte a entrada correspondente em ActionScript 2.0 Language Reference
(Referência à linguagem ActionScript 2.0.
Aplicar os princípios básicos do ActionScript para criar programas sofisticados pode ser
desafiador para usuários novatos no ActionScript. Para obter mais informações sobre como
aplicar as regras descritas nesta seção, consulte Capítulo 19, “Melhores práticas e convenções
de codificação para ActionScript 2.0”, na página 767.
NO TA
Neste capítulo, você adicionará o ActionScript diretamente a um quadro da Timeline
(Linha de tempo). Nos capítulos posteriores, você usará as classes para separar o
ActionScript do arquivo FLA.
119
Para obter mais informações sobre como trabalhar com os fundamentos da sintaxe e da
linguagem do ActionScript, consulte os seguintes tópicos:
Sobre sintaxe, instruções e expressões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
Sobre sintaxe de ponto e caminhos de destino. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
Sobre pontuadores de linguagem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
Sobre constantes e palavras-chave. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Sobre instruções. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
Sobre arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
Sobre operadores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
Sobre sintaxe, instruções e expressões
A linguagem ActionScript é composta de classes internas. É necessário usar a sintaxe correta do
ActionScript para formar as instruções, a fim de que o código seja compilado e executado
corretamente no Flash. Nesse caso, a sintaxe seria a gramática e a ortografia de uma linguagem
de programação. O compilador não poderá compreender uma sintaxe incorreta e exibirá erros
ou avisos no painel Output (Saída) quando você tentar utilizar o documento no ambiente de
teste. Portanto, a sintaxe é um conjunto de regras e diretrizes que ajudam a compor a
linguagem ActionScript corretamente.
Uma instrução é uma diretriz fornecida ao arquivo FLA para fazer algo; por exemplo, executar
uma ação específica. Você pode, por exemplo, utilizar uma instrução condicional para
determinar se algo é verdadeiro ou existe. Em seguida, poderá executar ações especificadas,
como funções ou expressões, de acordo com o status da condição, se verdadeira ou não. A
instrução if é condicional e avalia uma condição para determinar a próxima ação a ser
executada no código.
// if statement
if (condition) {
// statements;
}
Para obter mais informações sobre as instruções, consulte “Sobre instruções” na página 149.
As expressões, diferentes das instruções, são combinações legais de símbolos do ActionScript
que representam um valor. As expressões têm valores, enquanto os valores e as propriedades
têm tipos. Uma expressão pode ser composta por operadores, operandos, valores, funções e
procedimentos. A expressão segue as regras de precedência e associação do ActionScript.
Geralmente, o Flash Player interpreta a expressão e retorna um valor que pode ser utilizado no
aplicativo.
120
Fundamentos da sintaxe e da linguagem
Por exemplo, o código a seguir é uma expressão:
x + 2
Na expressão anterior, x e 2 são operandos e + é um operador. Para obter mais informações
sobre os operadores e operandos, consulte “Sobre operadores” na página 185. Para obter mais
informações sobre os objetos e as propriedades, consulte “Tipo de dados Object”
na página 83.
A maneira como a linguagem ActionScript é formatada também determina até que ponto será
possível fazer a manutenção do código. Por exemplo, é difícil entender a lógica de um arquivo
FLA que não contenha recuos ou comentários, ou que tenha convenções de formatação e
nomeação inconsistentes. Quando você recua blocos do ActionScript (como loops e
instruções if ), a leitura e a depuração do código tornam-se mais fáceis caso ocorra algum
problema. Para obter mais informações sobre como formatar o ActionScript, consulte
“Formatando a sintaxe do ActionScript” na página 799. Você encontrará também a
formatação correta do ActionScript nessas seções.
Para obter mais informações sobre os fundamentos da sintaxe e da linguagem, consulte os
seguintes tópicos:
■
“Diferenças entre o ActionScript e o JavaScript”
■
“Sobre distinção entre maiúsculas e minúsculas”
Diferenças entre o ActionScript e o JavaScript
O ActionScript é semelhante à linguagem de programação JavaScript básica. Não é preciso
conhecer o JavaScript para utilizara o ActionScript. No entanto, se você conhecê-lo, o
ActionScript lhe parecerá familiar.
Este manual não tem como objetivo ensinar programação. Há vários recursos que fornecem
mais informações sobre os conceitos gerais de programação e sobre a linguagem JavaScript.
■
A especificação de linguagem ECMAScript (ECMA-262) Edition 3 deriva-se do
JavaScript e serve como padrão internacional para a linguagem JavaScript. O ActionScript
também baseia-se nessa especificação. Para obter mais informações, consulte www.ecmainternational.org/publications/standards/Ecma-262.htm.
■
O site da tecnologia Java contém tutoriais sobre a programação orientada a objetos (http:/
/java.sun.com/docs/books/tutorial/java/index.html) que destinam-se à linguagem Java,
mas são úteis para compreendermos os conceitos aplicados ao ActionScript.
Algumas diferenças entre o ActionScript e o JavaScript são descritos na lista a seguir:
■
O ActionScript não oferece suporte a objetos específicos de navegadores, como
Document, Window e Anchor.
121
■
O ActionScript não oferece suporte completo a todos os objetos internos do JavaScript.
■
O ActionScript não oferece suporte a algumas construções sintáticas do JavaScript, como
rótulos de instrução.
■
No ActionScript, a função eval() pode executar somente referências a variáveis.
■
O ActionScript 2.0 oferece suporte a vários recursos que não constam na especificação
ECMA-262, como as classes e a atribuição forte de tipos de dados. Muitos desses recursos
são modelados após a especificação de linguagem ECMAScript (ECMA-262) Edition 3
(consulte www.ecma-international.org/publications/standards/Ecma-262.htm).
■
O ActionScript não oferece suporte a expressões regulares que usam o objeto RegExp. No
entanto, a Macromedia Central não oferece suporte ao objeto RegExp. Para obter mais
informações sobre a Macromedia Central, consulte www.macromedia.com/software/
central.
Sobre distinção entre maiúsculas e minúsculas
Quando você escreve usando a linguagem ActionScript para Flash Player 7 e posterior, o
código faz distinção entre maiúsculas e minúsculas. Isso significa que as variáveis com uso de
maiúsculas e minúsculas um pouco diferente não são consideradas idênticas. O código do
ActionScript a seguir mostra isso:
// use mixed capitalization
var firstName:String = "Jimmy";
// use all lower case
trace(firstname); // undefined
Uma outra alternativa seria escrever o código da seguinte maneira:
// In file targeting Flash Player 8
// and either ActionScript 1.0 or ActionScript 2.0
//
// Sets properties of two different objects
cat.hilite = true;
CAT.hilite = true;
// Creates three
var myVar:Number
var myvar:Number
var mYvAr:Number
N O TA
122
different variables
= 10;
= 10;
= 10;
Não é recomendável diferenciar as variáveis ou qualquer identificador pelo uso de
maiúsculas e minúsculas. Para obter mais informações sobre como atribuir nomes a
variáveis, consulte Capítulo 19, “Melhores práticas e convenções de codificação para
ActionScript 2.0”, na página 767.
Quando você publica usando versões do Flash Player (Flash Player 6 e anterior), o Flash
rastreia a seqüência de caracteres Jimmy no painel Output (Saída). Como o Flash Player 7 e as
versões posteriores fazem distinção entre maiúsculas e minúsculas, firstName e firstname
são consideradas duas variáveis separadas (no ActionScript 1.0 ou ActionScript 2.0). Esse é
um conceito importante. Se você criou arquivos FLA para Flash Player 6 ou anterior com
maiúsculas e minúsculas não correspondentes nas variáveis, a funcionalidade e os arquivos
podem ser interrompidos durante a conversão do arquivo ou aplicativo que referencia uma
versão mais recente do Flash Player.
Portanto, recomenda-se ser coerente na escolha das convenções de maiúsculas e minúsculas,
como foi feito neste manual. Assim, também será mais fácil diferenciar as variáveis, as classes e
os nomes de função. Não use maiúsculas e minúsculas para diferenciar dois identificadores.
Altere a instância, a variável ou o nome da classe, e não apenas as maiúsculas ou minúsculas.
Para obter mais informações sobre as convenções de codificação, consulte Capítulo 19,
“Melhores práticas e convenções de codificação para ActionScript 2.0”, na página 767.
A distinção entre maiúsculas e minúsculas tem um grande impacto quando se está
trabalhando com um serviço da Web que usa suas próprias regras de nomeação de variáveis e
quando as variáveis são incluídas ao retornarem do servidor para o arquivo SWF. Por exemplo,
se você usar o serviço da Web ColdFusion, os nomes de propriedade em uma estrutura ou
objeto poderão ter todas as letras maiúsculas; por exemplo, FIRSTNAME. Os resultados podem
ser inesperados se você não utilizar os nomes exatamente como fornecidos no Flash.
N OT A
A distinção entre maiúsculas e minúsculas também afeta as variáveis externas
carregadas em um arquivo SWF (as variáveis carregadas com LoadVars.load(), por
exemplo).
A distinção entre maiúsculas e minúsculas é implementada para scripts externos, como os
arquivos de classe do ActionScript 2.0, os scripts importados através do comando #include e
os scripts de um arquivo FLA. Se você encontrar erros durante a execução e estiver exportando
para mais de uma versão do Flash Player, analise os arquivos de script externos e os scripts dos
arquivos FLA para confirmar se o uso de maiúsculas e minúsculas está consistente.
A distinção entre maiúsculas e minúsculas é implementada em cada arquivo SWF. Se um
aplicativo Flash Player 8 estrito (que faz distinção entre maiúsculas e minúsculas) chamar um
arquivo SWF do Flash Player 6 não estrito, o ActionScript executado no arquivo SWF do
Player 6 será não estrito. Por exemplo, se você usar loadMovie() para carregar um arquivo
SWF do Flash Player 6 em um arquivo SWF do Flash Player 8, o SWF da versão 6 continuará
não fazendo distinção entre maiúsculas e minúsculas, embora o da versão 8 seja considerado
um arquivo que faz distinção entre maiúsculas e minúsculas.
123
Quando a sinalização da sintaxe por cores for ativada, os elementos de linguagem escritos com
as maiúsculas ou minúsculas corretas ficarão azuis, por padrão. Para obter mais informações,
consulte “Sobre palavras reservadas” na página 147.
Sobre sintaxe de ponto e caminhos de
destino
No ActionScript, você usa o operador de ponto (.) (sintaxe de ponto) para acessar as
propriedades ou os métodos que pertencem a um objeto ou a uma instância do Stage (Palco).
Além disso, esse operador é utilizado para identificar o caminho de destino de uma instância
(como um clipe de filme), variável, função ou objeto.
Uma expressão com sintaxe de ponto começa com o nome do objeto ou clipe de filme seguido
de um ponto e termina com o elemento a ser especificado. As seções a seguir demonstram
como escrever expressões com sintaxe de ponto.
Para controlar um clipe de filme, arquivo SWF carregado ou botão, é necessário especificar
um caminho de destino. Os caminhos de destino são endereços hierárquicos de nomes de
instâncias de clipes de filme, variáveis e objetos em um arquivo SWF. Para especificar um
caminho de destino de um clipe de filme ou botão, você deve atribuir um nome de instância
ao clipe de filme ou botão. Para atribuir um nome a uma instância de clipe de filme, selecione
a instância e digite o nome da instância no Property inspector (Inspetor de propriedades).
Uma outra alternativa é especificar o nome da instância com o código, caso ela tenha sido
criada através do ActionScript. Você pode usar um caminho de destino para atribuir uma ação
a um clipe de filme ou para obter ou definir o valor de uma variável ou propriedade.
Para obter mais informações sobre como atribuir um nome de instância e usar a sintaxe de
ponto para referenciar uma instância, consulte os seguinte tópicos:
■
“Sobre uso da sintaxe de ponto para referenciar uma instância” na página 125.
■
“Sobre escopo e referência” na página 130
■
“Usando o botão Target Path” na página 131
■
“Sobre sintaxe de barra” na página 131
Para obter mais informações sobre os objetos e as propriedades, consulte “Tipo de dados
Object” na página 83.
124
Sobre uso da sintaxe de ponto para referenciar uma
instância
Para escrever a linguagem ActionScript que controla uma instância (por exemplo, um clipe de
filme) ou manipula ativos em um arquivo SWF carregado, especifique o nome e o endereço
dessa instância no código. Isso é denominado caminho de destino. Para referenciar (ou
endereçar) objetos em um arquivo SWF, use a sintaxe de ponto (também denominada notação
de ponto). Por exemplo, é necessário referenciar uma instância de clipe de filme ou de botão
antes de aplicar uma ação a ela. A sintaxe de ponto ajuda a criar um caminho para a instânciaalvo. O caminho da instância-alvo é, algumas vezes, denominado caminho de destino.
Um arquivo FLA tem uma hierarquia específica. É possível criar instâncias no Stage (Palco) ou
usar o ActionScript. É possível, até mesmo, criar instâncias dentro de outras ou deixá-las
aninhadas em várias outras instâncias. Qualquer instância pode ser manipulada, contanto que
ela tenha um nome.
Para atribuir um nome às instâncias, use um nome de instância, que você pode especificar de
duas formas (conforme demonstrado abaixo):
■
Manualmente, selecionando uma instância e digitando um nome de instância no Property
inspector (Inspetor de propriedades) (quando uma instância estiver no Stage).
■
Dinamicamente, usando o ActionScript. Para criar uma instância, use o ActionScript.
Atribua um nome a ela ao criá-la.
Para atribuir um nome à instância no Property inspector, digite um nome na caixa de texto
Instance Name (Nome da instância).
Também é possível atribuir um nome de instância a um objeto criado com o ActionScript.
Isso pode ser muito simples, como mostra o código a seguir:
this.createEmptyMovieClip("pic_mc", this.getNextHighestDepth());
pic_mc.loadMovie("http://www.helpexamples.com/flash/images/image1.jpg");
Esse código cria um novo clipe de filme e atribui a ele o nome de instância pic_mc. Em
seguida, você pode manipular a instância pic_mc usando o código, como acontece ao carregar
uma imagem nele, conforme demonstrou o código anterior.
Para obter mais informações sobre como trabalhar com o escopo, consulte “Sobre escopo e
referência” na página 130 e “Sobre variáveis e escopo” na página 101.
Sobre sintaxe de ponto e caminhos de destino
125
Referenciando uma instância
Para que uma instância funcione no arquivo SWF, é necessário referenciá-la e instruí-la a
executar alguma tarefa, atribuindo uma ação a ela ou alterando suas propriedades.
Geralmente, é preciso definir o local do arquivo SWF em que essa instância está (por exemplo,
em que linha de tempo ela está ou em que instância ela está aninhada), criando o caminho de
destino. Lembre-se que você recebeu várias instâncias nos nomes de instância do arquivo FLA
e, depois, adicionou código ao arquivo FLA que usa esses nomes de instância. Ao fazer isso,
você referencia essa instância e a instrui a fazer algo (por exemplo, mover a reprodução ou
abrir uma página da Web). Para obter mais informações sobre os objetos e as propriedades,
consulte “Tipo de dados Object” na página 83.
Para referenciar uma instância:
1.
Selecione File (Arquivo) > New (Novo) e, em seguida, selecione Flash Document
(Documento do Flash).
2.
Selecione File > Save As (Salvar como) e atribua o nome target.fla ao arquivo.
3.
Use a ferramenta Oval para desenhar uma forma no Stage (Palco). Desenhe uma forma oval
de qualquer tamanho e cor.
4.
Use a ferramenta Selection (Seleção) para selecionar a forma oval no Stage.
DICA
Lembre-se de selecionar o traço e preenchê-lo se necessário.
5.
Selecione Modify (Modificar) > Convert to Symbol (Converter em símbolo), selecione a
opção Movie Clip (Clipe de filme) e clique em OK para criar o símbolo.
6.
Selecione o clipe de filme no Stage e atribua a ele o nome de instância myClip no Property
inspector (Inspetor de propriedades).
7.
Insira uma nova camada e renomeie-a como actions.
8.
Adicione o seguinte ActionScript ao Frame 1 (Quadro 1) da camada actions:
myClip._xscale = 50;
Essa linha de código referencia a instância myClip no Stage. O ActionScript dimensiona a
instância para a metade de sua largura original. Como o ActionScript está na mesma linha
de tempo que o símbolo de clipe de filme, é necessário referenciar a instância usando
somente o nome da instância. Se a instância estiver em outra linha de tempo ou aninhada
em outra instância, será necessário modificar o caminho de destino apropriadamente.
126
Referenciando uma instância aninhada
Também é possível referenciar as instâncias aninhadas dentro de outras instâncias. Talvez você
queira colocar uma segunda instância de clipe de filme dentro da instância myClip no
exercício de “Referenciando uma instância” na página 126. Você também pode referenciar
essa instância aninhada usando o ActionScript. Antes de passar para o próximo exercício, é
necessário concluir o exercício de “Referenciando uma instância” na página 126 e seguir estas
etapas para referenciar uma instância aninhada.
Para referenciar uma instância aninhada:
1.
Abra target.fla conforme indicado no procedimento sobre como referenciar uma instância
e renomeie-a como target2.fla.
2.
Clique duas vezes na instância myClip no Stage (Palco).
3.
Selecione a ferramenta Oval e desenhe a forma oval dentro da instância myClip.
4.
Selecione a nova forma e, em seguida, selecione Modify (Modificar)> Convert to Symbol
(Converter em símbolo).
5.
Selecione a opção Movie Clip (Clipe de filme) e clique em OK.
6.
Selecione a nova instância e digite myOtherClip na caixa de texto Instance Name (Nome
da instância) no inspetor Properties (Inspetor de propriedades).
7.
Clique em Scene 1 (Cena 1) na barra de edição para retornar à Timeline (Linha de tempo)
principal.
8.
myClip.myOtherClip._xscale = 50;
Esse ActionScript redimensiona a instância myOtherClip para metade de sua largura
atual. Como o arquivo target.fla modificou a propriedade _xscale das instâncias myClip
e myOtherClip é um símbolo aninhado, observe que myOtherClip terá 25% da largura
original.
Se você trabalhar com clipes de filme aninhados que tenham suas próprias linhas de tempo,
manipule a reprodução na linha de tempo de uma instância aninhada usando um código
similar ao trecho a seguir:
myClip.nestedClip.gotoAndPlay(15);
myClip.someOtherClip.gotoAndStop("tweenIn");
Observe que o clipe manipulado (nestedClip, por exemplo) aparece imediatamente antes da
ação. Você observará essa tendência nas próximas seções.
127
Você não está limitado a acessar métodos e propriedades de instâncias predefinidos no Stage,
conforme demonstrado nos exemplos anteriores. Também é possível definir uma variável em
um clipe de filme, conforme visto no código a seguir, que define uma variável no clipe de
filme starClip:
starClip.speed = 1.1;
starClip.gravity = 0.8;
Se as variáveis de velocidade ou gravidade já existissem na instância de clipe de filme starClip,
os valores anteriores seriam substituídos assim que os novos valores fossem definidos. É
possível adicionar novas propriedades ao clipe de filme starClip, pois a classe MovieClip foi
definida com a palavra-chave dynamic. A palavra-chave dynamic especifica que os objetos
baseados na classe especificada (nesse caso, MovieClip) podem adicionar e acessar
propriedades dinâmicas durante a execução. Para obter mais informações sobre a instrução
dinâmica, consulte %{dynamic statement}% em ActionScript 2.0 Language Reference
(Referência à linguagem ActionScript 2.0).
Referenciando instâncias dinâmicas e conteúdo carregado
Também é possível criar um objeto usando o ActionScript e referenciá-lo posteriormente
usando um caminho de destino. Por exemplo, você pode usar o ActionScript a seguir para
criar um clipe de filme. Depois, poderá alterar a rotação desse clipe de filme usando o
ActionScript, conforme mostrado neste exemplo:
Para referenciar uma instância de clipe de filme criada dinamicamente:
1.
Crie um novo documento do Flash e salve o arquivo como targetClip.fla.
2.
Insira uma nova camada e renomeie-a como actions.
3.
this.createEmptyMovieClip("rotateClip", this.getNextHighestDepth());
trace(rotateClip);
rotateClip._rotation = 50;
4.
Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento.
Você pode informar que criou um clipe de filme devido à instrução trace, mas não
conseguirá ver nada no Stage (Palco). Mesmo que tenha adicionado um código que crie
uma instância de clipe de filme, nada aparecerá no Stage, a menos que tenha adicionado
algo ao clipe. Por exemplo, você poderia carregar uma imagem no clipe de filme.
5.
Retorne ao ambiente de criação e abra o painel Actions (Ações).
6.
Digite o seguinte ActionScript após o código adicionado na etapa 3:
rotateClip.loadMovie("http://www.helpexamples.com/flash/images/
image1.jpg");
128
Esse código carregará uma imagem no clipe de filme rotateClip criado junto com o
código. Você está referenciando a instância rotateClip com o ActionScript.
7.
Agora, aparecerá uma imagem no Stage que pode ser girada 50º no sentido horário.
Também é possível referenciar ou identificar partes dos arquivos SWF carregados em um
arquivo SWF base.
Para identificar um arquivo SWF carregado:
■
Use _levelX, onde X é o número de nível especificado na função loadMovie() que
carregou o arquivo SWF.
Por exemplo, um arquivo SWF carregado no nível 99 possui o caminho de destino
_level99. No exemplo a seguir, um arquivo SWF é carregado no nível 99 e define sua
visibilidade para false:
//Load the SWF onto level 99.
loadMovieNum("contents.swf", 99);
//Set the visibility of level 99 to false.
loaderClip.onEnterFrame = function(){
_level99._visible = false;
};
DICA
É recomendável evitar o uso de níveis caso seja possível carregar um conteúdo nos
clipes de filme em profundidades diferentes. O método
MovieClip.getNextHighestDepth() permite criar dinamicamente novas instâncias de
clipe de filme no Stage sem que seja necessário verificar se já existe alguma
instância em uma profundidade específica.
Definindo variáveis através de um caminho
É possível definir variáveis para instâncias aninhadas dentro de outras instâncias. Por exemplo,
se você quiser definir uma variável para uma forma que esteja dentro de outra forma, use o
código a seguir. A instância submitBtn está dentro de formClip na linha de tempo principal:
this.formClip.submitBtn.mouseOver = true;
Para expressar um método ou propriedade de um objeto específico (como um clipe de filme
ou um campo de texto), use esse padrão. Por exemplo, a propriedade de um objeto seria
myClip._alpha = 50;
129
Sobre escopo e referência
Quando você aninha instâncias, o clipe de filme que aninha um segundo clipe de filme é
denominado pai da instância aninhada. A instância aninhada chama-se instância filha. O
Stage (Palco) e a Timeline (Linha de tempo) principais são basicamente um clipe de filme e
podem, portanto, serem referenciados como tal. Para obter mais informações sobre o escopo,
consulte “Sobre variáveis e escopo” na página 101.
É possível referenciar instâncias pai e linhas de tempo pai usando o ActionScript. Para
referenciar a linha de tempo atual, use a palavra-chave this. Por exemplo, ao referenciar um
clipe de filme chamado myClip que esteja na linha de tempo atual, use
this.myClip.
Se desejar, elimine a palavra-chave this e use apenas
myClip
Você poderia adicionar a palavra-chave this para fins de legibilidade e consistência. Para
obter mais informações sobre as práticas de codificação recomendadas, consulte Capítulo 19,
Caso rastreie o clipe de filme, _level0.myClip aparecerá no painel Output (Saída) para cada
trecho de código acima. No entanto, se o ActionScript estiver dentro do clipe de filme
myClip, mas a linha de tempo principal tiver que ser referenciada, referencie o pai do clipe de
filme (que é o Stage principal). Clique duas vezes em um clipe de filme e coloque o seguinte
ActionScript na linha de tempo do clipe de filme:
trace("me: " + this);
trace("my parent: " + this._parent);
Teste o arquivo SWF e a seguinte mensagem aparecerá no painel Output:
me: _level0.myClip
my parent: _level0
Isso significa que você referenciou a linha de tempo principal. Use parent para criar um
caminho relativo para um objeto. Por exemplo, se o clipe de filme dogClip estiver aninhado
dentro do clipe de filme de animação animalClip, a seguinte instrução da instância dogClip
instruirá animalClip a interromper a animação:
this._parent.stop();
Se você estiver familiarizado com o Flash e o ActionScript, provavelmente já observou pessoas
usando o escopo _root. O escopo _root geralmente se refere à linha de tempo principal do
documento atual do Flash. Evite usar o escopo _root, a não ser que seja absolutamente
necessário. Use caminhos de destino relativos, em vez de _root.
130
Caso utilize _root no código, possivelmente ocorrerão erros se o arquivo SWF for carregado
em outro documento do Flash. Quando o arquivo SWF é carregado em outro arquivo SWF, o
escopo _root do arquivo carregado pode apontar para o escopo raiz no qual ele é carregado,
em vez de referenciar sua própria raiz, conforme o desejado. Isso pode gerar resultados
imprevisíveis ou interromper a funcionalidade.
Usando o botão Target Path
Às vezes, demora um pouco para descobrir um caminho de destino específico ou qual
caminho de destino é necessário para um determinado código. Se você referenciar uma
instância existente no Stage (Palco), poderá usar o botão Target Path (Caminho de destino)
para determinar qual deve ser o caminho dessa instância.
Para usar o botão Target Path:
1.
Abra o painel Actions (Ações) (Window (Janela) > Actions) e clique no botão Insert Target
Path (Inserir caminho de destino). Os clipes de filme do documento atual aparecem em
uma caixa de diálogo.
2.
Selecione uma das instâncias na lista da caixa de diálogo.
3.
Clique em OK.
4.
O caminho de destino da instância selecionada aparece no painel Script.
Sobre sintaxe de barra
A sintaxe de barra foi usada no Flash 3 e 4 para indicar o caminho de destino de um clipe de
filme ou de uma variável. Essa sintaxe é suportada pelo ActionScript 1.0 no Flash Player 7 e
versões anteriores, mas não é suportada no ActionScript 2.0 e Flash Player 7 ou 8.
O uso da sintaxe de barra não é recomendável, a menos que não haja outra opção. Ela é
necessária, por exemplo, quando é preciso criar um conteúdo destinado especificamente ao
Flash Player 4 ou Flash Lite 1.1 (e versões anteriores), no qual a sintaxe de barra deve ser
utilizada. Para obter mais informações sobre o Flash Lite, consulte a página de produtos do
Flash Lite.
131
Sobre pontuadores de linguagem
Existem diversos pontuadores de linguagem no Flash. Os tipos de pontuadores mais comuns
são ponto-e-vírgula, (;), dois-pontos (:), parênteses [()] e chaves ({}). Cada um desses
pontuadores têm um significado especial na linguagem Flash e ajuda a definir tipos de dados,
encerrar instruções ou estruturar o ActionScript. As seções a seguir explicam como usar os
pontuadores no código.
Para obter mais informações sobre os pontuadores de linguagem, consulte os seguintes
tópicos:
■
“Ponto-e-vírgula e dois-pontos” na página 132
■
“Chaves” na página 133
■
“Parênteses” na página 137
■
“Sobre literais” na página 138
■
“Sobre comentários” na página 139
Para obter mais informações sobre o operador de ponto (.) e os operadores de acesso de array
([]), consulte “Usando operadores de ponto e de acesso de array” na página 194. Para obter
informações sobre espaço em branco e formatação de código, consulte “Formatando a sintaxe
do ActionScript” na página 799.
Ponto-e-vírgula e dois-pontos
As instruções do ActionScript são encerradas com um ponto-e-vírgula (;), conforme
demonstrado nas duas linhas de código a seguir:
myClip._alpha = myNum;
É possível omitir o ponto-e-vírgula. Nesse caso, o compilador do ActionScript assumirá que
cada linha de código representa uma única instrução. No entanto, é recomendável usar o
ponto-e-vírgula ao criar scripts, pois ele melhora a legibilidade do código. Quando você clica
no botão Auto Format (Formatação automática) do painel Actions (Ações) ou da janela
Script, os ponto-e-vírgulas precedentes são anexados ao final da instrução, por padrão.
N OT A
O uso de um ponto-e-vírgula para encerrar uma instrução permite inserir mais de uma
instrução em uma única linha, mas isso geralmente dificulta a leitura do código.
Um outro local em que se usa o ponto-e-vírgula é nos loops for. Ele é utilizado para separar
parâmetros, conforme mostrado no exemplo a seguir. O exemplo se repete de 0 a 9 e exibe
cada número no painel Output (Saída):
132
var i:Number;
for (i = 0; i < 10; i++) {
trace(i); // 0,1,...,9
}
Os dois-pontos (:) são utilizados no código para atribuir tipos de dados às variáveis. Para
atribuir a um item um tipo de dados específico, defina seu tipo usando a palavra-chave var e a
sintaxe pós-dois-pontos, como no exemplo a seguir:
// strict typing of variable or object
var myDate:Date = new Date();
// strict typing of parameters
function welcome(firstName:String, myAge:Number) {
}
// strict typing of parameter and return value
function square(num:Number):Number {
var squared:Number = num * num;
return squared;
}
É possível declarar o tipo de dados de objetos com base em classes internas (Button, Date,
MovieClip etc.) e em classes e interfaces criadas por você. No trecho a seguir, você criará um
novo objeto, do tipo personalizado Student:
var firstStudent:Student = new Student();
Também é possível especificar se os objetos são do tipo de dados Function ou Void. Para obter
mais informações sobre como atribuir tipos de dados, consulte Capítulo 4, “Dados e tipos de
dados”, na página 75.
Chaves
Agrupe os eventos, as definições de classe e as funções do ActionScript em blocos usando as
chaves ({}). Coloque a chave de abertura na mesma linha da declaração.
N OT A
Também é possível colocar a chave de abertura na linha após a declaração. As
convenções de codificação recomendam colocar a chave de abertura na mesma linha
para fins de consistência. Para obter informações sobre as chaves e convenções de
codificação, consulte Capítulo 19, “Melhores práticas e convenções de codificação para
ActionScript 2.0”, na página 767.
Delimite cada instrução entre chaves quando ela fizer parte de uma estrutura de controle
ou for), mesmo que ela contenha somente uma instrução. Essa prática ajudará a
evitar erros no ActionScript quando você esquecer de adicionar chaves ao código. O exemplo
a seguir mostra um código escrito de modo insatisfatório:
if..else
133
var numUsers:Number;
if (numUsers == 0)
trace("no users found.");
Embora esse código seja válido, ele é considerado insatisfatório porque não tem chaves
delimitando as instruções.
DICA
As chaves serão adicionadas a essa instrução se você clicar no botão Check Syntax
(Verificar sintaxe).
Nesse caso, se você adicionar uma segunda instrução após a instrução trace, a segunda
instrução será executada, quer a variável numUsers seja igual a 0 ou não, o que poderá gerar
resultados inesperados. Por isso, adicione as chaves para que a saída do código seja semelhante
à mostrada neste exemplo:
var numUsers:Number;
if (numUsers == 0) {
trace("no users found");
}
O exemplo a seguir cria um objeto ouvinte de eventos e uma instância MovieClipLoader.
var imgUrl:String = "http://www.helpexamples.com/flash/images/image1.jpg";
mclListener.onLoadStart = function() {
trace("starting");
};
trace("success");
};
mclListener.onLoadError = function(target_mc:MovieClip):Void {
trace("failure");
};
var myClipl:MovieClipLoader = new MovieClipLoader();
myClipl.addListener(mclListener);
myClipl.loadClip(imgUrl, img_mc);
O exemplo a seguir exibe um arquivo de classe simples que pode ser utilizado para criar um
objeto Student. Para obter mais informações sobre os arquivos de classe, consulte Capítulo 7,
“Classes”, na página 239.
Para usar chaves em um arquivo do ActionScript:
1.
Selecione File (Arquivo) > New (Novo) e, em seguida, selecione ActionScript File (Arquivo
do ActionScript).
2.
Selecione File > Save As (Salvar como) e salve o novo documento como Student.as.
134
3.
Adicione o seguinte ActionScript ao arquivo AS:
// Student.as
class Student
private var
private var
private var
private var
{
_id:String;
_firstName:String;
_middleName:String;
_lastName:String;
public function Student(id:String, firstName:String,
middleName:String, lastName:String) {
this._id = id;
this._firstName = firstName;
this._middleName = middleName;
this._lastName = lastName;
}
public function get firstName():String {
return this._firstName;
}
public function set firstName(value:String):Void {
this._firstName = value;
}
// ...
}
4.
Salve o arquivo de classe.
5.
Selecione File > New e clique em Flash Document (Documento do Flash) para criar um
novo arquivo FLA.
6.
Salve o novo arquivo FLA como student_test.fla.
7.
Digite o seguinte ActionScript no Frame 1 (Quadro 1) da Timeline (Linha de tempo)
principal:
// student_test.fla
import Student;
var firstStudent:Student = new Student("cst94121", "John", "H.", "Doe");
trace(firstStudent.firstName); // John
firstStudent.firstName = "Craig";
trace(firstStudent.firstName); // Craig
8.
Selecione File > Save (Salvar) para salvar as alterações efetuadas em student_test.fla.
9.
Selecione Control (Controlar) > Test Movie (Testar filme) para testar os arquivos FLA e
AS.
O exemplo a seguir demonstra como as chaves são utilizadas nas funções.
Para usar chaves nas funções:
1.
Selecione File > New e, em seguida, selecione Flash Document para criar um novo arquivo
FLA.
135
2.
Selecione File > Save As e atribua o nome checkform.fla ao arquivo.
3.
Arraste uma instância do componente Label do painel Components (Componentes) para
o Stage (Palco).
4.
Abra o Property inspector (Inspetor de propriedades) (Window (Janela) > Properties
(Propriedades) > Properties) e, com a instância de componente Label selecionada, digite o
nome de instância status_lbl na caixa de texto Instance Name (Nome da instância).
5.
Digite 200 na caixa de texto W (width) (L (largura)) para redimensionar o componente
para 200 pixels de largura.
6.
Arraste uma instância do componente TextInput para o Stage e atribua a ela o nome
firstName_ti.
7.
Arraste uma instância do componente Button para o Stage e atribua a ela o nome
submit_button.
8.
Selecione o Frame 1 da Timeline e adicione o seguinte ActionScript ao painel Actions
(Ações):
function checkForm():Boolean {
status_lbl.text = "";
if (firstName_ti.text.length == 0) {
status_lbl.text = "Please enter a first name.";
return false;
}
return true;
}
function clickListener(evt_obj:Object):Void {
var success:Boolean = checkForm();
};
submit_button.addEventListener("click", clickListener);
9.
Selecione File > Save para salvar o documento do Flash.
10. Selecione
Control > Test Movie para testar o código no ambiente de criação.
No arquivo SWF, uma mensagem de erro será exibida se você clicar na instância Button do
Stage e não tiver o texto no componente TextInput firstName_ti. Esse erro aparecerá no
componente Label e informará aos usuários que eles precisam digitar um nome.
O próximo exemplo que utiliza chaves mostra como criar e definir propriedades em um
objeto. Neste exemplo, as propriedades são definidas no objeto através da especificação dos
nomes de variáveis entre chaves ({}):
var myObject:Object = {id:"cst94121", firstName:"John", middleName:"H.",
lastName:"Doe"};
var i:String;
for (i in myObject) {
trace(i + ": " + myObject[i]);
}
136
/*
id: cst94121
firstName: John
middleName: H.
lastName: Doe
*/
Também é possível usar chaves vazias como atalho de sintaxe para a função new Object().
Por exemplo, o código a seguir cria uma instância Object vazia:
var myObject:Object = {};
DICA
Lembre-se de que cada chave de abertura deve ter uma chave de fechamento.
Parênteses
Ao definir uma função no ActionScript, você coloca os parâmetros entre parênteses [()],
conforme mostrado nas linhas de código a seguir:
function myFunction(myName:String, myAge:Number, happy:Boolean):Void {
// Your code goes here.
}
Ao chamar uma função, você também coloca qualquer parâmetro transmitido para a função
entre parênteses, conforme mostrado no exemplo a seguir:
myFunction("Carl", 78, true);
É possível usar parênteses para substituir a ordem de precedência do ActionScript ou para
facilitar a leitura das instruções do ActionScript. Isso significa que é possível alterar a ordem
em que os valores são computados delimitando certos valores entre colchetes, conforme
mostra o exemplo a seguir:
var computedValue:Number = (circleClip._x + 20) * 0.8;
Devido à ordem de precedência, se você não utilizou os parênteses ou usou duas instruções
separadas, a multiplicação será computada primeiro, o que significa que a primeira operação
será 20 * 0.8. O resultado, 16, será adicionado ao valor atual de circleClip._x e, por fim,
atribuído à variável computedValue.
Se você não usar parênteses, deverá adicionar uma instrução para avaliar a expressão, conforme
mostrado no exemplo a seguir:
var tempValue:Number = circleClip._x + 20;
var computedValue:Number = tempValue * 0.8;
Assim com os colchetes e as chaves, é necessário verificar se o parêntese de abertura tem um
parêntese de fechamento.
137
Sobre literais
Um literal é um valor que aparece diretamente no código. Os literais são valores de constante
(invariáveis) dos documentos do Flash. Como exemplos de literal, pode-se citar true, false,
0, 1, 52 ou, até mesmo, a seqüência de caracteres “foo”.
Os exemplos a seguir são literais:
17
"hello"
-3
9.4
null
undefined
true
false
Os literais também podem ser agrupados para formar literais compostos. Os literais de array
são delimitados por colchetes ([]) e usam a vírgula (,) para separar elementos de array. Um
literal de array pode ser usado para inicializar um array. Os exemplos a seguir mostram dois
arrays que são inicializados através de literais de array. É possível usar a instrução new e
transmitir o literal composto como um parâmetro para o construtor da classe Array, mas
também é possível atribuir valores de literal diretamente ao instanciar qualquer classe interna
do ActionScript.
// using new statement
var myStrings:Array = new Array("alpha", "beta", "gamma");
var myNums:Array = new Array(1, 2, 3, 5, 8);
// assigning literal directly
var myStrings:Array = ["alpha", "beta", "gamma"];
var myNums:Array = [1, 2, 3, 5, 8];
Os literais também podem ser usados para inicializar um objeto genérico. Um objeto genérico
é uma instância da classe Object. Os literais de objeto são delimitados por chaves ({}) e usam
a vírgula (,) para separar as propriedades de objeto. Cada propriedade é declarada com doispontos (:), pontuador que separa o nome da propriedade do valor da propriedade.
É possível criar um objeto genérico usando a instrução new e transmitir o literal de objeto
como um parâmetro para o construtor da classe Object. Uma outra alternativa é atribuir o
literal de objeto diretamente à instância que está sendo declarada. O exemplo a seguir cria um
novo objeto genérico e o inicializa com três propriedades, propA, propB e propC, cada uma
delas com valores definidos para 1, 2 e 3, respectivamente.
// using new statement
var myObject:Object = new Object({propA:1, propB:2, propC:3});
// assigning literal directly
var myObject:Object = {propA:1, propB:2, propC:3};
138
Não confunda um literal de seqüência de caracteres com um objeto String. No exemplo a
seguir, a primeira linha de código cria o literal de seqüência de caracteres firstStr e a
segunda linha de código cria o objeto String secondStr:
var firstStr:String = "foo"
var secondStr:String = new String("foo")
Use literais de seqüência de caracteres, a menos que seja estritamente necessário usar um
objeto String para obter melhor desempenho. Para obter mais informações sobre as seqüências
de caracteres, consulte “Sobre seqüências de caracteres e a classe String” na página 477.
Sobre comentários
Os comentários são uma forma de fazer anotações no código com descrições em inglês sem
formatação que não serão avaliadas pelo compilador. É possível usar comentários no código
para descrever o que o código está fazendo ou quais dados serão retornados ao documento. O
uso dos comentários pode ajudar você a lembrar decisões de codificação importantes e pode
ser útil para qualquer outra pessoa que leia o código. Os comentários devem explicar
claramente a intenção do código, e não apenas traduzi-lo. Se algo não estiver muito óbvio no
código, adicione comentários.
É altamente recomendável o uso de comentários para adicionar observações aos scripts. Os
comentários documentam as decisões tomadas em relação ao código, respondendo a
perguntas "como" e "por quê". Eles facilitam a compreensão do ActionScript. Por exemplo,
você pode descrever uma solução alternativa nos comentários. Assim, você ou outro
desenvolvedor poderá localizar facilmente seções de código para atualizar ou corrigir. Se o
problema for corrigido ou amenizado em uma versão futura do Flash ou Flash Player, será
possível aperfeiçoar o ActionScript removendo a solução alternativa.
Evite usar comentários desordenados. Um exemplo de comentário desordenado é uma linha
de sinais de igual (=) ou asteriscos (*) utilizada para criar um bloco ou uma separação em
torno dos comentários. Em vez disso, use espaços em branco para separar os comentários do
ActionScript. Se você formatar o ActionScript usando o botão Auto Format (Formatação
automática) do painel Actions (Ações) ou da Janela Script, o espaço em branco será removido.
Lembre-se de adicionar novamente o espaço em branco no código ou use linhas de
comentário únicas (//) para manter o espaçamento. Será mais fácil remover essas linhas depois
que você formatar o código do que tentar encontrar o espaço em branco.
139
Antes de implantar o projeto, remova quaisquer comentários supérfluos do código, como
“define the x and y variables” (definir variáveis x e y) ou outros comentários óbvios para outros
desenvolvedores. Caso ache que há muitos comentários extras no ActionScript, considere se
não é necessário reescrever alguns códigos. Se for necessário incluir vários comentários sobre o
funcionamento do código, isso geralmente será um indício de que o ActionScript não é
sofisticado nem intuitivo.
Quando a sinalização da sintaxe por cores for ativada, os comentários aparecerão em cinza, por
padrão. O tamanho dos comentários não afeta o tamanho do arquivo exportado e eles não
precisam seguir as regras de palavras-chave ou sintaxe do ActionScript.
NO TA
O uso de comentários no ActionScript é mais importante quando o objetivo é treinar o
público-alvo. Adicione comentários ao código se você estiver criando aplicativos de
exemplo destinados a demonstrar o Flash ou se estiver escrevendo artigos ou tutoriais
sobre o ActionScript.
Comentários de linha única
Use comentários de linha única para adicionar um comentário a uma única linha de código.
Você poderia criar uma única linha de código ou adicionar uma breve descrição sobre a função
de uma parte de um código. Para indicar que uma linha ou parte de uma linha é um
comentário, anteceda o comentário com duas barras (//), conforme mostrado no código a
seguir:
// The following sets a local variable for age.
var myAge:Number = 26;
Os comentários de linha única são geralmente utilizados para explicar um pequeno trecho de
código. É possível usar comentários de linha única para fazer qualquer comentário breve que
caiba em uma linha. O exemplo a seguir inclui um comentário de linha única:
while (condition) {
// handle condition with statements
}
Comentários de várias linhas
Use comentários de várias linhas (também denominados comentários em bloco) para fazer
comentários que ocupem diversas linhas. Os desenvolvedores geralmente usam comentários
de várias linhas para descrever arquivos, estruturas de dados e métodos. Eles são geralmente
inseridos no início de um arquivo e antes ou dentro de um método.
140
Para criar um bloco de comentário, coloque /* no início das linhas comentadas e */ no final
do bloco de comentário. Essa técnica permite criar comentários extensos sem adicionar // no
início de cada linha. O uso de // em diversas linhas seqüenciais pode acarretar alguns
problemas quando os comentários são modificados.
O formato de um comentário de várias linhas é o seguinte:
/*
O ActionScript a seguir inicializa variáveis utilizadas nos sistemas
principais e de submenus. As variáveis são usadas para controlar as
opções escolhidas.
*/
D IC A
Se você inserir os caracteres de comentário (/* e */) em linhas separadas no início e no
final do comentário, poderá comentá-las facilmente antecedendo-as com caracteres de
barras duplas (//) (por exemplo, ///* e //*/). Isso permitirá inserir e retirar o comentário do
código com rapidez e facilidade.
Ao inserir uma grande quantidade de scripts em um bloco de comentários (que significa
comentar uma parte do script), você poderá testar partes específicas de um script. Por exemplo,
quando o script a seguir é executado, a parte do código contida no bloco não é executada:
// The following code runs.
var x:Number = 15;
var y:Number = 20;
// The following code is commented out and will not run.
/*
// create new Date object
var myDate:Date = new Date();
var currentMonth:Number = myDate.getMonth();
// convert month number to month name
var monthName:String = calcMonth(currentMonth);
var year:Number = myDate.getFullYear();
var currentDate:Number = myDate.getDate();
*/
// The code below runs.
var namePrefix:String = "My name is";
DICA
Recomenda-se inserir uma linha em branco antes de um comentário em bloco.
141
Comentários finais
Use o recurso de comentário final para adicionar um comentário à mesma linha do código.
Esses comentários aparecem na mesma linha do código do ActionScript. Os desenvolvedores
geralmente usam comentários finais para indicar o que uma variável contém ou para descrever
o valor retornado em uma linha do of ActionScript. Os comentários finais devem ter o
seguinte formato:
var myAge:Number = 26; // variable for my age
trace(myAge); // 26
Recue os comentários para a direita, a fim de que os leitores possam distinguí-los do código.
Tente manter os comentários alinhados, se possível, conforme mostrado no código a seguir.
var myCountry:String = "Canada";
var myCoffee:String = "Hortons";
// my age
// my country
// my coffee preference
Se você usar a formatação automática (clique no botão Auto Format (Formatação automática)
no painel Actions (Ações), os comentários finais se moverão para a próxima linha. Adicione
esses comentários depois que formatar o código. Do contrário, será necessário modificar a
posição dos comentários após o uso do botão Auto Format.
Comentários dentro das classes
Use comentários nas classes e interfaces para documentá-las e ajudar os desenvolvedores a
compreender o conteúdo da classe. Recomenda-se iniciar todos os arquivos de classe com um
comentário que forneça o nome da classe, seu número de versão, a data e o copyright. Por
exemplo, você poderia documentar a classe com um comentário semelhante a este:
/**
Pelican, class
version 1.2
10/10/2005
copyright Macromedia, Inc.
*/
Use comentários em bloco para descrever arquivos, estruturas de dados e métodos. Eles são
geralmente inseridos no início de um arquivo e antes ou dentro de um método.
Há dois tipos de comentários em uma classe ou arquivo de interface comum: comentários de
documentação e comentários de implementação. Os comentários de documentação são
usados para descrever as especificações do código e não descrevem a implementação. Use os
comentários de documentação para descrever interfaces, classes, métodos e construtores. Os
comentários de implementação são usados para fazer comentários sobre o código ou sobre a
implementação de seções específicas do código.
142
Inclua um comentário de documentação para cada classe, interface ou membro e coloque-o
diretamente antes da declaração. Se houver informações adicionais a serem documentadas que
não se ajustem aos comentários de documentação, use comentários de implementação (em
blocos de comentários ou em comentários de linha única). Os comentários de implementação
devem vir logo após a declaração.
Os dois tipos de comentários usam delimitadores um pouco diferentes. Os comentários de
documentação são delimitados por /** e */, enquanto os de implementação são delimitados
por /* e */.
DICA
Não inclua comentários que não estejam diretamente relacionados à classe que está
sendo lida. Por exemplo, não inclua comentários que descrevam o pacote
correspondente.
Também é possível usar comentários de linha única, comentários em bloco e comentários
finais nos arquivos de classe. Para obter mais informações sobre esses tipos de comentários,
consulte as seguintes seções:
■
“Comentários de linha única” na página 140
■
“Comentários de várias linhas” na página 140
■
“Comentários finais” na página 142
Sobre constantes e palavras-chave
As constantes e as palavras-chave são os componentes básicos da sintaxe do ActionScript. As
constantes são propriedades com um valor fixo que não podem ser alteradas. Portanto, elas são
valores que não se alteram em todo o aplicativo.
O Flash possui diversas constantes predefinidas, que podem ajudar a simplificar o
desenvolvimento de um aplicativo. A classe Key possui um exemplo de constantes. Além
disso, ela contém várias propriedades, como Key.ENTER ou Key.PGDN. Se você utilizar as
constantes, nunca precisará memorizar que os valores de código das teclas Enter e Page Down
são 13 e 34. Os valores de constante não facilitam apenas o desenvolvimento e a depuração,
mas também a leitura do código pelos outros desenvolvedores.
As palavras-chave no ActionScript são usadas para executar tipos específicos de ações. Por isso,
elas também são palavras reservadas, que não podem ser usadas como identificadores (como os
nomes de variável, função ou rótulo). Como exemplos de palavras reservadas, pode-se citar if,
else, this, function e return.
143
Para obter mais informações sobre as constantes e palavras-chave, consulte os seguintes
tópicos:
■
“Usando constantes” na página 144
■
“Sobre palavras-chave” na página 146
■
“Sobre palavras reservadas” na página 147
Object” na página 83. Para obter uma lista das constantes da linguagem (como false e NaN),
consulte ActionScript Language Elements (Elementos da linguagem ActionScript) > categoria
Constants (Constantes) em ActionScript 2.0 Language Reference (Referência à linguagem
ActionScript 2.0).
Usando constantes
As constantes são propriedades com um valor fixo que não podem ser alteradas. Portanto, elas
são valores que não se alteram em todo o aplicativo. A linguagem ActionScript contém várias
constantes predefinidas. Por exemplo, as constantes BACKSPACE, ENTER, SPACE e TAB são
propriedades da classe Key e se referem às teclas do teclado. A constante Key.TAB sempre tem
o mesmo significado: ela indica a tecla Tab em um teclado. As constantes são úteis quando se
quer comparar valores e usar valores fixos no aplicativo.
Para testar se o usuário está pressionando a tecla Enter, use a seguinte instrução:
var keyListener:Object = new Object();
keyListener.onKeyDown = function() {
if (Key.getCode() == Key.ENTER) {
trace("Are you ready to play?");
}
};
Key.addListener(keyListener);
Para que o ActionScript anterior funcione, talvez seja necessário desativar os atalhos de teclado
no ambiente de criação. Selecione Control (Controlar) > Test Movie (Testar filme) no menu
principal. Depois, enquanto visualiza o arquivo SWF no player, selecione Control > Disable
Keyboard Shortcuts (Desativar atalhos de teclado) na janela de visualização do arquivo SWF.
No Flash, não há como criar seus próprios valores de constante, a não ser quando você cria
suas próprias classes personalizadas com variáveis de membro privadas. Não é possível criar
uma variável “somente leitura” no Flash.
As variáveis devem conter letras minúsculas ou letras minúsculas e maiúsculas. No entanto, as
constantes (variáveis que não se alteram) devem conter letras maiúsculas. Separe as palavras
com caracteres de sublinhado, conforme mostrado no ActionScript a seguir:
144
var BASE_URL:String = "http://www.macromedia.com"; //constant
var MAX_WIDTH:Number = 10;
//constant
Escreva as constantes estáticas em maiúsculas e separe as palavras com um sublinhado. Não
codifique diretamente constantes numéricas, a menos que a constante seja 1, 0 ou -1, que você
pode usar em um loop for como um valor de contador.
É possível usar constantes em situações nas quais é necessário fazer referência a uma
propriedade cujo valor nunca é alterado. Isso ajudará a detectar erros de digitação no código
que provavelmente não serão encontrados se você usar literais, além de permitir a alteração do
valor em um único local. Para obter mais informações sobre os literais, consulte “Sobre
literais” na página 138.
Por exemplo, a definição de classe no exemplo a seguir cria três constantes que seguem a
convenção de nomeação utilizada pelo ActionScript 2.0.
Para usar constantes em um aplicativo:
1.
do ActionScript) para criar um arquivo AS.
2.
Atribua o nome ConstExample.as ao novo arquivo.
3.
Digite o seguinte código na janela Script:
class ConstExample {
public static var EXAMPLE_STATIC:String = "Global access";
public var EXAMPLE_PUBLIC:String = "Public access";
private var EXAMPLE_PRIVATE:String = "Class access";
}
A propriedade EXAMPLE_STATIC é estática, o que significa que ela se aplica à classe como
um todo, e não a uma determinada instância da classe. Você deve acessar a propriedade
estática de uma classe usando o nome da classe, e não o nome de uma instância. Não é
possível acessar uma propriedade estática através de uma instância de classe.
4.
Crie um novo documento do Flash e salve-o como const.fla.
5.
Abra o painel Actions (Ações) e digite o código a seguir no Frame 1 (Quadro 1) da Timeline
(Linha de tempo):
trace(ConstExample.EXAMPLE_STATIC); // output: Global access
Ao declarar a propriedade EXAMPLE_STATIC como estática, você usa esse código para
acessar o valor da propriedade.
6.
Global access
7.
será exibido no painel Output (Saída).
No painel Actions, digite esse código após o código adicionado na etapa 5.
145
trace(ConstExample.EXAMPLE_PUBLIC); // error
trace(ConstExample.EXAMPLE_PRIVATE); // error
8.
As propriedades EXAMPLE_PUBLIC e EXAMPLE_PRIVATE não são estáticas. Quando você
tenta acessar os valores através da classe, recebe a seguinte mensagem de erro:
The property being referenced does not have the static attribute.
Para acessar uma propriedade não estática, acesse o valor através de uma instância da
classe. Como a propriedade EXAMPLE_PUBLIC é pública, ela está disponível para ser
codificada fora da definição da classe.
9.
No painel Actions, exclua as instruções trace adicionadas nas etapas 5 e 7.
10. Insira
o seguinte código no painel Actions:
var myExample:ConstExample = new ConstExample();
trace(myExample.EXAMPLE_PUBLIC); // output: Public access
Esse código cria a instância myExample e acessa a propriedade EXAMPLE_PUBLIC.
11.
Public access
12. No
13.
será exibido no painel Output.
painel Actions, exclua a instrução trace adicionada na etapa 10.
Insira o seguinte código no painel Actions:
trace(myExample.EXAMPLE_PRIVATE); // error
A propriedade EXAMPLE_PRIVATE é privada e, portanto, está disponível somente na
definição da classe.
14. Selecione
Control > Test Movie para testar o documento.
A mensagem The member is private and cannot be accessed (O membro é privado
e não pode ser acessado) será exibida no painel Output.
Para obter mais informações sobre as classes internas e sobre como criar classes
personalizadas, consulte Capítulo 7, “Classes”, na página 239.
Sobre palavras-chave
As palavras-chave são palavras do ActionScript que têm uma função específica. Por exemplo,
use a palavra-chave var para declarar uma variável. A palavra-chave var é mostrada na linha
de código a seguir:
146
Uma palavra-chave é uma palavra reservada que tem um significado específico: por exemplo,
use a palavra-chave class para definir uma nova classe do ActionScript e a palavra-chave var
para declarar variáveis locais. Estes são outros exemplos de palavras-chave reservadas: if, else,
this, function e return.
As palavras-chave não podem ser usadas como identificadores (como nomes de variável,
função ou rótulo) e você não deve usá-las em nenhum outro local dos arquivos FLA para
outros fins (como nomes de instância). Você já utilizou bastante a palavra-chave var,
principalmente se leu o Capítulo 4, “Dados e tipos de dados”, na página 75. O ActionScript
reserva palavras da linguagem para fins específicos. Portanto, não é possível usar palavraschave como identificadores (como nomes de variável, função ou rótulo). Essas palavras-chave
estão listadas em “Sobre palavras reservadas” na página 147.
Sobre palavras reservadas
As palavras reservadas são palavras que não podem ser utilizadas como identificadores no
código, pois elas estão reservadas para serem usadas pelo ActionScript. As palavras reservadas
são palavras-chave, que, por sua vez, são instruções e palavras do ActionScript reservadas para
uso futuro. Isso significa que você não deve usá-las para atribuir nomes a variáveis, instâncias,
classes personalizadas etc., pois isso pode acarretar problemas técnicos no seu trabalho.
A tabela a seguir lista as palavras-chave do Flash que ocasionam erros nos scripts:
add
and
break
case
catch
class
continue
default
delete
do
dynamic
else
eq
extends
finally
for
function
ge
get
gt
if
ifFrameLoaded
implements
import
in
instanceof
interface
intrinsic
le
lt
ne
new
not
on
onClipEvent
or
private
public
return
set
static
switch
tellTarget
this
throw
try
typeof
var
void
while
with
147
A tabela a seguir lista palavras-chave que são reservadas para uso futuro no ActionScript ou
pela especificação preliminar ECMAScript (ECMA-262) Edition 4. Evite também usar estas
palavras-chave no código:
abstract
enum
export
short
byte
long
synchronized
char
debugger
protected
double
volatile
float
throws
transient
goto
Todos os nomes de classe interna, classe de componente e interface são palavras reservadas e
não devem ser usados como identificadores no código:
Accessibility
Accordion
Alert
Array
Binding
Boolean
Button
Camera
CellRenderer
CheckBox
Collection
Color
ComboBox
ComponentMixins
ContextMenu
ContextMenuItem
CustomActions
CustomFormatter
CustomValidator
DataGrid
DataHolder
DataProvider
DataSet
DataType
Date
DateChooser
DateField
Delta
DeltaItem
DeltaPacket
DepthManager
EndPoint
Error
FocusManager
Form
Function
Iterator
Key
Label
List
Loader
LoadVars
LocalConnection
Log
Math
Media
Menu
MenuBar
Microphone
Mouse
MovieClip
MovieClipLoader
NetConnection
NetStream
Number
NumericStepper
Object
PendingCall
PopUpManager
PrintJob
ProgressBar
RadioButton
RDBMSResolver
Screen
ScrollPane
Selection
SharedObject
Slide
SOAPCall
Sound
Stage
String
StyleManager
System
TextArea
TextField
TextFormat
TextInput
TextSnapshot
TransferObject
Tree
TreeDataProvider
TypedValue
UIComponent
UIEventDispatcher
UIObject
Video
WebService
148
WebServiceConnector Window
XML
XMLConnector
XUpdateResolver
Diversas palavras, embora não sejam palavras reservadas, não devem ser usadas como
identificadores (como nomes de variável ou instância) no código do ActionScript. Essas
palavras são usadas pelas classes internas que compõem a linguagem ActionScript. Portanto,
não use nomes de propriedades, métodos, classes, interfaces, nomes de classe de componente e
valores como nomes no código (como acontece quando você atribui nomes a variáveis, classes
ou instâncias).
Para entender o que são esses nomes, consulte ActionScript 2.0 Language Reference (Referência
à linguagem ActionScript 2.0) e pesquise o painel Help (Ajuda) para obter instruções
adicionais e as seções de uso deste manual (Introdução ao ActionScript 2.0 no Flash).
Sobre instruções
Uma instrução é uma diretriz fornecida ao arquivo FLA para fazer algo; por exemplo, executar
uma ação específica. Você pode, por exemplo, utilizar uma instrução condicional para
determinar se algo é verdadeiro ou existe. Em seguida, o código poderá executar ações
especificadas, como funções ou expressões, de acordo com o status da condição, se verdadeira
ou não.
Por exemplo, a instrução if é condicional e avalia uma condição para determinar a próxima
ação a ser executada no código.
// if statement
if (condition) {
// statements;
}
Um outro exemplo é a instrução return, que retorna um resultado como valor da função em
que ela é executada.
Existem diversas maneiras de formatar ou escrever o ActionScript. A escrita do ActionScript
pode ser diferenciada através do modo como você forma a sintaxe; por exemplo, através da
maneira como você espaça as instruções ou do local em que insere as chaves ({}) no código.
Mesmo que haja diferentes formas de compor instruções sem interromper o código, existem
algumas diretrizes gerais que você pode seguir para escrever um ActionScript válido.
Coloque apenas uma instrução em uma linha para aumentar a legibilidade do
ActionScript.
O exemplo a seguir mostra o uso recomendado e não recomendado das
instruções:
Sobre instruções
149
theNum++;
// recommended
theOtherNum++; // recommended
aNum++; anOtherNum++; // not recommended
Atribua variáveis como instruções separadas.
Considere o seguinte exemplo do
ActionScript:
var myNum:Number = (a = b + c) + d;
Esse ActionScript incorpora uma atribuição no código, o que dificulta a leitura. Se você
atribuir variáveis como instruções separadas, isso melhorará a legibilidade, como mostra o
exemplo a seguir:
var a:Number = b + c;
var myNum:Number = a + d;
As seções a seguir mostram como compor instruções específicas no ActionScript. Para obter
informações sobre como escrever e formatar eventos, consulte Capítulo 10, “Manipulando
eventos”, na página 347.
Para obter mais informações sobre cada instrução, consulte os seguintes tópicos:
■
“Sobre instruções compostas” na página 150
■
“Sobre condições” na página 151
■
“Repetindo ações através de loops” na página 162
Sobre instruções compostas
Uma instrução composta contém diversas instruções delimitadas por chaves ({}). As
instruções dentro de uma instrução composta podem ser qualquer tipo de instrução do
ActionScript. Uma instrução composta típica é mostrada a seguir.
As instruções dentro de chaves são recuadas na instrução composta, como mostra o
ActionScript a seguir:
var a:Number = 10;
var b:Number = 10;
if (a == b) {
// This code is indented.
trace("a == b");
trace(a);
trace(b);
}
Essa instrução composta contém várias instruções, mas atua como se fosse uma instrução
única no código do ActionScript. A chave de abertura é colocada no final da instrução
composta. A chave de fechamento começa com uma linha e se alinha ao início da instrução
composta.
150
Para obter mais informações sobre como usar as chaves, consulte “Chaves” na página 133.
Sobre condições
Você usa as condições para determinar se algo é verdadeiro ou existe. Em seguida, se desejar,
pode repetir uma ação (usando loops) ou executar ações especificadas, como funções ou
expressões, com base no status da condição, se verdadeira ou não. Por exemplo, é possível
determinar se uma determinada variável é definida ou tem um valor específico e executar um
bloco de código com base no resultado. Além disso, é possível alterar os gráficos no
documento do Flash com base na hora do relógio do sistema do usuário ou nas condições
climáticas do local em que o usuário está no momento.
Para executar uma ação que dependa da existência de uma condição ou para repetir uma ação
(criar instruções de loop), use as instruções if, else, else if, for, while, do while,
for..in ou switch.
Para obter mais informações sobre quais condições você pode usar e sobre como escrevê-las,
consulte os seguintes tópicos:
■
“Sobre condições de escrita” na página 151
■
“Usando a instrução if ” na página 152
■
“Usando a instrução if..else” na página 153
■
“Usando a instrução if..else if ” na página 154
■
“Usando uma instrução switch” na página 156
■
“Usando as instruções try..catch e try..catch..finally” na página 158
■
“Sobre o operador condicional e a sintaxe alternativa” na página 160
Sobre condições de escrita
As instruções que verificam se uma condição é verdadeira ou falsa começam com o termo if.
Se a condição retornar true, o ActionScript executará a próxima instrução. Se a condição
retornar false, o ActionScript passará para a próxima instrução fora do bloco de código.
DICA
Para otimizar o desempenho do código, verifique as condições mais prováveis primeiro.
Sobre instruções
151
As instruções a seguir testam três condições. O termo else if especifica testes alternativos
que poderão ser executados se as condições anteriores forem falsas.
if ((passwordTxt.text.length == 0) || (emailTxt.text.length == 0)) {
gotoAndStop("invalidLogin");
} else if (passwordTxt.text == userID){
gotoAndPlay("startProgram");
}
Nesse trecho de código, se o tamanho dos campos de texto passwordTxt ou emailTxt for 0
(por exemplo, o usuário não digitou um valor), o documento do Flash será redirecionado para
o rótulo de quadro invalidLogin. Se os campos passwordTxt e emailTxt contiverem valores
e o conteúdo do campo de texto passwordTxt corresponder à variável userID, o arquivo SWF
será redirecionado para o rótulo de quadro startProgram.
Para procurar uma das diversas condições, use a instrução switch, em vez de várias instruções
else if. Para obter mais informações sobre as instruções switch, consulte “Usando uma
instrução switch” na página 156.
Consulte as seções a seguir para obter informações sobre como escrever diferentes tipos de
condições nos aplicativos ActionScript.
Usando a instrução if
Use a instrução if quando quiser executar uma série de instruções com base no status true de
uma determinada condição.
// if statement
if (condition) {
// statements;
}
Você terá diversas oportunidades de usar as instruções if enquanto estiver trabalhando em um
projeto do Flash. Por exemplo, se você estiver criando um site do Flash que exija que os
usuários façam login antes de acessar determinadas seções do site, use uma instrução if para
confirmar que o usuário digitará algum texto nos campos de nome de usuário e senha.
Caso seja necessário validar nomes de usuário e senhas usando um banco de dados externo,
provavelmente será preciso verificar se a combinação nome de usuário/senha utilizada por um
usuário corresponde a um registro no banco de dados. Também será necessário verificar se o
usuário tem permissão para acessar a parte especificada do site.
Se você criar scripts de animações no Flash, provavelmente usará a instrução if para testar se
uma instância no Stage (Palco) ainda está dentro dos limites do Stage. Por exemplo, se uma
bola se mover para baixo no eixo y, provavelmente será necessário detectar quando a bola
colidirá com a borda final do Stage, para que seja possível alterar a direção e a bola possa subir.
152
Para usar uma instrução if:
1.
2.
Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) e digite o seguinte
ActionScript no painel Actions (Ações):
// create a string to hold AM and PM
var amPm:String = "AM";
// no parameters pass to Date, so returns current date/time
var current_date:Date = new Date();
// if current hour is greater than/equal to 12, sets amPm string to "PM".
if (current_date.getHours() >= 12) {
amPm = "PM";
}
trace(amPm);
3.
Nesse código, você cria uma seqüência de caracteres que exibirá AM ou PM com base na
hora do dia. Se a hora atual for maior ou igual a 12, a seqüência de caracteres amPM será
definida para PM. Por fim, você rastreia a seqüência de caracteres amPm e, se a hora for
maior ou igual a 12, a sigla PM será exibida. Do contrário, a sigla AM será exibida.
Usando a instrução if..else
A instrução condicional if..else permitirá testar uma condição e, em seguida, executar um
bloco de código se a condição existir ou executar um bloco de código alternativo se a condição
não existir.
Por exemplo, o código a seguir testa se o valor x é maior que 20, gera uma instrução trace()
se o valor for maior que 20 ou gera uma instrução trace() diferente se valor não for maior
que 20:
if (x > 20) {
trace("x is > 20");
} else {
trace("x is <= 20");
}
Para executar um bloco de código alternativo, use a instrução if sem a instrução else.
Sobre instruções
153
A instrução if..else do Flash é semelhante à instrução if. Por exemplo, se você usar a
instrução if para confirmar se o nome de usuário e a senha fornecidos por um usuário
corresponde a um valor armazenado em um banco de dados, provavelmente será necessário
redirecionar o usuário com base na validade do nome de usuário e da senha. Se o login for
válido, redirecione o usuário para uma página de boas-vindas usando o bloco if. No entanto,
se o login for válido, redirecione o usuário para o formulário de login e exiba uma mensagem
de erro usando o bloco else.
Para usar a instrução if..else em um documento:
1.
(Documento do Flash) para criar um novo arquivo FLA.
2.
// create a string that holds AM/PM based on the time of day.
var amPm:String;
// no parameters pass to Date, so returns current date/time.
var current_date:Date = new Date();
// if current hour is greater than/equal to 12, sets amPm string to "PM".
if (current_date.getHours() >= 12) {
amPm = "PM";
} else {
amPm = "AM";
}
trace(amPm);
3.
Nesse código, você cria uma seqüência de caracteres que retém a sigla AM ou PM de acordo
com a hora do dia. Se a hora atual for maior ou igual a 12, a seqüência de caracteres amPM
será definida para PM. Por fim, você rastreia a seqüência de caracteres amPm e, se a hora for
maior ou igual a 12, a sigla PM será exibida. Do contrário, você verá a sigla AM no painel
Output (Saída).
Usando a instrução if..else if
É possível testar mais de uma condição usando a instrução condicional if..else if. A
seguinte sintaxe é utilizada em uma instrução if..else if:
// else-if statement
if (condition) {
// statements;
} else if (condition) {
// statements;
} else {
154
// statements;
}
Um bloco if..else if é utilizado nos projetos do Flash quando é necessário verificar uma
série de condições. Por exemplo, se você quiser exibir uma imagem diferente na tela com base
na hora do dia em que o usuário está acessando, crie uma série de instruções if que
determinarão se é de manhã cedo, de tarde, início da noite ou final da noite. Em seguida,
exiba um gráfico apropriado.
O código a seguir não somente testa se o valor x é maior que 20, mas também se o valor x é
negativo:
if (x > 20) {
trace("x is > 20");
} else if (x < 0) {
trace("x is negative");
}
Para usar uma instrução if..else if em um documento:
1.
2.
var now_date:Date = new Date();
var currentHour:Number = now_date.getHours();
// if the current hour is less than 11AM...
if (currentHour < 11) {
trace("Good morning");
// else..if the current hour is less than 3PM...
} else if (currentHour < 15) {
trace("Good afternoon");
// else..if the current hour is less than 8PM...
} else if (currentHour < 20) {
trace("Good evening");
// else the current hour is between 8PM and 11:59PM
} else {
trace("Good night");
}
3.
Nesse código, você cria uma seqüência de caracteres chamada currentHour que retém o
número da hora atual (por exemplo, se a hora for 18:19, currentHour reterá o número
18). Use o método getHours() da classe Date para obter a hora atual. Em seguida, use a
instrução if..else if para rastrear informações no painel Output (Saída), com base no
número retornado. Para obter mais informações, consulte os comentários no trecho de
código anterior.
Sobre instruções
155
Usando uma instrução switch
A instrução switch cria uma estrutura ramificada para as instruções do ActionScript. Assim
como a instrução if, a instrução switch testará uma condição e executará instruções se a
condição retornar um valor true.
Quando a instrução switch é utilizada, a instrução break solicita ao Flash que ignore o
restante das instruções do bloco case e passe para a primeira instrução após a instrução switch
delimitada. Se um bloco case não contiver uma instrução break, uma condição chamada “fall
through” será emitida. Nesse caso, a instrução case a seguir também será executada até que
uma instrução break seja encontrada ou que a instrução switch seja encerrada. Esse
comportamento é demonstrado no exemplo a seguir, onde a primeira instrução case não
contém uma instrução break e, portanto, os dois blocos de códigos dos dois primeiros casos (A
e B) são executados.
Todas as instruções switch devem incluir um caso default. O caso default deve sempre ser
o último em uma instrução switch e incluir uma instrução break para impedir que um erro
de anulação ocorra se outro caso for adicionado. Por exemplo, se a condição do exemplo a
seguir retornar A, as duas instruções dos casos A e B serão executadas, pois o caso A não possui
uma instrução break. Quando um caso é anulado, ele não possui uma instrução break, mas
inclui um comentário no local da instrução break (consulte o exemplo a seguir após o caso
A). Use o seguinte formato ao escrever instruções switch:
switch (condition) {
case A :
// statements
// falls through
case B :
// statements
break;
case Z :
// statements
break;
default :
// statements
break;
}
Para usar uma instrução switch em um documento:
1.
156
2.
var listenerObj:Object = new Object();
listenerObj.onKeyDown = function() {
// Use the String.fromCharCode() method to return a string.
switch (String.fromCharCode(Key.getAscii())) {
case "A" :
trace("you pressed A");
break;
case "a" :
trace("you pressed a");
break;
case "E" :
case "e" :
/* E doesn't have a break statement, so this block executes if you
press e or E. */
trace("you pressed E or e");
break;
case "I" :
case "i" :
trace("you pressed I or i");
break;
default :
/* If the key pressed isn’t caught by any of the above cases,
execute the default case here. */
trace("you pressed some other key");
}
};
Key.addListener(listenerObj);
3.
Digite letras usando o teclado, incluindo as teclas a, e ou i. Ao digitar essas três teclas, você
verá as instruções trace no ActionScript anterior. A linha de código cria um novo objeto
que será utilizado como ouvinte da classe Key. Use esse objeto para informar ao evento
onKeyDown() que o usuário pressionou uma tecla. O método Key.getAscii() retorna o
código ASCII da última tecla que o usuário pressionou ou liberou; portanto, é necessário
usar o método String.fromCharCode() para retornar uma seqüência de caracteres que
contém os caracteres representados pelos valores ASCII dos parâmetros. Como “E” não
possui uma instrução break, o bloco será executado se o usuário pressionar a tecla e ou E.
Se o usuário pressionar uma tecla que não seja abordada por nenhum dos três primeiros
casos, o caso padrão será executado.
Sobre instruções
157
Usando as instruções try..catch e try..catch..finally
Os blocos try..catch..finally permitem adicionar uma manipulação de erros aos
aplicativos do Flash. As palavras-chave try..catch..finally permitem delimitar o bloco de
códigos onde um erro pode ocorrer e responder a esse erro. Se algum código do bloco de
códigos try gerar um erro (através da instrução throw), o controle passará para o bloco
catch, se houver algum. Depois, o controle passará para o bloco de códigos finally, se
houver algum. O bloco finally opcional sempre é executado, independentemente da
geração de um erro.
Se o código do bloco try não gerar um erro (ou seja, se o bloco try for concluído
normalmente), ainda assim, o código do bloco finally será executado.
NO TA
O bloco finally será executado mesmo que o bloco try seja encerrado por uma instrução
return.
Escreva as instruções try..catch e try..catch..finally no seguinte formato:
// try-catch
try {
// statements
} catch (myError) {
// statements
}
// try-catch-finally
try {
// statements
} catch (myError) {
// statements
} finally {
// statements
}
Sempre que o código gerar um erro, você poderá escrever manipuladores personalizados para
lidar com esse erros e executar as ações apropriadas. Talvez seja necessário carregar dados
externos de um serviço da Web ou de um arquivo de texto ou exibir uma mensagem de erro
para o usuário final. Você pode, até mesmo, usar o bloco catch para tentar se conectar a um
serviço da Web que informe um administrador sobre um determinado erro, a fim de que ele
possa verificar o funcionamento do aplicativo.
Para usar o bloco try..catch..finally para validação de dados antes de dividir
alguns números:
1.
158
2.
var n1:Number = 7;
var n2:Number = 0;
try {
if (n2 == 0) {
throw new Error("Unable to divide by zero");
}
trace(n1/n2);
} catch (err:Error) {
trace("ERROR! " + err.toString());
} finally {
delete n1;
delete n2;
}
3.
4.
O painel Output (Saída) exibirá a mensagem Unable to divide by zero (Não é possível
dividir por zero).
5.
Retorne ao ambiente de criação e altere a seguinte linha de código:
var n2:Number = 0;
to
var n2:Number = 2;
6.
Selecione Control > Enter (Entrar) para testar o documento novamente.
Se o valor n2 for igual a zero, ocorrerá um erro, que será detectado pelo bloco catch e
resultará na exibição de uma mensagem no painel Output. Se o valor y não for igual a
zero, o painel Output exibirá o resultado de n1 dividido por n2. O bloco finally será
executado, independentemente da geração de um erro, e excluirá os valores das variáveis
n1 e n2 do documento do Flash.
Você não está limitado a gerar novas instâncias da classe Error quando ocorrer um erro. Você
poderá também estender a classe Error para criar erros personalizados, conforme demonstrado
no exemplo a seguir.
Para criar um erro personalizado:
1.
Selecione File > New e crie um novo arquivo do ActionScript.
2.
Selecione File > Save As (Salvar como) e atribua o nome DivideByZeroException.as ao
arquivo.
3.
Digite o seguinte ActionScript no painel Script:
// In DivideByZeroException.as:
class DivideByZeroException extends Error {
Sobre instruções
159
var message:String = "Divide By Zero error";
}
4.
Salve o arquivo do ActionScript.
5.
Crie um novo documento do Flash chamado exception_test.fla no mesmo diretório do
arquivo do ActionScript e salve o arquivo.
6.
Digite o seguinte ActionScript no painel Actions do Frame 1 da Timeline principal:
var n1:Number = 7;
var n2:Number = 0;
try {
if (n2 == 0) {
throw new DivideByZeroException();
} else if (n2 < 0) {
throw new Error("n2 cannot be less than zero");
} else {
trace(n1/n2);
}
} catch (err:DivideByZeroException) {
trace(err.toString());
} catch (err:Error) {
trace("An unknown error occurred; " + err.toString());
}
7.
Salve o documento do Flash e selecione Control > Test Movie para testar o arquivo no
ambiente de teste.
Como o valor de n2 é igual a 0, o Flash gera uma classe de erro personalizada
DivideByZeroException e exibe o erro Divide By Zero no painel Output. Se você
alterar o valor de n2 na segunda linha de 0 para -1 e testar novamente o documento do
Flash, verá a mensagem An unknown error occurred; n2 cannot be less than
zero (Erro desconhecido; n2 não pode ser menor que zero) no painel Output. A definição
do valor de n2 para qualquer número maior que 0 fará com que o resultado da divisão
apareça no painel Output. Para obter mais informações sobre como criar classes
personalizadas, consulte o Capítulo 7, “Classes”, na página 239.
Sobre o operador condicional e a sintaxe alternativa
Se quiser usar atalhos, poderá utilizar o operador condicional (?:), conhecido também como
expressões condicionais. O operador condicional permite converter instruções if..else
simples em uma única linha de código. O operador ajuda a diminuir o valor do código escrito
enquanto realiza a mesma tarefa, mas ele também tende a dificultar mais a leitura do
ActionScript.
A condição a seguir é escrita na forma extensa, verifica se a variável numTwo é maior que zero e
retorna o resultado numOne/numTwo ou a seqüência de caracteres carrot:
160
var numOne:Number = 8;
var numTwo:Number = 5;
if (numTwo > 0) {
trace(numOne / numTwo); // 1.6
} else {
trace("carrot");
}
Usando uma expressão condicional, você escreverá o mesmo código usando o seguinte
formato:
var numOne:Number = 8;
var numTwo:Number = 0;
trace((numTwo > 0) ? numOne/numTwo : "carrot");
Como pode ver, a sintaxe reduzida prejudica a legibilidade e, portanto, não é preferencial.
Caso precise usar operadores condicionais, coloque a condição inicial (antes do ponto de
interrogação [?]) entre parênteses. Isso ajudará a melhorar a legibilidade do ActionScript. O
código a seguir é um exemplo de ActionScript com melhor legibilidade:
var numOne:Number;
(numOne >= 5) ? numOne : -numOne;
É possível escrever uma instrução condicional que retorne um valor booleano, como mostra o
exemplo a seguir:
if (cartArr.length > 0) {
return true;
} else {
return false;
}
No entanto, se comparado ao código anterior, o ActionScript do exemplo a seguir será
preferencial:
return (cartArr.length > 0);
O segundo trecho é mais curto e tem menos expressões para avaliação, além de ser mais fácil
de ler e entender.
Ao escrever condições complexas, recomenda-se usar parênteses [()] para agrupar as
condições. Caso não use parênteses, você (ou outras pessoas que estejam usando o
ActionScript) poderá encontrar erros de precedência de operador. Para obter mais informações
sobre precedência de operador, consulte “Sobre associatividade e precedência de operadores”
na página 188.
Por exemplo, o código a seguir não usa parênteses ao redor da condição:
if (fruit == "apple" && veggie == "leek") {}
O código a seguir usa um formato adequado, delimitando as instruções entre parênteses:
if ((fruit == "apple") && (veggie == "leek")) {}
Sobre instruções
161
Repetindo ações através de loops
O ActionScript pode repetir uma ação um número especificado de vezes ou enquanto uma
condição específica existir. Os loops permitem repetir uma série de instruções quando uma
condição específica é true. Existem quatro tipos de loops no ActionScript: for, for..in,
while e do..while. Cada tipo de loop se comporta de um jeito e tem uma função diferente.
A maioria dos loops usa algum tipo de contador para controlar o número de execuções. Cada
execução de um loop é denominada iteração. Você pode declarar uma variável e escrever uma
instrução que aumente ou diminua a variável sempre que o loop for executado. Na ação for,
o contador e a instrução que aumenta a contagem fazem parte da ação.
Loop
Descrição
for
Repete uma ação usando um contador interno.
for..in
Itera os filhos de um clipe de filme ou objeto.
while
Repete uma ação enquanto uma condição existir.
do..while
É semelhante aos loops; a única diferença é que a expressão é avaliada
na parte inferior do bloco de códigos, para que o loop sempre seja
executado pelo menos uma vez.
O tipo de loop mais comum é o for, que é repetido em um bloco de códigos um número
predefinido de vezes. Por exemplo, se você tiver um array de itens e quiser executar uma série
de instruções em cada item do array, use um loop for e execute-o de 0 até o número de itens
do array. Um outro tipo de loop é o for..in, que pode ser muito útil quando é necessário
repetir cada combinação nome/valor de um objeto e executar algum tipo de ação. Isso poderá
ser útil quando você estiver depurando projetos do Flash e quiser exibir os valores carregados
de fontes externas, como serviços da Web ou arquivos de texto/XML externos. Os dois
últimos tipos de loops (while e do..while) são úteis quando é necessário executar uma
repetição em uma série de instruções mas você não sabe necessariamente quantas vezes precisa
fazer isso. Nesse caso, é possível usar um loop while que execute a repetição desde que uma
determinada condição seja verdadeira.
O ActionScript pode repetir uma ação um número especificado de vezes ou enquanto uma
condição específica existir. Use as ações while, do..while, for e for..in para criar loops.
Esta seção contém informações gerais sobre esses loops. Consulte os procedimentos a seguir
para obter mais informações sobre cada um desses loops.
Para repetir uma ação enquanto uma condição existir:
■
162
Use a instrução while.
Um loop while avaliará uma expressão e executará o código em seu corpo se a expressão
for true. Depois que cada instrução do corpo for executada, a expressão será avaliada
novamente. No exemplo a seguir, o loop é executado quatro vezes:
var i:Number = 4;
while (i > 0) {
myClip.duplicateMovieClip("newMC" + i, i, {_x:i*20, _y:i*20});
i--;
}
Você pode usar a instrução do...while para criar o mesmo tipo de loop que while. Em
um loop do..while, a expressão é avaliada na parte inferior do bloco de códigos, a fim de
que o loop sempre seja executado pelo menos uma vez.
Isso é mostrado no exemplo a seguir:
var i:Number = 4;
do {
i--;
} while (i > 0);
Para obter mais informações sobre a instrução while, consulte “Usando os loops while”
na página 169.
Para repetir uma ação usando um contador interno:
■
Use a instrução for.
A maioria dos loops usa algum tipo de contador para controlar o número de execuções.
Cada execução de um loop é denominada iteração. Você pode declarar uma variável e
escrever uma instrução que aumente ou diminua a variável sempre que o loop for
executado. Na ação for, o contador e a instrução que aumenta a contagem fazem parte da
ação.
No exemplo a seguir, a primeira expressão (var i:Number = 4) é a expressão inicial que é
avaliada antes da primeira iteração. A segunda expressão ( i > 0) é a condição que é
verificada sempre antes da execução do loop. A terceira expressão (i--) é denominada
expressão final e é avaliada sempre após a execução do loop.
for (var i:Number = 4; i > 0; i--) {
}
Para obter mais informações sobre a instrução for, consulte “Usando os loops for”
na página 166.
Sobre instruções
163
Para executar uma repetição nos filhos de um clipe de filme ou objeto:
■
Use a instrução for..in.
Os filhos são outros clipes de filme, funções, objetos e variáveis. O exemplo a seguir usa a
instrução trace para imprimir seus resultados no painel Output (Saída):
var myObject:Object = {name:'Joe', age:25, city:'San Francisco'};
var propertyName:String;
for (propertyName in myObject) {
trace("myObject has the property: " + propertyName + ", with the
value: " + myObject[propertyName]);
}
Este exemplo produz os seguintes resultados no painel Output:
myObject has the property: name, with the value: Joe
myObject has the property: age, with the value: 25
myObject has the property: city, with the value: San Francisco
Talvez seja necessário que o script itere um determinado tipo de filho; por exemplo, apenas
filhos de clipes de filme. Você pode fazer isso usando for..in com o operador typeof.
No exemplo a seguir, uma instância de clipe de filme filho (chamada instance2) está
dentro de um clipe de filme no Stage (Palco). Adicione o seguinte ActionScript ao Frame 1
(Quadro 1) da Timeline (Linha de tempo):
for (var myName in this) {
if (typeof (this[myName]) == "movieclip") {
trace("I have a movie clip child named " + myName);
}
}
Para obter mais informações sobre a instrução for..in, consulte “Usando os loops for..in”
na página 167.
A VI S O
As iterações do Flash são executadas rapidamente no Flash Player, mas os loops
dependem muito do processador. Quanto mais iterações um loop tem e quanto mais
instruções são executadas em cada bloco, mais recursos do processador são
consumidos. Loops escritos de modo insatisfatório podem ocasionar problemas de
desempenho e de estabilidade.
Para obter mais informações sobre cada instrução, consulte as seções individuais que
acompanham este capítulo, como “Usando os loops while” na página 169 e suas respectivas
entradas em ActionScript 2.0 Language Reference (Referência à linguagem ActionScript 2.0).
164
Sobre criação e término de loops
O exemplo a seguir mostra um array simples de nomes de meses. Um loop for é iterado de 0
até o número de itens do array e exibe cada item no painel Output.
var monthArr:Array = new Array("Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
var i:Number;
for (i = 0; i < monthArr.length; i++) {
trace(monthArr[i]);
}
Quando se trabalha com arrays, quer eles sejam simples ou complexos, é necessário conhecer
uma condição chamada loop infinito. O loop infinito, como o próprio nome já diz, é um loop
sem condição de término. Isso gera problemas, pois ocasiona falha no aplicativo Flash, faz
com que o documento do Flash pare de responder a um navegador da Web ou gera um
comportamento muito inconsistente do documento do Flash. O código a seguir é um
exemplo de loop infinito:
// BAD CODE- creates an infinite loop
// USE AT OWN RISK!
var i:Number;
for (i = 0; i < 10; i--) {
trace(i);
}
O valor de i é inicializado para 0 e a condição de término é atendida quando i é maior ou
igual a 10 e depois que cada iteração do valor de i é decrementada. É provável que o erro fique
imediatamente óbvio: se o valor de i diminuir após cada iteração do loop e a condição de
término nunca for atendida. Os resultados variam de acordo com o computador em que a
condição é executada. Além disso, a velocidade em que o código apresenta falha depende da
velocidade da CPU e de outros fatores. Por exemplo, o loop é executado aproximadamente
142.620 vezes antes de exibir uma mensagem de erro em um determinado computador.
A mensagem de erro a seguir é exibida em uma caixa de diálogo:
A script in this movie is causing Flash Player to run slowly. If it
continues to run, your computer may become unresponsive. Do you want to
abort the script?
Quando se trabalha com um loop (especialmente com os loops while e do..while), sempre
verifique se é possível encerrá-lo adequadamente (ou seja, se ele não é encerrado com um loop
infinito).
Para obter mais informações sobre como controlar loops, consulte “Usando uma instrução
switch” na página 156.
Sobre instruções
165
Usando os loops for
O loop for permite iterar uma variável de um intervalo específico de valores. O loop for é
útil quando você sabe exatamente quantas vezes precisa repetir uma série de instruções do
ActionScript. Isso será útil se for necessário duplicar um clipe de filme no Stage (Palco) um
determinado número de vezes ou repetir um array e executar uma tarefa em cada item desse
array. O loop for repete uma ação usando um contador interno. Em uma instrução for, o
contador e a instrução que incrementa o contador fazem parte da instrução for. Escreva a
instrução for usando o seguinte formato básico:
for (init; condition; update) {
// statements;
}
Você deve fornecer três expressões a uma instrução for: uma variável que é definida com um
valor inicial, uma instrução condicional que determina quando o loop terminará e uma
expressão que altera o valor da variável com cada loop. Por exemplo, o código a seguir se
repete cinco vezes. O valor da variável i começa em 0 e termina em 4. A saída da variável são
os números de 0 a 4, cada um na sua própria linha.
var i:Number;
for (i = 0; i < 5; i++) {
trace(i);
}
No exemplo a seguir, a primeira expressão (i = 0) é a expressão inicial que é avaliada antes da
primeira iteração. A segunda expressão (i < 5) é a condição que é verificada sempre antes da
execução do loop. A terceira expressão (i++) é denominada expressão final e é avaliada sempre
após a execução do loop.
Para criar um loop for:
1.
2.
Crie um clipe de filme no Stage.
3.
Clique com o botão direito do mouse no símbolo de clipe de filme do painel Library
(Biblioteca) e selecione Linkage (Vinculação) no menu contextual.
4.
Marque a caixa de seleção Export for ActionScript (Exportar para ActionScript) e digite
libraryLinkageClassName na caixa de entrada de texto Class (Classe). Clique em OK.
5.
var i:Number;
for (i = 0; i < 5; i++) {
166
this.attachMovie("libraryLinkageClassName", "clip" + i + "_mc", i,
{_x:(i * 100)});
}
6.
Selecione Control (Controlar) > Test Movie (Testar filme) para testar o código no Flash
Player.
Observe como cinco clipes de filme se duplicaram na parte superior do Stage. Esse
ActionScript duplica o símbolo de clipe de filme na biblioteca e reposiciona os clipes no
Stage nas coordenadas x de 0, 100, 200, 300 e 400 pixels. O loop é executado cinco vezes,
com a variável i definida com um valor de 0 a 4. Na última iteração do loop, o valor de i
é incrementado para 4 e a segunda expressão (i < 5) não é mais verdadeira, o que fará
com o loop seja encerrado.
Lembre-se de incluir um espaço após cada expressão em uma instrução for. Para obter mais
informações, consulte %{for statement}% em ActionScript 2.0 Language Reference
(Referência à linguagem ActionScript 2.0).
Usando os loops for..in
Use a instrução for..in para repetir (ou iterar) os filhos de um clipe de filme, as propriedades
de um objeto ou os elementos de um array. Os filhos, já mencionados anteriormente, são
outros clipes de filme, funções, objetos e variáveis. As funções comuns do loop for..in
incluem a repetição de instâncias em uma linha de tempo ou a repetição das combinações
chave/valor em um objeto. A repetição de objetos pode ser uma maneira eficaz de depurar
aplicativos, pois ela permite ver quais dados são retornados pelos serviços da Web ou
documentos externos, como arquivos de texto ou XML.
Por exemplo, é possível usar um loop for...in para iterar as propriedades de um objeto
genérico (as propriedades de objeto não são mantidas em nenhuma ordem específica; elas são
exibidas em uma ordem aleatória):
var myObj:Object = {x:20, y:30};
for (var i:String in myObj) {
trace(i + ": " + myObj[i]);
}
Esse código exibe o seguinte no painel Output (Saída):
x: 20
y: 30
É possível também iterar os elementos de um array:
var myArray:Array = ["one", "two", "three"];
for (var i:String in myArray) {
trace(myArray[i]);
}
Sobre instruções
167
Esse código exibe o seguinte no painel Output:
three
two
one
Object” na página 83.
NO T A
Não será possível iterar as propriedades de um objeto se ele for um instância de uma
classe personalizada, a menos que a classe seja dinâmica. Mesmo com instâncias de
classes dinâmicas, você pode iterar somente as propriedades adicionadas
dinamicamente.
NO TA
As chaves ({}) usadas para delimitar o bloco de instruções a ser executado pela
instrução for..in não serão necessárias se apenas uma instrução for executada.
O exemplo a seguir usa for..in para iterar as propriedades de um objeto:
Para criar um loop:
1.
2.
var myObj:Object = {name:"Tara", age:27, city:"San Francisco"};
var i:String;
for (i in myObj) {
trace("myObj." + i + " = " + myObj[i]);
}
3.
Selecione Control (Controlar) > Test Movie (Testar filme) para testar o código no Flash
Player.
Ao testar o arquivo SWF, você verá o seguinte texto no painel Output:
myObj.name = Tara
myObj.age = 27
myObj.city = San Francisco
Se você escrever um loop for..in em um arquivo de classe (um arquivo externo do
ActionScript), os membros de instância não estarão disponíveis no loop, mas os membros
estáticos estarão. No entanto, se você escrever um loop for..in em um arquivo FLA de uma
instância de classe, os membros de instância estarão disponíveis, mas os membros estáticos
não. Para obter mais informações sobre como escrever arquivos de classe, consulte Capítulo 7,
“Classes”, na página 239. Para obter mais informações, consulte %{for..in statement}% em
ActionScript 2.0 Language Reference (Referência à linguagem ActionScript 2.0)
168
Usando os loops while
Use a instrução while para repetir uma ação enquanto existir uma condição; ela é semelhante
à instrução if, que se repete contanto que a condição seja true.
Um loop while avaliará uma expressão e executará o código em seu corpo se a expressão for
true. Se a condição retornar true, uma instrução ou uma série de instruções será executada
antes que o loop reverso avalie a condição novamente. Quando a condição retornar false, a
instrução ou a série de instruções será ignorada e o loop terminará. O uso do loop while pode
ser útil quando você não tem certeza de quantas vezes precisará repetir um bloco de códigos.
Por exemplo, o código a seguir rastreia os números no painel Output (Saída):
var i:Number = 0;
while (i < 5) {
trace(i);
i++;
}
Você verá os seguintes números rastreados no painel Output:
0
1
2
3
4
Uma desvantagem do uso de um loop while, em vez de um loop for, é que os loops infinitos
são mais fáceis de serem gerados com os loops while. O código de exemplo do loop for não
será compilado se você omitir a expressão que incrementa a variável do contador, mas o
exemplo do loop while é compilado mesmo que essa etapa seja omitida. Sem a expressão que
incrementa i, o loop se torna um loop infinito.
Para criar e usar um loop while em um arquivo FLA, siga este exemplo.
Para criar um loop while:
1.
2.
Abra o painel Components (Componentes) e arraste um componente DataSet para o Stage
(Palco).
3.
Abra o Property inspector (Inspetor de propriedades) (Window (Janela) > Properties
(Propriedades) > Properties) e digite o nome de instância users_ds.
4.
var users_ds:mx.data.components.DataSet;
//
users_ds.addItem({name:"Irving", age:34});
Sobre instruções
169
users_ds.addItem({name:"Christopher", age:48});
users_ds.addItem({name:"Walter", age:23});
//
users_ds.first();
while (users_ds.hasNext()) {
trace("name:" + users_ds.currentItem["name"] + ", age:" +
users_ds.currentItem["age"]);
users_ds.next();
}
5.
As seguintes informações são exibidas no painel Output:
name:Irving, age:34
name:Christopher, age:48
name:Walter, age:23
Para obter mais informações, consulte %{while statement}% em ActionScript 2.0 Language
Reference (Referência à linguagem ActionScript 2.0).
Sobre loops do..while
Você pode usar a instrução do...while para criar o mesmo tipo de loop que while. No
entanto, a expressão é avaliada na parte inferior do bloco de códigos em um loop do..while
(ele é verificado depois que o bloco de códigos é executado), para que o loop sempre seja
executado pelo menos uma vez. As instruções são executadas apenas se a condição retornar
true.
O código a seguir mostra um exemplo simples de loop do..while que gera a saída mesmo
que a condição não seja atendida.
var i:Number = 5;
do {
trace(i);
i++;
} while (i < 5);
// Output: 5
Ao usar loops, é necessário evitar a criação de loops infinitos. Se a condição em um loop
do..while retornar continuamente true, um loop infinito será gerado e exibirá um aviso ou
travará o Flash Player. Use o loop for em vez disso, caso você sabia quantas vezes deseja
executar a repetição. Para obter mais informações sobre isso e exemplos de %{do..while
statement}%, consulte ActionScript 2.0 Language Reference (Referência à linguagem
ActionScript 2.0).
170
Usando loops aninhados no ActionScript
O exemplo a seguir demonstra como criar um array de objetos e exibir cada um dos valores na
estrutura aninhada. Este exemplo mostra como usar o loop for para repetir cada item do array
e como usar o loop for..in para iterar cada combinação chave/valor nos objetos aninhados.
Aninhando um loop dentro de outro loop:
1.
2.
Selecione File (Arquivo) > Save As (Salvar como) e atribua o nome loops.fla ao documento.
3.
Adicione o seguinte código ao Frame 1 (Quadro 1) da Timeline (Linha de tempo):
myArr[0] = {name:"One", value:1};
myArr[1] = {name:"Two", value:2};
//
var i:Number;
var item:String;
for (i = 0; i < myArr.length; i++) {
trace(i);
for (item in myArr[i]) {
trace(item + ": " + myArr[i][item]);
}
trace("");
}
4.
Selecione Control (Controlar) > Test Movie (Testar filme) para testar o código.
O seguinte será exibido no painel Output (Saída):
0
name: One
value: 1
1
name: Two
value: 2
Você sabe quantos itens há no array; portanto, pode repetir cada item usando um loop for
simples. Como cada objeto do array pode ter diferentes combinações nome/valor, é
possível usar um loop for..in para iterar cada valor e exibir os resultados no painel
Output.
Sobre instruções
171
Sobre arrays
Um array é um objeto cujas propriedades são identificadas por números que representam suas
posições dentro da estrutura. Basicamente, um array é uma lista de itens. É importante
lembrar que cada elemento de um array não precisa ter o mesmo tipo de dados. É possível
misturar números, datas, seqüências de caracteres e objetos, e até mesmo adicionar um array
aninhado em cada índice de arrays.
O exemplo a seguir é um array simples de nomes de meses.
myArr[0] = "January";
myArr[1] = "February";
myArr[2] = "March";
myArr[3] = "April";
O array anterior de nomes de meses também pode ser reescrito da seguinte maneira:
var myArr:Array = new Array("January", "February", "March", "April");
Uma outra alternativa é usar a sintaxe abreviada conforme mostrado a seguir:
var myArr:Array = ["January", "February", "March", "April"];
Um array é como uma estrutura de dados. É como um edifício comercial, onde cada andar
contém um tipo de dados diferente (como contabilidade no terceiro andar e engenharia no
quinto). Assim, é possível armazenar diferentes tipos de dados em um único array, incluindo
outros arrays. Cada andar desse prédio pode conter vários tipos de conteúdo (o executivo e a
contabilidade poderiam compartilhar o terceiro andar).
Um array contém elementos, que são equivalentes a cada andar do prédio. Cada elemento tem
uma posição numérica (o índice), que é como você indica a posição de cada elemento no array.
É semelhante ao número dos andares de um prédio. Cada elemento pode conter uma parte
dos dados (que pode ser um número, uma seqüência de caracteres, um valor booleano ou, até
mesmo, um array ou objeto) ou ficar vazio.
É possível também controlar e modificar o próprio array. Por exemplo, talvez seja necessário
mover o departamento de engenharia para o térreo do prédio. Os arrays permitem que você
mova os valores e altere o tamanho do array (digamos que ele permite renovar o prédio e
adicionar ou remover andares). Assim, é possível adicionar ou remover elementos e mover
valores para vários elementos.
Portanto, o prédio (o array) contém andares (os elementos), que são numerados (o índice), e
cada andar contém um ou mais departamentos (os valores).
172
Para obter mais informações sobre como modificar arrays, consulte “Sobre modificação de
arrays” na página 175. Para obter informações sobre como usar arrays e sobre os índices,
consulte “Usando arrays” na página 173. Para obter informações sobre como adicionar e
remover elementos, consulte “Sobre adição e remoção de elementos” na página 177. Para
obter informações sobre o operador de acesso de array, consulte “Usando operadores de ponto
e de acesso de array” na página 194.
Na pasta Samples do disco rígido, há um arquivo de exemplo de origem chamado array.fla.
Esse exemplo ilustra a manipulação de arrays usando o ActionScript. O código do exemplo
cria um array e classifica, adiciona e remove itens de dois componentes List. Localize o arquivo
de exemplo nos diretórios a seguir:
■
No Windows, vá para a unidade de inicialização\Program Files\Macromedia\Flash
8\Samples e Tutorials\Samples\ActionScript\Arrays.
■
No Macintosh, vá para Macintosh HD/Applications/Macromedia Flash 8/Samples e
Tutorials/Samples/ActionScript/Arrays.
Usando arrays
Existem diversas maneiras de usar os arrays. Utilize-os para armazenar listas de objetos, como
um grupo de itens retornados. Se você carregar dados dos servidores Web remotos, é provável
que receba até mesmo dados como um array de objetos aninhados. Geralmente, os arrays
contêm dados em um formato similar. Por exemplo, se você criar um aplicativo de áudio no
Flash, provavelmente terá a lista de reprodução de um usuário armazenada como um array de
informações de música, armazenada nos objetos. Cada objeto contém o nome da música, o
nome do artista, a duração da música, o local de um arquivo de som (como um MP3) ou
quaisquer outras informações que precisem ser associadas a um determinado arquivo.
O local de um item em um array chama-se índice. Todos os arrays começam com zero, o que
significa que o seu primeiro elemento é [0], o segundo é [1] e assim sucessivamente.
Existem diferentes tipos de arrays, que você descobrirá nas seções a seguir. Os arrays mais
comuns usam um índice numérico para pesquisar um determinado item em um array
indexado. O segundo tipo de array chama-se array associativo e usa um índice de texto, em vez
de um índice numérico, para pesquisar informações. Para obter mais informações sobre os
arrays comuns, consulte “Sobre arrays” na página 172. Para obter mais informações sobre os
arrays associativos, consulte “Criando arrays associativos” na página 181. Para obter mais
informações sobre as matrizes, consulte “Criando matrizes” na página 178. Para obter
informações sobre o operador de acesso de array, consulte “Usando operadores de ponto e de
acesso de array” na página 194.
Sobre arrays
173
A classe Array interna permite acessar e manipular arrays. Para criar um objeto Array, use o
construtor new Array() ou o operador de acesso de array ([]). Para acessar os elementos de
um array, use também o operador de acesso de array ([]). O exemplo a seguir usa um array
indexado.
Para usar arrays no código:
1.
Crie um novo documento do Flash e salve-o como basicArrays.fla.
2.
Adicione o seguinte ActionScript ao Frame 1 (Quadro 1) da Timeline (Linha de tempo):
// define a new array
// define values at two indexes
myArr[1] = "value1";
myArr[0] = "value0";
// iterate over the items in the array
var i:String;
for (i in myArr) {
// trace the key/value pairs
trace("key: " + i + ", value: " + myArr[i]);
}
Na primeira linha do ActionScript, defina um novo array para reter os valores. Em
seguida, defina dados (value0 e value1) nos dois índices do array. Use um loop for..in
para iterar cada um dos itens desse array e exibir as combinações chave/valor no painel
Output (Saída) usando uma instrução trace.
3.
O seguinte texto será exibido no painel Output:
key: 0, value: value0
key: 1, value: value1
Para obter mais informações sobre os loops for..in, consulte “Usando os loops for..in”
na página 167.
Para obter informações sobre como criar diferentes tipos de arrays, consulte as seguintes
seções:
■
“Criando arrays indexados” na página 178
■
“Criando matrizes” na página 178
■
“Criando arrays associativos” na página 181
174
■
■
Sobre modificação de arrays
É possível também controlar e modificar o array usando o ActionScript. Você pode mover
valores em torno de um array ou alterar o tamanho do array. Por exemplo, se você quiser
trocar dados nos dois índices de um array, use o código a seguir:
var buildingArr:Array = new Array();
buildingArr[2] = "Accounting";
buildingArr[4] = "Engineering";
trace(buildingArr); // undefined,undefined,Accounting,undefined,Engineering
var temp_item:String = buildingArr[2];
buildingArr[2] = buildingArr[4];
buildingArr[4] = temp_item;
trace(buildingArr); // undefined,undefined,Engineering,undefined,Accounting
Talvez seja necessário saber porque é preciso criar uma variável temporária no exemplo
anterior. Se você copiou o conteúdo do índice de array 4 no índice de array 2 e vice-versa, o
conteúdo original do índice de array 2 se perderá. Ao copiar o valor de um dos índices de array
em uma variável temporária, é possível salvar o valor e copiá-lo com segurança de volta para o
código posteriormente. Por exemplo, se você usar o código a seguir, verá que o valor do índice
de array 2 (Accounting) se perdeu. Agora, você tem duas equipes de engenharia, mas
nenhuma de contabilidade.
// wrong way (no temporary variable)
trace(buildingArr); //
undefined,undefined,Engineering,undefined,Engineering
■
■
Sobre arrays
175
Sobre referência e localização de tamanho
Quando você trabalha com arrays, geralmente precisa saber quantos itens existem no array.
Isso pode ser muito útil durante a criação de loops for que iteram cada elemento do array e
executam uma série de instruções. Veja um exemplo no trecho a seguir:
trace(monthArr); // Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec
trace(monthArr.length); // 12
var i:Number;
for (i = 0; i < monthArr.length; i++) {
monthArr[i] = monthArr[i].toUpperCase();
}
trace(monthArr); // JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC
No exemplo anterior, você cria um array e o preenche com nomes de meses. O conteúdo e o
tamanho do array é exibido. O loop for itera cada item do array e converte o valor em
maiúsculas. Depois, o conteúdo do array é exibido novamente.
No ActionScript a seguir, se você criar um elemento no índice de array 5, o tamanho do array
retornará 6 (já que o array começa sempre com zero), em vez do número real de itens do array,
conforme seria o esperado:
myArr[5] = "five";
trace(myArr.length); // 6
trace(myArr); // undefined,undefined,undefined,undefined,undefined,five
Para obter mais informações sobre os loops for, consulte “Usando os loops for”
na página 166. Para obter informações sobre o operador de acesso de array, consulte “Usando
operadores de ponto e de acesso de array” na página 194.
■
■
176
Sobre adição e remoção de elementos
Um array contém elementos e cada elemento tem uma posição numérica (o índice), que é a
maneira utilizada para indicar a posição de cada elemento no array. Cada elemento pode reter
uma parte dos dados ou ficar vazio. Um elemento pode reter os seguintes dados: um número,
uma seqüência de caracteres ou, até mesmo, um array ou objeto.
Ao criar elementos em um array, crie os índices seqüencialmente sempre que possível. Isso será
útil na depuração dos aplicativos. Em “Sobre referência e localização de tamanho”
na página 176, você viu que, se atribuir um único valor em um array no índice 5, o tamanho
do array será retornado como 6. Isso fará com que cinco valores indefinidos sejam inseridos no
array.
O exemplo a seguir demonstra como criar um novo array, excluir um item em um
determinado índice, e adicionar e substituir dados em um índice do array:
delete monthArr[5];
trace(monthArr); // Jan,Feb,Mar,Apr,May,undefined,Jul,Aug,Sep,Oct,Nov,Dec
trace(monthArr.length); // 12
monthArr[5] = "JUN";
trace(monthArr); // Jan,Feb,Mar,Apr,May,JUN,Jul,Aug,Sep,Oct,Nov,Dec
Mesmo que você tenha excluído o item no índice de array 5, o tamanho do array ainda será 12
e o item no índice de array 5 será alterado para uma seqüência de caracteres em branco, em vez
de desaparecer completamente.
■
■
Sobre arrays
177
Criando arrays indexados
Os arrays indexados armazenam uma série de um ou mais valores. É possível pesquisar os itens
por sua posição no array, que é o que você poderia ter feito nas seções anteriores. O primeiro
índice é sempre o número 0. Ele é incrementado em um em cada elemento subseqüente que
você adiciona ao array. É possível criar um array indexado chamando o construtor de classe
Array ou inicializando o array com um literal de array. Crie arrays usando o construtor Array e
um literal de array no próximo exemplo.
Para criar um array indexado:
1.
Crie um novo documento do Flash e salve-o como indexArray.fla.
2.
var myArray:Array = new Array();
myArray.push("one");
myArray.push("two");
myArray.push("three");
trace(myArray); // one,two,three
Na primeira linha do ActionScript, defina um novo array para reter os valores.
3.
O seguinte texto será exibido no painel Output (Saída):
one,two,three
4.
Retorne à ferramenta de criação e exclua o código do painel Actions (Ações).
5.
var myArray:Array = ["one", "two", "three"];
trace(myArray); // one,two,three
Nesse código, você usará o literal de array para definir um novo array para o código. Esse
código equivale ao ActionScript escrito na etapa 2. Durante o teste do código, a mesma
saída aparece no painel Output.
Criando matrizes
No ActionScript, é possível implementar arrays como arrays aninhados, que são basicamente
arrays de arrays. Os arrays aninhados, também conhecidos como matrizes, podem ser
considerados grades. Portanto, durante a programação, você provavelmente usará matrizes
para modelar esses tipos de estruturas. Por exemplo, um tabuleiro de xadrez é uma grade de
oito colunas e linhas. Você pode modelar esse tabuleiro como um array com oito elementos,
cada um deles contendo também um array com oito elementos.
178
Por exemplo, considere uma lista de tarefas armazenadas como um array indexado de
seqüências de caracteres:
var tasks:Array = ["wash dishes", "take out trash"];
Para armazenar uma lista separada de tarefas para cada dia da semana, crie um matriz com um
elemento para cada dia da semana. Cada elemento contém um array indexado que armazena a
lista de tarefas.
A T E NÇ ÃO
Quando você usa o operador de acesso de array, o compilador do ActionScript não
pode verificar se o elemento acessado é uma propriedade válida do objeto.
Para criar uma matriz básica e recuperar elementos no array:
1.
Crie um novo documento do Flash e salve-o como multiArray1.fla.
2.
var twoDArray:Array = new Array(new Array("one","two"), new
Array("three", "four"));
trace(twoDArray);
Esse array, o twoDArray, consiste em dois elementos de array. Esses elementos são arrays
compostos por dois elementos. Nesse caso, twoDArray é o array principal que contém dois
arrays aninhados.
3.
Selecione Control (Controlar) > Test Movie (Testar filme) para testar o código. O seguinte
será exibido no painel Output (Saída):
one,two,three,four
4.
Retorne ao ambiente de criação e abra o painel Actions (Ações). Insira um comentário na
instrução trace, conforme mostrado a seguir:
// trace(twoDArray);
5.
Adicione o seguinte ActionScript ao final do código no Frame 1 da Timeline:
trace(twoDArray[0][0]); // one
trace(twoDArray[1][1]); // four
Para recuperar elementos de uma matriz, use vários operadores de acesso de array ([]) após
o nome do array de nível superior. O primeiro [] refere-se ao índice do array de nível
superior. Os operadores de acesso de array subseqüentes referem-se aos elementos dos
arrays aninhados.
6.
Selecione Control > Test Movie para testar o código. O seguinte será exibido no painel
Output:
one
four
Sobre arrays
179
É possível usar loops for aninhados para criar matrizes. O exemplo a seguir mostrará como
fazer isso.
Para criar uma matriz usando um loop for:
1.
2.
var gridSize:Number = 3;
var mainArr:Array = new Array(gridSize);
var i:Number;
var j:Number;
for (i = 0; i < gridSize; i++) {
mainArr[i] = new Array(gridSize);
for (j = 0; j < gridSize; j++) {
mainArr[i][j] = "[" + i + "][" + j + "]";
}
}
trace(mainArr);
Esse ActionScript cria um array 3 x 3 e define o valor de cada nó de array com seu índice.
Em seguida, você rastreia o array (mainArr).
3.
Selecione Control > Test Movie para testar o código.
O seguinte será exibido no painel Output:
[0][0],[0][1],[0][2],[1][0],[1][1],[1][2],[2][0],[2][1],[2][2]
Também é possível usar loops for aninhados para iterar os elementos de uma matriz,
conforme mostrado no exemplo a seguir.
Para usar um loop for para iterar uma matriz:
1.
2.
// from previous example
var gridSize:Number = 3;
var mainArr:Array = new Array(gridSize);
var i:Number;
var j:Number;
for (i = 0; i < gridSize; i++) {
mainArr[i] = new Array(gridSize);
for (j = 0; j < gridSize; j++) {
mainArr[i][j] = "[" + i + "][" + j + "]";
}
}
Nesse código, conforme mostrado no exemplo anterior, o loop externo itera cada elemento
de mainArray. O loop interno itera cada array aninhado e retorna cada nó de array.
180
3.
Adicione o seguinte ActionScript ao Frame 1 da Timeline, seguindo o código digitado na
etapa 2:
// iterate through elements
var outerArrayLength:Number = mainArr.length;
for (i = 0; i < outerArrayLength; i++) {
var innerArrayLength:Number = mainArr[i].length;
for (j = 0; j < innerArrayLength; j++) {
trace(mainArr[i][j]);
}
}
Esse ActionScript itera os elementos do array. Use a propriedade length de cada array
como condição do loop.
4.
Selecione Control > Test Movie para exibir os elementos mostrados no painel Output. O
seguinte será exibido no painel Output:
[0][0]
[0][1]
[0][2]
[1][0]
[1][1]
[1][2]
[2][0]
[2][1]
[2][2]
Para obter informações sobre como usar os arrays, consulte o “Usando arrays” na página 173.
Para obter informações sobre os elementos do array, consulte “Sobre adição e remoção de
elementos” na página 177. Para obter informações sobre o operador de acesso de array,
consulte “Usando operadores de ponto e de acesso de array” na página 194.
Criando arrays associativos
Um array associativo, que é como um objeto, é composto de chaves e valores fora de ordem. Os
arrays associativos usam chaves, em vez de um índice numérico, para organizar os valores
armazenados. Cada chave é uma seqüência exclusiva. Ela é associada a um valor e usada para
acessá-lo. Esse valor pode ser um tipo de dados, como Number, Array, Object etc. Ao criar um
código para localizar um valor associado a uma chave, você está indexando ou executando
uma pesquisa. É por isso que você usará arrays associativos na maioria das vezes.
Sobre arrays
181
A associação entre uma chave e um valor é geralmente chamada de vinculação. A chave e o
valor são mapeados entre si. Por exemplo, um livro de contatos poderia ser considerado um
array associativo, onde os nomes são as chaves e os endereços de e-mail são os valores.
NO TA
Os arrays associativos são coleções de combinações chave/valor dispostas fora de
ordem. O código não deve esperar que as chaves de um array associativo sejam
exibidas em uma ordem específica.
Ao usar arrays associativos, você pode chamar o elemento de array necessário usando uma
seqüência de caracteres em vez de um número, que é geralmente mais fácil de memorizar. A
desvantagem é que esses arrays não são tão úteis em um loop porque não utilizam números
como valor de índice. Eles são úteis quando é necessário realizar freqüentemente a pesquisa
por valores de chave. Por exemplo, se você tivesse um array de nomes e idades que precisasse
utilizar com muita freqüência, seria recomendável usar um array associativo.
O exemplo a seguir demonstra como criar um objeto e definir uma série de propriedades em
um array associativo.
Para criar um array associativo simples:
1.
2.
Digite o seguinte ActionScript no Frame 1 (Quadro 1) da Timeline (Linha de tempo):
// Define the object to use as an associative array.
var someObj:Object = new Object();
// Define a series of properties.
someObj.myShape = "Rectangle";
someObj.myW = 480;
someObj.myH = 360;
someObj.myX = 100;
someObj.myY = 200;
someObj.myAlpha = 72;
someObj.myColor = 0xDFDFDF;
// Display a property using dot operator and array access syntax.
trace(someObj.myAlpha); // 72
trace(someObj["myAlpha"]); // 72
A primeira linha do ActionScript define um novo objeto (someObj) que é utilizado como
array associativo. Depois disso, você define uma série de propriedades em someObj. Por
fim, você exibe uma propriedade selecionada através do operador de ponto e da sintaxe de
acesso de array.
N O TA
3.
182
É possível acessar variáveis em um array associativo usando dois métodos diferentes:
sintaxe de ponto (someObj.myColor) e sintaxe de array (someObj[‘myColor’]).
O painel Output (Saída) exibe o número 72 duas vezes, que representa os dois níveis alfa
rastreados.
Existem duas maneiras de criar arrays associativos no ActionScript 2.0:
■
Usando um construtor Object
■
Usando um construtor Array
Essas duas maneiras são demonstradas nos exemplos a seguir.
NO T A
O exemplo anterior utilizou um construtor Object para criar um array associativo.
Se você usar o construtor Object para criar um array associativo, poderá tirar proveito da
inicialização do array com um literal de objeto. Uma instância da classe Object, também
chamada de objeto genérico, é funcionalmente idêntica a um array associativo. Na verdade, as
instâncias Object são basicamente arrays associativos. Recomenda-se usar arrays associativos
nas funcionalidades semelhantes a dicionário, nas quais é mais conveniente ter chaves de
seqüência de strings em vez de índices numéricos. Cada nome de propriedade do objeto
genérico atua como a chave que fornece acesso a um valor armazenado. Para obter mais
informações sobre os literais, consulte “Sobre literais” na página 138. Para obter mais
informações sobre as classes, consulte Capítulo 7, “Classes”, na página 239.
Para criar um array associativo usando um construtor Object:
1.
Crie um novo documento do Flash e salve-o como assocArray.fla.
2.
var monitorInfo:Object = {type:"Flat Panel", resolution:"1600 x 1200"};
trace(monitorInfo["type"] + ", " + monitorInfo["resolution"]);
Esse código cria um array associativo chamado monitorInfo e usa um literal de objeto
para inicializar o array com duas combinações chave/valor.
N OT A
Se não for necessário inicializar o array no momento da declaração, use o construtor
Object para criar o array:
var monitorInfo:Object = new Object();
3.
Selecione Control > Test Movie.
O painel Output exibirá o seguinte:
Flat Panel, 1600 x 1200
Sobre arrays
183
4.
Adicione o seguinte ActionScript ao Frame 1 da Timeline (após o código digitado
anteriormente):
monitorInfo["aspectRatio"] = "16:10";
monitorInfo.colors = "16.7 million";
trace(monitorInfo["aspectRatio"] + ", " + monitorInfo.colors);
Depois que você usar um literal de objeto ou o construtor de classe Object para criar o
array, será possível adicionar novos valores ao array usando o operador de colchetes ([]) ou
o operador de ponto (.), conforme demonstrado nesse código. O código que você acabou
de digitar adiciona dois novos valores ao array monitorInfo.
5.
O painel Output exibirá o seguinte texto:
16:10, 16.7 million
Observe que uma chave pode conter um caractere de espaço. Isso é possível com o
operador de colchetes, mas gerará um erro se você tentar isso com o operador de ponto. O
uso de espaços nos nomes de chave não é recomendado. Para obter mais informações sobre
os operadores de colchetes e operadores de ponto, consulte “Sobre operadores”
na página 185. Para obter mais informações sobre o código formatado corretamente,
consulte “Formatando a sintaxe do ActionScript” na página 799.
A segunda maneira de criar um array associativo é usar o construtor Array e o operador de
colchetes ([]) ou o operador de ponto (.) para adicionar as combinações chave/valor ao array.
Se você declarar o array associativo para ser do tipo Array, não é possível usar um literal de
objeto para inicializar o array.
NO T A
Não há nenhuma vantagem em usar o construtor Array para criar um array associativo.
O construtor Array é melhor para criar arrays indexados.
O próximo exemplo demonstra como usar o construtor Array para criar um array associativo.
Para criar um array associativo usando um construtor Array:
1.
Crie um novo documento do Flash e salve-o como assocArray2.fla.
2.
var monitorInfo:Array = new
monitorInfo["type"] = "Flat
monitorInfo["resolution"] =
trace(monitorInfo["type"] +
Array();
Panel";
"1600 x 1200";
", " + monitorInfo["resolution"]);
Esse código cria um array associativo chamado monitorInfo usando o construtor Array e
adiciona uma chave chamada type e outra denominada resolution, junto com seus
respectivos valores.
184
3.
Flat Panel, 1600 x 1200
N OT A
Não há nenhuma vantagem em usar o construtor Array para criar um array
associativo. O construtor Array é melhor para criar arrays indexados.
Os arrays associativos são basicamente instâncias da classe Object e não existe nenhuma
vantagem em criar arrays associativos com o construtor Array. Mesmo que você crie um array
associativo com o construtor new Array(), não poderá usar nenhum método e propriedade
da classe Array (como sort() ou length) ao utilizar um array associativo. Para usar
combinações chave/valor em vez de índice numérico, use a classe Object em vez de um array
associativo.
Sobre operadores
Esta seção descreve regras gerais sobre tipos comuns, precedência e associatividade de
operadores.
Os operadores são caracteres que especificam como combinar, comparar ou alterar valores em
uma expressão. Uma expressão é qualquer instrução que o Flash possa avaliar e que retorne
um valor. Você pode criar uma expressão combinando operadores e valores ou chamando uma
função. Para obter mais informações sobre as expressões, consulte “Sobre sintaxe, instruções e
expressões” na página 120.
Por exemplo, uma expressão matemática usa operadores numéricos para manipular os valores
utilizados. Como exemplos de caracteres de operador, pode-se citar +, <, * e =. Uma expressão
consiste em operadores e operandos, os quais são qualquer combinação legal de símbolos do
ActionScript que representam um valor. Um operando é a parte do código na qual o operador
executa ações. Por exemplo, na expressão x + 2, x e 2 são operandos e + é um operador.
As expressões e os operadores são utilizados com freqüência no código. É possível combinar
operadores e valores para criar uma expressão e, ainda, chamar uma função.
N O TA
Esta seção descreve como usar cada tipo de operador. No entanto, não haverá tempo
de discutir cada um deles. Para obter informações sobre cada operador, incluindo os
operadores especiais que não se enquadram nas categorias a seguir, consulte
ActionScript 2.0 Language Reference (Referência à linguagem ActionScript 2.0).
Sobre operadores
185
As partes do código em que o operador executa ações são chamadas de operandos. Por
exemplo, você pode usar o operador de adição (+) para somar valores de um literal numérico.
Você pode fazer isso para somar o valor de uma variável chamada myNum.
myNum + 3;
Neste exemplo, myNum e 3 são operandos.
Esta seção descreve regras gerais sobre tipos comuns, precedência e associatividade de
operadores:
■
“Usando operadores para manipular valores” na página 187
■
“Sobre associatividade e precedência de operadores” na página 188
■
“Sobre uso de operadores com seqüências de caracteres” na página 192
■
“Usando operadores de ponto e de acesso de array” na página 194
■
“Sobre operadores pós-fixados” na página 196
■
“Sobre operadores unários” na página 197
■
“Sobre operadores multiplicativos” na página 197
■
“Sobre operadores aditivos” na página 198
■
“Usando operadores numéricos” na página 198
■
“Sobre operadores relacionais” na página 200
■
“Sobre operadores de igualdade” na página 200
■
“Usando operadores relacionais e de igualdade” na página 200
■
“Sobre operadores de atribuição” na página 204
■
“Usando operadores de atribuição” na página 204
■
“Sobre operadores lógicos” na página 205
■
“Usando operadores lógicos” na página 206
■
“Sobre operadores de deslocamento bit a bit” na página 207
■
“Sobre operadores lógicos bit a bit” na página 208
■
“Usando operadores bit a bit” na página 208
■
“Sobre o operador condicional” na página 210
■
“Usando operadores em um documento” na página 210
Para obter informações sobre os operadores que não se enquadram nessas categorias, consulte
ActionScript 2.0 Language Reference (Referência à linguagem ActionScript 2.0), que contém
informações sobre todos os operadores que podem ser utilizados.
As seções a seguir mostram algumas funções comuns dos operadores. Para obter mais
informações sobre como usar vários operadores em um único exemplo de código, consulte
“Usando operadores em um documento” na página 210.
186
Usando operadores para manipular valores
Os operadores são geralmente utilizados para manipular valores no Flash. Por exemplo, você
poderia criar um jogo no Flash onde o placar mudasse de acordo com a interação do usuário
com as instâncias no Stage (Palco). Use uma variável para reter o valor e os operadores para
manipular o valor da variável.
Por exemplo, você poderia aumentar o valor de uma variável chamada myScore. O exemplo a
seguir demonstra como usar os operadores + (adição) e += (atribuição de adição) para somar e
incrementar valores no código.
Para manipular valores usando os operadores:
1.
2.
Abra o painel Actions (Ações) (Window (Janela) > Actions) e digite o código a seguir no
painel Script:
// example one
var myScore:Number = 0;
myScore = myScore + 1;
trace("Example one: " + myScore); // 1
// example two
var secondScore:Number = 1;
secondScore += 3;
trace("Example two: " + secondScore); // 4
3.
Selecione Control (Controlar) > Test Movie (Testar filme).
O painel Output (Saída) exibirá o seguinte texto:
Example one: 1
Example two: 4
O operador de adição é fácil de compreender, pois soma dois valores. No primeiro
exemplo de código, ele soma o valor atual de myScore com o número 1. Depois, armazena
o resultado na variável myScore.
O segundo exemplo de código usa o operador de atribuição de adição para somar e atribuir
um novo valor em uma única etapa. É possível reescrever a linha myScore = myScore + 1
(no exercício anterior) como myScore++ ou, até mesmo, myScore += 1. O operador de
incremento (++) é um modo simplificado de dizer myScore = myScore + 1, pois ele
manipula um incremento e uma atribuição simultaneamente. Veja um exemplo do operador
de incremento no ActionScript a seguir:
myNum++;
trace(myNum); // 1
myNum++;
trace(myNum); // 2
Sobre operadores
187
Observe que o trecho de código anterior não tem operadores de atribuição. Em vez disso, ele
se baseia no operador de incremento.
É possível manipular o valor de uma variável usando operadores quando uma condição é
true. Por exemplo, você poderá usar o operador de incremento (++) para incrementar a
variável i enquanto a condição for true. No código a seguir, a condição será true enquanto i
for menor que 10. Enquanto a condição for true, você incrementará i em um número mais
alto usando i++.
var i:Number;
for (i = 1; i < 10; i++) {
trace(i);
}
O painel Output exibirá os números de 1 a 9, que é a incrementação da variável i até chegar à
condição de término (i é igual a 10), e parará. O último valor exibido é 9. Portanto, o valor de
i será 1 quando o arquivo SWF começar a ser executado e 9 depois que o rastreamento for
concluído.
Para obter mais informações sobre as condições e os loops, consulte “Sobre instruções”
na página 149.
Sobre associatividade e precedência de operadores
Quando dois ou mais operadores são utilizados em uma instrução, alguns deles têm
precedência sobre outros. A precedência e associatividade de operador determinam a ordem
em que os operadores são processados. O ActionScript tem uma hierarquia que determina
quais operadores serão executados primeiro. No final desta seção, há uma tabela que descreve
essa hierarquia.
Embora possa parecer natural para os usuários familiarizados com a aritmética ou a
programação básica que o compilador processe o operador de multiplicação (*) antes do
operador de adição (+), o compilador precisa de instruções explícitas sobre quais operadores
devem ser processados primeiro. Essas instruções são conhecidas como precedência de operador.
Você verá um exemplo de precedência de operador quando estiver trabalhando com os
operadores de multiplicação e adição:
var mySum:Number;
mySum = 2 + 4 * 3;
trace(mySum); // 14
Observe que a saída dessa instrução é 14, pois a multiplicação tem uma precedência de
operador mais alta. Portanto, 4 * 3 e avaliado primeiro e o resultado é somado com o número
2.
188
É possível determinar o que acontecerá delimitando as expressões entre parênteses. O
ActionScript define uma precedência de operador padrão que pode ser alterada através dos
parênteses (()). Quando uma expressão de adição é colocada entre parênteses, o ActionScript
executa a adição primeiro:
var mySum:Number;
mySum = (2 + 4) * 3;
trace(mySum); // 18
Agora, a saída dessa instrução será 18.
Os operadores também podem ter a mesma precedência. Nesse caso, a associatividade
determinará a ordem em que os operadores serão executados. A associatividade pode ser da
esquerda para a direita ou da direita para a esquerda.
Observe o operador de multiplicação novamente. Ele tem uma associatividade da esquerda
para a direita; portanto, as duas instruções a seguir são idênticas.
var mySum:Number;
var myOtherSum:Number;
mySum = 2 * 4 * 3;
myOtherSum = (2 * 4) * 3;
trace(mySum); // 24
trace(myOtherSum); // 24
Dois ou mais operadores de mesma precedência podem aparecer na mesma expressão. Nesses
casos, o compilador usa as regras de associatividade para determinar qual operador deve ser
processado primeiro. Todos os operadores binários, exceto os de atribuição, possuem a
associatividade da esquerda para direita, o que significa que os operadores da esquerda são
processados antes dos operadores da direita. Os operadores de atribuição e o operador
condicional (?:) possuem a associatividade da direita para a esquerda, o que significa que os
operadores da direita são processados antes dos operadores da esquerda. Para obter mais
informações sobre os operadores de atribuição, consulte “Usando operadores de atribuição”
na página 204. Para obter mais informações sobre o operador condicional (?:), consulte
“Sobre o operador condicional” na página 210.
Por exemplo, considere os operadores de sinal de menor (<) e sinal de maior (>), que possuem
a mesma precedência. Se esses dois operadores forem utilizados na mesma expressão, o
operador da esquerda será processado primeiro porque ambos possuem a associatividade da
esquerda para direita. Isso significa que as duas instruções a seguir produzem a mesma saída:
trace(3 > 2 < 1);
// false
trace((3 > 2) < 1); // false
Sobre operadores
189
O operador maior que (>) é processado primeiro, o que resultará em um valor true porque o
operando 3 é maior que o operando 2. Em seguida, o valor true é passado para o operador
menor que (<), junto com o operando 1. O operador menor que (<) converte o valor true no
valor numérico 1 e compara esse valor numérico com o segundo operando 1 para retornar o
valor false (o valor 1 não é menor que 1).
Considere a ordem dos operandos no ActionScript, particularmente quando você estiver
configurando condições complexas e souber a freqüência em que uma dessas condições se
apresenta como true. Por exemplo, se você souber que i será maior que 50 na sua condição,
será necessário escrever i<50 primeiro. Portanto, isso será verificado primeiro, para que a
segunda condição a ser escrita não precise ser verificada com tanta freqüência.
A tabela a seguir lista todos os operadores do ActionScript e sua associatividade, da
precedência mais alta para a mais baixa. Para obter mais informações e diretrizes sobre como
usar os operadores e os parênteses, consulte Capítulo 19, “Formatando a sintaxe do
ActionScript”, na página 799.
Operador
Descrição
Associatividade
Precedência mais alta
x++
Pós-incremento
Esquerda para
direita
x--
Pós-decremento
Esquerda para
direita
.
Acesso de propriedade de objeto
Esquerda para
direita
[ ]
Elemento de array
Esquerda para
direita
( )
Parênteses
Esquerda para
direita
function ( )
Chamada de função
Esquerda para
direita
++x
Pré-incremento
Direita para
esquerda
--x
Pré-decremento
Direita para
esquerda
-
Negação unária, como x = -1
Esquerda para
direita
~
NOT bit a bit
Direita para
esquerda
190
Operador
Descrição
Associatividade
!
NOT lógico
Direita para
esquerda
new
Alocar objeto
Direita para
esquerda
delete
Desalocar objeto
Direita para
esquerda
typeof
Tipo de objeto
Direita para
esquerda
void
Retorna um valor indefinido
Direita para
esquerda
*
Multiplicar
Esquerda para
direita
/
Dividir
Esquerda para
direita
%
Módulo
Esquerda para
direita
+
Mais unário
Direita para
esquerda
-
Menos unário
Direita para
esquerda
<<
Deslocamento para esquerda bit a bit
Esquerda para
direita
>>
Deslocamento para direita bit a bit
Esquerda para
direita
>>>
Deslocamento para direita bit a bit (sem sinal)
Esquerda para
direita
instanceof
Instância de (localiza a classe da qual o objeto é
uma instância)
Requer Flash Player 6 ou posterior
Esquerda para
direita
<
Menor que
Esquerda para
direita
<=
Menor ou igual a
Esquerda para
direita
>
Maior que
Esquerda para
direita
Sobre operadores
191
Operador
Descrição
Associatividade
>=
Maior ou igual a
Esquerda para
direita
==
Igual a
Esquerda para
direita
!=
Diferente de
Esquerda para
direita
&
AND bit a bit
Esquerda para
direita
^
XOR bit a bit
Esquerda para
direita
|
OR bit a bit
Esquerda para
direita
&&
AND lógico
Esquerda para
direita
||
OR lógico
Esquerda para
direita
?:
Condicional
Direita para
esquerda
=
Atribuição
Direita para
esquerda
*=, /=, %=, +=, =, &=, |=, ^=,
<<=, >>=, >>>=
Atribuição composta
Direita para
esquerda
,
Vírgula
Esquerda para
direita
Precedência mais baixa
Sobre uso de operadores com seqüências de
caracteres
Os operadores de comparação só compararão seqüências de caracteres se os dois operandos
forem seqüências de caracteres. Uma exceção a essa regra é o operador de igualdade estrita
(===). Se apenas um operando for uma seqüência de caracteres, o ActionScript converterá
ambos os operandos em números e executará uma comparação numérica. Para obter mais
informações sobre os operadores numéricos, consulte “Usando operadores numéricos”
na página 198.
192
Com exceção do operador de igualdade (==), os operadores de comparação (>, >=, < e <=)
afetam seqüências de caracteres de maneira diferente quando operam em outros valores.
Os operadores de comparação comparam seqüências de caracteres para determinar qual virá
primeiro pela ordem alfabética. As seqüências de caracteres em maiúsculas têm precedência
sobre as seqüências de caracteres em minúsculas. Isso significa que o "Egg" vem antes de
"chicken".
var c:String = "chicken";
var e:String = "Egg";
trace(c < e); // false
var riddleArr:Array = new Array(c, e);
trace(riddleArr); // chicken,Egg
trace(riddleArr.sort()); // Egg,chicken
Nesse ActionScript, o método sort() da classe Array reordena o conteúdo do array em ordem
alfabética. Observe que o valor “Egg” vem antes de “chicken” porque o E maiúsculo vem antes
do c minúsculo. Para comparar as seqüências de caracteres independentemente do uso de
maiúsculas e minúsculas, é necessário converter as seqüências de caracteres em maiúsculas ou
minúsculas antes de compará-las. Para obter mais informações sobre os operadores de
comparação, consulte “Sobre operadores de igualdade” na página 200 e “Usando operadores
relacionais e de igualdade” na página 200.
É possível usar os métodos toLowerCase() ou toUpperCase() para converter as seqüências
de caracteres e deixá-las com o mesmo uso de maiúsculas e minúsculas antes que elas sejam
comparadas. No exemplo a seguir, as duas seqüências de caracteres são convertidas em
minúsculas e comparadas. Agora, "chicken" virá antes de "egg":
var c:String = "chicken";
var e:String = "Egg";
trace(c.toLowerCase() < e.toLowerCase()); // true
NO T A
Os operadores de comparação comparam apenas duas seqüências de caracteres. Por
exemplo, os operadores não compararão os valores se um operando for um valor
numérico. Se apenas um dos operandos for uma seqüência de caracteres, o
ActionScript converterá ambos os operandos em números e executará uma
comparação numérica.
É possível usar operadores para manipular seqüências de caracteres. Use o operador de adição
(+) para concatenar operandos de seqüências de caracteres. Talvez você já tenha usado o
operador de adição para concatenar seqüências de caracteres ao escrever instruções trace. Por
exemplo, você poderia escrever o seguinte:
trace("The variable is " +
myNum + ".");
Sobre operadores
193
Após o teste do código, o painel Output (Saída) exibirá o seguinte:
The variable is 10.
No exemplo a seguir, a instrução trace usa o operador + para concatenar, e não para somar.
Quando você está trabalhando com seqüências de caracteres e números, o Flash, algumas
vezes, concatena em vez de somar numericamente.
Por exemplo, é possível concatenar duas seqüências de caracteres de diferentes variáveis em um
único campo de texto. No código ActionScript a seguir, a variável myNum é concatenada com
uma seqüência de caracteres, que, por sua vez, é exibida no campo de texto myTxt do Stage
(Palco).
myTxt.text = "One carrot. " + myNum + " large eggplants.";
myTxt.text += " Lots of vegetable broth.";
Esse código retorna o seguinte em um campo de texto com o nome de instância myTxt:
One carrot. 10 large eggplants. Lots of vegetable broth.
O exemplo anterior mostrou como é possível usar os operadores de adição (+) e atribuição de
adição (+=) para concatenar seqüências de caracteres. Observe como a terceira linha do código
usa o operador de adição para concatenar o valor da variável myNum no campo de texto e como
a quarta linha do código usa o operador de atribuição de adição para concatenar uma
seqüência de caracteres no valor existente do campo de texto.
Se apenas um dos operandos de seqüência de texto for uma seqüência de caracteres, o Flash
converterá o outro operando em seqüência de caracteres. Portanto, o valor de myNum será
convertido em seqüência de caracteres no exemplo anterior.
NO T A
O ActionScript trata os espaços no começo ou final de uma seqüência de caracteres
como uma parte literal dessa seqüência.
Usando operadores de ponto e de acesso de array
É possível usar o operador de ponto (.) e o operador de acesso de array ([]) para acessar
propriedades internas ou personalizadas do ActionScript. Use os operadores de ponto para
referenciar determinados índices em um objeto. Por exemplo, se um objeto contiver alguma
informação do usuário, especifique um determinado nome de chave no operador de acesso de
array para recuperar o nome de um usuário, conforme demonstrado no ActionScript a seguir:
var someUser:Object = {name:"Hal", id:2001};
trace("User's name is: " + someUser["name"]); // User's name is: Hal
trace("User's id is: " + someUser["id"]); // User's id is: 2001
194
Por exemplo, o ActionScript a seguir usa o operador de ponto para definir determinadas
propriedades dentro dos objetos:
myTextField.border = true;
year.month.day = 9;
myTextField.text = "My text";
Os operadores de ponto e de acesso de array são muito parecidos. O operador de ponto utiliza
um identificador como propriedade, mas o operador de acesso de array retorna o conteúdo
como nome e acessa o valor desse nome de propriedade. O operador de acesso de array
permite definir e recuperar dinamicamente nomes de instância e variáveis.
O operador de acesso de array será útil ser você não souber exatamente quais chaves estão em
um objeto. Quando isso ocorrer, use o loop for..in para iterar um objeto ou clipe de filme e
exibir seu conteúdo.
Para usar os operadores de ponto e de acesso de array:
1.
Em um novo documento do Flash, crie um clipe de filme na Timeline (Linha de tempo)
principal.
2.
Selecione o clipe de filme e abra o Property inspector (Inspetor de propriedades).
3.
Digite o nome de instância myClip.
4.
Adicione o seguinte ActionScript ao Frame 1 (Quadro 1) da Timeline:
myClip.spam = 5;
trace(myClip.spam); // 5
Para definir um valor na instância myClip da linha de tempo atual, use os operadores de
ponto ou de acesso de array, conforme demonstrado nesse ActionScript. Se você escrever
uma expressão dentro do operador de acesso de array, ele a avaliará primeiro e usará o
resultado como nome da variável.
5.
O painel Output (Saída) exibirá o número 5.
6.
Retorne ao ambiente de criação e substitua a primeira linha do ActionScript pelo seguinte:
myClip["spam"] = 10;
7.
O painel Output exibirá o número 10.
8.
Retorne ao ambiente de criação e clique duas vezes na instância myClip.
9.
Adicione quatro novas instâncias a myClip.
10. Use
o Property inspector para adicionar os seguintes nomes de instância a cada uma das
quatro instâncias: nestedClip1, nestedClip2, nestedClip3, nestedClip4.
Sobre operadores
195
11.
Adicione o seguinte código ao Frame 1 da Timeline principal:
var i:Number;
for (i = 1; i <= 4; i++) {
myClip["nestedClip" + i]._visible = false;
}
Esse ActionScript alternará a visibilidade de cada clipe de filme aninhado.
12. Selecione
Control > Test Movie para testar o ActionScript recém-adicionado.
Agora as quatro instâncias aninhadas não estão mais visíveis. Você está usando o operador
de acesso de array para iterar cada clipe de filme aninhado na instância myClip e definir
sua propriedade visível dinamicamente. Isso economizará tempo porque não é necessário
referenciar especificamente cada instância.
Também é possível usar o operador de acesso de array que fica no lado esquerdo de uma
atribuição, o que permitirá definir dinamicamente a instância, a variável e os nomes de objeto:
myNum[i] = 10;
No ActionScript 2.0, é possível usar o operador de colchetes para acessar propriedades em um
objeto criado dinamicamente, caso a definição de classe desse objeto não receba o atributo
dynamic. Também é possível criar matrizes através desse operador. Para obter mais
informações sobre como criar matrizes com operadores de acesso de array, consulte “Criando
matrizes” na página 178.
Sobre operadores pós-fixados
Os operadores pós-fixados utilizam um operador e incrementam ou decrementam o valor
desse operador. Embora esses operadores sejam unários, eles não são classificados junto com os
demais operadores unários, pois têm uma precedência mais alta e um comportamento
especial. Para obter informações sobre os operadores unários, consulte “Sobre operadores
unários” na página 197.
Quando um operador pós-fixado é utilizado como parte de uma expressão maior, o valor da
expressão é retornado antes do processamento do operador pós-fixado. Por exemplo, o código
a seguir mostra como o valor da expressão xNum++ é retornado antes que ele seja
incrementado.
var xNum:Number = 0;
trace(xNum++); // 0
trace(xNum); // 1
Quando esse código é rastreado, o texto exibido no painel Output (Saída) é o seguinte:
0
1
196
Os operadores desta tabela possuem a mesma precedência:
Operador
Operação executada
++
Incremento (pós-fixado)
--
Decremento (pós-fixado)
Sobre operadores unários
Os operadores unários utilizam um operando. Os operadores de incremento (++) e
decremento (--) desse grupo são operadores pré-fixados; isso significa que eles aparecerão antes
do operando em uma expressão. Eles também podem aparecer depois do operando; nesse
caso, eles serão operadores pós-fixados. Para obter informações sobre os operadores pós-fixados,
consulte “Sobre operadores pós-fixados” na página 196.
Os operadores pré-fixados diferem dos pós-fixados porque o operador de incremento ou
decremento é concluído antes que o valor da expressão geral seja retornado. Por exemplo, o
código a seguir mostra como o valor da expressão xNum++ é retornado depois que ele é
incrementado.
var xNum:Number = 0;
trace(++xNum); // 1
trace(xNum); // 1
Todos os operadores desta tabela possuem a mesma precedência:
Operador
++
Incremento (pré-fixado)
--
Decremento (pré-fixado)
+
+ unário
!
- unário (negação)
typeof
Retorna informações de tipo
void
Retorna um valor indefinido
Sobre operadores multiplicativos
Os operadores multiplicativos usam dois operandos e executam cálculos de multiplicação,
divisão ou módulo. Outros operadores numéricos incluem operadores aditivos. Para obter
informações sobre os operadores aditivos, consulte “Sobre operadores aditivos” na página 198.
Sobre operadores
197
Todos os operadores desta tabela possuem a mesma precedência:
Operador
*
Multiplicação
/
Divisão
%
Módulo
Para obter informações sobre como usar os operadores multiplicativos, consulte “Usando
operadores numéricos” na página 198.
Sobre operadores aditivos
Os operadores aditivos utilizam dois operandos e executam cálculos de adição ou subtração.
Outros operadores numéricos incluem operadores multiplicativos. Para obter informações
sobre os operadores multiplicativos, consulte “Sobre operadores multiplicativos”
na página 197.
Os operadores desta tabela possuem a mesma precedência:
Operador
+
Adição
-
Subtração
Para obter informações sobre como usar operadores aditivos, consulte “Usando operadores
numéricos” na página 198.
Usando operadores numéricos
Use operadores numéricos para adicionar, subtrair, dividir e multiplicar valores no
ActionScript. É possível executar vários tipos de operações aritméticas. Um dos operadores
mais comuns é o operador de incremento, geralmente formado como i++. Esse operador tem
outras funções. Para obter mais informações sobre o operador de incremento, consulte
“Usando operadores para manipular valores” na página 187.
É possível adicionar o incremento antes (pré-incremento) ou depois (pós-incremento) de um
operando.
198
Para compreender os operadores numéricos no ActionScript:
1.
2.
// example one
var firstScore:Number = 29;
if (++firstScore >= 30) {
// should trace
trace("Success! ++firstScore is >= 30");
}
// example two
var secondScore:Number = 29;
if (secondScore++ >= 30) {
// shouldn't trace
trace("Success! secondScore++ is >= 30");
}
3.
O bloco de códigos “Example one” rastreia, mas o bloco de códigos “Example two” não. O
primeiro exemplo usa um pré-incremento (++firstScore) para incrementar e calcular
firstScore antes que ele seja testado em relação ao número 30. Portanto, firstScore é
incrementado em 30 e, em seguida, testado em relação a esse número.
Entretanto, Example two usa um pós-incremento (secondScore++), que é avaliado após a
execução do teste. Portanto, 29 é comparado com 30 e incrementado em 30 após a
avaliação.
Para obter mais informações sobre a precedência de operador, consulte “Sobre associatividade
e precedência de operadores” na página 188.
Ao carregar dados de fontes externas (como arquivos XML, FlashVars, serviços da Web etc.), é
preciso ter cuidado ao trabalhar com operadores numéricos. Às vezes, o Flash trata os números
como seqüências de caracteres, pois o arquivo SWF não conhece o tipo de dados do número.
Nesse caso, você pode adicionar 3 e 7 para obter o resultado 37, pois os dois números são
concatenados como seqüências de caracteres, em vez de serem somados numericamente. Nesse
caso, é necessário converter manualmente os dados das seqüências de caracteres em números
através da função Number().
Sobre operadores
199
Sobre operadores relacionais
Os operadores relacionais utilizam dois operandos, comparam seus valores e retornam um
valor booleano. Todos os operadores desta tabela possuem a mesma precedência:
Operador
<
Menor que
>
Maior que
<=
Menor ou igual a
>=
Maior ou igual a
instanceof
Verifica a cadeia de protótipos
in
Procura propriedades de objeto
Para obter informações sobre como usar os operadores relacionais, consulte “Usando
operadores relacionais e de igualdade” na página 200.
Sobre operadores de igualdade
Os operadores de igualdade utilizam dois operandos, comparam seus valores e retornam um
valor booleano. Todos os operadores desta tabela possuem a mesma precedência:
Operador
==
Igualdade
!=
Diferença
===
Igualdade estrita
!==
Diferença estrita
Para obter informações sobre como usar operadores de igualdade, consulte “Usando
operadores relacionais e de igualdade” na página 200.
Usando operadores relacionais e de igualdade
Os operadores relacionais e de igualdade, também chamados de operadores de comparação,
comparam os valores das expressões e retornam true ou false (um valor booleano).
Geralmente, os operadores de comparação são utilizados em loops e instruções condicionais
para especificar a condição aplicável no momento em que o loop deve parar.
200
Use o operador de igualdade (==) para determinar se os valores ou as referências dos dois
operandos são iguais e se essa comparação retornará um valor booleano. Os operandos de
seqüência de caracteres, números ou valores booleanos são comparados através de um valor.
Os operandos de objeto e array são comparados através de uma referência.
Neste exemplo, veja como usar o operador de igualdade para testar o tamanho do array e
exibir uma mensagem no painel Output (Saída) caso não haja itens no array.
if (myArr.length == 0) {
trace("the array is empty.");
}
Quando você seleciona Control (Controlar) > Test Movie (Testar filme), a seqüência de
caracteres the array is empty aparece no painel Output.
É possível usar o operador de igualdade para comparar valores, mas não para definir valores.
Tente usar o operador de atribuição (=) para verificar a igualdade.
Para usar os operadores relacionais e de igualdade no código:
1.
2.
if (myNum == 2) {
// do something
trace("It equals 2");
}
Nesse ActionScript, use o operador de igualdade (==) para verificar a igualdade. Verifique
se a variável myNum é igual a 2.
3.
A seqüência de caracteres It equals 2 aparece no painel Output.
4.
Retorne ao ambiente de criação e altere:
para:
5.
Selecione Control > Test Movie novamente.
A seqüência de caracteres It equals 2 não aparece no painel Output.
6.
Retorne ao ambiente de criação e altere:
if (myNum == 2) {
para
if (myNum = 2) {
Sobre operadores
201
7.
Selecione Control > Test Movie novamente.
A seqüência de caracteres It equals 2 aparece no painel Output novamente.
Na etapa 6, você atribui o valor 2 a myNum, em vez de comparar myNum com 2. Nesse caso,
a instrução if é executada independente do valor anterior de myNum, o que pode gerar
resultados inesperados durante o teste do documento do Flash.
Para obter mais informações sobre como utilizar corretamente o operador de atribuição,
consulte “Usando operadores de atribuição” na página 204.
O operador de igualdade estrita (===) é similar ao operador de igualdade; a única diferença é
que ele não realiza a conversão de tipo. Se dois operandos forem de tipos diferentes, o
operador de igualdade retornará false. O operador de diferença estrita (!==) retorna o
resultado oposto ao do operador de igualdade estrita.
O ActionScript a seguir demonstra a diferença-chave entre o operador de igualdade (==) e o
operador de igualdade estrita (===):
var num1:Number = 32;
var num2:String = new String("32");
trace(num1 == num2); // true
trace(num1 === num2); // false
Primeiro, você define as variáveis numéricas: num1 enum2. Se você comparar as variáveis
usando o operador de igualdade, o Flash tentará converter os valores no mesmo tipo de dados
e, em seguida, comparará esses valores para constatar se são iguais. Quando o operador de
igualdade estrita (===) é utilizado, o Flash não tenta realizar nenhuma conversão de tipo de
dados antes de comparar os valores. Conseqüentemente, o Flash considera as variáveis como
dois valores separados.
No exemplo a seguir, você usará o operador de maior ou igual a (>=) para comparar valores e
executar o código com base no valor digitado por um usuário em um campo de texto.
Para usar o operador de maior ou igual a no código:
1.
(Documento do Flash) para criar um arquivo FLA.
2.
Adicione o seguinte código ao Frame 1 da Timeline principal:
myTxt.type = "input";
myTxt.border = true;
myTxt.restrict = "0-9";
this.createEmptyMovieClip("submit_mc", 30);
submit_mc.beginFill(0xFF0000);
submit_mc.moveTo(0, 0);
submit_mc.lineTo(100, 0);
202
submit_mc.endFill();
submit_mc._x = 110;
submit_mc.onRelease = function(evt_obj:Object):Void {
var myNum:Number = Number(myTxt.text);
if (isNaN(myNum)) {
trace("Please enter a number");
return;
}
if (myNum >= 10) {
trace("Your number is greater than or equal to 10");
} else {
trace("Your number is less than 10");
}
};
3.
Selecione Control > Test Movie para testar o ActionScript.
Também é possível verificar se determinadas condições são verdadeiras e executar um
bloco alternativa se a condição não for verdadeira.
4.
Altere a condição no ActionScript da seguinte maneira.
if (myNum == 10) {
trace("Your number is 10");
} else {
trace("Your number is not 10");
}
5.
Selecione Control > Test Movie para testar o ActionScript novamente.
Com exceção do operador de igualdade estrita (===), os operadores de comparação
compararão seqüências de caracteres somente se os operandos forem seqüências de caracteres.
Se apenas um dos operandos for uma seqüência de caracteres, os dois operandos serão
convertidos em números e executarão uma comparação numérica. Para obter mais
informações sobre as seqüências de caracteres e os operadores, consulte “Sobre uso de
operadores com seqüências de caracteres” na página 192. Para obter informações sobre como a
ordem e a precedência de operador afetam o ActionScript, consulte “Sobre associatividade e
precedência de operadores” na página 188.
Sobre operadores
203
Sobre operadores de atribuição
Os operadores de atribuição utilizam dois operandos e atribuem um valor a um operando com
base no valor do outro operando. Todos os operadores desta tabela possuem a mesma
precedência:
Operador
=
Atribuição
*=
Atribuição de multiplicação
/=
Atribuição de divisão
%=
Atribuição de módulo
+=
Atribuição de adição
-=
Atribuição de subtração
<<=
Atribuição de deslocamento para esquerda bit a bit
>>=
Atribuição de deslocamento para direita bit a bit
>>>=
Atribuição de deslocamento para direita bit a bit (sem sinal)
&=
Atribuição AND bit a bit
^=
Atribuição XOR bit a bit
|=
Atribuição OR bit a bit
Para obter informações sobre como usar operadores de atribuição, consulte “Usando
operadores de atribuição” na página 204.
Usando operadores de atribuição
Use o operador de atribuição (=) para atribuir um determinado valor a uma variável. Para
atribuir uma seqüência de caracteres a uma variável, faça o seguinte:
var myText:String = "ScratchyCat";
Também é possível usar o operador de atribuição para atribuir diversas variáveis na mesma
expressão. Na instrução a seguir, o valor 10 é atribuído às variáveis numOne, numTwo e
numThree.
var numOne:Number;
var numTwo:Number;
var numThree:Number;
numOne = numTwo = numThree = 10;
204
Também é possível usar operadores de atribuição composta para combinar operações. Esses
operadores são executados nos dois operandos e, depois, atribuem o novo valor ao primeiro
operando. Por exemplo, essas duas instruções desempenham a mesma função:
myNum += 15;
myNum = myNum + 15;
Ao trabalhar com o operador de atribuição, você poderá ter problemas se tentar somar os
valores de uma expressão, conforme mostrado no exemplo a seguir:
trace("the sum of 5 + 2 is: " + 5 + 2); // the sum of 5 + 2 is: 52
O Flash concatena os valores 5 e 2, em vez de somá-los. Para resolver isso, coloque a expressão
5+2 entre parênteses, conforme mostrado no código a seguir:
trace("the sum of 5 + 2 is: " + (5 + 2)); // the sum of 5 + 2 is: 7
Sobre operadores lógicos
Use operadores lógicos para comparar valores booleanos (true e false) e, em seguida, retorne
um valor booleano com base nessa comparação. Por exemplo, se dois operandos forem
avaliados como true, o operador AND lógico (&&) retornará true. Se um ou ambos os
operandos forem avaliados como true, o operador OR lógico (||) retornará true.
Os operadores lógicos utilizam dois operandos e retornam um resultado booleano. Estes
operadores não têm a mesma precedência e são listados na tabela a seguir por ordem
decrescente de precedência:
Operador
&&
AND lógico
||
OR lógico
Para obter informações sobre como usar os operadores lógicos, consulte “Usando operadores
lógicos” na página 206.
Sobre operadores
205
Usando operadores lógicos
Os operadores lógicos são freqüentemente usados com os operadores de comparação para
determinar a condição de uma instrução if. Isso é demonstrado pelo exemplo a seguir.
Para usar operadores lógicos no código:
1.
Selecione File (Arquivo) > New (Novo) e crie um novo documento do Flash.
2.
Abra o painel Actions (Ações) e digite o seguinte ActionScript no Frame 1 (Quadro 1) da
Timeline (Linha de tempo):
myTxt.type = "input";
myTxt.border = true;
myTxt.restrict = "0-9";
this.createEmptyMovieClip("submit_mc", 30);
submit_mc.beginFill(0xFF0000);
submit_mc.moveTo(0, 0);
submit_mc.endFill();
submit_mc._x = 110;
submit_mc.onRelease = function():Void {
if (isNaN(myNum)) {
return;
}
if ((myNum > 10) && (myNum < 20)) {
trace("Your number is between 10 and 20");
} else {
trace("Your number is NOT between 10 and 20");
}
};
Nesse ActionScript, você cria um campo de texto durante a execução. Se você digitar um
número no campo de texto e clicar no botão do Stage (Palco), o Flash usará o operador
lógico para exibir uma mensagem no painel Output (Saída). A mensagem dependerá do
número digitado no campo de texto.
206
Ao usar operandos, é necessário ter cuidado com a ordem; principalmente quando você estiver
utilizando condições complexas. No trecho a seguir, observe como o operador AND lógico é
utilizado para verificar se um número está entre 10 e 20. De acordo com o resultado, uma
mensagem apropriada será exibida. Se o número for menor que 10 ou maior que 20, uma
mensagem alternativa será exibida no painel Output.
submit_mc.onRelease = function():Void {
if (isNaN(myNum)) {
return;
}
if ((myNum > 10) && (myNum < 20)) {
trace("Your number is between 10 and 20");
} else {
trace("Your number is NOT between 10 and 20");
}
};
Sobre operadores de deslocamento bit a bit
Os operadores de deslocamento bit a bit utilizam dois operandos e deslocam os bits do
primeiro operando até o ponto especificado pelo segundo operando. Todos os operadores
desta tabela possuem a mesma precedência:
Operador
<<
Deslocamento para esquerda bit a bit
>>
Deslocamento para direita bit a bit
>>>
Deslocamento para direita bit a bit (sem sinal)
Para obter informações sobre como usar operadores bit a bit, consulte “Usando operadores bit
a bit” na página 208. Para obter informações específicas sobre cada operador bit a bit, consulta
a entrada correspondente em ActionScript 2.0 Language Reference (Referência à Linguagem
ActionScript 2.0).
Sobre operadores
207
Sobre operadores lógicos bit a bit
Os operadores lógicos bit a bit utilizam dois operandos e executam operações lógicas em nível
de bit. Estes operadores não têm a mesma precedência e são listados na tabela a seguir por
ordem decrescente de precedência:
Operador
&
AND bit a bit
^
XOR bit a bit
|
OR bit a bit
Para obter informações sobre como usar operadores bit a bit, consulte “Usando operadores bit
a bit” na página 208. Para obter mais informações sobre cada operador bit a bit, consulte a
entrada correspondente em ActionScript 2.0 Language Reference (Referência à linguagem
ActionScript 2.0).
Usando operadores bit a bit
Os operadores bit a bit manipulam internamente números de ponto flutuante para
transformá-los em números inteiros de 32 bits. A operação exata realizada depende do
operador, mas todas as operações bit a bit avaliam cada dígito binário (bit) do número inteiro
de 32 bits individualmente para computar um novo valor. Para obter uma lista de operadores
de deslocamento bit a bit, consulte “Sobre operadores de deslocamento bit a bit”
na página 207. Para obter uma lista de operadores lógicos bit a bit, consulte “Sobre operadores
lógicos bit a bit” na página 208.
Usar os operadores bit a bit no Flash não é muito comum, mas pode ser útil em algumas
circunstâncias. Por exemplo, talvez seja necessário criar uma matriz de permissões para um
projeto do Flash, mas sem criar variáveis separadas para cada tipo de permissão. Nesse caso,
você poderia usar operadores bit a bit.
O exemplo a seguir mostra como usar o operador OR bit a bit com o método Array.sort()
para especificar opções de classificação.
Para usar o operador OR bit a bit:
1.
Selecione File (Arquivo) > New (New) e crie um novo documento do Flash.
208
2.
Digite o seguinte ActionScript no painel Actions (Ações):
var myArr:Array = new Array("Bob", "Dan", "doug", "bill", "Hank",
"tom");
trace(myArr); // Bob,Dan,doug,bill,Hank,tom
myArr.sort(Array.CASEINSENSITIVE | Array.DESCENDING);
trace(myArr); // tom,Hank,doug,Dan,Bob,bill
A primeira linha define um array de nomes aleatórios e os rastreia no painel Output
(Saída). Depois, você chama o método Array.sort() e especifica duas opções de
classificação usando os valores constantes Array.CASEINSENSITIVE e
Array.DESCENDING. O resultado do método de classificação faz com que os itens no array
sejam classificados na ordem inversa (de 'z' a 'a'). A pesquisa não faz distinção entre
maiúsculas e minúsculas; ou seja, a e A são considerados idênticos, diferente da pesquisa
que faz distinção entre maiúsculas e minúsculas, onde o Z teria precedência sobre o a.
3.
Selecione Control (Controlar) > Test Movie (Testar filme) para testar o ActionScript. O
seguinte texto será exibido no painel Output (Saída):
Bob,Dan,doug,bill,Hank,tom
tom,Hank,doug,Dan,Bob,bill
Existem cinco opções disponíveis no método de classificação:
■
1 ou Array.CASEINSENSITIVE (binary = 1)
■
2 ou Array.DESCENDING (binary = 10)
■
4 ou Array.UNIQUESORT (binary = 100)
■
8 ou Array.RETURNINDEXEDARRAY (binary = 1000)
■
16 ou Array.NUMERIC (binary = 10000)
Existem três maneiras diferentes de definir as opções de classificação de um array:
my_array.sort(Array.CASEINSENSITIVE | Array.DESCENDING); // constants
my_array.sort(1 | 2); // numbers
my_array.sort(3); // adding the numbers
Embora isso provavelmente não seja óbvio, os valores numéricos das opções de classificação
são, na verdade, dígitos bit a bit (binários ou de base 2). O valor de constante
Array.CASEINSENSITIVE equivale ao valor numérico 1, que também é o valor binário 1. O
valor de constante Array.DECENDING tem um valor numérico 2 ou um valor binário 10.
Trabalhar com números binários pode ser confuso. O valor binário tem apenas dois valores
possíveis, 1 ou 0. É por isso que o valor 1 é representado como 10. Para exibir o número 3
como valor binário, ele seria 11 (1+10). O número 4 representado em binário é 100, o
número 5 em binário é 101, e assim sucessivamente.
Sobre operadores
209
O ActionScript a seguir demonstra como classificar um array de valores numéricos em ordem
decrescente usando o operador AND bit a bit para adicionar as constantes
Array.DESCENDING e Array.NUMERIC juntas.
var scores:Array = new Array(100,40,20,202,1,198);
trace(scores); // 100,40,20,202,1,198
trace(scores.sort()); // 1,100,198,20,202,40
var flags:Number = Array.NUMERIC|Array.DESCENDING;
trace(flags); // 18 (base 10)
trace(flags.toString(2)); // 10010 (binary -- base2)
trace(scores.sort(flags)); // 202,198,100,40,20,1
Sobre o operador condicional
O operador condicional é ternário, o que significa que ele utiliza três operandos. Ele é um
método abreviado de aplicação da instrução condicional if..else:
Operador
?:
Condicional
Para obter informações sobre como usar o operador condicional e um exemplo, consulte
“Sobre o operador condicional e a sintaxe alternativa” na página 160.
Usando operadores em um documento
No exemplo a seguir, o método Math.round() é utilizado para arredondar os cálculos para
um número arbitrário de casas decimais. Esse método arredonda o valor do parâmetro x para
cima ou para baixo até chegar ao inteiro mais próximo e retorna esse valor. Após modificar um
pouco o ActionScript, você pode fazer com que o Flash arredonde os números para um
determinado número de casas decimais.
No exemplo a seguir, os operadores de divisão e multiplicação também são utilizados para
calcular os pontos de um usuário com base no número de respostas corretas dividido pelo
número total de perguntas. Os pontos do usuário podem ser multiplicados por um número e
exibidos para que se obtenha pontos entre 0% e 100%. Em seguida, use o operador de adição
para concatenar os pontos do usuário em uma seqüência de caracteres exibida no painel
Output (Saída).
210
Para usar os operadores no ActionScript:
1.
2.
Digite o seguinte ActionScript no Frame 1 (Quadro 1) da Timeline (Linha de tempo)
principal:
var correctAnswers:Number = 11;
var totalQuestions:Number = 13;
//round to the nearest integer
//var score:Number = Math.round(correctAnswers / totalQuestions * 100);
//round to two decimal places
var score:Number = Math.round(correctAnswers / totalQuestions * 100 *
100) / 100;
trace("You got " + correctAnswers + " out of " + totalQuestions + "
answers correct, for a score of " + score + "%.");
3.
Selecione Control (Controlar) > Test Movie (Testar filme).
You got 11 out of 13 answers correct, for a score of 84.62%.
Quando você chamar Math.round() nesse exemplo, os pontos serão arredondados para o
número inteiro mais próximo (85) e exibidos no painel Output. Se você multiplicar o
número por 100, antes de chamar Math.round() e dividi-lo por 100, faça com que o
Flash arredonde o número para 2 casas decimais. Esse procedimento retornará uma
pontuação mais precisa.
4.
Tente alterar a variável correctAnswers para 3 e selecione Control > Test Movie para
testar o arquivo SWF novamente.
Caso esteja desenvolvendo um aplicativo de teste, talvez seja necessário criar uma série de
perguntas verdadeiro/falso ou de múltipla escolha usando os componentes RadioButton e
Label. Depois que os usuários terminarem de responder cada pergunta e clicar no botão
Submit (Enviar), compare as respostas com um gabarito e calcule os pontos dos usuários.
Sobre operadores
211
212
CAPÍTULO 6
6
Funções e métodos
Entender funções é importante quando se está escrevendo ActionScript, criando classes e
usando métodos. Há diversos tipos de funções com os quais você irá trabalhar. Nesse capítulo,
você aprenderá sobre funções e métodos: como usá-los nos aplicativos quando se usa classes
internas e como criá-los. No Capítulo 7, “Classes,”, você criará classes personalizadas para as
quais escreverá funções regularmente. Você também aprenderá a criar funções em arquivos de
classe do ActionScript.
Você pode usar funções no seu código para adicionar interatividade, animações e outros
efeitos aos aplicativos. Esse capítulo aborda os tipos de função que você pode criar nos
aplicativos Flash. Para obter informações sobre quais são essas funções e esses métodos, assim
como exercícios nos quais você poderá criar e usar funções e métodos no Flash, consulte os
tópicos a seguir:
Sobre funções e métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
Noções básicas sobre métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .235
Sobre funções e métodos
Os métodos e as funções são blocos de código ActionScript que podem ser reutilizados em
qualquer lugar de um arquivo SWF. Você pode criar suas funções no arquivo FLA ou em um
arquivo externo do ActionScript e chamá-las em qualquer local de seus documentos. Métodos
são meramente funções que estão localizadas dentro de uma definição de classe do
ActionScript. Você pode definir funções para executar uma série de instruções sobre valores
passados. As funções também podem retornar valores. Depois que uma função for definida,
ela poderá ser chamada de qualquer Timeline, incluindo aquela de um arquivo SWF
carregado.
213
Se você passar valores como parâmetros para uma função, esta poderá executar cálculos
usando os valores fornecidos. Cada função tem suas próprias características e algumas delas
exigem que você passe determinados tipos ou números de valores. Se você passar mais
parâmetros do que o necessário para a função, ela ignorará os valores extras. Se algum
parâmetro obrigatório não for passado, a função atribuirá o tipo de dados undefined aos
parâmetros vazios. o que poderá gerar erros durante a execução. Uma função também pode
retornar valores (consulte “Retornando valores de funções” na página 233).
N OT A
Para chamar uma função, a definição dessa função deve estar em um quadro que já
tenha sido reproduzido.
Uma função bem escrita pode ser considerada uma “caixa-preta”. Se ela tiver comentários
cuidadosamente inseridos a respeito de sua entrada, saída e objetivo, um usuário da função
não precisará compreender exatamente como ela funciona internamente.
A sintaxe básica para uma função com nome simples é:
function traceMe() {
trace("sua mensagem");
}
traceMe();
Para obter informações sobre a criação de funções com nome, consulte “Criando funções com
nome” na página 219.
A sintaxe básica de uma função com nome simples que é criada no exemplo anterior passando
um parâmetro, yourMessage, é:
function traceMe(yourMessage:String) {
trace(yourMessage);
}
traceMe("Como vai você?");
Como alternativa, se você quiser passar diversos parâmetros, você poderia usar o seguinte
código:
var yourName:String = "Ester";
var yourAge:String = "65";
var favSoftware:String = "Flash";
function traceMe(favSoftware:String, yourName:String, yourAge:String) {
trace("I'm " + yourName + ", I like " + favSoftware + ", and I'm " +
yourAge + ".");
}
traceMe(favSoftware,yourName,yourAge);
Para obter mais informações sobre como passar parâmetros, consulte “Passando parâmetros
para uma função” na página 231.
214
Há diversos tipos de função que você pode criar. Para obter mais informações sobre criação de
funções, assim como links para seções sobre criação de tipos específicos de função, consulte
“Sobre tipos de métodos e funções” na página 215. Para ver um exemplo de comparação entre
métodos e funções, consulte “Noções básicas sobre métodos” na página 235.
N OT A
Para obter informações sobre criação de código usando Script Assist, consulte
“Criando ActionScript com o Script Assist” na página 368, “Criando um evento
startDrag/stopDrag com o Script Assist” na página 372 e o tutorial ActionScript:Use
Script Assist Mode (que começa com “Open the starter document” on page 211).
Para obter mais informações sobre funções e métodos, consulte os tópicos a seguir:
■
“Sobre tipos de métodos e funções” na página 215
Sobre tipos de métodos e funções
As funções pertencentes a uma classe são denominadas de métodos dessa classe. Há diversos
tipos de funções que você pode usar nos aplicativos, incluindo funções internas, com nome e
definidas pelo usuário, anônimas, de retorno, construtoras e literais de função. As seções a
seguir contêm informações sobre como definir essas funções.
Você também pode criar funções em um arquivo de classe do ActionScript. Essas funções são
usadas como métodos nos scripts. No exemplo a seguir, a classe Person exibe um método
construtor, métodos de classe, métodos de instância e métodos de acesso (getters e setters): Os
comentários no código de exemplo mostram em que parte do código esses métodos ocorrem.
N OT A
Para obter informações sobre criação de arquivos de classe, tais como o seguinte,
consulte o Capítulo 7, “Classes”, na página 239.
class Person {
public static var numPeople:Number = 0;
// membros de instância
private var _speed:Number;
// construtor
public function Person(speed:Number) {
Person.numPeople++;
this._speed = speed;
}
// métodos estáticos
public static function getPeople():Number {
return Person.numPeople;
}
215
// métodos de instância
public function walk(speed:Number):Void {
}
public function run():Void {
this._speed *= 2;
}
public function rest():Void {
this._speed = 0;
}
// getters/setters (métodos de acesso)
public function get speed():Number {
return this._speed;
}
}
Para obter uma demonstração completa de como criar métodos como os do código de
exemplo anterior, consulte o Capítulo 7, “Classes”, na página 239. Os métodos usados no
código devem pertencer a uma classe que seja interna à linguagem ActionScript. MovieClip e
Math são exemplos de classes de nível superior que podem ser usadas em um aplicativo.
Quando são usados no código métodos dessas classes, isso significa que eles são funções
criadas na classe interna (semelhantes ao código de exemplo anterior). Opcionalmente, você
poderia usar métodos de uma classe personalizada que tivesse criado.
As funções não pertencentes a uma classe são chamadas de funções de nível superior (às vezes
chamadas de pré-definidas ou funções internas), significando que você pode chamá-las sem um
construtor. Exemplos de funções que são internas ao nível superior da linguagem ActionScript
são trace() e setInterval().
Para adicionar uma chamada de função de nível superior ao código, basta adicionar uma única
linha de código no painel Script do painel Actions (Ações). Por exemplo, digite o seguinte:
trace("minha mensagem");
Quando o arquivo SWF é testado com essa única linha de código, a função de nível superior
trace() é chamada e o texto é exibido no painel Output (Saída).
Quando desejar atribuir um método a uma propriedade, lembre-se de que é necessário omitir
os parênteses após o nome do método porque você está passando uma referência à função:
my_mc.myMethod = aFunction;
216
Entretanto, para chamar um método em seu código, você precisará incluir os parênteses após
o nome do método:
my_mc.myMethod();
NO T A
Para obter mais informações sobre funções de nível superior, consulte “Sobre funções
internas e de nível superior” na página 217.
Também há várias outras maneiras de se definir funções. Para obter mais informações sobre
cada tipo de função, consulte as seguintes seções:
■
“Sobre funções internas e de nível superior” na página 217
■
“Criando funções com nome” na página 219
■
“Criando funções anônimas e de retorno de chamada” na página 220
■
“Sobre literais de função” na página 222
■
“Especificando e chamando funções definidas pelo usuário” na página 225
■
“Sobre funções construtoras” na página 223
Para obter informações sobre a criação e o uso de funções e métodos, consulte as seguintes
seções relacionadas. Para obter informações sobre o uso de funções, consulte “Usando funções
no Flash” na página 227. Para obter informações sobre o uso de métodos, consulte “Noções
básicas sobre métodos” na página 235.
N OT A
Sobre funções internas e de nível superior
Como já foi discutido em “Sobre funções e métodos” na página 213, uma função é um bloco
de código ActionScript que pode ser reutilizado em qualquer lugar de um arquivo SWF. Se
você passar valores como parâmetros para uma função, a função operará com esses valores.
Uma função também pode retornar valores.
Você pode usar funções que são internas à linguagem ActionScript. Elas podem ser funções de
nível superior, como descrito em “Sobre tipos de métodos e funções” na página 215, ou estar
contidas em uma classe interna, como Math ou MovieClip, que podem ser usadas como
métodos no aplicativo.
217
No ActionScript, funções internas são utilizadas para realizar determinadas tarefas e acessar
informações. Por exemplo, para obter o número de milissegundos de reprodução do arquivo
SWF, você pode usar getTimer(). Também é possível obter o número da versão do Flash
Player que hospeda o arquivo usando getVersion(). As funções que pertencem a um objeto
são denominadas métodos. As funções que não pertencem a um objeto são denominadas
funções de nível superior e são encontradas em subcategorias da categoria Global Functions
(Funções globais) do painel Actions (Ações).
Algumas funções internas exigem que se passe determinados valores. Se forem passados mais
parâmetros do que o exigido pela função, os valores extras serão ignorados. Se algum
parâmetro obrigatório não for passado, o tipo de dados undefined será atribuído aos
parâmetros vazios, o que poderá gerar erros durante a execução.
NO T A
Para chamar uma função, a definição dessa função deve estar em um quadro que já
tenha sido reproduzido.
As funções de nível superior são fáceis de usar. Para chamar uma função, basta usar o nome da
função e passar os parâmetros necessários: (Para obter informações sobre parâmetros
necessários, consulte a entrada para a função em ActionScript 2.0 Language Reference,
Referência da linguagem ActionScript). Por exemplo, adicione o seguinte ActionScript ao Frame
1 (Quadro 1) da Timeline (Linha de tempo):
trace("minha mensagem");
Ao testar o arquivo SWF, minha mensagem é exibida no painel Output (Saída). Dois outros
exemplos de funções de nível superior são setInterval() e getTimer(). O próximo
exemplo mostra como usar essas duas funções em conjunto. Adicione o seguinte código ao
Frame 1 (Quadro 1) da Timeline (Linha de tempo):
function myTimer():Void {
trace(getTimer());
}
var intervalID:Number = setInterval(myTimer, 100);
Esse código cria um temporizador simples usando getTimer() e usa as funções de nível
superior setInterval() e trace() para exibir o número de milissegundos desde que o
arquivo SWF começou a ser reproduzido no Flash Player.
Chamar uma função de nível superior é como chamar uma função definida pelo usuário. Para
obter mais informações, consulte “Especificando e chamando funções definidas pelo usuário”
na página 225. Para obter informações sobre cada função, consulte a entrada correspondente
em ActionScript 2.0 Language Reference (Referência da linguagem ActionScript).
218
Criando funções com nome
Uma função com nome é um tipo de função que você geralmente cria no código ActionScript
para executar todos os tipos de ação. Quando você cria um arquivo SWF, as funções com
nome são compiladas primeiro, o que significa que você pode fazer referência à função em
qualquer parte do código, contanto que a função tenha sido definida no quadro atual ou
anterior. Por exemplo, se uma função for definida no Frame 2 de uma timeline, você não
poderá acessar essa função no Frame 1 da timeline.
O formato padrão das funções com nome é o seguinte:
function functionName(parameters) {
// bloco de função
}
Esse código contém as seguintes partes:
■
nomeFunção é o nome exclusivo da função. Todos os nomes de funções em um
documento devem ser exclusivos.
■
paramêtros contém um ou mais parâmetros que são passados para a função. Os
parâmetros são às vezes chamados argumentos. Para obter mais informações sobre
parâmetros, consulte “Passando parâmetros para uma função” na página 231.
■
// bloco de função
contém todo o código ActionScript executado pela função. Essa
parte contém as instruções que executam várias ações. Você pode colocar o código que
deseja executar aqui. O comentário // bloco de função é um espaço reservado onde o
código referente ao bloco de função deve ser inserido.
Para usar uma função com nome:
1.
Crie um novo documento chamado namedFunc.fla.
2.
Importe um arquivo de som curto para a biblioteca selecionando File (Arquivo) > Import
(Importar) > Import to Library (Importar para a biblioteca) e selecionando um arquivo de
som.
3.
Clique com o botão direito do mouse no arquivo de som e selecione Linkage (Vinculação).
4.
Digite mySoundID na caixa de texto Identifier (Identificador).
5.
Selecione o Frame 1 da Timeline e adicione o seguinte código ao painel Actions:
function myMessage() {
trace("mySoundID completed");
}
var my_sound:Sound = new Sound();
my_sound.attachSound("mySoundID");
my_sound.onSoundComplete = myMessage;
my_sound.start();
219
Nesse código, você cria uma função com nome chamada myMessage, que pode ser usada
posteriormente no script para chamar uma função trace().
6.
Selecione Control (Controlar) > Test Movie (Testar filme) para testar o arquivo SWF.
Use a instrução function para criar sua própria função no ActionScript. Lembre-se de que os
parâmetros são opcionais; entretanto, se não houver parâmetros, ainda será necessário incluir
os colchetes. O conteúdo entre as chaves ({}) é chamado bloco de função.
Você pode criar funções na timeline principal ou em arquivos externos do ActionScript,
incluindo arquivos de classes.
Também é possível criar funções construtoras em arquivos de classes usando esse formato
(entretanto, o nome da função corresponde à classe). Para obter mais informações sobre
funções construtoras, consulte “Criando a função construtora” na página 283. Consulte
também o Capítulo 7, “Classes”, na página 239 para obter exemplos e informações sobre a
criação de funções em classes.
Criando funções anônimas e de retorno de chamada
Uma função com nome é uma função a que você se refere no script antes ou depois de definila, enquanto que uma função anônima é uma função sem nome que faz referência a si mesma;
você faz referência à função anônima ao criá-la. Ao criar código ActionScript, você cria muitas
funções anônimas.
As funções anônimas são normalmente usadas quando se trabalha com manipuladores de
eventos. Para criar uma função anônima, você pode armazenar um literal de função em uma
variável. Portanto, é possível fazer referência à função posteriormente no código. O próximo
exemplo mostra como criar uma função anônima.
Para criar uma função anônima:
1.
Crie um clipe de filme no Stage (Palco) e selecione o clipe.
2.
Abra o inspetor Properties e digite my_mc na caixa de texto Instance Name (Nome de
instância).
3.
Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) e digite o seguinte código
no painel Actions (Ações):
var myWidth = function () {
trace(my_mc._width);
};
//posteriormente no código você pode adicionar
myWidth();
4.
A largura do clipe de filme é exibida no painel Output (Saída).
220
Também é possível criar uma função em um objeto, como uma instância LoadVars ou XML.
Você pode associar uma função anônima a um determinado evento para criar uma função de
retorno de chamada. Uma função chama uma função de retorno de chamada quando ocorre
um evento específico, como, por exemplo, após um carregamento (onLoad()) ou uma
animação (onMotionFinished()).
Por exemplo, às vezes é necessário criar um código ActionScript para manipular os dados
carregados em um arquivo SWF a partir do servidor. Depois que os dados são carregados no
arquivo, é possível acessá-los nesse local. É importante usar o ActionScript para verificar se os
dados foram totalmente carregados. As funções de retorno de chamada podem ser usadas para
enviar um sinal indicando que os dados foram carregados no documento.
Na função de retorno de chamada a seguir, na qual você carrega um documento XML remoto,
uma função anônima é associada ao evento onLoad(). Você usa XML.load() e a função de
retorno de chamada, como mostra o exemplo a seguir. Digite o seguinte código no Frame 1
(Quadro 1) da Timeline (Linha de tempo):
var my_xml:XML = new XML();
my_xml.onLoad = function(success:Boolean):Void {
trace(success);
};
my_xml.load("http://www.helpexamples.com/crossdomain.xml");
No trecho de código anterior, observe que o manipulador de eventos onLoad() usa uma
função anônima para manipular o evento onLoad().
Para obter mais informações sobre funções de retorno de chamada, consulte o Capítulo 10,
“Manipulando eventos”, na página 347.
Você também pode usar funções anônimas com a função setInterval(), conforme
mostrado no código a seguir, que usa setInterval() para chamar a função anônima
aproximadamente a cada 1000 milissegundos (1 segundo):
setInterval(function() {trace("intervalo");}, 1000);
Você pode usar funções com nome em vez de funções anônimas. Funções com nome são
geralmente mais fáceis de ler e entender (exceto em algumas circunstâncias, tais como funções
de retorno de chamada). Também é possível fazer referência antecipada a uma função com
nome; isso significa que ela é referenciada antes de existir em uma Timeline.
Você não pode referenciar uma função anônima em nenhuma parte do código (a menos que
atribua a função a uma variável), da mesma maneira que pode ser feito com funções com
nome. Por exemplo, suponha que você tenha funções anônimas no Frame 5 do arquivo FLA,
como as seguintes:
//com um clipe de filme chamado my_mc que estende uma timeline
stop();
var myWidth = function () {
221
};
Se você colocar o código a seguir no Frame 1, ele não referenciará a função:
myWidth();
Da mesma maneira, o código a seguir, colocado em qualquer quadro, não funciona:
myWidth();
var myWidth:Function = function () {
};
No entanto, este código funciona corretamente:
};
myWidth();
N OT A
Você também pode colocar myWidth() em qualquer quadro após o quadro que contém a
função myWidth.
Ao definir uma função com nome, chamá-la em um script de quadro funciona, embora o
código equivalente com uma função anônima não funcione:
// o código a seguir funciona porque você está chamando uma função com nome:
myWidth();
function myWidth() {
trace("foo");
}
// o código a seguir não funciona porque você está chamando uma função
anônima:
myWidth();
trace("foo");
};
Para obter mais informações, consulte “Criando funções com nome” na página 219.
N OT A
Sobre literais de função
Um literal de função é uma função sem nome declarada em uma expressão em vez de em uma
instrução. Os literais são úteis quando é necessário usar uma função temporariamente ou usar
uma função no código no lugar de uma expressão. Esta é a sintaxe de um literal de função:
222
function (param1, param2, etc) {
// instruções
};
Por exemplo, o código a seguir usa um literal de função como expressão:
var yourName:String = "Ester";
setInterval(function() {trace(yourName);}, 200);
N OT A
Quando você redefine um literal de função, a definição da nova função substitui a antiga.
Você pode armazenar um literal de função em uma variável para acessá-lo posteriormente em
seu código. Para fazer isso, use uma função anônima. Para obter mais informações, consulte
“Criando funções anônimas e de retorno de chamada” na página 220.
Sobre funções construtoras
Um construtor de classe é uma função especial chamada automaticamente quando você cria
uma instância de uma classe usando a palavra-chave new (por exemplo, var my_xml:XML =
new XML();). A função construtora tem o mesmo nome da classe que a contém. Por exemplo,
uma classe personalizada Person criada conteria a seguinte função construtora:
public function Person(speed:Number) {
Person.numPeople++;
}
Em seguida, você poderia criar uma nova instância usando:
var myPerson:Person = new Person();
NO T A
Se nenhuma função construtora for explicitamente declarada, ou seja, se você não criar
uma função cujo nome corresponda ao da classe, o compilador automaticamente criará
uma função construtora vazia.
Uma classe pode conter apenas uma função construtora; funções construtoras sobrecarregadas
não são permitidas no ActionScript 2.0. Além disso, uma função construtora não pode ter um
tipo de retorno. Para obter mais informações sobre a criação de funções construtoras em
arquivos de classe, consulte “Criando a função construtora” na página 283.
223
Definindo funções globais e de timeline
Em “Sobre funções e métodos” na página 213, você explorou os diversos tipos de funções
disponíveis no Flash. Assim como as variáveis, as funções são anexadas à Timeline do clipe de
filme que as define, e você deve usar um caminho de destino para chamá-las. Como ocorre
com as variáveis, você pode usar o identificador _global se desejar declarar uma função global
disponível para todas as timelines e escopos sem usar um caminho de destino. Para definir
uma função global, preceda o nome da função com o identificador _global, como no
seguinte exemplo:
_global.myFunction = function(myNum:Number):Number {
return (myNum * 2) + 3;
};
trace(myFunction(5)) // 13
Para obter informações sobre _global e escopo, consulte “Sobre variáveis e escopo”
na página 101.
Para definir uma função de timeline, use a instrução function seguida do nome da função,
dos parâmetros a serem passados para a função e das instruções do ActionScript que indicam o
que ela faz.
O exemplo a seguir é uma função denominada areaOfCircle com o parâmetro radius:
function areaOfCircle(radius:Number):Number {
return (Math.PI * radius * radius);
}
trace (areaOfCircle(8));
Também há várias outras maneiras de se definir funções. Para obter mais informações sobre
cada tipo de função, consulte as seguintes seções:
■
“Sobre funções internas e de nível superior” na página 217
■
“Criando funções com nome” na página 219
■
“Criando funções anônimas e de retorno de chamada” na página 220
■
“Sobre literais de função” na página 222
■
“Sobre funções construtoras” na página 223
■
“Especificando e chamando funções definidas pelo usuário” na página 225
224
Para obter informações sobre a atribuição de nomes a funções, consulte “Atribuindo nomes a
funções” na página 226. Para obter um exemplo detalhado do uso de funções em um arquivo
de classe externo, consulte “Usando funções no Flash” na página 227 e o Capítulo 7,
“Classes”, na página 239
N OT A
Especificando e chamando funções definidas pelo
usuário
As funções definidas pelo usuário são aquelas criadas para serem usadas em aplicativos, em
contraposição às funções de classes internas que executam funções predefinidas. Você mesmo
atribui um nome às funções e adiciona instruções ao bloco de função. As seções anteriores
abordam a criação de funções com nome, sem nome e de retorno de chamada. Para obter
informações sobre a atribuição de nomes a funções, consulte “Atribuindo nomes a funções”
na página 226 e, para obter informações sobre o uso de funções, consulte “Usando funções no
Flash” na página 227.
Você pode usar um caminho de destino para chamar uma função em qualquer timeline a
partir de qualquer outra timeline, inclusive daquela de um arquivo SWF carregado. Para
chamar uma função, digite o caminho de destino para o nome da função, se for preciso, e
passe os parâmetros necessários entre parênteses. Há vários tipos de sintaxe para as funções
definidas pelo usuário. O código a seguir usa um caminho para chamar a função
initialize(), que foi definida na timeline atual e não requer parâmetro algum:
this.initialize();
O exemplo a seguir usa um caminho relativo para chamar a função list() definida no clipe
de filme functionsClip:
this._parent.functionsClip.list(6);
Para obter informações sobre a criação de funções com nome, consulte “Criando funções com
nome” na página 219. Para obter mais informações sobre parâmetros, consulte “Passando
parâmetros para uma função” na página 231.
Você também pode definir suas próprias funções com nome. Por exemplo, a seguinte função
com nome helloWorld() é definida pelo usuário:
function helloWorld() {
trace("Olá mundo!");
};
225
O exemplo a seguir mostra como usar uma função definida pelo usuário em um arquivo FLA.
Para criar e chamar uma função simples definida pelo usuário:
1.
Crie um novo documento do Flash e salve-o como udf.fla.
2.
Adicione o seguinte ActionScript ao Frame 1 (Quadro 1) da Timeline (Linha de tempo)
principal:
function traceHello(name:String):Void {
trace("hello, " + name + "!");
}
traceHello("world"); // hello, world!
O código anterior cria uma função definida pelo usuário chamada traceHello() que
utiliza um argumento, name, e apresenta uma mensagem de saudação. Para chamar uma
função definida pelo usuário, você pode chamar traceHello a partir da mesma timeline
que a definição da função e passar um único valor de seqüência de caracteres.
3.
Selecione Control (Controlar) > Test Movie (Testar filme) para testar o documento do
Flash.
Para obter mais informações sobre funções com nome, consulte “Criando funções com nome”
na página 219. As classes contêm várias funções definidas pelo usuário. Para obter
informações sobre a criação de funções em arquivos de classes, consulte “Usando funções no
Flash” na página 227. Consulte também as seguintes seções do Capítulo 7, “Classes”: “Usando
métodos e propriedades de um arquivo de classe” na página 260, “Sobre propriedades
(membros) e métodos públicos, privados e estáticos” na página 262 e “Sobre membros de
classe” na página 265.
Atribuindo nomes a funções
Os nomes de funções devem iniciar em letra minúscula e descrever o valor retornado por elas,
se for o caso. Por exemplo, se a função estiver retornando o nome de uma música, você deverá
atribuir à função o nome getCurrentSong().
Estabeleça um padrão para agrupar funções semelhantes (funções relacionadas entre si com
base na funcionalidade) porque o ActionScript não permite sobrecarga. No contexto da
programação orientada a objeto, a sobrecarga refere-se à capacidade de fazer com que as
funções se comportem de maneira diferente, dependendo dos tipos de dados que são passados
para elas.
Assim como as variáveis, você não pode usar caracteres especiais e o nome do método não
pode começar com número. Para obter mais informações, consulte “Convenções de atribuição
de nome” na página 769. Para obter informações sobre a atribuição de nomes a métodos,
consulte “Atribuindo nomes a métodos” na página 237.
226
Usando funções no Flash
Essa seção mostra como usar funções em um aplicativo. Alguns dos exemplos de código a
seguir usam o ActionScript que reside no arquivo FLA, enquanto outros colocam funções em
um arquivo de classe para comparação. Para obter mais informações e exemplos sobre o uso de
funções em um arquivo de classe ,consulte o Capítulo 7, “Classes”, na página 239. Para obter
informações e instruções detalhadas sobre como criar funções para um arquivo de classe,
consulte “Exemplo: Criando classes personalizadas” na página 278.
Para reduzir o volume de trabalho necessário, bem como o tamanho do arquivo SWF, tente
reutilizar os blocos de código sempre que possível. Uma das maneiras de reutilizar o código é
chamando uma função várias vezes, em vez de criar um código diferente a cada vez. As funções
podem ser códigos genéricos; é possível usar os mesmos blocos de código para finalidades
ligeiramente diferentes em um arquivo SWF. A reutilização do código permite criar aplicativos
eficientes e minimiza o código ActionScript que precisa ser criado, reduzindo o tempo de
desenvolvimento.
Você pode criar funções em um arquivo FLA ou em um arquivo de classe; também pode criar
o código ActionScript residente em um componente baseado em código. Os exemplos a seguir
mostram como criar funções na timeline e em um arquivo de classe.
DICA
Empacotando o código em arquivos de classes ou em componentes baseados em
código, é possível compartilhar, distribuir ou reutilizar facilmente blocos de código.
Usuários podem instalar o componente, arrastá-lo para o Stage e usar o código
armazenado no arquivo, como, por exemplo, o fluxo de trabalho para componentes
baseados em código disponíveis no Flash (Window - Janela> Common Libraries Bibliotecas comuns > Classes).
O exemplo a seguir mostra como criar e chamar uma função em um arquivo FLA.
Para criar e chamar uma função em um arquivo FLA:
1.
Crie um novo documento do Flash e salve-o como basicFunction.fla.
2.
Selecione Window > Actions (Ações) para abrir o painel Library (Biblioteca).
3.
Digite o seguinte código ActionScript no painel Script:
function helloWorld(){
// as instruções entram aqui
trace("Olá mundo!");
};
Esse ActionScript define a função (com nome e definida pelo usuário) chamada
Se você testar o arquivo SWF desta vez, nada acontecerá. Por exemplo,
você não verá a instrução trace no painel Output (Saída). Para ver essa instrução, é
necessário chamar a função helloWorld().
helloWorld().
227
4.
Digite a seguinte linha de código ActionScript após a função:
helloWorld();
Esse código chama a função helloWorld().
5.
Selecione Control (Controlar) > Test Movie (Testar filme) para testar o arquivo FLA.
O seguinte texto é exibido no painel Output: Olá mundo!
Para obter informações sobre como passar valores (parâmetros) para uma função, consulte
“Passando parâmetros para uma função” na página 231.
Há diversas maneiras de criar funções na Timeline principal. A principal delas é usar funções
com nome e funções anônimas. Por exemplo, você pode usar a seguinte sintaxe ao criar
funções:
function myCircle(radius:Number):Number {
}
trace(myCircle(5));
Em geral, as funções anônimas são de mais difícil leitura. Compare o código apresentado a
seguir com o anterior.
var myCircle:Function = function(radius:Number):Number {
// insira o bloco de função aqui
};
trace(myCircle(5));
Também é possível colocar funções em arquivos de classes ao usar o ActionScript 2.0, como
mostra este exemplo:
class Circle {
public function area(radius:Number):Number {
return (Math.PI * Math.pow(radius, 2));
}
public function perimeter(radius:Number):Number {
return (2 * Math.PI * radius);
}
public function diameter(radius:Number):Number {
return (radius * 2);
}
}
Para obter mais informações sobre a criação de funções em um arquivo de classe, consulte o
Capítulo 7, “Classes”, na página 239.
228
Como você pode ver no código de exemplo anterior, você não precisa colocar funções em uma
timeline. O exemplo a seguir também coloca funções em um arquivo de classe. Essa prática é
recomendada quando você cria aplicativos grandes com o ActionScript 2.0, pois ela permite a
reutilização do código em diversos aplicativos. Para reutilizar as funções em outros aplicativos,
você pode importar a classe existente em vez de reescrever o código desde o início. Também é
possível duplicar as funções no novo aplicativo.
Para criar funções em um arquivo de classe:
1.
Crie um novo documento do ActionScript e salve-o como Utils.as.
2.
class Utils {
public static function randomRange(min:Number, max:Number):Number {
if (min > max) {
var temp:Number = min;
min = max;
max = temp;
}
return (Math.floor(Math.random() * (max - min + 1)) + min);
}
public static function arrayMin(num_array:Array):Number {
if (num_array.length == 0) {
return Number.NaN;
}
num_array.sort(Array.NUMERIC | Array.DESCENDING);
var min:Number = Number(num_array.pop());
return min;
}
public static function arrayMax(num_array:Array):Number {
if (num_array.length == 0) {
return undefined;
}
num_array.sort(Array.NUMERIC);
var max:Number = Number(num_array.pop());
return max;
}
}
3.
Selecione File (Arquivo) > Save (Salvar) para salvar o arquivo do ActionScript.
4.
Crie um novo documento do Flash e salve-o como classFunctions.fla no mesmo diretório
que Utils.as.
5.
Selecione Window > Actions (Ações) para abrir o painel Library (Biblioteca).
6.
var randomMonth:Number = Utils.randomRange(0, 11);
var min:Number = Utils.arrayMin([3, 3, 5, 34, 2, 1, 1, -3]);
var max:Number = Utils.arrayMax([3, 3, 5, 34, 2, 1, 1, -3]);
229
trace("month: " + randomMonth);
trace("min: " + min); // -3
trace("max: " + max); // 34
7.
Selecione Control (Controlar) > Test Movie (Testar filme) para testar os documentos. O
seguinte texto é exibido no painel Output:
month: 7
min -3
max 34
NO TA
Usando variáveis em funções
As variáveis locais são ferramentas valiosas para organizar códigos e facilitar sua compreensão.
Quando uma função usa variáveis locais, ela pode ocultar suas variáveis de todos os outros
scripts no arquivo SWF; as variáveis locais são chamadas no escopo do corpo da função e
deixam de existir quando a função é encerrada. O Flash também trata todos os parâmetros
passados para uma função como variáveis locais.
NO TA
Também é possível usar variáveis comuns em uma função. No entanto, se essas
variáveis forem modificadas, é recomendável usar comentários de script para
documentar essas modificações.
Para usar variáveis em funções:
1.
Crie um novo documento do Flash e salve-o como flashvariables.fla.
2.
principal:
var myName:String = "Ester";
var myAge:String = "65";
var myFavSoftware:String = "Flash";
function traceMe(yourFavSoftware:String, yourName:String,
yourAge:String) {
trace("I'm " + yourName + ", I like " + yourFavSoftware + ", and I'm "
+ yourAge + ".");
}
traceMe(myFavSoftware, myName, myAge);
3.
Flash.
230
Para obter mais informações sobre parâmetros, consulte “Passando parâmetros para uma
função” na página 231. Para obter mais informações sobre variáveis e dados, leia o Capítulo 4,
“Dados e tipos de dados”, na página 75.
Passando parâmetros para uma função
Os parâmetros, também chamados argumentos, são os elementos com base nos quais as
funções executam seu código. (Neste manual, os termos parâmetro e argumento são
equivalentes.) Você pode passar parâmetros (valores) para uma função e, depois, usar esses
parâmetros para processar a função. Use os valores contidos no bloco da função (instruções da
função).
Algumas vezes, os parâmetros são obrigatórios e, outras, opcionais. Poderão até mesmo existir
alguns parâmetros obrigatórios e alguns opcionais na mesma função. Se você não passar
parâmetros suficientes para uma função, o Flash define os valores dos parâmetros ausentes
como undefined, o que pode gerar resultados inesperados no arquivo SWF.
A função a seguir chamada myFunc() utiliza o parâmetro someText:
function myFunc(someText:String):Void {
trace(someText);
}
Após passar o parâmetro, você poderá passar um valor para a função ao chamá-la. Esse valor é
exibido no painel Output (Saída), da seguinte maneira:
myFunc("Isso é o que é mostrado");
Ao chamar a função, você deve sempre passar o número especificado de parâmetros, a menos
que a sua função verifique se há valores indefinidos e defina valores padrão de acordo. A
função substitui os valores passados para os parâmetros na definição da função; se algum
parâmetro estiver faltando, o Flash define o valor como undefined. Você passa parâmetros
regularmente para funções ao criar o código ActionScript.
Também é possível passar vários parâmetros para uma função, o que poderá ser tão simples
como mostrado a seguir:
var birthday:Date = new Date(1901, 2, 3);
trace(birthday);
Cada parâmetro é separado por uma vírgula. Várias funções internas da linguagem
ActionScript têm vários parâmetros. Por exemplo, o método startDrag() da classe
MovieClip utiliza cinco parâmetros, lockCenter, left, top, right e bottom:
startDrag(lockCenter:Boolean, left:Number, top:Number, right:Number,
bottom:Number):Void
231
Para passar um parâmetro para uma função:
1.
Crie um novo documento do Flash e salve-o como parameters.fla.
2.
function traceMe(yourMessage:String):Void {
trace(yourMessage);
}
traceMe("Como vai você?");
As primeiras linhas de código criam uma função definida pelo usuário chamada
traceMe(), que utiliza um único parâmetro, yourMessage. A última linha de código
chama a função traceMe() e passa o valor da seqüência de caracteres “Como vai você?”.
3.
Flash.
O próximo exemplo demonstra como passar vários parâmetros para uma função.
Para passar vários parâmetros para uma função:
1.
Crie um novo documento do Flash e salve-o como functionTest.fla.
2.
Adicione o seguinte código ao Frame 1 (Quadro 1) da Timeline (Linha de tempo)
principal:
function getArea(width:Number, height:Number):Number {
return width * height;
}
A função getArea() utiliza dois parâmetros, width e height.
3.
Digite o seguinte código após a função:
var area:Number = getArea(10, 12);
trace(area); // 120
A chamada da função getArea() atribui os valores 10 e 12 à largura e à altura,
respectivamente, e o valor de retorno é salvo na instância area. Em seguida, rastreie os
valores salvos na instância area.
4.
Você verá 120 no painel Output.
Os parâmetros da função getArea() assemelham-se aos valores de uma variável local; eles
existem enquanto a função é chamada e deixam de existir quando ela é encerrada.
No próximo exemplo, o ActionScript retorna o valor NaN (Not a Number, não é número) se
você não passar parâmetros suficientes para a função addNumbers().
Para passar um número variável de parâmetros para uma função:
1.
Crie um novo documento do Flash e salve-o como functionTest2.fla.
232
2.
principal:
function addNumbers(a:Number, b:Number, c:Number):Number {
return (a + b + c);
}
trace(addNumbers(1, 4, 6)); // 11
trace(addNumbers(1, 4)); // NaN (Not a Number), c igual a undefined
trace(addNumbers(1, 4, 6, 8)); // 11
Se você não passar parâmetros suficientes para a função addNumbers, os argumentos
ausentes recebem o valor padrão de undefined. Se você passar parâmetros demais, o
excesso de parâmetros será ignorado.
3.
Flash.
O Flash exibe os seguintes valores: 11, NaN, 11.
Retornando valores de funções
Use a instrução return para retornar valores de funções. A instrução return especifica o valor
retornado por uma função. A instrução return retorna o resultado de uma avaliação como o
valor da função na qual a expressão é executada. A instrução return retorna os resultados
imediatamente ao código de chamada.
Para obter mais informações, consulte %{return statement}% em ActionScript 2.0 Language
Reference (Referência da linguagem ActionScript).
As regras a seguir regem o uso da instrução return em funções:
■
Se um tipo de retorno diferente de Void for especificado para uma função, será necessário
incluir uma instrução return seguida do valor retornado na função.
■
Se você especificar o tipo de retorno Void, não precisará incluir uma instrução return; no
entanto, se fizer isso, não insira nenhum valor após a instrução.
■
Independentemente do tipo de retorno, você poderá usar uma instrução return para sair
de uma função antes de ela terminar.
■
Se você não especificar um tipo de retorno, a inclusão de uma instrução return será
opcional.
Por exemplo, a função a seguir retorna o quadrado do parâmetro myNum e especifica que o
valor retornado deve ser um tipo de dados Number:
function sqr(myNum:Number):Number {
return myNum * myNum;
}
233
Algumas funções executam uma série de tarefas sem retornar um valor. O próximo exemplo
retorna o valor processado. Você capturará o valor em uma variável, a qual poderá ser usada
em seu aplicativo.
Para retornar um valor e capturá-lo em uma variável:
1.
Crie um novo documento do Flash e salve-o como return.fla.
2.
principal:
function getArea(width:Number, height:Number):Number {
return width * height;
}
A função getArea() utiliza dois parâmetros, width e height.
3.
Digite o seguinte código após a função:
var area:Number = getArea(10, 12);
trace(area); // 120
A chamada da função getArea() atribui os valores 10 e 12 à largura e à altura,
respectivamente, e o valor de retorno é salvo na instância area. Em seguida, rastreie os
valores salvos na instância area.
4.
Você verá 120 no painel Output.
Os parâmetros da função getArea() assemelham-se aos valores de uma variável local; eles
existem enquanto a função é chamada e deixam de existir quando ela é encerrada.
Sobre funções aninhadas
É possível chamar uma função a partir de outra. Isso permite aninhar funções para que
executem tarefas específicas no Flash.
Por exemplo, você pode aninhar funções na timeline para executar tarefas específicas em uma
seqüência de caracteres. Digite o seguinte código no Frame 1 (Quadro 1) da Timeline (Linha
de tempo):
var myStr:String = "My marshmallow chicken is yellow.";
trace("Original string: " + myStr);
function formatText():Void {
changeString("Put chicken in microwave.");
trace("Changed string: " + myStr);
}
function changeString(newtext:String):Void {
myStr = newtext;
}
234
// Chame a função.
formatText();
Selecione Control (Controlar) > Test Movie (Testar filme) para testar a função aninhada. As
funções formatText() e changeString() são aplicadas à seqüência de caracteres quando a
função formatText() é chamada.
Noções básicas sobre métodos
Métodos são funções associadas a uma classe, a qual pode ser uma classe personalizada ou
classes internas que fazem parte da linguagem ActionScript. Para obter informações sobre
comparação de métodos e funções, consulte “Sobre funções e métodos” na página 213 e
“Sobre tipos de métodos e funções” na página 215.
Por exemplo, sortOn() é um método interno associado à classe Array (sortOn é uma função
da classe Array pré-definida interna no Flash).
Para usar o método sortOn() em um arquivo FLA:
1.
Crie um novo documento do Flash e salve-o como methods.fla.
2.
var userArr:Array = new Array();
userArr.push({firstname:"George", age:39});
userArr.push({firstname:"Dan", age:43});
userArr.push({firstname:"Socks", age:2});
userArr.sortOn("firstname");
var userArrayLenth:Number = userArr.length;
var i:Number;
for (i = 0; i < userArrayLenth; i++) {
trace(userArr[i].firstname);
}
O método sortOn() da classe Array é usado para criar um novo objeto Array chamado
userArr. O array é preenchido com três objetos que contêm um nome e uma idade; em
seguida, ele é classificado com base no valor da propriedade firstname de cada objeto.
Finalmente, você executará uma repetição em cada item do array e exibirá o nome no
painel Output (Saída); depois, classificará os nomes em ordem alfabética pela letra inicial.
3.
O código a seguir é exibido no painel Output:
Dan
George
Socks
235
Conforme demonstrado em “Criando funções com nome” na página 219, quando você cria o
código a seguir no Frame 1 (Quadro 1) da Timeline, o código ActionScript define uma função
chamada eatCabbage().
function eatCabbage() {
trace("tastes bad");
}
eatCabbage();
No entanto, se você criar a função eatCabbage() dentro de um arquivo de classe e, por
exemplo, chamar eatCabbage() no arquivo FLA, então eatCabbage() será considerado um
método.
Os próximos exemplos mostram como criar métodos dentro de uma classe.
Para comparar métodos e funções:
1.
Crie um novo arquivo do ActionScript, selecione File (Arquivo) > Save As (Salvar como) e
salve-o como EatingHabits.as.
2.
Digite o seguinte código ActionScript na janela Script :
class EatingHabits {
public function eatCabbage():Void {
trace("tastes bad");
}
}
3.
Salve as alterações feitas a EatingHabits.as.
4.
Crie um novo documento Flash, selecione File > Save As, atribua o nome methodTest.fla
e salve o arquivo no mesmo diretório que EatingHabits.as.
5.
Digite o seguinte código ActionScript no Frame 1 (Quadro 1) da Timeline (Linha de
tempo):
var myHabits:EatingHabits = new EatingHabits();
myHabits.eatCabbage();
Ao usar esse ActionScript, você chamará o método eatCabbage() da classe EatingHabits.
N O TA
6.
Ao usar métodos de uma classe interna (além da classe personalizada criada
anteriormente neste procedimento), você usará um método da Timeline.
Após a linha anterior do ActionScript, adicione o seguinte código:
function eatCarrots():Void {
trace("tastes good");
}
eatCarrots();
Nesse código, você irá criar e chamar a função eatCarrots().
7.
236
Atribuindo nomes a métodos
Você deve usar verbos para nomear métodos e palavras com letras maiúsculas e minúsculas
para palavras concatenadas, sendo que a inicial deve estar em letra minúscula. Por exemplo,
você poderia nomear métodos das seguintes maneiras:
sing();
boogie();
singLoud();
danceFast();
Utilize verbos para a maioria dos métodos, pois eles executam uma operação em um objeto.
Assim como as variáveis, você não pode usar caracteres especiais e o nome do método não
pode começar com número. Para obter mais informações, consulte “Convenções de atribuição
de nome” na página 769.
237
238
CAPÍTULO 7
7
Classes
Este capítulo mostra como usar e criar classes com o ActionScript 2.0. As classes são o
componente básico do ActionScript 2.0 e desempenham um papel mais importante do que
nas versões anteriores do Macromedia Flash. Neste capítulo, você aprenderá sobre a
importância das classes no Flash.
O capítulo inicia com uma explicação da terminologia fundamental e de sua relação com as
classes e a OOP (Object-Oriented Programming, Programação orientada a objeto). Em
seguida, você examina um arquivo de classe de exemplo para compreender como cada seção
do arquivo funciona e como a classe está organizada. O restante do capítulo mostra como criar
suas próprias classes personalizadas e usá-las nos documentos do Flash. Você aprenderá sobre o
caminho de classe do Flash e como uma classe deve ser documentada para que outras pessoas
possam compreender facilmente o seu código e o objetivo geral da classe ao lerem ou usarem o
código.
Esta seção contém exemplos de códigos para familiarizá-lo com a criação de classes no
ActionScript 2.0. Ao concluir este capítulo, você deverá ser capaz de criar um arquivo de classe
típico, compreender e reconhecer as classes do Flash, e ler arquivos de classes de outros
usuários.
Se não estiver familiarizado com os scripts do ActionScript 2.0, consulte o Capítulo 5,
“Fundamentos da sintaxe e da linguagem”, na página 119 e o Capítulo 19, “Melhores práticas
e convenções de codificação para ActionScript 2.0”, na página 767.
239
Para obter mais informações sobre como trabalhar com classes personalizadas e internas,
Sobre a programação orientada a objeto e o Flash . . . . . . . . . . . . . . . . . . . . . . . . . 240
Criando arquivos de classes personalizados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
Sobre como trabalhar com classes personalizadas em um aplicativo . . . . . . . . . .252
Exemplo: Criando classes personalizadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
Exemplo: Usando arquivos de classes personalizados no Flash. . . . . . . . . . . . . . . 291
Atribuindo uma classe a símbolos no Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
Compilando e exportando classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .296
Noções básicas sobre classes e escopo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
Sobre classes de nível superior e internas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
Sobre como trabalhar com classes internas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
Sobre a programação orientada a objeto
e o Flash
O ActionScript 2.0 é uma linguagem orientada a objeto. Assim como o ActionScript, as
linguagens OOP baseiam-se no conceito de classes e instâncias. Uma classe define todas as
propriedades que distinguem uma série de objetos. Por exemplo, a classe User representa um
grupo de usuários que utilizam o seu aplicativo. Em seguida, você tem um instanciamento da
classe, que, para a classe User, é um dos usuários individuais, ou seja, um de seus membros. O
instanciamento produz uma instância da classe User e essa instância possui todas as
propriedades da classe User.
As classes também são consideradas como tipos de dados ou modelos que podem ser criados
para definir um novo tipo de objeto. Por exemplo, se precisar do tipo de dados Lettuce em seu
aplicativo, você poderá criar a classe Lettuce. Isso definirá o objeto Lettuce, ao qual você
poderá atribuir métodos (wash()) e propriedades (leafy ou bugs). Para definir uma classe,
use a palavra-chave class em um arquivo de script externo. Você pode criar esse arquivo na
ferramenta de criação do Flash selecionando File (Arquivo) > New (Novo) e, em seguida,
selecionando ActionScript File (Arquivo do ActionScript).
240
Classes
O Flash Player 8, disponível no Flash Basic 8 e no Flash Professional 8, adiciona vários novos
recursos à linguagem ActionScript, como efeitos de filtro, upload e download de arquivos, e a
API (Application Programming Interface, Interface de programação de aplicativos) externa.
Como sempre, o ActionScript 2.0 fornece várias palavras-chave e conceitos avançados e
familiares de OOP (como classe, interface e pacote) encontrados em outras linguagens
de programação, como Java. A linguagem de programação permite criar estruturas de
programa reutilizáveis, dimensionáveis, resistentes e fáceis de manter. Ela também diminui o
tempo de desenvolvimento fornecendo aos usuários assistência completa sobre codificação e
informações de depuração. Você pode usar o ActionScript 2.0 para criar objetos e estabelecer
herança, bem como para criar classes personalizadas e estender as classes de nível superior e
internas do Flash. Neste capítulo, você aprenderá a criar classes e a usar classes personalizadas.
O Flash Basic 8 e o Flash Professional 8 contêm aproximadamente 65 classes de nível superior
e internas que fornecem desde tipos de dados básicos, ou “primitivos” (Array, Boolean, Date e
assim por diante), a erros e eventos personalizados, além de várias maneiras de carregar
conteúdo externo (XML, imagens, dados binários brutos e muito mais). Você também pode
criar suas próprias classes personalizadas e integrá-las aos documentos do Flash ou, até mesmo,
estender as classes de nível superior e adicionar sua própria funcionalidade ou modificar a
funcionalidade existente. Por exemplo, este capítulo mostra como criar uma classe Person
personalizada em “Sobre membros de classe” na página 265, que contém propriedades
personalizadas relativas ao nome e à idade de uma pessoa. Depois, você pode tratar essa classe
personalizada como um novo tipo de dados em seus documentos e criar uma nova instância
da classe usando o operador new.
Para obter mais informações sobre como trabalhar com programação orientada a objeto,
■
“As vantagens de usar classes” na página 241
■
“Sobre pacotes” na página 242
■
“Sobre valores e tipos de dados” na página 245
■
“Princípios da programação orientada a objeto” na página 246
As vantagens de usar classes
Na OOP, uma classe define uma categoria de objeto. Uma classe descreve as propriedades
(dados) e o método (comportamentos) de um objeto, da mesma maneira que uma planta
arquitetônica descreve as características de uma construção. As classes personalizadas são
criadas em um arquivo externo do ActionScript (AS), e você pode importá-las para o seu
aplicativo ao compilar o arquivo FLA.
Sobre a programação orientada a objeto e o Flash
241
As classes podem ser muito úteis quando você cria aplicativos Flash maiores, pois grande parte
da complexidade do aplicativo pode ser organizada em arquivos de classes externos. Ao mover
grande parte da lógica para uma classe personalizada, você não só facilita a reutilização do
código, como também pode “ocultar” alguns dos métodos e das propriedades de outras partes
do código ActionScript. Isso ajuda a impedir que outras pessoas acessem informações
confidenciais ou alterem dados que não devem ser alterados.
Ao usar uma classe, você também pode estender as classes existentes e adicionar nova
funcionalidade ou modificar a funcionalidade existente. Por exemplo, se você criar três classes
muito semelhantes, poderá criar uma classe base e, em seguida, duas outras que estendam essa
classe. Essas duas classes podem adicionar outros métodos e propriedades, de modo que você
não precise criar três arquivos de classe que dupliquem o mesmo código e a mesma lógica.
Outra vantagem de usar classes é a capacidade de reutilizar o código. Por exemplo, se você
criar uma classe personalizada que crie uma barra de progresso personalizada usando a
interface de programação de aplicativos (API) Drawing, poderá salvar a classe de barra de
progresso em seu caminho de classe e reutilizar o mesmo código em todos os documentos do
Flash importando a classe personalizada. Para obter mais informações sobre como definir o
caminho de classe, consulte “Sobre a importação de arquivos de classes” na página 254 e
Sobre pacotes
Ao criar classes, organize seus arquivos de classes do ActionScript em pacotes. Um pacote é um
diretório que contém um ou mais arquivos de classes e reside em um diretório determinado do
caminho de classe (consulte “Sobre a importação de arquivos de classes” na página 254 e
“Sobre a definição e a modificação do caminho de classe” na página 255). Um pacote pode,
por sua vez, conter outros pacotes, chamados subpacotes, cada um com seus próprios arquivos
de classes.
Assim como as variáveis, os nomes de pacotes podem ser identificadores; ou seja, o primeiro
caractere pode ser uma letra, sublinhado (_) ou cifrão ($) e os caracteres seguintes podem ser
uma letra, número, sublinhado ou cifrão. Existem maneiras mais usadas de atribuir nomes a
pacotes, por exemplo, a recomendação de evitar usar caracteres sublinhados ou de cifrão. Para
obter mais informações sobre atribuição de nome a pacotes, consulte “Atribuindo nomes a
pacotes” na página 777.
Os pacotes normalmente são usados para organizar classes relacionadas. Por exemplo, você
pode ter três classes relacionadas, Square, Circle e Triangle, que são definidas em Square.as,
Circle.as e Triangle.as. Suponha que você tenha salvo os arquivos ActionScript em um
diretório especificado do caminho de classe, como mostra o seguinte exemplo:
242
Classes
// Em Square.as:
class Square {}
// Em Circle.as:
class Circle {}
// Em Triangle.as:
class Triangle {}
Como esses três arquivos de classes estão relacionados, você pode decidir colocá-los em um
pacote (diretório) chamado Shapes. Nesse caso, o nome de classe totalmente qualificado
conterá o caminho do pacote e o nome de classe simples. Os caminhos de pacotes são
denotados com a sintaxe de ponto (.), na qual cada ponto indica um subdiretório.
Por exemplo, se você tivesse colocado no diretório Shapes cada arquivo ActionScript que
define uma forma, seria necessário alterar o nome de cada arquivo de classe para refletir o novo
local, da seguinte maneira:
// Em Shapes/Square.as:
class Shapes.Square {}
// Em Shapes/Circle.as:
class Shapes.Circle {}
// Em Shapes/Triangle.as:
class Shapes.Triangle {}
Para fazer referência a uma classe que se encontra em um diretório de pacote, você poderá
especificar seu nome de classe totalmente qualificado ou importar o pacote usando a instrução
import. Para obter mais informações, consulte “Trabalhando com pacotes” na página 244.
Comparação de classes e pacotes
Na OOP, uma classe define uma categoria de objeto. As classes são essencialmente tipos de
dados que você poderá criar se desejar definir um novo tipo de objeto em seu aplicativo. Uma
classe descreve as propriedades (dados) e os comportamentos (métodos) de um objeto, da mesma
maneira que uma planta arquitetônica descreve as características de uma construção. As
propriedades (variáveis definidas em uma classe) e os métodos da classe são designados
coletivamente como os membros da classe. Para usar as propriedades e os métodos definidos
por uma classe, geralmente você cria primeiro uma instância dessa classe (exceto no caso de
classes com membros estáticos, consulte “Sobre os membros de classe (estáticos)”
na página 315, como a classe Math de nível superior e “Propriedades e métodos estáticos”
na página 264). A relação entre uma instância e sua classe é semelhante à existente entre uma
casa e sua planta arquitetônica.
243
No Flash, os pacotes são diretórios que contêm um ou mais arquivos de classes e residem em
um caminho de arquivo designado. É possível colocar arquivos de classes personalizados
relacionados em um mesmo diretório. Por exemplo, você pode ter três classes relacionadas
chamadas SteelWidget, PlasticWidget e WoodWidget que são definidas em SteelWidget.as,
PlasticWidget.as e WoodWidget.as. Essas classes seriam organizadas no pacote Widget. Para
obter mais informações sobre pacotes, consulte “Trabalhando com pacotes” na página 244 e
“Criando e empacotando arquivos de classes” na página 281.
Trabalhando com pacotes
Pacotes são diretórios que contêm um ou mais arquivos de classes e residem em um diretório
específico do caminho da classe. Por exemplo, o pacote flash.filters é um diretório no disco
rígido que contém diversos arquivos de classe para cada tipo de filtro (tais como BevelFilter,
BlurFilter, DropShadowFilter e assim por diante) no Flash 8.
N OT A
Para usar a instrução import, é necessário especificar ActionScript 2.0 e Flash Player 6
ou uma versão posterior na guia Flash da caixa de diálogo Publish Settings
(Configurações de publicação) do arquivo FLA.
A instrução import permite acessar classes sem especificar os nomes totalmente qualificados.
Por exemplo, se você quiser usar a classe BlurFilter em um script, você deve referir-se a ela pelo
nome totalmente qualificado (flash.filters.BlurFilter) ou importá-la; se você a importar,
poderá então fazer referência a ela pelo nome da classe (BlurFilter). O código ActionScript a
seguir demonstra as diferenças entre usar a instrução import e usar nomes de classe
totalmente qualificados.
Se você não importar a classe BlurFilter, o seu código precisa usar o nome de classe totalmente
qualificado (nome do pacote seguido do nome da classe) a fim de usar o filtro:
// sem importação
var myBlur:flash.filters.BlurFilter = new flash.filters.BlurFilter(10, 10,
3);
O mesmo código, escrito com uma instrução import, permite acessar o BlurFilter usando
somente o nome da classe em vez de sempre ter que usar o nome totalmente qualificado. Isso
pode representar menos tempo de digitação e reduzir a possibilidade de erros:
// com importação
import flash.filters.BlurFilter;
var myBlur:BlurFilter = new BlurFilter(10, 10, 3);
Se você estiver importando diversas classes em um pacote (tais como BlurFilter,
DropShadowFilter e GlowFilter) você pode usar um dos métodos de importar cada classe. O
primeiro método de importação de diversas classes é importar cada classe usando uma
instrução import separada, conforme observado no trecho a seguir:
244
Classes
import flash.filters.BlurFilter;
import flash.filters.DropShadowFilter;
import flash.filters.GlowFilter;
Usando instruções import individuais para cada classe em um pacote pode tornar-se muito
desgastante e pode levar a erros de digitação. O segundo método de importação de classes em
um pacote é usar um caractere curinga que importa todas as classes dentro de um determinado
nível de um pacote. O ActionScript a seguir mostra um exemplo de importação com caractere
curinga:
import flash.filters.*; // importa cada classe dentro de um pacote
flash.filters
A instrução import aplica-se apenas ao script atual (quadro ou objeto) no qual ela é chamada.
Por exemplo, suponha que você importe todas as classes do pacote macr.util no Frame 1
(Quadro 1) de um documento do Flash. Nesse quadro, você pode fazer referência às classes
desse pacote por seus nomes de classe em vez de usar os nomes totalmente qualificados. Se
você quisesse usar o nome de classe em outro script de quadro, no entanto, você deveria
referenciar classes naquele pacote pelos nomes totalmente qualificados ou adicionar uma
instrução import ao outro quadro que importa as classes naquele pacote.
Ao usar instruções import, também é importante observar que classes são importadas
somente para o nível especificado. Por exemplo, se você importou todas as classes no pacote
mx.transitions, somente as classes no diretório /transitions/ serão importadas, e não todas as
classes dentro dos subdiretórios (tais como as classes no pacote mx.transitions.easing).
DICA
Se você importar uma classe, mas não a usar no script, a classe não será exportada
como parte do arquivo SWF. Isso significa que você pode importar pacotes grandes
sem se preocupar com o tamanho do arquivo SWF. O bytecode associado a uma classe
será incluído em um arquivo SWF somente se a classe for realmente usada.
Sobre valores e tipos de dados
Dados, valores e tipos são conceitos importantes quando você começa a criar classes e a usálas. Você aprendeu sobre dados e tipos em Capítulo 4, “Dados e tipos de dados”, na
página 75. Ao trabalhar com classes, lembre-se de que os tipos de dados descrevem o tipo de
informação que uma variável ou um elemento do ActionScript pode conter, como Boolean,
Number e String. “Sobre tipos de dados” na página 76Para obter mais informações, consulte .
As expressões têm valores, enquanto os valores e as propriedades têm tipos. Os valores que
podem ser definidos, bem como fornecidos e obtidos de uma propriedade de uma classe,
devem ser compatíveis com essa propriedade. A compatibilidade indica que o tipo de um valor
é compatível com o tipo em uso, como no seguinte exemplo:
245
Para obter mais informações sobre como atribuir tipos de dados estritos, consulte “Sobre a
atribuição de tipos de dados e a atribuição estrita de tipos de dados” na página 85.
Princípios da programação orientada a objeto
Nas seções a seguir, você examinará a terminologia usada neste capítulo antes de começar a
criar o código ActionScript. Esta breve introdução aos princípios envolvidos no
desenvolvimento de programas orientados a objeto o ajudará a acompanhar as seções e os
exemplos apresentados neste capítulo e no restante deste manual. Esses princípios são
descritos mais profundamente no restante deste capítulo, junto com os detalhes sobre como
eles são implementados no Flash 8.
As seções a seguir usam a analogia de um gato para demonstrar a semelhança entre gatos e os
conceitos de programação orientada a objeto (OOP).
Objetos
Considere um objeto do mundo real, como, por exemplo, um gato. Pode-se dizer que os gatos
têm propriedades (ou estados) como nome, idade e cor; eles também têm comportamentos,
como dormir, comer e ronronar. Na OOP, os objetos também têm propriedades e
comportamentos. Com as técnicas orientadas a objeto, é possível modelar um objeto do
mundo real (como um gato) ou um objeto mais abstrato (como um processo químico).
N OT A
A palavra comportamentos é usada genericamente aqui e não se refere ao painel
Behaviors (Comportamentos) do ambiente de criação do Flash.
Para obter mais informações sobre objetos, consulte “Tipo de dados Object” na página 83.
Instâncias e membros de classe
Continuando com a analogia do mundo real, considere que há gatos de cores, idades e nomes
diferentes, com maneiras diferentes de comer e ronronar. Porém, apesar de suas diferenças
individuais, todos os gatos são membros da mesma categoria, ou em termos da OOP, da
mesma classe: a classe de gatos. Na terminologia da OOP, cada gato é considerado como uma
instância da classe Cat.
Da mesma maneira, na OOP, uma classe define a estrutura de um tipo de objeto. As
características e os comportamentos pertencentes a uma classe são tratadas, em conjunto,
como membros dessa classe. As características (nome, idade e cor, no exemplo do gato) são
chamadas propriedades da classe e são representadas como variáveis; os comportamentos
(brincar, dormir) são chamados métodos da classe e são representados como funções.
246
Classes
Para obter mais informações sobre instâncias e membros de classe, consulte “Sobre membros
de classe” na página 265 e “Usando membros de classe” na página 269.
Herança
Uma das principais vantagens da OOP é a capacidade de criar subclasses de (ou estender) uma
classe; a subclasse herda todas as propriedades e métodos da classe. A subclasse normalmente
define métodos e propriedades adicionais ou sobrescreve métodos ou propriedades definidas
na superclasse. As subclasses também substituem (fornecem suas próprias definições para) os
métodos definidos em uma superclasse.
Uma das principais vantagens de usar uma estrutura de superclasse/subclasse é que é mais fácil
reutilizar código semelhante entre diversas classes. Por exemplo, você poderia criar uma
superclasse chamada Animal, que contém as características e os comportamentos comuns de
todos os animais. Em seguida, você poderia criar várias subclasses que herdam as
características da superclasse Animal e adicionar características específicas a esse tipo de
animal.
Você poderia criar uma classe Cat que herda características de outra classe. Por exemplo, você
pode criar uma classe Mamifero, que define certas propriedades e comportamentos comuns a
todos os mamíferos. em seguida, criar uma classe Cat que estenda essa classe. Outra subclasse,
como a classe Siamese, poderia estender a classe Cat (ou criar uma subclasse dela) e assim por
diante.
Criar subclasses permite reutilizar o código. Em vez de recriar todos os códigos comuns às
duas classes, você pode simplesmente estender uma classe existente.
DICA
Em um aplicativo complexo, determinar como estruturar a hierarquia das classes é uma
parte importante do projeto. Certifique-se de determinar essa hierarquia antes iniciar a
programação.
Para obter mais informações sobre herança e subclasses, consulte o Capítulo 8, “Herança”, na
página 319.
Interfaces
Na OOP, as interfaces podem ser descritas como modelos de definições de classes, e as classes
que implementam interfaces precisam implementar esse modelo de métodos. Usando a
analogia do gato, uma interface é semelhante à planta arquitetônica de um gato: a planta
informa de que partes você precisa, mas não necessariamente como essas partes são montadas,
ou como as partes funcionam.
247
Você pode usar interfaces para adicionar estrutura e facilitar a manutenção dos aplicativos.
Como o ActionScript 2.0 oferece suporte somente à extensão de uma única superclasse, as
interfaces podem ser usadas como uma forma de herança múltipla limitada.
Uma interface também pode ser considerada como um “contrato de programação” que pode
ser usado para impor os relacionamentos entre classes não relacionadas de outra maneira. Por
exemplo, suponha que você esteja trabalhando com uma equipe de programadores, cada um
responsável por uma parte diferente (classe) do mesmo aplicativo. Ao projetar o aplicativo,
você estabelece um conjunto de métodos que as diferentes classes usam para se comunicarem.
Portanto, você cria uma interface que declara esses métodos, seus parâmetros e tipos de
retorno. Qualquer classe que implemente essa interface deve fornecer definições para esses
métodos; caso contrário, ocorrerá um erro do compilador.
Para obter mais informações sobre herança, consulte Capítulo 8, “Herança”, na página 319.
Para obter mais informações sobre interfaces, consulte o Capítulo 9, “Interfaces”, na
página 331.
Encapsulamento
Em um projeto orientado a objeto bem elaborado, os objetos são considerados como “caixaspretas” que contêm ou encapsulam funcionalidade. O programador deve ser capaz de interagir
com um objeto conhecendo somente suas propriedades, métodos e eventos (sua interface de
programação), sem conhecer os detalhes de sua implementação. Essa abordagem permite que
os programadores utilizem níveis mais elevados de abstração e fornece uma estrutura de
organização para a criação de sistemas complexos.
O encapsulamento é o motivo pelo qual o ActionScript 2.0 inclui, por exemplo, controle de
acesso a membros, permitindo que os detalhes da implementação permaneçam privados e
invisíveis para o código externo aos objetos. O código externo ao objeto é forçado a interagir
com a interface de programação do objeto em vez de com os detalhes da implementação (o
que pode ser oculto em métodos e propriedades privados. Essa abordagem oferece algumas
vantagens importantes; por exemplo, ela permite que o criador do objeto altere a sua
implementação sem a necessidade de alterar o código externo ao objeto, ou seja, desde que a
interface de programação não seja alterada.
Para obter mais informações sobre encapsulamento, consulte “Sobre o uso de
encapsulamento” na página 276.
248
Classes
Polimorfismo
A OOP permite expressar as diferenças entre classes individuais usando uma técnica chamada
polimorfismo, pela qual as classes podem substituir os métodos de suas superclasses e definir
implementações especializadas desses métodos. No Flash, as subclasses podem definir
implementações especializadas de métodos herdados da superclasse, mas não podem acessar a
implementação da superclasse como em outras linguagens de programação.
Por exemplo, você pode criar inicialmente uma classe chamada Mammal com os métodos
play() e sleep() e, em seguida, criar as subclasses Cat, Monkey e Dog para estender essa
classe. As subclasses substituem o método play() da classe Mammal para refletir os hábitos
desses tipos específicos de animais. Monkey implementa o método play() para pendurar-se
nos galhos de árvores; Cat implementa o método play() para avançar em um novelo de lã;
Dog implementa o método play() para apanhar uma bola. Como a funcionalidade sleep()
é semelhante entre os animais, você usaria a implementação de superclasse.
Para obter mais informações sobre polimorfismo, consulte o Capítulo 8, “Herança”, na
página 319 e “Usando o polimorfismo em um aplicativo” na página 327.
Criando arquivos de classes
personalizados
O exemplo a seguir examina as partes de um arquivo de classe. Você aprenderá a criar uma
classe e a modificá-la para que possa usá-la de várias maneiras com o Flash. Você também
aprenderá sobre as partes de uma classe, como importá-las e como trabalhar com arquivos de
classes personalizados no Flash.
Em primeiro lugar, você examinará uma classe muito simples. O exemplo a seguir mostra a
organização de uma classe simples chamada UserClass.
Para definir uma classe, use a palavra-chave class em um arquivo de script externo, e não em
um script criado no painel Actions (Ações). A estrutura de classes também é relevante para os
arquivos de interface. Essa estrutura é ilustrada a seguir e, depois da ilustração, você criará uma
classe.
■
O arquivo de classe inicia com comentários de documentação que incluem uma descrição
geral do código, bem como informações sobre autor e versão.
■
Adicione suas instruções import (se aplicável).
■
Crie uma instrução de pacote, uma declaração de classe ou uma declaração de interface, da
seguinte maneira:
class UserClass {...}
Criando arquivos de classes personalizados
249
■
Inclua os comentários necessários sobre a implementação de classe ou interface. Nesses
comentários, adicione informações pertinentes à toda classe ou interface.
■
Adicione todas as variáveis estáticas. Escreva as variáveis de classe pública primeiro,
seguidas de variáveis de classe privada.
■
Adicione variáveis de instância. Escreva primeiro as variáveis membro públicas, seguidas
das variáveis membro privadas.
■
Adicione a instrução construtora, como a do exemplo abaixo:
public function UserClass(username:String, password:String) {...}
■
Escreva os métodos. Agrupe-os por funcionalidade, e não por acessibilidade ou escopo. A
organização dos métodos dessa maneira aumenta a legibilidade e a clareza do código.
■
Escreva os métodos getter/setter no arquivo de classe.
O exemplo a seguir examina uma classe simples do ActionScript chamada User.
Para criar arquivos de classes:
1.
Selecione File (Arquivo) > New (Novo), selecione ActionScript File (Arquivo ActionScript)
e, em seguida, clique em OK.
2.
Selecione File > Save As (Salvar como) e atribua o nome User.as ao novo arquivo.
3.
Digite o seguinte código ActionScript na janela Script:
/**
Classe de usuário
author: John Doe
version: 0.8
modified: 08/21/2005
copyright: Macromedia, Inc.
Esse código define uma classe User personalizada que permite criar
novos usuários e especificar as informações de login dos usuários.
*/
class User {
// variáveis de instância privadas
private var __username:String;
private var __password:String;
// instrução construtora
public function User(p_username:String, p_password:String) {
this.__username = p_username;
this.__password = p_password;
}
public function get username():String {
return this.__username;
}
250
Classes
public function set username(value:String):Void {
this.__username = value;
}
public function get password():String {
return this.__password;
}
public function set password(value:String):Void {
this.__password = value;
}
}
4.
Salve as alterações no arquivo de classe.
O trecho de código anterior inicia com um comentário de documentação padronizado, que
especifica o nome da classe, o autor, a versão, a data da última modificação, informações
de copyright e uma breve descrição do que a classe faz.
A instrução construtora da classe User utiliza dois parâmetros: p_username e p_password,
que são copiados para as variáveis de instância privadas __username e __password da
classe. O restante do código da classe define as propriedades getter e setter das variáveis de
instância privadas. Para criar uma propriedade somente leitura, você definiria uma função
getter, mas não uma função setter. Por exemplo, para garantir que um nome de usuário
não seja alterado após ser definido, você excluiria a função setter username do arquivo de
classe User.
5.
Selecione File > New e, em seguida, selecione Flash Document (Documento Flash).
6.
Selecione File > Save As e atribua o nome user_test.fla ao arquivo. Salve o arquivo no
mesmo diretório que User.as.
7.
import User;
var user1:User = new User("un1", "pw1");
trace("Before:");
trace("\t username = " + user1.username);
trace("\t password = " + user1.password);
user1.username = "1nu";
user1.password = "1wp";
trace("After:");
trace("\t username = " + user1.username);
trace("\t password = " + user1.password);
// un1
// pw1
// 1nu
// 1wp
Como a classe User criada anteriormente é muito básica, o ActionScript contido no
documento do Flash também é muito simples. A primeira linha do código importa a
classe User personalizada para o documento do Flash. A importação dessa classe permite
usá-la como um tipo de dados personalizado.
Criando arquivos de classes personalizados
251
Uma única instância da classe User é definida e atribuída a uma variável chamada user1.
Você atribui um valor ao objeto User user1 e define username como un1 e password
como pw1. As duas instruções trace apresentadas a seguir exibem o valor atual de
user1.username e user1.password utilizando as funções getter da classe User, que
retornam seqüências de caracteres. A duas próximas linhas usam as funções setter da classe
User a fim de definir novos valores para as variáveis username e password. Finalmente,
você exibe os valores de username e password no painel Output (Saída). As instruções
trace exibem os valores modificados definidos com as funções setter.
8.
Salve o arquivo FLA e selecione Control (Controlar) > Test Movie (Testar filme) para testar
os arquivos.
Você verá os resultados das instruções trace no painel Output. Nos próximos exemplos,
você usará esses arquivos em um aplicativo.
Um arquivo de exemplo no disco rígido demonstra como criar um menu dinâmico com dados
XML e um arquivo de classe personalizado. O exemplo chama o construtor XmlMenu() do
ActionScript e passa dois parâmetros: o caminho para o arquivo de menu XML e uma
referência à timeline atual. O resto da funcionalidade reside em um arquivo de classe
personalizado, XmlMenu.as.
Você pode encontrar o arquivo de origem de exemplo, xmlmenu.fla, na pasta Samples
(Exemplos) no disco rígido.
■
8\Samples and Tutorials\Samples\ActionScript\XML_Menu.
■
and Tutorials/Samples/ActionScript/XML_Menu.
Sobre como trabalhar com classes
personalizadas em um aplicativo
Em “Criando arquivos de classes personalizados” na página 249, você criou um arquivo de
classe personalizado. Nas seções a seguir, você usará esse arquivo em um aplicativo. O fluxo de
trabalho para a criação de classes envolve, no mínimo, as seguintes etapas:
1.
Definir uma classe em um arquivo de classe externo do ActionScript. Para obter
informações sobre como definir e criar um arquivo de classe, consulte “Criando arquivos
de classes personalizados” na página 249.
252
Classes
2.
Salvar o arquivo de classe no diretório de caminho de classe designado (o local em que o
Flash procura as classes) ou no mesmo diretório que o arquivo FLA do aplicativo. Para
obter mais informações sobre como definir o caminho de classe, consulte “Sobre a definição
e a modificação do caminho de classe” na página 255. Para ver uma comparação e obter
mais informações sobre a importação de arquivos de classes, consulte “Sobre a importação
de arquivos de classes” na página 254.
3.
Criar uma instância da classe em outro script, em um documento FLA ou em um arquivo
de script externo, ou criando uma subclasse com base na classe original. Para obter mais
informações sobre a criação de instâncias de uma classe, consulte “Criando instâncias de
classes em um exemplo” na página 294.
As seções subseqüentes deste capítulo contêm exemplos de código que você poderá usar para
se familiarizar com a criação de classes no ActionScript 2.0. Se não estiver familiarizado com o
ActionScript 2.0, leia o Capítulo 4, “Dados e tipos de dados”, na página 75 e o Capítulo 5,
“Fundamentos da sintaxe e da linguagem”, na página 119
Para obter mais informações sobre como trabalhar com classes personalizadas, consulte os
seguintes tópicos:
■
“Sobre a importação de arquivos de classes” na página 254
■
“Usando um arquivo de classe no Flash” na página 259
■
“Usando métodos e propriedades de um arquivo de classe” na página 260
■
“Sobre membros de classe” na página 265
■
“Sobre os métodos getter e setter” na página 270
■
“Como o compilador resolve as referências de classes” na página 258
■
“Sobre classes dinâmicas” na página 273
■
“Sobre o uso de encapsulamento” na página 276
■
“Sobre o uso da palavra-chave this em classes” na página 277
■
■
Sobre como trabalhar com classes personalizadas em um aplicativo
253
Sobre a importação de arquivos de classes
Para usar uma classe ou uma interface definida, o Flash deve localizar os arquivos externos do
ActionScript que contêm a definição da classe ou da interface de modo que possa importar o
arquivo. A lista de diretórios na qual o Flash procura as definições de classes, interfaces,
funções e variáveis é denominada caminho de classe. O Flash possui duas configurações de
caminho de classe, um caminho de classe global e um em nível de documento:
é um caminho de classe compartilhado por todos os
documentos do Flash e Você deve configurá-lo na caixa de diálogo Preferences
(Preferências) (Edit (Editar) > Preferences (Windows) ou Flash > Preferences (Macintosh),
clique em ActionScript na lista Category (Categoria) e, em seguida, clique em
ActionScript 2.0 Settings (Configurações do ActionScript 2.0)).
■
Caminho de classe global
■
Caminho de classe em nível de documento é um caminho de classe definido
especificamente para um único documento do Flash, Ele é configurado na caixa de diálogo
Publish Settings (Configurações de publicação) (File > Publish Settings, selecione a guia
Flash e, em seguida, clique no botão Settings, Configurações).
As seguintes regras se aplicam à importação de arquivos de classes:
■
■
As instruções import podem existir nos seguintes locais:
■
Qualquer local antes da definição de classe nos arquivos de classe
■
Qualquer local nos scripts de quadro ou de objetos
■
Qualquer local nos arquivos ActionScript que você incluir em um aplicativo (usando a
instrução #include).
Para importar definições empacotadas individuais, use esta sintaxe:
import flash.display.BitmapData;
■
Você pode importar pacotes inteiros com a sintaxe de caracteres curingas:
import flash.display.*;
Você também pode incluir código ActionScript em um arquivo de documento do Flash (FLA)
usando uma instrução include. As seguintes regras se aplicam à instrução include:
■
Essencialmente, as instruções include copiam e colam o conteúdo no arquivo incluído do
ActionScript.
■
As instruções include dentro dos arquivos de classe do ActionScript são relativas ao
subdiretório que contém o arquivo.
254
Classes
■
Em um arquivo do Flash (FLA), as instruções include só podem inserir código válido em
arquivos FLA, e a mesma regra se aplica aos outros locais em que as instruções include
podem residir. Por exemplo, se uma definição de classe contiver uma instrução include,
somente definições de propriedades e de métodos poderão existir no arquivo incluído do
ActionScript:
// Foo.as
class Foo {
#include "FooDef.as"
}
// FooDef.as:
var fooProp;
function fooMethod() {}
trace("Foo"); // Essa instrução não é permitida na definição de classe.
Para obter mais informações sobre a instrução include, consulte %{#include directive}% em
ActionScript 2.0 Language Reference (Referência da linguagem ActionScript). Para obter mais
informações sobre caminhos de classes, consulte “Sobre a definição e a modificação do
caminho de classe” na página 255.
Sobre a definição e a modificação do caminho de classe
Para usar uma classe ou uma interface definida, o Flash deve localizar os arquivos ActionScript
externos que contêm a definição da classe ou da interface. A lista de diretórios na qual o Flash
procura as definições de classes e interfaces é denominada caminho de classe.
Depois de criar um arquivo de classe do ActionScript, você precisa salvar o arquivo em um dos
diretórios especificados no caminho de classe ou em um subdiretório desse caminho. (Você
pode modificar o caminho de classe para incluir o caminho de diretório desejado). Caso
contrário, o Flash não poderá resolver, ou seja, localizar a classe ou a interface especificada no
script. Os subdiretórios criados em um diretório do caminho de classe chamam-se pacotes e
permitem a você organizar as suas classes. (Para obter mais informações sobre pacotes,
consulte “Criando e empacotando arquivos de classes” na página 281.)
O Flash tem duas configurações de caminho de classe: um caminho de classe global e um
caminho de classe em nível de documento. O caminho de classe global é compartilhado por
todos os documentos do Flash. O caminho de classe em nível de documento é definido
especificamente para um único documento do Flash.
255
O caminho de classe global aplica-se aos arquivos ActionScript e FLA externos, e é definido na
caixa de diálogo Preferences (Preferências) (Windows: Edit (Editar) > Preferences (Windows)
ou Flash > Preferences (Macintosh), selecione ActionScript da lista Category (Categoria) e, em
seguida, clique em ActionScript 2.0 Settings (Configurações do ActionScript)). Você pode
definir o caminho de classe em nível de documento na caixa de diálogo Publish Settings
(Configurações de publicação) do documento do Flash (File (Arquivo) > Publish Settings,
selecione a guia Flash e, em seguida, clique no botão Settings (Configurações).
N OT A
Quando você clica no botão Check Syntax (Verificar sintaxe) acima do painel Script ao
editar um arquivo do ActionScript, o compilador examina somente o caminho de classe
global. Os arquivos do ActionScript não são associados a arquivos FLA no modo de
edição e não possuem o seu próprio caminho de classe.
Usando um caminho de classe global
O caminho de classe global é compartilhado por todos os documentos do Flash.
Você pode modificar o caminho de classe global usando a caixa de diálogo Preferences. Para
modificar a configuração do caminho de classe em nível de documento, use a caixa de diálogo
Publish Settings para o arquivo FLA. Nos dois casos, você pode adicionar caminhos de
diretório absolutos (por exemplo, C:/my_classes) e caminhos de diretório relativos (por
exemplo, ../my_classes ou “.”). A ordem dos diretórios na caixa de diálogo reflete a ordem
em que eles são pesquisados.
Por padrão, o caminho de classe global contém um caminho absoluto e outro relativo. O
caminho absoluto é denotado por $(LocalData)/Classes na caixa de diálogo Preferences. O
local do caminho absoluto é mostrado aqui:
■
Windows: Hard Disk\Documents and Settings\user\Local Settings\Application
■
Macintosh: Hard Disk/Users/usuário/Library/Application Support/Macromedia/Flash 8/
NO T A
Não exclua o caminho de classe global absoluto. O Flash utiliza esse caminho de
classe para acessar as classes internas. Se você acidentalmente excluir esse
caminho de classe, restabeleça-o adicionando $(LocalData)/Classes como um
novo caminho de classe.
A parte do caminho de classe global referente ao caminho relativo é denotada por um ponto
(.) e aponta para o diretório de documentos atual. Saiba que os caminhos de classe relativos
podem apontar para diretórios diferentes, dependendo do local do documento que está sendo
compilado ou publicado.
Para adicionar um caminho de classe global ou editar um caminho de classe existente, siga
estas etapas.
256
Classes
Para modificar o caminho de classe global:
1.
Selecione Edit (Editar) > Preferences (Preferências) (Windows) ou Flash > Preferences
(Macintosh) para abrir a caixa de diálogo Preferences.
2.
Clique no ActionScript na coluna esquerda e, em seguida, clique no botão ActionScript 2.0
Settings (Configurações do ActionScript 2.0).
3.
Clique no botão Browse to Path (Navegar até caminho) para navegar até o diretório que
deseja adicionar.
4.
Navegue até o caminho desejado e clique em OK.
Para excluir um diretório do caminho de classe:
1.
Selecione o caminho na lista Classpath (Caminho de classe).
2.
Clique no botão Remove from Path (Remover do caminho).
NO T A
Não exclua o caminho de classe global absoluto. O Flash utiliza esse caminho de
classe para acessar as classes internas. Se você acidentalmente excluir esse
caminho de classe, restabeleça-o adicionando $(LocalData)/Classes como um
novo caminho de classe.
Para obter informações sobre a importação de pacotes, consulte “Trabalhando com pacotes”
na página 244.
Usando um caminho de classe em nível de documento
O caminho de classe em nível de documento se aplica somente a arquivos FLA. Para defini-lo,
use a caixa de diálogo Publish Settings (Configurações de publicação) referente a um arquivo
FLA, em File (Arquivo) > Publish Settings, clique na guia Flash e, em seguida, clique em
ActionScript 2.0 Settings (Configurações do ActionScript 2.0). O padrão é que o caminho de
classe em nível de documento fique vazio. Quando você cria e salva um arquivo FLA em um
diretório, esse diretório torna-se um diretório de caminho de classe designado.
Ao criar classes, é possível que, algumas vezes, você deseje armazená-las em um diretório que
será adicionado posteriormente à lista de diretórios de caminho de classe global nas seguintes
situações:
■
Se você tiver um conjunto de classes utilitárias que sejam usadas em todos os seus projetos
■
Se você desejar verificar a sintaxe do seu código (clique no botão Check Syntax (Verificar
sintaxe)) dentro do arquivo ActionScript externo
A criação de um diretório evita a perda de classes personalizadas se você desinstalar e reinstalar
o Flash, especialmente se o diretório de caminho de classe global padrão for excluído e
substituído, porque todas as classes armazenadas nesse diretório seriam perdidas.
257
Por exemplo, você pode criar para suas classes personalizadas um diretório como o
apresentado a seguir:
■
Windows: Hard Disk\Documents and Settings\usuário\custom classes.
■
Macintosh: Hard Disk/Users/usuário/custom classes.
Em seguida, você adicionaria esse caminho à lista de caminhos de classe global (consulte
“Usando um caminho de classe global” na página 256).
Quando o Flash tenta resolver as referências de classes em um script FLA, ele pesquisa
primeiro o caminho de classe em nível de documento especificado para esse arquivo FLA. Se
ele não encontrar a classe nesse caminho ou se o caminho estiver vazio, ele pesquisará o
caminho de classe global. Se ele não encontrar a classe nesse caminho, ocorrerá um erro do
compilador.
Para modificar o caminho de classe no nível do documento:
1.
Selecione File > Publish Settings para abrir a caixa de diálogo Publish Settings.
2.
Clique na guia Flash.
3.
Clique no botão Settings perto do menu pop-up ActionScript Version (Versão do
ActionScript).
4.
Você pode digitar manualmente um caminho de arquivo ou clicar no botão Browse to Path
(Navegar até caminho) para navegar até o diretório que deseja adicionar ao caminho de
classe.
NO T A
Classpath (Caminho de classe), clique no botão Browse to Path, navegue até o
diretório que deseja adicionar e clique em OK.
N OT A
Para excluir um diretório do caminho de classe, selecione o caminho na lista
Classpath e clique no botão Remove Selected Path (-) (Remover o caminho
selecionado).
Para obter mais informações sobre pacotes, consulte “Sobre pacotes” na página 242.
Como o compilador resolve as referências de classes
Quando o Flash tenta resolver as referências de classes em um script FLA, ele pesquisa
primeiro o caminho de classe em nível de documento especificado para esse arquivo FLA. Se a
classe não for encontrada nesse caminho ou se o caminho estiver vazio, o Flash pesquisará o
caminho de classe global. Se a classe não for encontrada nesse caminho, ocorrerá um erro do
compilador.
258
Classes
No Flash Professional, quando você clica no botão Check Syntax (Verificar sintaxe) ao editar
um arquivo ActionScript, o compilador examina somente o caminho de classe global; os
arquivos ActionScript não são associados a arquivos FLA no modo de edição nem possuem o
seu próprio caminho de classe.
Usando um arquivo de classe no Flash
Para criar uma instância de uma classe do ActionScript, use o operador new para chamar a
função construtora da classe. A função construtora sempre tem o mesmo nome da classe e
retorna uma instância da classe, que você normalmente atribui a uma variável. Por exemplo, se
estivesse usando a classe User criada em “Criando arquivos de classes personalizados”
na página 249, você escreveria o seguinte código para criar um objeto User:
var firstUser:User = new User();
N OT A
Em alguns casos, não é necessário criar uma instância de uma classe para usar suas
propriedades e métodos. Para obter mais informações sobre membros (estáticos) de
classes, consulte “Sobre os membros de classe (estáticos)” na página 315 e
“Propriedades e métodos estáticos” na página 264.
Use o operador ponto (.) para acessar o valor de uma propriedade em uma instância. Digite o
nome da instância à esquerda do ponto e o nome da propriedade à direita. Por exemplo, na
instrução a seguir, firstUser é a instância e username é a propriedade:
firstUser.username
Você também pode usar em um documento do Flash as classes de nível superior ou internas
da linguagem ActionScript. Por exemplo, o código a seguir cria um novo objeto Array e,
depois, mostra sua propriedade length:
var myArray:Array = new Array("apples", "oranges", "bananas");
trace(myArray.length); // 3
Para obter mais informações sobre o uso de classes personalizadas no Flash, consulte o
“Exemplo: Usando arquivos de classes personalizados no Flash” na página 291. Para obter
informações sobre a função construtora, consulte “Criando a função construtora”
na página 283.
259
Usando métodos e propriedades de um arquivo de
classe
Na OOP, os membros (propriedades ou métodos) de uma classe podem ser membros de
instância ou membros de classe. Os membros de instância são criados para cada instância da
classe; eles são definidos para o protótipo da classe quando são inicializados na definição de
classe. Os membros de classe, por outro lado, são criados uma vez por classe. (Os membros da
classe também são conhecidos como membros estáticos.)
Propriedades são atributos que definem um objeto. Por exemplo, length é uma propriedade
de todos os arrays que especifica o número de elementos do array. Métodos são funções
associadas a uma classe. Para obter mais informações sobre funções e métodos, consulte o
Capítulo 6, “Funções e métodos”, na página 213.
O exemplo a seguir mostra como criar um método em um arquivo de classe:
class Sample {
public function myMethod():Void {
trace("myMethod");
}
}
Depois, você poderia chamar esse método em seu documento. Para chamar um método de
instância ou acessar uma propriedade de instância, você faz referência a uma instância da
classe. No exemplo a seguir, picture01, uma instância da classe personalizada Picture
(disponível no exercício a seguir), chama o método showInfo():
var img1:Picture = new Picture("http://www.helpexamples.com/flash/images/
image1.jpg");
// Chame o método showInfo().
img1.showInfo();
O próximo exemplo demonstra como criar uma classe personalizada Picture para armazenar
várias informações sobre uma foto.
Para usar as classes Picture e PictureClass em um arquivo FLA:
1.
ActionScript). Salve o documento como Picture.as e, em seguida, clique em OK.
Crie sua classe Picture personalizada nesse documento.
2.
/**
Picture class
author: John Doe
version: 0.53
modified: 6/24/2005
260
Classes
A classe Picture é usada como um recipiente para uma imagem e seu URL.
*/
class Picture {
private var __infoObj:Object;
public function Picture(src:String) {
this.__infoObj = new Object();
this.__infoObj.src = src;
}
public function showInfo():Void {
trace(this.toString());
}
private function toString():String {
return "[Picture src=" + this.__infoObj.src + "]";
}
public function get src():String {
return this.__infoObj.src;
}
public function set src(value:String):Void {
this.__infoObj.src = value;
}
}
3.
Salve o arquivo do ActionScript.
4.
Selecione File > New Flash Document (Documento do Flash) para criar um arquivo FLA.
Salve-o como picture_test.fla no mesmo diretório em que salvou o arquivo de classe
Picture.
5.
tempo):
var picture1:Picture = new Picture("http://www.helpexamples.com/flash/
images/image1.jpg");
picture1.showInfo();
img_mc.loadMovie(picture1.src);
6.
Salve o documento do Flash.
7.
O seguinte texto é exibido no painel Output:
[Picture src=http://www.helpexamples.com/flash/images/image1.jpg]
261
■
■
Sobre propriedades (membros) e métodos públicos, privados
e estáticos
Ao criar arquivos de classes do ActionScript em um arquivo de script externo, você poderá
criar quatro tipos de métodos e propriedades: métodos públicos e propriedades, métodos
privados e propriedades, métodos estáticos públicos e propriedades e métodos estáticos
privados e propriedades. Esses métodos e propriedades definem como o Flash pode acessar
variáveis e permitem especificar quais partes do código podem acessar determinados métodos
ou propriedades.
Ao criar aplicativos pequenos ou grandes baseados em classes, é importante considerar se um
método ou propriedade deve ser privado ou público. Isso garantirá a segurança máxima do
código. Por exemplo, se você criar uma classe User, talvez não deseje que os usuários dessa
classe sejam capazes de alterar a ID de outros usuários. Definindo a propriedade da classe (às
vezes chamada membro de instância) como privada, você poderá limitar ao código da classe
ou das subclasses dessa classe o acesso à propriedade, o que significa que nenhum usuário
poderá alterar essa propriedade diretamente.
Propriedades e métodos públicos
A palavra-chave public especifica que uma variável ou função está disponível para qualquer
chamador. Como as variáveis e as funções são públicas por padrão, a palavra-chave this é
usada principalmente por razões estilísticas e de legibilidade, indicando que a variável existe
no escopo atual. Por exemplo, você pode usá-la para manter a consistência em um bloco de
código que também contém variáveis privadas ou estáticas. Ela pode ser usada como palavrachave pública ou privada.
262
Classes
A classe Sample a seguir já contém um método público chamado myMethod():
class Sample {
private var ID:Number;
this.ID = 15;
trace(this.ID); // 15
trace("myMethod");
}
}
Se desejar adicionar uma propriedade pública, use a palavra “public” em vez de “private”,
como mostra o seguinte código de exemplo:
class Sample {
public var email:String;
trace("myMethod");
}
}
Como a propriedade email é pública, você pode alterá-la na classe Sample ou diretamente em
um FLA.
Propriedades e métodos privados
A palavra-chave private determina que uma variável ou função está disponível apenas para a
classe que a declara ou a define ou para subclasses dessa classe. Por padrão, uma variável ou
função é pública e está disponível para qualquer chamador. Use a palavra-chave this se
desejar restringir o acesso a uma variável ou função, como mostra o seguinte exemplo:
class Sample {
this.ID = 15;
trace(this.ID); // 15
trace("myMethod");
}
}
Para adicionar uma propriedade privada à classe anterior, você deve usar simplesmente a
palavra-chave private antes da palavra-chave var.
Se você tentar acessar a propriedade ID privada fora da classe Sample, você receberá um erro
de compilador e uma mensagem no painel Output (Saída). A mensagem indica que o
membro é privado e não pode ser acessado.
263
Propriedades e métodos estáticos
A palavra-chave static determina que uma variável ou função seja criada somente uma vez
por classe, em vez de em todos os objetos baseados nessa classe. Você pode acessar um membro
de classe estático sem criar uma instância da classe. As propriedades e os métodos estáticos
podem ser definidos no escopo público ou privado.
Os membros estáticos, também chamados membros de classe, são atribuídos à classe, e não a
uma instância da classe. Para chamar um método ou acessar uma propriedade da classe, você
faz referência ao nome da classe, em vez de a uma instância específica dela, como mostra o
seguinte código:
trace(Math.PI / 8); // 0.392699081698724
Se você digitar essa linha de código no painel de script do painel Actions (Ações), será exibido
um resultado no painel Output (Saída).
Por exemplo, no exemplo da classe Sample anterior, você poderia criar uma variável estática
para controlar quantas instâncias da classe foram criadas, como demonstrado no seguinte
código:
class Sample {
public static var count:Number = 0;
public var email:String;
public function Sample() {
Sample.count++;
trace("count updated: " + Sample.count);
}
trace("myMethod");
}
}
Toda vez que uma nova instância da classe Sample é criada, o método construtor apresenta o
número total de instâncias de classe Sample definidas até o momento.
Algumas das classes de nível superior do ActionScript têm membros de classe (ou membros
estáticos), como você viu anteriormente nesta seção ao chamar a propriedade Math.PI. Os
membros de classe (propriedades e métodos) são acessados ou chamados no nome da classe, e
não em uma instância dela. Portanto, você não cria uma instância da classe para usar essas
propriedades e métodos.
Por exemplo, a classe Math de nível superior consiste apenas em métodos e propriedades
estáticos. Para chamar qualquer um dos seus métodos, você não cria uma instância dessa
classe. Em vez disso, basta chamar os métodos na própria classe Math. O código a seguir
chama o método sqrt() da classe Math:
264
Classes
var squareRoot:Number = Math.sqrt(4);
trace(squareRoot); // 2
O código a seguir chama o método max() da classe Math, que determina o maior de dois
números:
var largerNumber:Number = Math.max(10, 20);
trace(largerNumber); // 20
Para obter mais informações sobre a criação de membros de classe, consulte “Sobre membros
de classe” na página 265 e “Usando membros de classe” na página 269.
■
■
Sobre membros de classe
A maioria dos membros (métodos e propriedades) abordados até agora neste capítulo são de
um tipo denominado membros de instância. Para cada membro de instância, há uma cópia
exclusiva desse membro em cada instância da classe. Por exemplo, a variável de membro email
da classe Sample tem um membro de instância, pois cada pessoa tem um endereço eletrônico
diferente.
Outro tipo de membro é o membro de classe. Há somente uma cópia de um membro de classe,
e ela é usada para a classe inteira. Qualquer variável declarada em uma classe, mas fora de uma
função, é uma propriedade da classe. No exemplo a seguir, a classe Person tem duas
propriedades, age e name, de tipo Number e String, respectivamente.
class Person {
public var age:Number;
public var username:String;
}
Igualmente, qualquer função declarada em uma classe é considerada um método da classe. No
exemplo da classe Person, você pode criar um método chamado getInfo().
265
class Person {
public var username:String;
public function getInfo():String {
// definição do método getInfo()
}
}
No trecho de código anterior, o método getInfo() da classe Person, bem como as
propriedades age e username, são membros de instância públicos. A propriedade age não
poderia ser considerada com um membro de classe, pois cada pessoa tem uma idade diferente.
Somente as propriedades e os métodos compartilhados por todos os indivíduos da classe
devem ser membros de classe.
Suponha que toda classe deva ter uma variável species que indique o nome em latim da
espécie que a classe representa. Para cada objeto Person, a espécie é Homo sapiens. Como não
valeria a pena armazenar uma cópia exclusiva da seqüência de caracteres "Homo sapiens"
para cada instância da classe, esse membro deve ser um membro de classe.
Os membros de classe são declarados com a palavra-chave static. Por exemplo, você poderia
declarar o membro de classe species com o seguinte código:
class Person {
public static var species:String = "Homo sapiens";
// ...
}
Você também pode declarar os métodos de uma classe como estáticos, como no seguinte
código:
public static function getSpecies():String {
return Person.species;
}
Os métodos estáticos podem acessar somente propriedades estáticas, e não propriedades de
instância. Por exemplo, o código a seguir resultará em um erro do compilador, porque o
método getAge() da classe faz referência à variável de instância age.
class Person {
public var age:Number = 15;
// ...
public static function getAge():Number {
return age; /* **Error**: Não é possível acessar variáveis de instância
em funções estáticas. */
}
}
Para resolver esse problema, você pode transformar o método em um método de instância ou
transformar a variável em uma variável de classe.
266
Classes
Para obter mais informações sobre membros de classe (também chamados propriedades
estáticas), consulte “Propriedades e métodos estáticos” na página 264.
■
■
Usando o padrão de design Singleton
Uma forma comum de usar membros de classe é com o padrão de design Singleton. Um
padrão de design define uma abordagem formal para estruturar o código. Geralmente, você
estrutura um padrão de design como uma solução para um problema comum de
programação. Há vários padrões de design estabelecidos, como o Singleton. Esse padrão
garante que uma classe tenha apenas uma instância e permite acessar globalmente a instância.
Para obter informações detalhadas sobre o padrão de design Singleton, consulte
www.macromedia.com/devnet/mx/coldfusion/articles/design_patterns.html.
Freqüentemente, há situações em que é necessário ter exatamente um objeto de determinado
tipo em um sistema. Por exemplo, em um jogo de xadrez, há somente um tabuleiro; da mesma
maneira, em cada país, há somente uma capital. Embora exista apenas um objeto, você deve
encapsular a funcionalidade desse objeto em uma classe. Entretanto, talvez você precise
gerenciar e acessar a instância única desse objeto. Uma das maneiras de fazer isso é usar uma
variável global; contudo, as variáveis globais não são desejáveis para a maioria dos objetos.
Uma abordagem melhor é fazer com que a classe gerencie a instância única do objeto usando
membros de classe. O exemplo a seguir mostra um uso padrão típico do design Singleton, em
que a instância Singleton é criada apenas uma vez.
Para usar o padrão de design Singleton:
1.
ActionScript). Salve o documento como Singleton.as.
267
2.
/**
Singleton class
author: John Doe
version: 0.53
modified: 6/24/2008
*/
class Singleton {
private static var instance:Singleton = null;
public function trackChanges():Void {
trace("tracking changes.");
}
public static function getInstance():Singleton {
if (Singleton.instance == null) {
trace("creating new Singleton.");
Singleton.instance = new Singleton();
}
return Singleton.instance;
}
}
3.
Salve o documento Singleton.as.
4.
Selecione File > New e, em seguida, selecione Flash Document (Documento do Flash) para
criar um arquivo FLA, e salve-o como singleton_test.fla no mesmo diretório em que foi
salvo o arquivo de classe Singleton.
5.
tempo):
Singleton.getInstance().trackChanges(); // controlando alterações.
var s:Singleton = Singleton.getInstance(); // controlando alterações.
s.trackChanges();
6.
7.
O objeto Singleton só será criado quando for necessário; ou seja, quando outro código
solicitá-lo chamando o método getInstance(). Esse procedimento é geralmente chamado
criação lenta e pode ajudar a tornar o seu código mais eficiente em várias circunstâncias.
268
Classes
Lembre-se de não usar nem classes de menos nem demais para o aplicativo, porque isso pode
levar a arquivos de classe malfeitos, o que pode prejudicar o desempenho do aplicativo ou do
seu fluxo de trabalho. Você deve sempre tentar usar arquivos de classe em vez de colocar
código em outros lugares (por exemplo, timelines); no entanto, evite criar muitas classes que
tenham uma pequena quantidade de funcionalidade ou algumas classes que realizem muitas
funcionalidades. Essas duas situações podem indicar design inadequado.
Usando membros de classe
É possível usar os membros de classe para manter as informações de estado de uma classe e
suas instâncias. Por exemplo, para acompanhar o número de instâncias que foram criadas de
uma determinada classe. Uma maneira fácil de fazer isso é usar uma propriedade da classe que
é incrementada sempre que uma nova instância é criada.
No exemplo a seguir, você criará uma classe Widget que define um contador de instância
simples e estático chamado widgetCount. Sempre que uma nova instância da classe é criada, o
valor de widgetCount é incrementado em 1, e o valor atual de widgetCount é exibido no
painel Output (Saída).
Para criar um contador de instância usando uma variável de classe:
1.
2.
class Widget {
//Inicialize a variável de classe
public static var widgetCount:Number = 0;
public function Widget() {
Widget.widgetCount++;
trace("Creating widget #" + Widget.widgetCount);
}
}
A variável widgetCount é declarada como estática, portanto, é inicializada como 0
somente uma vez. Sempre que a instrução construtora da classe Widget é chamada, ela
adiciona 1 a widgetCount e exibe o número da instância atual que está sendo criada.
3.
Salve o arquivo como Widget.as.
4.
Selecione File > New Flash document (Documento do Flash) para criar um arquivo FLA e
salve-o como widget_test.fla no mesmo diretório que Widget.as.
5.
Em widget_test.fla, digite o seguinte código no Frame 1 (Quadro 1) da Timeline (Linha de
tempo):
// Antes que você crie qualquer instância da classe,
// Widget.widgetCount é igual a zero (0).
269
trace("Widget count at start: " + Widget.widgetCount); // 0
var widget1:Widget = new Widget(); // 1
trace("Widget count at end: " + Widget.widgetCount); // 3
6.
Salve as alterações em widget_test.fla.
7.
Selecione Control > Test Movie para testar o arquivo.
O Flash exibe as seguintes informações no painel Output (Saída):
Widget count at
Creating widget
Creating widget
Creating widget
Widget count at
start: 0
# 1
# 2
# 3
end: 3
Sobre os métodos getter e setter
Getter e setter são métodos de acesso, ou seja, eles são geralmente uma interface pública para
alterar os membros privados de uma classe. Esses métodos são usados para definir uma
propriedade. Você acessa esses métodos como propriedades fora da classe, embora defina-os na
classe como métodos. As propriedades externas à classe podem ter um nome diferente do
nome da propriedade na classe.
O uso dos métodos getter e setter oferece algumas vantagens, como a capacidade de criar, com
uma funcionalidade sofisticada, membros que podem ser acessados como propriedades. Eles
também permitem criar propriedades somente leitura e somente gravação.
Embora os métodos getter e setter sejam úteis, evite uso excessivo porque, entre outros
problemas, eles podem dificultar a manutenção do código em determinadas situações. Além
disso, eles permitem o acesso à sua implementação de classes, como membros públicos. A
prática de OOP não recomenda o acesso direto às propriedades em uma classe.
Ao criar classes, procure sempre tornar o maior número possível de suas variáveis de instância
privadas e adicionar métodos getter e setter conforme adequado. Isso é recomendável porque,
muitas vezes, você não desejará permitir que os usuários alterem determinadas variáveis de
suas classes. Por exemplo, se tiver um método estático privado que controle o número de
instâncias criadas para uma classe específica, você não desejará que os usuários modifiquem
esse contador usando o código. Somente a instrução construtora deverá incrementar essa
variável quando for chamada. Nesse caso, você pode criar uma variável de instância privada e
permitir um método getter somente para a variável de contador; dessa maneira, os usuários só
poderão recuperar o valor atual usando o método getter e não poderão definir novos valores
com o método setter. A criação de um método getter sem um setter é uma forma simples de
tornar somente leitura determinadas variáveis de sua classe.
270
Classes
Usando métodos getter e setter
A sintaxe dos métodos getter e setter é a seguinte:
■
O método getter não usa parâmetros e sempre retorna um valor.
■
O método setter sempre usa um parâmetro e nunca retorna um valor.
As classes normalmente definem métodos getter que fornecem acesso de leitura e métodos
setter que fornecem acesso de gravação a uma propriedade específica. Por exemplo, imagine
uma classe que contenha uma propriedade userName:
private var userName:String;
Em vez de permitir que instâncias da classe acessem diretamente essa propriedade
(user.userName = "Buster", por exemplo), a classe pode ter dois métodos, getUserName()
e setUserName(), que serão implementados como mostra o seguinte exemplo:
Para usar métodos getter e setter:
1.
2.
class Login {
public function Login(username:String) {
this.__username = username;
}
public function getUserName():String {
}
public function setUserName(value:String):Void {
}
}
3.
Salve o documento do ActionScript como Login.as.
Como você pode observar, getUserName retorna o valor atual de userName, e
setUserName() define o valor de userName como o parâmetro de seqüência de caracteres
passado para o método.
4.
salve-o como login_test.fla no mesmo diretório que Login.as.
5.
principal:
var user:Login = new Login("RickyM");
// chamando o método getUserName()
271
var userName:String = user.getUserName();
trace(userName); // RickyM
// chamando o método setUserName()
user.setUserName("EnriqueI");
trace(user.getUserName()); // EnriqueI
6.
Selecione Control > Test Movie para testar o arquivo.
RickyM
EnriqueI
Entretanto, se desejar uma sintaxe mais concisa, use os métodos getter e setter implícitos.
Esses métodos permitem acessar as propriedades da classe de maneira direta e, ao mesmo
tempo, seguir as práticas recomendadas de OOP.
Para definir esses métodos, use os atributos de método get e set. Crie métodos que
obtenham ou definam o valor de uma propriedade e adicione a palavra-chave get ou set
antes do nome do método, como mostra o próximo exemplo:
N OT A
Os métodos getter/setter implícitos são abreviações sintáticas do método
Object.addProperty() encontrado no ActionScript 1.0.
Para usar métodos getter e setter implícitos:
1.
2.
class Login2 {
public function Login2(username:String) {
this.__username = username;
}
public function get userName():String {
}
public function set userName(value:String):Void {
}
}
3.
272
Salve o documento do ActionScript como Login2.as.
Classes
Lembre-se de que os métodos getter não utilizam parâmetros. Os métodos setter devem
ter exatamente um parâmetro obrigatório. Um método setter pode ter o mesmo nome de
um método getter no mesmo escopo. Os métodos getter e setter não podem ter o mesmo
nome de outras propriedades. Por exemplo, no código anterior em que você definiu
métodos getter e setter chamados userName, não poderia existir também uma propriedade
chamada userName na mesma classe.
4.
salve-o como login2_test.fla no mesmo diretório que Login2.as.
5.
principal:
var user:Login2 = new Login2("RickyM");
// chamando o método "get"
var userNameStr:String = user.userName;
trace(userNameStr); // RickyM
// chamando o método "set"
user.userName = "EnriqueI";
trace(user.userName); // EnriqueI
Diferentemente dos métodos comuns, os métodos getter e setter são chamados sem
parênteses ou argumentos. Os métodos getter e setter são chamados da mesma maneira
que uma propriedade de mesmo nome.
6.
Salve o documento do Flash e selecione Control (Controlar) > Test Movie (Testar filme)
para testar o arquivo.
RickyM
EnriqueI
N OT A
Não é possível usar atributos de métodos getter e setter em declarações de método
de interface.
Sobre classes dinâmicas
Ao adicionar a palavra-chave dynamic a uma definição de classe, você especifica que os objetos
com base nessa classe podem adicionar e acessar propriedades dinâmicas durante a execução.
Você deve criar classes dinâmicas somente se precisar especificamente dessa funcionalidade.
A verificação de tipo em classes dinâmicas é menos estrita que em classes não-dinâmicas, pois
os membros acessados na definição de classe e em instâncias da classe não são comparados
com aqueles definidos no escopo da classe. No entanto, ainda é possível realizar a verificação
de tipo das funções de membros de classes para detectar tipos de retorno e tipos de parâmetro.
273
Para obter informações sobre a criação de classes dinâmicas, consulte “Criando classes
dinâmicas” na página 274.
Criando classes dinâmicas
O padrão é que as propriedades e os métodos de uma classe sejam fixos. Ou seja, uma
instância de uma classe não pode criar ou acessar as propriedades ou os métodos que não
foram originalmente declarados ou definidos pela classe. Por exemplo, considere uma classe
Person que define duas propriedades, userName e age.
Para criar uma classe que não seja dinâmica:
1.
2.
Digite o seguinte ActionScript na janela Script:
class Person {
public var userName:String;
}
Se, em outro script, você criar uma instância da classe Person e tentar acessar uma
propriedade da classe que não existe, o compilador gerará um erro.
3.
Salve o arquivo no disco rígido como Person.as.
4.
Selecione File > New Flash Document (Documento do Flash) para criar um arquivo FLA
e clique em OK.
5.
Selecione File > Save As (Salvar como), atribua um nome ao arquivo person_test.fla e salve
o arquivo no mesmo diretório que a classe Person criada anteriormente.
6.
Adicione o código a seguir para criar uma nova instância da classe Person (firstPerson)
e tente atribuir um valor a uma propriedade chamada hairColor (que não existe na classe
Person):
var firstPerson:Person = new Person();
firstPerson.hairColor = "blue"; // Erro. Não existe uma propriedade com o
nome 'hairColor'.
7.
8.
Esse código gera um erro do compilador porque a classe Person não declara uma
propriedade chamada hairColor. Na maioria dos casos, é exatamente isso que você deseja
que aconteça. Embora os erros do compilador não sejam desejáveis, eles são muito úteis
para os programadores: mensagens de erro adequadas o ajudam a criar o código correto
apontando os erros no início do processo de codificação.
274
Classes
Entretanto, em alguns casos, você poderá adicionar e acessar, durante a execução,
propriedades ou métodos de uma classe que não foram definidos na classe original. O
modificador de classe dynamic permite que você faça exatamente isso.
Para criar uma classe dinâmica:
1.
2.
Selecione File > Save As (Salvar como) e atribua o nome Person2.as ao arquivo. Salve o
arquivo no disco rígido.
3.
dynamic class Person2 {
public var userName:String;
}
Esse ActionScript adiciona a palavra-chave dynamic à classe Person no exemplo anterior.
As instâncias da classe Person2 podem adicionar e acessar as propriedades e os métodos
não definidos nessa classe.
4.
Salve as alterações no arquivo do ActionScript.
5.
e clique em OK.
6.
Selecione File > Save As (Salvar como) e atribua o nome person2_test.fla ao novo arquivo.
Salve-o no mesmo diretório que Person2.as.
7.
Digite o código a seguir para criar uma nova instância da classe Person2 (firstPerson) e
atribua um valor a uma propriedade chamada hairColor (que não existe na classe
Person2).
var firstPerson:Person2 = new Person2();
firstPerson.hairColor = "blue";
trace(firstPerson.hairColor); // azul
8.
Salve as alterações no arquivo person2_test.fla.
9.
Como a classe personalizada do Flash é dinâmica, é possível adicionar métodos e
propriedades a ela durante a execução (quando o arquivo SWF é reproduzido). Quando
você testar o código, o texto azul deverá ser exibido no painel Output (Saída).
275
Ao desenvolver aplicativos, não convém tornar as classes dinâmicas, a menos que isso seja
necessário. Um dos motivos disso é que a verificação de tipo em classes dinâmicas é menos
estrita do que em classes não-dinâmicas, pois os membros acessados na definição e nas
instâncias da classe não são comparados com os definidos no escopo da classe. No entanto,
ainda é possível realizar a verificação de tipo das funções de membros de classes para detectar
tipos de retorno e tipos de parâmetro.
As subclasses de classes dinâmicas também são dinâmicas, com uma exceção. As subclasses da
classe MovieClip não são dinâmicas por padrão, embora a classe MovieClip seja dinâmica.
Essa implementação permite maior controle sobre as subclasses da classe MovieClip, pois você
tem a opção de torná-las dinâmicas ou não:
class A
dynamic
class C
class D
dynamic
extends
class B
extends
extends
class E
MovieClip {}
extends A {}
B {}
A {}
extends MovieClip{}
//
//
//
//
//
A
B
C
D
E
não é dinâmico
é dinâmico
é dinâmico
não é dinâmico
é dinâmico
Para obter informações sobre subclasses, consulte Capítulo 8, “Herança”, na página 319.
Sobre o uso de encapsulamento
Em um projeto orientado a objeto bem elaborado, os objetos são considerados como “caixaspretas” que contêm ou encapsulam funcionalidade. O programador deve ser capaz de interagir
com um objeto conhecendo somente suas propriedades, métodos e eventos (sua interface de
programação), sem conhecer os detalhes de sua implementação. Essa abordagem permite que
os programadores utilizem níveis mais elevados de abstração e fornece uma estrutura de
organização para a criação de sistemas complexos.
O encapsulamento é o motivo pelo qual o ActionScript 2.0 inclui, por exemplo, controle de
acesso a membros, de modo que os detalhes da implementação possam permanecer privados e
invisíveis para o código externo aos objetos. O código externo ao objeto é forçado a interagir
com a interface de programação do objeto em vez de com os detalhes da implementação. Essa
abordagem oferece algumas vantagens importantes; por exemplo, ela permite que o criador do
objeto altere a sua implementação sem a necessidade de alterar o código externo ao objeto,
desde que a interface de programação não seja alterada.
Um exemplo de encapsulamento no Flash seria definir todas as variáveis de membro e de
classe como privadas e forçar as pessoas que implementam suas classes a acessar essas variáveis
com os métodos getter e setter. Essa forma de encapsulamento garante que, se houver
necessidade de alterar a estrutura das variáveis no futuro, você precisará alterar somente o
comportamento das funções getter e setter, em vez de forçar todos os desenvolvedores a
alterarem o modo como acessam as variáveis da classe.
276
Classes
O código a seguir mostra como você poderia modificar a classe Person dos exemplos
anteriores, definir seus membros de instância como privados e definir métodos getter e setter
para esses membros:
class Person {
private var __userName:String;
private var __age:Number;
public function get userName():String {
return this.__userName;
}
public function set userName(value:String):Void {
this.__userName = value;
}
public function get age():Number {
return this.__age;
}
public function set age(value:Number):Void {
this.__age = value;
}
}
Sobre o uso da palavra-chave this em classes
Use a palavra-chave this como prefixo nas suas classes para métodos e variáveis membro.
Embora não seja necessária, a palavra-chave this permite identificar facilmente se uma
propriedade ou um método pertence a uma classe quando tem um prefixo; sem a palavrachave, não é possível saber se a propriedade ou o método pertence à superclasse.
Você também pode usar um prefixo de nome de classe para variáveis e métodos, mesmo
dentro de uma classe. Isso ajuda a qualificar as referências que você faz, tornando o código
legível. Dependendo do ambiente de codificação usado, a adição de prefixos também poderá
ativar referências de código.
N OT A
Não é necessário adicionar esses prefixos, e alguns desenvolvedores consideram isso
desnecessário. A Macromedia recomenda a adição da palavra-chave this como um
prefixo, pois ela pode melhorar a legibilidade e o ajuda a criar um código claro
fornecendo contexto para seus métodos e variáveis.
277
Exemplo: Criando classes personalizadas
Depois de explorar os conceitos básicos de arquivos de classes e os tipos de elementos que eles
contêm, é hora de aprender algumas diretrizes gerais para a criação desses arquivos. O
primeiro exemplo deste capítulo mostra como criar classes e empacotá-las. O segundo
exemplo mostra como usar os arquivos de classes com um arquivo FLA.
A T E NÇ ÃO
O código do ActionScript em arquivos externos é compilado em um arquivo SWF
quando você publica, exporta, testa ou depura um arquivo FLA. Portanto, se você fizer
qualquer alteração em um arquivo externo, será preciso salvá-lo e recompilar os
arquivos FLA que o utilizam.
Como vimos em “Criando arquivos de classes personalizados” na página 249, uma classe
consiste em duas partes principais: a declaração e o corpo. A declaração da classe consiste pelo
menos na instrução class, seguida do identificador do nome da classe e de chaves ({}). Tudo o
que estiver dentro das chaves é o corpo da classe, como mostra o seguinte exemplo:
class className {
// corpo da classe
}
Quando desejar, você pode definir classes somente em arquivos ActionScript externos. Por
exemplo, não é possível definir uma classe em um script de quadro no arquivo FLA. Portanto,
você criará um novo arquivo para este exemplo.
Na sua forma mais básica, uma classe declaration consiste na palavra-chave class, seguida
pelo nome da classe (Person, neste caso) e chaves ({}). Tudo entre as chaves chama-se corpo da
classe e é onde as propriedades e os métodos da classe são definidos.
No final deste exemplo, a organização básica de seus arquivos de classes será a seguinte:
■
Comentários de documentação
■
Declaração da classe
■
Função construtora
■
Corpo da classe
Você não cria subclasses neste capítulo. Para obter mais informações sobre herança e
subclasses, consulte o Capítulo 8, “Herança”, na página 319.
Este exemplo contém os seguintes tópicos:
■
“Sobre as diretrizes gerais para criação de classes” na página 279
■
“Criando e empacotando arquivos de classes” na página 281
■
“Criando a função construtora” na página 283
■
“Adicionando métodos e propriedades” na página 285
278
Classes
■
“Controlando o acesso de membros em classes” na página 288
■
“Documentando as classes” na página 290
■
■
Sobre as diretrizes gerais para criação de classes
Você deve usar as diretrizes a seguir ao criar arquivos de classes personalizados. Elas o ajudarão
a criar classes corretas e bem estruturadas. Você praticará essas diretrizes nos próximos
exemplos.
■
Em geral, coloque apenas uma declaração por linha e não coloque o mesmo tipo ou tipos
diferentes de declarações na mesma linha. Formate as declarações como no seguinte
exemplo:
private var SKU:Number; // número SKU do produto (identificação)
private var quantity:Number; // quantidade do produto
■
Inicialize as variáveis locais ao declará-las, a menos que o valor inicial seja determinado por
um cálculo. Para obter informações sobre a inicialização de variáveis, consulte
“Adicionando métodos e propriedades” na página 285.
■
Declare as variáveis antes de usá-las (incluindo repetições). Por exemplo, o código a seguir
predeclara a variável de iterador de repetição (i) antes de usá-la para a repetição for:
var my_array:Array = new Array("one", "two", "three");
var i:Number;
for (i = 0 ; i < my_array.length; i++) {
trace(i + " = " + my_array[i]);
}
■
Evite usar declarações locais que ocultem declarações de nível superior. Por exemplo, não
declare uma variável duas vezes, como mostra o seguinte exemplo:
279
// código incorreto
var counter:Number = 0;
function myMethod() {
var counter:Number;
for (counter = 0; counter <= 4; counter++) {
// instruções;
}
}
Esse código declara a mesma variável dentro de um bloco interno.
■
Não atribua diversas variáveis a um único valor em uma instrução, pois isso dificulta a
leitura, como você pode observar nos seguintes exemplos de código ActionScript:
// formulário incorreto
xPos = yPos = 15;
ou
// formulário incorreto
class User {
private var m_username:String, m_password:String;
}
■
Só crie variáveis de instância públicas ou variáveis de membro ou de classe estáticas
públicas se houver um bom motivo para isso. Verifique se essas variáveis são
explicitamente públicas antes de criá-las dessa maneira.
■
Defina a maioria das variáveis de membro como privadas a menos que haja um bom
motivo para torná-las públicas. Do ponto de vista do design, é preferível tornar as variáveis
de membro privadas e permitir o acesso a essas variáveis somente por meio de um pequeno
grupo de funções getter e setter.
Sobre a atribuição de nomes a arquivos de classes
Os nomes de classes devem ser identificadores; ou seja, o primeiro caractere deve ser uma letra,
sublinhado (_) ou cifrão ($), e os caracteres subseqüentes devem ser uma letra, número,
sublinhado ou cifrão. Como prática recomendada, tente usar somente letras em nomes de
classes.
O nome da classe deve corresponder exatamente ao do arquivo ActionScript que o contém,
incluindo o uso de maiúsculas e minúsculas. No exemplo a seguir, se você criar uma classe
chamada Rock, o arquivo ActionScript que contém a definição da classe deverá se chamar
Rock.as:
// No arquivo Rock.as
class Rock {
// Corpo da classe Rock
}
280
Classes
Você irá nomear e criar uma definição de classe na seção a seguir. Consulte a seção “Criando e
empacotando arquivos de classes” na página 281 para criar, nomear e empacotar os arquivos
de classes. Para obter mais informações sobre nomeação de arquivos de classe, consulte
“Nomeando classes e objetos” na página 776.
Criando e empacotando arquivos de classes
Nesta seção, você irá criar, nomear e empacotar os arquivos de classe usados neste exemplo
(“Exemplo: Criando classes personalizadas” na página 278). As seções subseqüentes mostram
como criar arquivos de classes completos (embora simples). Para obter informações detalhadas
sobre pacotes, consulte “Sobre pacotes” na página 242, “Comparação de classes e pacotes”
na página 243 e “Trabalhando com pacotes” na página 244.
Ao criar um arquivo de classe, decida onde deseja armazená-lo. Nas etapas a seguir, você
salvará o arquivo de classe e o arquivo FLA de aplicativo que usa esse arquivo no mesmo
diretório para fins de simplicidade. Entretanto, se desejar verificar a sintaxe, também será
necessário informar ao Flash como ele poderá encontrar o arquivo. Normalmente, ao criar um
aplicativo, você adiciona ao caminho de classe do Flash o diretório onde deseja armazenar o
aplicativo e os arquivos de classes. Para obter informações sobre caminhos de classe, consulte
Os arquivos de classes também são denominados arquivos do ActionScript (AS). Os arquivos
AS são criados com a ferramenta de criação do Flash ou com um editor externo. Vários
editores externos, como o Macromedia Dreamweaver e o Macromedia Flex Builder, podem
criar esses arquivos.
N OT A
O nome da classe (Person) deve corresponder exatamente ao nome do arquivo AS que
a contém (ClassA.as). Isso é muito importante; se esses dois nomes forem diferentes,
incluindo o uso de maiúsculas e minúsculas, a classe não será compilada.
Para criar um arquivo de classe e uma declaração de classe:
1.
Selecione File (Arquivo) > New (Novo) Flash Document (Documento do Flash) para criar
um documento FLA e clique em OK.
2.
Selecione File > Save as (Salvar como) e atribua o nome package_test.fla ao novo arquivo;
em seguida, salve o documento do Flash no diretório atual.
3.
4.
Selecione File > Save As e crie um novo subdiretório chamado com e, em seguida, faça o
seguinte:
Você adicionará conteúdo a esse documento do Flash em uma etapa posterior.
281
5.
a.
No subdiretório com, crie um novo subdiretório chamado macromedia.
b.
No subdiretório macromedia, crie um novo subdiretório chamado utils.
c.
Salve o documento atual do ActionScript no diretório utils e atribua o nome ClassA.as
ao arquivo.
class com.macromedia.utils.ClassA {
}
O código anterior cria uma nova classe chamada ClassA no pacote com.macromedia.utils.
6.
Salve o documento do ActionScript ClassA.as.
7.
8.
Selecione File > Save As, atribua o nome ClassB.as ao novo arquivo e salve-o no mesmo
diretório que o arquivo ClassA.as criado em uma etapa anterior.
9.
class com.macromedia.utils.ClassB {
}
O código anterior cria uma nova classe chamada ClassB no pacote com.macromedia.utils.
10. Salve
as alterações nos arquivos de classes ClassA.as e ClassB.as.
Os arquivos de classes usados em um arquivo FLA são importados para um arquivo SWF
quando compilados. O código criado em um arquivo de classe deve ter determinada
metodologia e organização, as quais são abordadas nas seções subseqüentes.
Se estiver criando várias classes personalizadas, use pacotes para organizar seus arquivos de
classes. Um pacote é um diretório que contém um ou mais arquivos de classes e reside em um
diretório de caminho de classe designado. Os nomes das classes devem ser totalmente
qualificados no arquivo em que forem declarados; ou seja, eles devem refletir o diretório
(pacote) em que estão armazenados. Para obter mais informações sobre caminhos de classes,
consulte “Sobre a definição e a modificação do caminho de classe” na página 255.
Por exemplo, uma classe chamada com.macromedia.docs.YourClass é armazenada no
diretório com/macromedia/docs. A declaração da classe no arquivo YourClass.as deve ser
semelhante à seguinte:
class com.macromedia.docs.YourClass {
// sua classe
}
N O TA
282
Você criará a declaração de classe que reflete o diretório de pacotes na seção a seguir,
“Exemplo: Criando classes personalizadas” na página 278.
Classes
Por essa razão, é recomendável planejar a sua estrutura de pacotes antes de começar a criar as
classes. De outra forma, se você decidir mover os arquivos das classes depois de criá-los, será
necessário modificar as instruções de declaração dessas classes para refletir sua nova
localização.
Para empacotar os arquivos de classes:
1.
Escolha o nome de pacote que deseja usar.
Os nomes de pacotes devem ser intuitivos e facilmente identificáveis pelos
desenvolvedores. Lembre-se de que o nome do pacote também corresponde à estrutura de
diretório determinada. Por exemplo, todas as classes do pacote com.macromedia.utils
precisarão ser colocadas na pasta com/macromedia/utils de seu disco rígido.
2.
Crie a estrutura de diretório necessária após escolher o nome do pacote.
Por exemplo, se tiver atribuído o nome com.macromedia.utils ao pacote, você precisará
criar a estrutura de diretório com/macromedia/utils e colocar suas classes na pasta utils.
3.
Use o prefixo com.macromedia.utils para todas as classes criadas nesse pacote.
Por exemplo, se o nome da classe for ClassA, o nome completo da classe precisará ser
com.macromedia.utils.ClassA no arquivo de classe com/macromedia/utils/
ClassA.as.
4.
Se a estrutura do pacote for alterada no futuro, lembre-se de modificar não só a estrutura
de diretório como também o nome do pacote em cada arquivo de classe; além disso, todas
as instruções de importação ou referências a uma classe desse pacote precisarão ser
modificadas.
Para continuar a criar os arquivos de classes, consulte “Criando a função construtora”
na página 283.
Criando a função construtora
Você já aprendeu a criar a declaração da classe em “Criando e empacotando arquivos de
classes” na página 281. Nesta parte do capítulo, você criará o que chamamos de função
construtora do arquivo de classe.
N O TA
Você aprenderá a criar comentários, instruções e declarações em seções posteriores.
283
Construtores são funções usadas para inicializar (definir) as propriedades e os métodos de uma
classe. Por definição, construtores são funções em uma definição de classe que têm o mesmo
nome da classe. Por exemplo, o código a seguir define uma classe Person e implementa uma
função construtora. Na OOP, a função construtora inicializa cada nova instância de uma
classe.
Uma função construtora de classe é uma função especial chamada automaticamente quando
você cria uma instância de uma classe usando o operador new. A função construtora tem o
mesmo nome da classe que a contém. Por exemplo, a classe Person criada anteriormente
continha a seguinte função construtora:
// Função construtora da classe Person
public function Person (uname:String, age:Number) {
this.__name = uname;
this.__age = age;
}
Considere os seguintes pontos ao criar funções construtoras:
■
Se nenhuma função construtora for explicitamente declarada, ou seja, se você não criar
uma função cujo nome corresponda ao da classe, o compilador automaticamente criará
uma função construtora vazia.
■
Uma classe pode conter apenas uma função construtora; funções construtoras
sobrecarregadas não são permitidas no ActionScript 2.0.
■
Uma função construtora não deve ter nenhum tipo de retorno.
O termo construtor também é normalmente usado quando você cria (instancia) um objeto
com base em uma classe específica. As instruções a seguir são chamadas das funções
construtoras relativas à classe Array de nível superior e à classe Person personalizada:
var day_array:Array = new Array("Sun", "Mon", "Tue", "Wed", "Thu", "Fri",
"Sat");
var somePerson:Person = new Person("Tom", 30);
Em seguida, você adicionará uma função especial denominada função construtora.
NO T A
Este exercício faz parte do “Exemplo: Criando classes personalizadas” na página 278.
Se você não desejar avançar no exemplo, faça o download dos arquivos de classe em
www.helpexamples.com/flash/learnas/classes/.
Para adicionar funções construtoras aos arquivos de classes:
1.
Abra o arquivo de classe ClassA.as na ferramenta de criação do Flash.
2.
Modifique o arquivo de classe existente de acordo com o seguinte código (as alterações a
serem feitas estão em negrito):
284
Classes
function ClassA() {
trace("ClassA constructor");
}
}
O código anterior define um método construtor para a classe ClassA. Esse construtor
envia uma seqüência de caracteres simples para o painel Output (Saída) que informa
quando uma nova instância da classe foi criada.
3.
Abra o arquivo de classe ClassB.as na ferramenta de criação do Flash.
4.
Modifique o arquivo de classe de acordo com o seguinte código (as alterações a serem feitas
estão em negrito):
function ClassB() {
trace("ClassB constructor");
}
}
5.
Salve os dois arquivos do ActionScript antes de continuar.
Para continuar a criar o arquivo de classe, consulte “Adicionando métodos e propriedades”
na página 285.
Adicionando métodos e propriedades
Para criar as propriedades das classes ClassA e ClassB, use a palavra-chave var para definir
variáveis.
N OT A
Os três exercícios a seguir fazem parte do “Exemplo: Criando classes personalizadas”
na página 278. Se você não desejar avançar no exemplo, faça o download dos arquivos
de classe em www.helpexamples.com/flash/learnas/classes/.
Para adicionar propriedades às classes ClassA e ClassB:
1.
Abra ClassA.as e ClassB.as na ferramenta de criação do Flash.
2.
Modifique o arquivo ActionScript ClassA.as de acordo com o seguinte código (as alterações
a serem feitas estão em negrito):
static var _className:String;
function ClassA() {
}
}
O bloco de código anterior adiciona uma nova variável estática, _className, que contém
o nome da classe atual.
285
3.
Modifique a classe ClassB e adicione a variável estática para tornar essa classe semelhante
ao código anterior.
4.
D IC A
Por convenção, as propriedades da classe são definidas na parte superior do corpo
da classe. A sua definição nesse local facilita a compreensão do código, mas não é
obrigatória.
A sintaxe pós-dois-pontos (por exemplo, var username:String e var age:Number) é usada
nas declarações de variáveis. Esse é um exemplo de atribuição estrita de tipos de dados.
Quando você atribui um tipo a uma variável usando o formato var
variableName:variableType, o compilador ActionScript verifica se os valores atribuídos a
essa variável correspondem ao tipo especificado. Se o tipo de dados correto não for usado no
arquivo FLA que importa essa classe, o compilador gerará um erro. Para obter mais
informações sobre como atribuir tipos de dados estritos, consulte “Sobre a atribuição de tipos
de dados e a atribuição estrita de tipos de dados” na página 85.
Os membros de uma classe consistem em propriedades (declarações de variáveis) e métodos
(definições de funções). Você deve declarar e definir todas as propriedades e métodos no corpo
da classe (entre as chaves [{}]); caso contrário, ocorrerá um erro durante a compilação. Para
obter informações sobre membros, consulte “Sobre propriedades (membros) e métodos
públicos, privados e estáticos” na página 262.
Para adicionar métodos às classes ClassA e ClassB:
1.
2.
Modifique o arquivo de classe ClassA de acordo com o seguinte código (as alterações a
serem feitas estão em negrito):
function ClassA() {
}
function doSomething():Void {
trace("ClassA - doSomething()");
}
}
O bloco de código em negrito cria um novo método na classe que envia uma seqüência de
caracteres para o painel Output (Saída).
286
Classes
3.
Em ClassA.as, selecione Tools (Ferramentas) > Check Syntax (Verificar sintaxe) para
verificar a sintaxe do arquivo do ActionScript.
Se algum erro for informado no painel Output, compare o ActionScript do script com o
código completo criado na etapa anterior. Se não for possível corrigir os erros do código,
copie e cole o código completo na janela Script antes de continuar.
4.
Verifique a sintaxe de ClassB.as da mesma maneira que foi feito para ClassA.as.
Se houver algum erro no painel Output, copie e cole o código completo na janela Script
antes de continuar:
function ClassB() {
trace("ClassB constructor");
}
trace("ClassB - doSomething()");
}
}
5.
Você pode inicializar as propriedades inline, ou seja, quando as declara, com os valores padrão,
como mostra o seguinte exemplo:
class Person {
var username:String = "John Doe";
}
Quando você inicializa as propriedades inline, a expressão à direita de uma atribuição deve ser
uma constante de tempo de compilação. Ou seja, a expressão não pode se referir a algo
definido durante a execução. As constantes de tempo de compilação incluem literais de
seqüência de caracteres, números, valores booleanos, null e undefined, bem como funções
construtoras para as seguintes classes de nível superior: Array, Boolean, Number, Object e
String.
Para inicializar propriedades inline:
1.
2.
Modifique o arquivo de classe ClassA de acordo com o seguinte ActionScript (as alterações
a serem feitas estão em negrito):
static var _className:String = "ClassA";
function ClassA() {
287
}
trace("ClassA - doSomething()");
}
}
A única diferença entre o arquivo de classe existente e o bloco de código anterior é que
agora há um valor definido para a variável estática _className, “ClassA”.
3.
Modifique o arquivo de classe ClassB e adicione a propriedade inline, alterando o valor para
“ClassB”.
4.
Essa regra aplica-se apenas a variáveis de instância (variáveis que são copiadas em cada
instância de uma classe), e não a variáveis de classe (variáveis que pertencem à classe).
N OT A
Quando você inicializa arrays inline, apenas um array é criado para todas as instâncias
da classe.
Para continuar a criar o arquivo de classe, consulte “Controlando o acesso de membros em
classes” na página 288.
Controlando o acesso de membros em classes
O padrão é que qualquer propriedade ou método de uma classe possa ser acessado por
qualquer outra classe: todos os membros de uma classe são públicos por padrão. Entretanto,
em alguns casos, talvez você queira proteger os dados ou os métodos de uma classe do acesso
de outras classes. Você precisará tornar esses membros privados (disponíveis apenas para a
classe que os declara ou os define).
Especifique membros públicos ou privados usando o atributo de membro public ou private.
Por exemplo, o código a seguir declara uma variável privada (uma propriedade) e um método
privado (uma função). A classe a seguir (LoginClass) define uma propriedade privada
chamada userName e um método privado chamado getUserName().
class LoginClass {
private var userName:String;
private function getUserName():String {
return this.userName;
}
// Construtor:
public function LoginClass(user:String) {
this.userName = user;
}
}
288
Classes
Os membros privados (propriedades e métodos) são acessíveis apenas para a classe que define
esses membros e para as subclasses dessa classe original. As instâncias da classe original, ou as
instâncias das subclasses dessa classe, não podem acessar as propriedades e os métodos
declarados de forma privada; ou seja, os membros privados só podem ser acessados nas
definições da classe, e não no nível da instância. No exemplo a seguir, você alterará o acesso a
membros em seus arquivos de classes.
NO TA
Para controlar o acesso a membros:
1.
2.
Modifique o arquivo ActionScript ClassA.as para que o conteúdo esteja de acordo com o
seguinte ActionScript (as alterações a serem feitas estão em negrito):
private static var _className:String = "ClassA";
public function
trace("ClassA
}
public function
trace("ClassA
}
ClassA() {
constructor");
doSomething():Void {
- doSomething()");
}
O código anterior define os dois métodos (o construtor de ClassA e o método
doSomething()) como públicos; isso significa que eles podem ser acessados por scripts
externos. A variável estática _className é definida como privada e, portanto, só pode ser
acessada a partir da classe, e não por scripts externos.
3.
Modifique o arquivo ClassB.as do ActionScript e adicione o acesso aos mesmos métodos e
propriedades que os da classe ClassA.
4.
Uma instância de classe ClassA ou ClassB não pode acessar membros privados. Por exemplo, o
código a seguir, adicionado ao Frame 1 (Quadro 1) da Timeline (Linha de tempo) em um
arquivo FLA, resultará em um erro do compilador indicando que o método é privado e não
pode ser acessado:
import com.macromedia.utils.ClassA;
var a:ClassA = new ClassA();
trace(a._className); // Erro. O membro é privado e não pode ser acessado.
289
O controle de acesso a membros é um recurso somente de tempo de compilação; durante a
execução, o Flash Player não distingue entre membros privados e públicos.
Para continuar a criar o arquivo de classe, consulte “Documentando as classes” na página 290.
Documentando as classes
O uso de comentários em suas classes e interfaces é importante ao documentá-las para outros
usuários. Por exemplo, talvez você deseje distribuir seus arquivos de classes na comunidade
Flash ou esteja trabalhando com uma equipe de designers ou desenvolvedores que usarão esses
arquivos em seu trabalho ou como parte de um projeto do qual você participe. A
documentação ajuda outros usuários a compreender a finalidade e as origens da classe.
Há dois tipos de comentários em uma classe ou arquivo de interface típico: comentários de
documentação e comentários de implementação. Use comentários de documentação para
descrever as especificações do código, mas não a implementação. Use comentários de
implementação para fazer comentários sobre o código ou sobre a implementação de seções
específicas do código. Os dois tipos de comentários usam delimitadores ligeiramente
diferentes. Os comentários de documentação são delimitados por /** e */, e os de
implementação são delimitados por /* e */.
N OT A
Os comentários da documentação não são uma construção de linguagem no
ActionScript 2.0. No entanto, eles são uma maneira comum de estruturar comentários
em um arquivo de classe que você pode usar nos arquivos AS.
Use os comentários de documentação para descrever interfaces, classes, métodos e constuções.
Inclua um comentário de documentação para cada classe, interface ou membro e coloque-o
diretamente antes da declaração.
Se precisar documentar mais informações que não caibam nos comentários de documentação,
use comentários de implementação (no formato de bloco ou de uma única linha, conforme
descrito em “Sobre comentários” na página 139). Quando adicionados, os comentários de
implementação devem vir logo após a declaração.
N OT A
Não inclua comentários que não estejam diretamente relacionados à classe que está
sendo lida. Por exemplo, não inclua comentários que descrevam o pacote
correspondente.
N O TA
Para documentar os arquivos de classes:
1.
290
Classes
2.
Modifique o arquivo de classe ClassA e adicione o novo código ao início do arquivo (as
alterações a serem feitas estão em negrito):
/**
ClassA class
version 1.1
6/21/2005
copyright Macromedia, Inc.
*/
private static var _className:String = "ClassA";
public function
trace("ClassA
}
public function
trace("ClassA
}
ClassA() {
constructor");
doSomething():Void {
- doSomething()");
}
O código acima adicionou um comentário ao início do arquivo de classe. É sempre
recomendável adicionar comentários aos arquivos do ActionScript e do Flash para que
você possa incluir informações úteis, como autor da classe, data da última modificação,
informações de copyright ou possíveis problemas/erros existentes no arquivo.
3.
Adicione um comentário semelhante ao início do arquivo ClassB.as do ActionScript,
alterando o nome da classe e outras informações aplicáveis.
4.
Você também pode adicionar comentários em bloco, de uma linha ou finais ao código da
classe. Para obter informações sobre a criação de comentários úteis no código, consulte
“Criando comentários adequados” na página 780. Para obter informações gerais sobre
comentários, consulte “Comentários de linha única” na página 140, “Comentários de várias
linhas” na página 140 e “Comentários finais” na página 142.
Para aprender a usar esses arquivos de classes personalizados em um arquivo SWF, consulte
“Exemplo: Usando arquivos de classes personalizados no Flash” na página 291.
Exemplo: Usando arquivos de classes
personalizados no Flash
Esse exemplo usa arquivos de classe criados no exemplo chamado “Exemplo: Criando classes
personalizadas” na página 278, ou você pode fazer download deles em
www.helpexamples.com/flash/learnas/classes/. Se você concluiu “Exemplo: Criando classes
personalizadas” na página 278, localize os arquivos ClassA.as e ClassB.as no disco rígido.
Exemplo: Usando arquivos de classes personalizados no Flash
291
Como o nome do pacote do arquivo de classe ClassA é com.macromedia.utils.ClassA,
você precisará salvar os arquivos de classes na estrutura de diretório adequada. Crie uma
subpasta chamada com no diretório atual. Na pasta com, adicione uma nova pasta chamada
macromedia. Nessa pasta, adicione um terceiro e último subdiretório chamado utils. Salve os
arquivos de classes ClassA.as e ClassB.as na pasta utils. Agora você está pronto para continuar
com o exemplo.
Você poderá usar as classes personalizadas criadas no “Exemplo: Criando classes
personalizadas” na página 278 com um arquivo FLA. Neste exemplo, você usará as classes
personalizadas para criar um pequeno aplicativo no Flash. Suas classes serão compiladas no
arquivo SWF quando você publicar o documento e, depois, tudo funcionará de forma
integrada. Nos exercícios a seguir, você aprenderá o funcionamento dos caminhos de classe,
aprenderá a usar os arquivos de classe no aplicativo, e a importar classes e pacotes.
Para continuar esse exemplo, vá para “Importando classes e pacotes” na página 292.
Importando classes e pacotes
Para fazer referência a uma classe em outro script, você deve incluir o nome do pacote da classe
antes do nome da classe. A combinação do nome da classe e do caminho do pacote
correspondente é o nome da classe totalmente qualificado. Se uma classe estiver em um
diretório do caminho de classe de nível superior, e não em um subdiretório do diretório do
caminho de classe, seu nome de classe totalmente qualificado será o nome da classe.
Para especificar caminhos de pacote, use a notação de ponto (.) para separar os nomes de
diretórios de pacote. Os caminhos de pacote são hierárquicos; ou seja, cada ponto representa
um diretório aninhado. Por exemplo, suponha que você tenha criado uma classe chamada
ClassName que resida no pacote com/macromedia/docs/learnAs2 no caminho de classe.
Para criar uma instância dessa classe, você pode especificar o seu nome totalmente qualificado.
Também é possível usar o nome totalmente qualificado da classe para atribuir um tipo às
variáveis, como mostra o seguinte exemplo:
var myInstance:com.macromedia.docs.learnAs2.ClassName = new
com.macromedia.docs.learnAs2.ClassName();
Você pode usar a instrução import para importar pacotes para um script, o que permite usar o
nome abreviado de uma classe em vez de seu nome de classe totalmente qualificado. Também
pode usar o caractere curinga (*) para importar todas as classes de um pacote. Se usar o
caractere curinga, você não precisará usar o nome totalmente qualificado da classe toda vez
que usar a classe.
292
Classes
Por exemplo, suponha que você tenha importado a classe acima para um script usando a
instrução import, como mostra o seguinte exemplo:
import com.macromedia.docs.learnAs2.util.UserClass;
Posteriormente, no mesmo script, você poderia fazer referência a essa classe por seu nome
abreviado, como neste exemplo:
var myUser:UserClass = new UserClass();
Você pode usar o caractere curinga (*) para importar todas as classes de determinado pacote.
Suponha que você tenha um pacote chamado com.macromedia.utils com dois arquivos de
classes do ActionScript, ClassA.as e ClassB.as. Em outro script, você poderia importar as duas
classes desse pacote usando o caractere curinga, como no seguinte código:
import com.macromedia.utils.*;
O exemplo a seguir mostra que é possível fazer referência às duas classes diretamente no
mesmo script:
var myA:ClassA = new ClassA();
var myB:ClassB = new ClassB();
A instrução import aplica-se apenas ao script atual (quadro ou objeto) no qual ela é chamada.
Se uma classe importada não for utilizada em um script, ela não será incluída no bytecode do
arquivo SWF resultante e não estará disponível para os arquivos SWF que poderão ser
carregados pelo arquivo FLA que contém a instrução import.
NO T A
O exercício a seguir faz parte do “Exemplo: Usando arquivos de classes personalizados
no Flash” na página 291 que continua os exemplos de “Exemplo: Criando classes
personalizadas”. Se você precisar das classes ClassA e ClassB, faça o download dos
arquivos de classe em www.helpexamples.com/flash/learnas/classes/.
Para importar uma classe ou um pacote:
1.
Abra o arquivo chamado package_test.fla.
2.
var a = new ClassA(); // Construtor ClassA
var b = new ClassB(); // Construtor ClassB
O bloco de código anterior importa primeiro cada uma das classes do pacote
com.macromedia.utils usando o caractere curinga (*). Em seguida, você cria uma nova
instância da classe ClassA, que faz com que o método construtor envie uma mensagem
para o painel Output (Saída). Uma instância da classe ClassB também é criada e envia
mensagens de depuração para o painel Output.
3.
Salve as alterações no documento do Flash antes de continuar.
Exemplo: Usando arquivos de classes personalizados no Flash
293
Para continuar usando esses arquivos de classes em um arquivo do Flash, consulte “Criando
instâncias de classes em um exemplo” na página 294.
Criando instâncias de classes em um exemplo
As instâncias são objetos que contêm todas as propriedades e métodos de determinada classe.
Por exemplo, arrays são instâncias da classe Array; portanto, você pode usar quaisquer
métodos ou propriedades dessa classe com qualquer instância de um array. Você também
poderia criar sua própria classe, como UserSettings, e, depois, criar uma instância dessa classe.
No exemplo iniciado em “Exemplo: Usando arquivos de classes personalizados no Flash”
na página 291, você modificou um arquivo FLA para importar as classes de modo que não
precisasse fazer sempre referência a elas por seus nomes totalmente qualificados.
A próxima etapa deste exemplo (“Exemplo: Usando arquivos de classes personalizados no
Flash” na página 291) será criar uma instância das classes ClassA e ClassB em um script, como
um script de quadro no documento do Flash package_test.fla, e atribuir uma variável a ela.
Para criar uma instância de uma classe personalizada, use o operador new, como faria ao criar
uma instância de uma classe de nível superior do ActionScript (como a classe Date ou Array).
Faça referência à classe usando o seu nome totalmente qualificado ou importe-a (como
demonstrado em “Importando classes e pacotes” na página 292.)
NO TA
O exercício a seguir faz parte do “Exemplo: Usando arquivos de classes personalizados
no Flash” na página 291 que continua os exemplos de “Exemplo: Criando classes
personalizadas”.
Para criar uma nova instância das classes ClassA e ClassB:
1.
Abra o arquivo chamado package_test.fla.
2.
Digite o seguinte código em negrito na janela Script:
var a:ClassA = new ClassA(); // Construtor ClassA
a.doSomething(); // chama o método doSomething() do ClassA
var b:ClassB = new ClassB(); // Construtor ClassB
b.doSomething(); // chama o método doSomething() do ClassB
A atribuição de um tipo de dados aos objetos nesse exemplo de código permite ao
compilador garantir que você não tentará acessar as propriedades ou os métodos que não
estão definidos em sua classe personalizada. Para obter mais informações sobre como
atribuir tipos de dados estritos, consulte “Sobre a atribuição de tipos de dados e a
atribuição estrita de tipos de dados” na página 85. A exceção é se você declarar a classe
como dinâmica usando a palavra-chave dynamic. Consulte “Criando classes dinâmicas”
na página 274.
294
Classes
3.
Salve as alterações no arquivo FLA antes de continuar.
Agora você já deve saber como criar e usar classes em documentos do Flash. Lembre-se de que
também é possível criar instâncias de classes internas ou de nível superior do ActionScript
(consulte “Sobre como trabalhar com classes internas” na página 312.).
Para continuar usando esses arquivos de classes em um arquivo do Flash, consulte “Atribuindo
uma classe a símbolos no Flash” na página 295.
Atribuindo uma classe a símbolos no
Flash
Você também pode atribuir uma classe aos símbolos usados em um arquivo do Flash, como
um objeto de clipe de filme no Stage (Palco).
Para atribuir uma classe a um símbolo de clipe de filme:
1.
2.
Selecione File > Save As (Salvar como), atribua o nome Animal.as e salve o arquivo no disco
rígido.
3.
class Animal {
public function Animal() {
trace("Animal::constructor");
}
}
Esse ActionScript cria uma nova classe chamada Animal que possui um método
construtor que envia uma seqüência de caracteres para o painel Output (Saída).
4.
5.
e clique em OK.
6.
Selecione File > Save As, atribua o nome animal_test.fla ao arquivo e salve o arquivo na
mesma pasta que o arquivo Animal.as criado na etapa 2.
7.
Selecione Insert (Inserir) > New Symbol (Novo símbolo) para iniciar a caixa de diálogo
Create New Symbol (Criar novo símbolo).
8.
Insira o nome do símbolo de animal e selecione a opção Movie Clip (Clipe de filme).
9.
Clique no botão Advanced (Avançado) no canto inferior direito da caixa de diálogo Create
New Symbol (Criar novo símbolo) para ativar mais opções.
Atribuindo uma classe a símbolos no Flash
295
O botão Advanced está disponível quando se está no modo básico da caixa de diálogo
Create New Symbol.
10. Clique
na caixa de seleção Export for ActionScript (Exportar para ActionScript) na seção
Linkage (Vinculação).
A ativação dessa opção permite anexar instâncias desse símbolo dinamicamente aos
documentos do Flash durante a execução.
11.
Insira o valor de identificador animal_id e defina a classe ActionScript 2.0 como Animal
(para que corresponda ao nome de classe especificado na etapa 3).
12. Selecione
a caixa de seleção Export in First Frame (Exportar no primeiro quadro) e clique
em OK para aplicar as alterações e fechar a caixa de diálogo.
13.
Salve o documento do Flash e selecione Control (Controlar) > Test Movie (Testar filme).
O painel Output exibe o texto da função construtora da classe Animal.
NO TA
Se precisar modificar as propriedades de vinculação de Movie Clip, clique com o
botão direito do mouse no símbolo na biblioteca do documento e selecione
Properties (Propriedades) ou Linkage no menu de contexto.
Compilando e exportando classes
Por padrão, as classes usadas por um arquivo SWF são empacotadas e exportadas no primeiro
quadro desse arquivo. Também é possível especificar um quadro diferente onde as classes serão
empacotadas e exportadas. Esse recurso é útil, por exemplo, quando um arquivo SWF usa
muitas classes que exigem um longo tempo de download (como componentes). Se as classes
forem exportadas no primeiro quadro, o usuário deverá aguardar o download de todo o
código das classes até o quadro aparecer. Especificando um quadro posterior na Timeline, você
pode exibir uma curta animação do carregamento nos primeiros quadros da Timeline durante
o download do código das classes do quadro posterior.
Para especificar o quadro de exportação das classes de um documento Flash:
1.
Selecione File > New e, em seguida, selecione Flash Document (Documento Flash). Salve
o novo documento como exportClasses.fla.
2.
Renomeie a camada padrão como content, arraste um componente ProgressBar do painel
Components (Components) até o Stage e atribua o nome de instância my_pb.
3.
Crie uma nova camada, arraste-a por cima da camada de conteúdo e renomeia-a como
actions.
296
Classes
4.
Adicione o seguinte código ActionScript ao Frame 1 (Quadro 1) da camada actions na
Timeline principal:
my_pb.indeterminate = true;
5.
Crie um novo quadro-chave no Frame 2 (Quadro 2) da camada actions e adicione o
seguinte código ActionScript:
var classesFrame:Number = 10;
if (_framesloaded < classesFrame) {
trace(this.getBytesLoaded() + " of " + this.getBytesTotal() + " bytes
loaded");
gotoAndPlay(1);
} else {
gotoAndStop(classesFrame);
}
6.
Crie um novo quadro-chave no Frame 10 da camada actions e adicione o seguinte
ActionScript:
stop();
7.
Crie um novo quadro-chave no Frame 10 da camada de conteúdo e arraste diversos
componentes para o Stage.
8.
Clique com o botão direito do mouse em cada componente (exceto ProgressBar) no painel
Library (Biblioteca) e selecione Linkage (Vinculação) em um menu de contexto para iniciar
a caixa de diálogo Linkage Properties (Propriedades de vinculação).
9.
Na caixa de diálogo Linkage Properties, verifique se Export for ActionScript (Exportar para
ActionScript) está selecionada, desmarque a seleção da caixa Export in First Frame
(Exportar no primeiro quadro) e clique em OK.
10. Selecione
11.
File > Publish Settings (Configurações de publicação).
Na caixa de diálogo Publish Settings, selecione a guia Flash.
12. Clique
no botão Settings perto do menu pop-up da versão do ActionScript para abrir a
caixa de diálogo ActionScript Settings (Configurações do ActionScript).
13.
Na caixa de texto Export Frame for Classes (Exportar quadro para classes), digite o número
do quadro para o qual deseja exportar o código das classes (Frame 10).
Se o quadro especificado não existir na Timeline, você receberá uma mensagem de erro ao
publicar o arquivo SWF.
14. Clique
em OK para fechar a caixa de diálogo ActionScript Settings e, em seguida, clique
em OK para fechar a caixa de diálogo Publish Settings.
Compilando e exportando classes
297
15.
Flash. Se o painel Components for carregado rápido demais, selecione View (Exibir) >
Simulate Download (Simular download) no arquivo SWF. O Flash simula o download do
documento Flash em uma velocidade menor, o que permite que você veja a animação do
componente de barra de progresso enquanto ocorre o download dos arquivos de classe.
Para obter mais informações sobre arquivos ASO, consulte “Usando arquivos ASO”
na página 298.
Usando arquivos ASO
Durante a compilação, o Flash cria, às vezes, arquivos com extensões .aso no subdiretório /aso
do diretório de caminho de classe global padrão (consulte “Sobre a definição e a modificação
do caminho de classe” na página 255). A extensão .aso significa ActionScript object(ASO,
objeto do ActionScript). Para cada arquivo do ActionScript 2.0 importado implícita ou
explicitamente e compilado com êxito, o Flash gera um arquivo ASO. O arquivo contém o
bytecode produzido a partir do arquivo ActionScript (AS) associado. Portanto, esses arquivos
contêm a forma compilada (o bytecode) de um arquivo de classe.
O Flash só precisará gerar novamente um arquivo ASO quando ocorrerem os seguintes
cenários:
■
O arquivo AS correspondente tiver sido modificado.
■
Os arquivos do ActionScript que contêm as definições importadas ou usadas pelo arquivo
correspondente do ActionScript tiverem sido modificados.
■
Os arquivos do ActionScript incluídos pelo arquivo correspondente do ActionScript
tiverem sido modificados.
O compilador cria arquivos ASO para fins de armazenamento em cache. Observe que a sua
primeira compilação é mais lenta do que as compilações subseqüentes. Isso ocorre porque
somente os arquivos AS que foram alterados são compilados em arquivos ASO. No caso dos
arquivos AS não alterados, o compilador lê o bytecode já compilado diretamente do arquivo
ASO, em vez de recompilar o arquivo AS.
O formato de arquivo ASO é um formato intermediário desenvolvido apenas para uso
interno. Ele não é um formato documentado e não deve ser redistribuído.
Se perceber que o Flash está compilando versões mais antigas de um arquivo que você editou,
exclua os arquivos ASO e recompile-os. Se planejar excluir os arquivos ASO, exclua-os quando
o Flash não estiver executando outras operações, como verificação de sintaxe ou exportação de
SWFs.
298
Classes
Para excluir arquivos ASO:
Se você estiver editando um arquivo FLA e desejar excluir um arquivo ASO, selecione uma
das opções a seguir no ambiente de criação:
■
Selecione Control (Controle) > Delete ASO Files (Excluir arquivos ASO) para excluir os
arquivos ASO e continue editando.
■
Selecione Control > Delete ASO Files e Test Movie (Testar filme) para excluir os arquivos
ASO e testar o aplicativo.
Se você estiver editando um documento ActionScript na janela Script:
■
Selecione Control > Delete ASO Files para excluir os arquivos ASO e continue editando.
■
Selecione Control > Delete ASO Files e Test Project (Testar projeto) para excluir os
arquivos ASO e testar o aplicativo.
Há um limite para a quantidade de código que pode ser colocada em uma única classe: o
bytecode de uma definição de classe em um arquivo SWF exportado não poderá ser superior a
32.767 bytes. Se o bytecode exceder esse limite, será exibida uma mensagem de aviso.
Não é possível prever o tamanho da representação de bytecode de determinada classe, mas
classes com até 1.500 linhas geralmente não ultrapassam o limite.
Caso a classe ultrapasse o limite, mova parte do código para outra classe. Em geral, uma
prática recomendada de OOP é manter as classes relativamente curtas.
Noções básicas sobre classes e escopo
Ao mover o código ActionScript para classes, talvez você precise alterar o modo como a
palavra-chave this é usada. Por exemplo, se um método de determinada classe usar uma
função de retorno de chamada (como o método onLoad() da classe LoadVars), poderá ser
difícil saber se a palavra-chave this se refere à classe ou ao objeto LoadVars. Nessa situação,
talvez seja necessário criar um ponteiro para a classe atual, como mostra o exemplo a seguir.
Para compreender o escopo e os arquivos de classes externos:
1.
2.
Digite ou cole o seguinte código na janela Script:
/**
Classe do produto
Product.as
*/
class Product {
private var productsXml:XML;
// construtor
299
// targetXmlStr - seqüência de caracteres, contém o caminho para um
arquivo XML
function Product(targetXmlStr:String) {
/* Cria uma referência local à classe atual.
Mesmo que esteja dentro do manipulador de eventos onLoad do XML,
você
pode fazer referência à classe atual, em vez de somente ao pacote
XML.
*/
var thisObj:Product = this;
// Cria uma variável local, usada para carregar o arquivo XML.
var prodXml:XML = new XML();
prodXml.ignoreWhite = true;
prodXml.onLoad = function(success:Boolean) {
if (sucesso) {
/* Se o XML for carregado e analisado com sucesso,
defina a variável productsXml da classe para o documento XML
analisado e chame a função init.
*/
thisObj.productsXml = this;
thisObj.init();
} else {
/* Houve erro ao carregar o arquivo XML. */
trace("error loading XML");
}
};
// Comece a carregar o documento XML.
prodXml.load(targetXmlStr);
}
public function init():Void {
// Exiba o pacote XML.
trace(this.productsXml);
}
}
Como você está tentando fazer referência à variável de membro privada em um
manipulador onLoad, a palavra-chave this se refere à instância prodXml, e não à classe
Product, como era de se esperar. Por isso, você deve criar um ponteiro para o arquivo de
classes local para que possa fazer referência direta à classe do manipulador onLoad. Agora
você poderá usar essa classe com um documento do Flash.
3.
Salve o código anterior do ActionScript como Product.as.
4.
Crie um novo documento do Flash chamado testProduct.fla no mesmo diretório.
5.
Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) principal.
6.
Digite o seguinte ActionScript no painel Actions (Ações):
var myProduct:Product = new Product("http://www.helpexamples.com/
crossdomain.xml");
300
Classes
7.
Selecione Control (Controlar) > Test Movie (Testar filme) para testar esse código no
ambiente de teste.
O conteúdo do documento XML especificado é exibido no painel Output (Saída).
Outro tipo de escopo que você encontrará ao trabalhar com essas classes são as variáveis e as
funções estáticas. A palavra-chave static determina que uma variável ou função seja criada
somente uma vez por classe, em vez de ser criada em todas as instâncias dessa classe. Você pode
acessar um membro estático da classe sem criar uma instância da classe usando a sintaxe
someClassName.username. Para obter mais informações sobre variáveis e funções estáticas,
consulte “Sobre propriedades (membros) e métodos públicos, privados e estáticos”
na página 262 e “Usando membros de classe” na página 269.
Outra vantagem das variáveis estáticas é que elas não perdem seus valores quando o seu escopo
é encerrado. O exemplo a seguir demonstra como usar a palavra-chave static para criar um
contador que controla quantas instâncias da classe o Flash criou. Como a variável
numInstances é estática, ela é criada apenas uma vez para a classe inteira, e não para cada
instância.
Para usar a palavra-chave static:
1.
Selecione File > New, selecione ActionScript File e, em seguida, clique em OK.
2.
class User {
private static var numInstances:Number = 0;
public function User() {
User.numInstances++;
}
public static function get instances():Number {
return User.numInstances;
}
}
O código anterior define uma classe User que controla o número de vezes que o construtor
foi chamado. Uma variável estática privada (User.numInstances) é incrementada no
método construtor.
3.
Salve o documento como User.as.
4.
Selecione File > New, selecione Flash Document (Documento do Flash) para criar um
novo arquivo FLA e salve-o no mesmo diretório que o arquivo User.as.
5.
tempo):
trace(User.instances); // 0
var user1:User = new User();
301
var user2:User = new User();
A primeira linha de código chama o método getter instances() estático, que retorna o
valor da variável numInstances estática privada. O restante do código cria novas
instâncias da classe User e exibe o valor atual retornado pelo método getter instances().
6.
Selecione Control (Controlar) > Test Movie (Testar filme) para testar os documentos.
Para obter informações sobre o uso da palavra-chave this em classes, consulte “Sobre o uso da
palavra-chave this em classes” na página 277.
Sobre classes de nível superior e internas
Além das construções e dos elementos de linguagem básicos do ActionScript (as repetições
for e while loops, por exemplo) e dos tipos de dados primitivos (números, seqüências de
carateres e booleanos) descritos anteriormente nesse manual (consulte o Capítulo 4, “Dados e
tipos de dados”, na página 75 e o Capítulo 5, “Fundamentos da sintaxe e da linguagem”, na
página 119), o ActionScript também fornece várias classes internas (tipos de dados complexos).
Essas classes oferecem vários recursos e funcionalidades de script. Nos capítulos anteriores,
você usou classes de nível superior e outras classes internas que fazem parte da linguagem
ActionScript e continuará a usá-las nos capítulos restantes. Várias classes fornecidas com o
Flash são usadas para criar interatividade e funcionalidade nos arquivos SWF e também
podem ser usadas para criar aplicativos complexos. Por exemplo, você pode usar a classe Math
para executar equações em seus aplicativos ou a classe BitmapData para criar pixels e
animações com script.
As classes de nível superior, listadas em “Classes de nível superior” na página 304, são criadas
no Flash Player. Na caixa de ferramentas Actions (Ações), essas classes estão localizadas no
diretório Classes do ActionScript 2.0. Algumas dessas classes se baseiam na especificação de
linguagem ECMAScript (ECMA-262) edição 3 e são chamadas classes básicas do ActionScript.
Array, Boolean, Date e Math são exemplos de classes básicas. Para obter mais informações
sobre pacotes, consulte “Trabalhando com pacotes” na página 244.
Você pode encontrar as classes ActionScript instaladas no disco rígido. Você pode encontrar as
pastas de classes aqui:
■
Windows: Hard Disk\Documents and Settings\user\Local Settings\Application
■
Macintosh: Hard Disk/Users/usuário/Library/Application Support/Macromedia/Flash 8/
Leia o documento Read Me localizado nesse diretório para obter mais informações sobre a
estrutura.
302
Classes
Para entender a diferença entre as classes básicas do ActionScript e as classes específicas do
Flash, considere a distinção entre JavaScript básico e cliente. As classes JavaScript do cliente
permitem controlar o ambiente do cliente (o conteúdo do navegador e da página da Web), e
as classes específicas do Flash permitem controlar, durante a execução, a aparência e o
comportamento de um aplicativo Flash.
As demais classes internas do ActionScript são específicas do modelo de objeto do
Macromedia Flash e do Flash Player. Camera, MovieClip e LoadVars são exemplos dessas
classes. Outras classes são organizadas em pacotes, como flash.display. Todas essas classes são
às vezes chamadas classes internas (classes predefinidas que podem ser usadas para adicionar
funcionalidade aos aplicativos).
As seções a seguir apresentam classes internas do ActionScript e descrevem as tarefas básicas
que podem ser realizadas com essas classes. Para obter uma visão geral sobre o trabalho com
classes e objetos na programação orientada a objeto, consulte “Sobre como trabalhar com
classes internas” na página 312. Exemplos de código usando essas classes estão incluídos em
todo o manual Learning ActionScript 2.0 in Flash.
Para obter informações sobre elementos de linguagem (como constantes, operadores e
diretivas), consulte o Capítulo 5, “Fundamentos da sintaxe e da linguagem”, na página 119.
Para obter mais informações sobre classes internas e de nível superior, consulte os seguintes
tópicos:
■
“Classes de nível superior” na página 304
■
“Pacote flash.display” na página 308
■
“Pacote flash.external” na página 309
■
“Pacote flash.filters” na página 309
■
“Pacote flash.geom” na página 310
■
“Pacote flash.net” na página 311
■
“Pacote flash.text” na página 311
■
“Pacote mx.lang” na página 311
■
“Pacotes System e TextField” na página 312
303
Outros elementos de linguagem
Há outros elementos de linguagem que compõem o ActionScript, fora das classes. São eles:
diretivas, constantes, funções globais, propriedades globais, operadores e instruções. Para obter
informações sobre como usar cada um desses elementos de linguagem, consulte os seguintes
tópicos:
■
Capítulo 5, “Fundamentos da sintaxe e da linguagem”
■
Capítulo 6, “Funções e métodos”
Você pode encontrar uma lista desses elementos de linguagem nas seguintes seções do
ActionScript 2.0 Language Reference (Referência da linguagem ActionScript):
■
%{Compiler Directives}%
■
%{Constants}%
■
%{Global Functions}%
■
%{Global Properties}%
■
%{Operators}%
■
%{Statements}%
Classes de nível superior
O nível superior contém as classes e as funções globais do ActionScript, muitas das quais
fornecem funcionalidade básica a seus aplicativos. As classes básicas, emprestadas diretamente
do ECMAScript, incluem Array, Boolean, Date, Error, Function, Math, Number, Object,
String e System. Para descobrir mais informações sobre cada classe, consulte a seguinte tabela.
N OT A
As classes CustomActions e XMLUI estão disponíveis somente no ambiente de criação
do Flash.
Classe
Description (Descrição)
Acessibilidade
A classe Accessibility gerencia a comunicação entre os arquivos SWF
e os aplicativos de leitura de tela. Use os métodos dessa classe junto
com a propriedade _accProps global para controlar as propriedades
acessíveis de clipes de filme, botões e campos de texto durante a
execução. Consulte %{Accessibility}%.
Array
A classe Array representa os arrays no ActionScript, e todos os objetos
de array são instâncias dessa classe. A classe Array contém métodos e
propriedades para o trabalho com os objetos de array. Consulte
%{Array}%.
304
Classes
Classe
AsBroadcaster
Fornece recursos de notificação de eventos e gerenciamento de
ouvinte que podem ser adicionados a outros objetos. Consulte
%{AsBroadcaster}%.
Boolean
A classe Boolean é um envoltório para valores booleanos (true ou
false). Consulte %{Boolean}%.>.
Button
A classe Button fornece métodos, propriedades e manipuladores de
eventos para trabalhar com botões. Consulte %{Button}%. Observe
que a classe interna Button é diferente da classe de componente
Button, associada ao componente Button de versão 2.
Camera (Câmera)
A classe Camera fornece acesso à câmera do usuário, se houver uma
instalada. Quando ela é usada com o Flash Communication Server, o
arquivo SWF pode capturar, transmitir e gravar imagens e vídeo da
câmera do usuário. Consulte %{Camera}%.
Color
A classe Color permite definir o valor de cor RGB (vermelho, verde e
azul) e a transformação de cor de instâncias de clipes de filme, bem
como recuperar esses valores após eles serem definidos. A classe
Color tornou-se obsoleta no Flash Player 8 tendo sido substituída pela
classe ColorTransform. Para obter mais informações sobre
transformações de cores, consulte %{ColorTransform
(flash.geom.ColorTransform)}%.
ContextMenu
A classe ContextMenu permite controlar o conteúdo do menu de
contexto do Flash Player durante a execução. Você pode associar
objetos ContextMenu separados a objetos MovieClip, Button ou
TextField usando a propriedade menu disponível para essas classes.
Também é possível adicionar itens de menu personalizados a um
objeto ContextMenu usando a classe ContextMenuItem. Consulte
%{ContextMenu}%.
ContextMenuItem
A classe ContextMenuItem permite que você crie novos itens de menu
que aparecem no menu de contexto do Flash Player. Para adicionar ao
menu de contexto do Flash Player novos itens de menu criados com
essa classe, use a classe ContextMenu. Consulte
%{ContextMenuItem}%.
CustomActions
A classe CustomActions permite que você gerencie qualquer ação do
cliente registrada com a ferramenta de criação. Consulte
%{CustomActions}%.
Date
A classe Date mostra como as datas e as horas são representadas no
ActionScript e oferece suporte às operações de manipulação de datas
e horas. Essa classe também permite obter a data e a hora atuais a
partir do sistema operacional. Consulte %{Date}%.
305
Classe
Error
A classe Error contém informações sobre os erros que ocorrem nos
scripts durante a execução. Em geral, use a instrução throw para gerar
uma condição de erro, que você pode manipular com uma instrução
try..catch..finally. Consulte %{Error}%.
Function
A classe Function é a representação de classe de todas as funções do
ActionScript, incluindo aquelas que são nativas do ActionScript e as
que você define. Consulte %{Function}%.
Key
A classe Key fornece métodos e propriedades para obter informações
sobre o teclado e os pressionamentos de teclas. Consulte %{Key}%.
LoadVars
A classe LoadVars permite transferir variáveis entre um arquivo SWF e
um servidor em pares nome/valor. Consulte %{LoadVars}%.
LocalConnection
A classe LocalConnection permite desenvolver arquivos SWF que
enviam instruções uns para os outros sem usar o método fscommand()
ou o JavaScript. Consulte %{LocalConnection}%.
Math
A classe Math permite o acesso conveniente a constantes
matemáticas comuns, bem como fornece várias funções matemáticas
comuns. Todas as propriedades e métodos da classe Math são
estáticos e devem ser chamados com a sintaxe
Math.método(parâmetro) ou Math.constante. Consulte %{Math}%.
Microphone
(Microfone)
A classe Microphone fornece acesso ao microfone do usuário, se
houver um instalado. Quando ela é usada com o Flash Communication
Server, o arquivo SWF pode transmitir e gravar áudio a partir do
microfone do usuário. Consulte %{Microphone}%.
Mouse
A classe Mouse fornece controle sobre o mouse em um arquivo SWF;
por exemplo, essa classe permite que você oculte ou mostre o ponteiro
do mouse. Consulte %{Mouse}%.
MovieClip
Cada clipe de filme em um arquivo SWF é uma instância da classe
MovieClip. Use os métodos e propriedades dessa classe para controlar
objetos de clipe de filme. Consulte %{MovieClip}%.
MovieClipLoader
Esta classe permite implementar retornos de chamada de ouvinte que
fornecem informações de status enquanto os arquivos SWF, JPEG,
GIF e PNG estão sendo carregados em instâncias de clipes de filme.
Consulte %{MovieClipLoader}%.
NetConnection
A classe NetConnection estabelece uma conexão de fluxo local para
reproduzir um arquivo FLV (Flash Video) de um endereço HTTP
(Hypertext Transfer Protocol, Protocolo de Transferência de
Hipertexto) ou do sistema de arquivos local. Consulte
%{NetConnection}%.
306
Classes
Classe
NetStream
A classe NetStream controla a reprodução de arquivos FLV de um
sistema de arquivos local ou de um endereço HTTP. Consulte
%{NetStream}%.
Number
A classe Number é um envoltório para o tipo de dados de número
primitivo. Consulte %{Number}%.
Object
A classe Object encontra-se na raiz da hierarquia de classes do
ActionScript; todas as outras classes herdam seus métodos e
propriedades. Consulte %{Object}%.
PrintJob
A classe PrintJob permite imprimir o conteúdo de um arquivo SWF,
incluindo o conteúdo renderizado dinamicamente, e documentos de
várias páginas. Consulte %{PrintJob}%.
Selection
A classe Selection permite definir e controlar o campo de texto no qual
está localizado o ponto de inserção (o campo de texto que possui o
foco). Consulte %{Selection}%.
SharedObject
A classe SharedObject oferece o armazenamento de dados local
persistente no computador cliente, de maneira semelhante aos
cookies. Essa classe permite o compartilhamento de dados em tempo
real entre objetos no computador do cliente. Consulte
%{SharedObject}%.
Sound
A classe Sound fornece controle sobre os sons em um arquivo SWF.
Consulte %{Sound}%.
Stage
A classe Stage fornece informações sobre as dimensões, o
alinhamento e o modo de escala de um arquivo SWF. Ela também
informa eventos de redimensionamento do Stage (Palco). Consulte
%{Stage}%.
String
A classe String é um envoltório para o tipo de dados String primitivo,
que permite o uso dos métodos e das propriedades do objeto String
para manipular tipos de valores String primitivos. Consulte
%{String}%.
System
A classe System fornece informações sobre o Flash Player e o sistema
em que o Flash Player está em execução (por exemplo, resolução da
tela e linguagem do sistema atual). Ela também permite que você
mostre ou oculte o painel Settings (Configurações) do Flash Player e
modifique as configurações de segurança do arquivo SWF. Consulte
%{System}%.
TextField
A classe TextField fornece controle sobre campos de texto dinâmicos
e de entrada, como a recuperação de informações de formatação, a
chamada de manipuladores de eventos e a alteração de propriedades
como alfa ou cor de fundo. Consulte %{TextField}%.
307
Classe
TextFormat
A classe TextFormat permite aplicar estilos de formatação a caracteres
e parágrafos em um objeto TextField. Consulte %{TextFormat}%.
TextSnapshot
O objeto TextSnapshot permite acessar texto estático, bem como criar
o seu layout, em um clipe de filme. Consulte %{TextSnapshot}%.
Video
A classe Video permite exibir objetos de vídeo em um arquivo SWF.
Você pode usá-la com o Flash Communication Server para exibir
fluxos de vídeo ao vivo em um arquivo SWF file ou no Flash para exibir
um arquivo FLV (Flash Video). Consulte %{Video}%.
XML
Esta classe contém métodos e propriedades usados com objetos XML.
Consulte %{XML}%.
XMLNode
A classe XMLNode representa um único nó em uma árvore de
documentos XML. Trata-se da superclasse da classe XML. Consulte
%{XMLNode}%.
XMLSocket
A classe XMLSocket permite criar uma conexão de soquete
persistente entre um computador servidor e um cliente que executa o
Flash Player. Os soquetes do cliente permitem a transferência de
dados de baixa latência, como a necessária para aplicativos de batepapo em tempo real. Consulte %{XMLSocket}%.
XMLUI
O objeto XMLUI permite a comunicação com arquivos SWF que são
usados como uma interface do usuário personalizada para os recursos
de extensibilidade da ferramenta de criação do Flash (como Behaviors,
Commands, Effects e Tools). Consulte %{XMLUI}%.
Pacote flash.display
O pacote flash.display contém a classe BitmapData que pode ser usada para criar exibições
visuais.
Classe
BitmapData
A classe BitmapData permite criar imagens bitmaps opacas ou
transparentes, dimensionadas de forma arbitrária, no documento e
manipulá-las de várias maneiras durante a execução. Consulte
%{BitmapData (flash.display.BitmapData)}%.
308
Classes
Pacote flash.external
O pacote flash.external permite que você se comunique com o recipiente do Flash Player
usando código ActionScript. Por exemplo, se você incorporar um arquivo SWF em uma
página HTML, essa página será o recipiente. Você poderia se comunicar com a página HTML
usando a classe ExternalInterface e o JavaScript. Também chamada de API externa.
Classe
ExternalInterface
A classe ExternalInterface é a API External, um subsistema que permite
a comunicação entre o ActionScript e o recipiente do Flash Player
(como uma página HTML que usa o JavaScript) ou um aplicativo
desktop que usa o Flash Player. Consulte %{ExternalInterface
(flash.external.ExternalInterface)}%.
Pacote flash.filters
O pacote flash.filters contém classes para os efeitos de filtro de bitmap disponíveis no Flash
Player 8. Os filtros permitem aplicar efeitos visuais sofisticados, como embaçamento, chanfro,
brilho e sombreamento, às instâncias de Image e MovieClip. Para obter mais informações
sobre cada classe, consulte as referências cruzadas fornecidas na tabela a seguir.
Classe
BevelFilter
A classe BevelFilter permite adicionar um efeito de chanfro a uma
instância de clipe de filme. Consulte %{BevelFilter
(flash.filters.BevelFilter)}%.
BitmapFilter
A classe BitmapFilter é uma classe base para todos os efeitos de
filtro. Consulte %{BitmapFilter (flash.filters.BitmapFilter)}%.
BlurFilter
A classe BlurFilter permite aplicar um efeito de embaçamento a
instâncias de clipes de filme. Consulte %{BlurFilter
(flash.filters.BlurFilter)}%.
ColorMatrixFilter
A classe ColorMatrixFilter permite aplicar uma matriz de
transformação 4x5 aos valores alfa e de cor RGBA (vermelho,
verde, azul e alfa) de cada pixel na imagem de entrada. Após aplicar
a transformação, você poderá produzir um resultado com um novo
conjunto de valores alfa e de cor RGBA. Consulte
%{ColorMatrixFilter (flash.filters.ColorMatrixFilter)}%.
ConvolutionFilter
A classe ConvolutionFilter permite aplicar um efeito de filtro de
convolução de matriz. Consulte %{ConvolutionFilter
(flash.filters.ConvolutionFilter)}%.
309
Classe
DisplacementMapFilte A classe DisplacementMapFilter permite usar os valores de pixel de
r
uma imagem especificada (imagem de mapa de deslocamento) para
deslocar espacialmente a instância original (um clipe de filme) à qual
o filtro foi aplicado. Consulte %{DisplacementMapFilter
(flash.filters.DisplacementMapFilter)}%.
DropShadowFilter
A classe DropShadowFilter permite adicionar um sombreamento a
um clipe de filme. Consulte %{DropShadowFilter
(flash.filters.DropShadowFilter)}%.
GlowFilter
A classe GlowFilter permite adicionar um efeito de brilho a um clipe
de filme. Consulte %{GlowFilter (flash.filters.GlowFilter)}%.
GradientBevelFilter
A classe GradientBevelFilter permite aplicar um efeito de chanfro
gradiente a um clipe de filme. Consulte %{GradientBevelFilter
(flash.filters.GradientBevelFilter)}%.
GradientGlowFilter
A GradientGlowFilter permite aplicar um efeito de gradiente de
brilho a um clipe de filme. Consulte %{GradientGlowFilter
(flash.filters.GradientGlowFilter)}%.
Pacote flash.geom
O pacote flash.geom contém classes de geometria, como pontos, retângulos e matrizes de
transformação. Essas classes oferecem suporte à classe BitmapData e ao recurso de
armazenamento de bitmap em cache. Para obter mais informações sobre cada classe, consulte
as referências cruzadas fornecidas na tabela a seguir.
Classe
ColorTransform
A classe ColorTransform permite definir matematicamente o valor de
cor RGB (vermelho, verde e azul) e a transformação de cor de uma
instância. É possível recuperar esses valores após eles serem
definidos. Consulte %{ColorTransform
(flash.geom.ColorTransform)}%.
Matrix
Representa uma matriz de transformação que determina como mapear
pontos de um espaço de coordenadas para outro. Consulte %{Matrix
(flash.geom.Matrix)}%.
Point
O objeto Point representa um local em um sistema de coordenadas
bidimensional, onde x representa o eixo horizontal e y representa o
eixo vertical. Consulte %{Point (flash.geom.Point)}%.
310
Classes
Classe
Rectangle
(Retângulo)
A classe Rectangle é usada para criar e modificar objetos Rectangle.
Consulte %{Rectangle (flash.geom.Rectangle)}%.
Transform
(Transformar)
Coleta dados sobre transformações de cores e manipulações
coordenadas que são aplicadas em uma instância de objeto. Consulte
%{Transform (flash.geom.Transform)}%.
Pacote flash.net
O pacote flash.net contém classes que permitem fazer upload e download de um ou mais
arquivos entre o computador do usuário e o servidor. Para obter mais informações sobre cada
classe, consulte as referências cruzadas fornecidas na tabela a seguir.
Classe
FileReference
A classe FileReference permite fazer upload e download de um ou
mais arquivos entre o computador do usuário e um servidor. Consulte
%{FileReference (flash.net.FileReference)}%.
FileReferenceList
A classe FileReferenceList permite fazer upload de um ou mais
arquivos do computador do usuário em um servidor. Consulte
%{FileReferenceList (flash.net.FileReferenceList)}%.
Pacote flash.text
O pacote flash.text contém a classe TextRenderer para trabalhar com o recurso sem serrilhado
avançado disponível no Flash Player 8.
Classe
TextRenderer
Esta classe oferece a funcionalidade para o recurso sem serrilhado
avançado no Flash Player 8. Consulte %{TextRenderer
(flash.text.TextRenderer)}%.
Pacote mx.lang
O pacote mx.lang contém a classe Locale para trabalhar com texto multilíngüe.
Classe
Locale
Essa classe permite controlar como o texto multilíngüe é exibido em um
arquivo SWF. Consulte %{Locale (mx.lang.Locale)}%.
311
Pacotes System e TextField
O pacote System contém as classes capabilities, IME e security. Essas classes controlam as
configurações do cliente que podem afetar o seu aplicativo no Flash Player. Para obter mais
informações sobre cada classe, consulte as referências cruzadas fornecidas na tabela a seguir.
Classe
capabilities
A classe Capabilities determina as capacidades do sistema e do Flash
Player que está hospedando o arquivo SWF. Isso permite personalizar
o conteúdo para diversos formatos. Consulte %{capabilities
(System.capabilities)}%.
IME
A classe IME permite manipular diretamente o IME (Input Method
Editor, Editor de método de entrada) do sistema operacional no
aplicativo Flash Player executado em um computador cliente. Consulte
%{IME (System.IME)}%.
segurança
A classe Security contém métodos que especificam como os arquivos
SWF de diversos domínios podem se comunicar uns com os outros.
Consulte %{security (System.security)}%.
O pacote TextField contém a classe StyleSheet que é usada para aplicar estilos CSS (Cascading
StyleSheets, Folhas de estilos em cascata) ao texto.
Classe
StyleSheet
A classe StyleSheet permite criar um objeto de folha de estilos que
contém as regras de formatação de texto, como tamanho da fonte, cor
e outros estilos de formatação. Consulte %{StyleSheet
(TextField.StyleSheet)}%.
Sobre como trabalhar com classes
internas
Na programação orientada a objeto, uma classe define uma categoria de objeto. Uma classe
descreve as propriedades (dados) e o comportamento (métodos) de um objeto, da mesma
maneira que uma planta arquitetônica descreve as características de uma construção. Para
obter informações sobre classes e outros conceitos de programação orientada a objetos,
■
“Princípios da programação orientada a objeto” na página 246
■
“Criando arquivos de classes personalizados” na página 249
312
Classes
O Flash 8 possui muitas classes internas que você pode usar no código (consulte “Sobre classes
de nível superior e internas” na página 302), para ajudar a adicionar interatividade aos
aplicativos. Para usar as propriedades e os métodos definidos por uma classe interna, você
geralmente cria primeiro uma instância dessa classe (exceto no caso de classes com membros
estáticos). A relação entre uma instância e sua classe é semelhante à relação entre uma casa e
sua planta arquitetônica, conforme discutido em “Sobre classes de nível superior e internas”
na página 302.
Para obter mais informações sobre o uso de classes internas no Flash 8, consulte os seguintes
tópicos:
■
“Sobre a criação de uma nova instância de uma classe interna” na página 313
■
“Acessando propriedades de objetos internos” na página 313
■
“Sobre a chamada de métodos de objetos internos” na página 314
■
“Sobre os membros de classe (estáticos)” na página 315
■
“Pré-carregando arquivos de classe” na página 316
■
“Excluindo classes” na página 315
Sobre a criação de uma nova instância de uma classe
interna
Para criar uma instância de uma classe do ActionScript, use o operador new para chamar a
função construtora da classe. A função construtora sempre tem o mesmo nome da classe e
retorna uma instância da classe, que você normalmente atribui a uma variável.
Por exemplo, o código a seguir cria um novo objeto Sound:
var song_sound:Sound = new Sound();
Em alguns casos, não é necessário criar uma instância de uma classe para usar suas
propriedades e métodos. Para obter mais informações, consulte “Sobre os membros de classe
(estáticos)” na página 315.
Acessando propriedades de objetos internos
Use o operador ponto (.) para acessar o valor de uma propriedade em um objeto. Insira o
nome do objeto à esquerda do ponto e o nome da propriedade à direita. Por exemplo, na
instrução a seguir, my_obj é o objeto e firstName é a propriedade:
my_obj.firstName
O código a seguir cria um novo objeto Array e, em seguida, mostra sua propriedade length:
Sobre como trabalhar com classes internas
313
var my_array:Array = new Array("apples", "oranges", "bananas");
trace(my_array.length); // 3
Também é possível usar o operador de acesso de array ([]) para acessar as propriedades de um
objeto; por exemplo, você pode usá-lo para fins de depuração. O exemplo a seguir executa
uma repetição em um objeto para exibir cada uma de suas propriedades.
Para executar uma repetição no conteúdo de um objeto:
1.
Crie um novo documento do Flash e salve-o como forin.fla.
2.
principal:
var results:Object = {firstName:"Tommy", lastName:"G", age:7, avg:0.336,
b:"R", t:"L"};
for (var i:String in results) {
trace("the value of [" + i + "] is: " + results[i]);
}
O código anterior define um novo objeto chamado de resultados e define valores para
firstName, lastName, age, avg, b e t. Uma repetição for..in apresenta cada
propriedade no objeto de resultados e apresenta o valor para o painel Output (Saída).
3.
Flash.
Para obter mais informações sobre operadores, incluindo operadores de acesso dot e array,
consulte “Sobre operadores” na página 185. Para obter mais informações sobre métodos e
propriedades, consulte Capítulo 6, “Funções e métodos”, na página 213. Para obter exemplos
de como trabalhar com propriedades da classe interna MovieClip, consulte o Capítulo 11,
“Trabalhando com clipes de filme”, na página 369. Para obter exemplos de como trabalhar
com propriedades das classes TextField, String, TextRenderer e TextFormat, consulte o
Capítulo 12, “Trabalhando com texto e seqüências de caracteres”, na página 403.
Sobre a chamada de métodos de objetos internos
Você pode chamar o método de um objeto usado o operador ponto (.) seguido do
método. Por exemplo, o código a seguir cria um novo objeto Sound e chama o seu método
setVolume():
var my_sound:Sound = new Sound(this);
my_sound.setVolume(50);
Para obter exemplos de como trabalhar com métodos da classe interna MovieClip, consulte o
Capítulo 11, “Trabalhando com clipes de filme”, na página 369. Para obter exemplos de como
trabalhar com métodos das classes internas TextField, String, TextRenderer e TextFormat,
consulte o Capítulo 12, “Trabalhando com texto e seqüências de caracteres”, na página 403.
314
Classes
Sobre os membros de classe (estáticos)
Algumas classes internas do ActionScript apresentam membros de classe (membros estáticos). Os
membros de classe (propriedades e métodos) são acessados ou chamados não em uma
instância da classe, mas no próprio nome da classe. Portanto, não é necessário criar uma
instância da classe para usar essas propriedades e métodos.
Por exemplo, todas as propriedades da classe Math são estáticas. O código a seguir chama o
método max() da classe Math para determinar o maior de dois números:
var largerNumber:Number = Math.max(10, 20);
trace(largerNumber); // 20
Para obter mais informações sobre métodos estáticos da classe Math, e exemplos de como usálos, consulte %{Math}% em ActionScript 2.0 Language Reference (Referência da linguagem
ActionScript).
Excluindo classes
Para reduzir o tamanho de um arquivo SWF, você poderá excluir classes da compilação, mas
ainda será capaz de acessá-las e usá-las para verificação de tipo. Por exemplo, você poderá fazer
isso se estiver desenvolvendo um aplicativo que utilize vários arquivos SWF ou bibliotecas
compartilhadas, especialmente os que acessam várias das mesmas classes. A exclusão das classes
ajudará a evitar que elas sejam duplicadas nesses arquivos.
Para obter mais informações sobre como excluir classes, consulte os seguintes tópicos:
■
“Pré-carregando arquivos de classe” na página 316
Para excluir classes da compilação:
1.
Crie um novo arquivo XML.
2.
Atribua o nome Nome_do_arquivo_FLA_exclude.xml ao arquivo XML, onde
Nome_do_arquivo_FLA é o nome do arquivo FLA sem a extensão.
Por exemplo, se o arquivo FLA for sellStocks.fla, o nome do arquivo XML deverá ser
sellStocks_exclude.xml.
3.
Salve o arquivo no mesmo diretório que o arquivo FLA.
4.
Coloque as seguintes marcas no arquivo XML:
<excludeAssets>
<asset name="className1" />
<asset name="className2" />
</excludeAssets>
315
Os valores especificados para os atributos de nome nas marcas <asset> são os nomes das
classes que você deseja excluir do arquivo SWF. Adicione quantas classes precisar para o
seu aplicativo. Por exemplo, o arquivo XML a seguir exclui as classes mx.core.UIObject e
mx.screens.Slide do arquivo SWF:
<excludeAssets>
<asset name="mx.core.UIObject" />
<asset name="mx.screens.Slide" />
</excludeAssets>
Para obter informações sobre o pré-carregamento de classes, consulte “Pré-carregando
arquivos de classe” na página 316.
Pré-carregando arquivos de classe
Essa seção descreve algumas das metodologias usadas para pré-carregamento e exportação de
classes no Flash 8 (incluindo as classes usadas por componentes na versão 2 do Macromedia
Component Architecture). Pré-carregamento envolve o carregamento de alguns dados para o
arquivo SWF antes que o usuário comece a interagir com ele. O Flash importa classes no
primeiro quadro de um arquivo SWF quando são usadas classes externas e esses dados são os
primeiros elementos a serem carregados no arquivo SWF. Isso é semelhante para as classes de
componente, porque o framework para componentes também é carregado no primeiro
quadro de um arquivo SWF. Ao criar grandes aplicativos, o tempo de carregamento pode ser
demorado quando é necessário importar dados; sendo assim, é preciso lidar com esses dados
de forma inteligente, conforme mostrado nos seguintes procedimentos.
Como as classes são os primeiros dados a serem carregados, você pode ter problemas ao criar
uma barra de progresso ou ao carregar animações se as classes forem carregadas antes da barra
de progresso, porque é desejável que ela reflita o progresso do carregamento de todos os dados
(incluindo classes). Portanto, carregue as classes depois de outras partes do arquivo SWF, mas
antes de usar componentes.
O seguinte procedimento mostra como alterar o quadro no qual as classes são carregadas no
arquivo SWF.
Para selecionar um quadro diferente para o carregamento das classes no
arquivo SWF:
1.
Selecione File > Publish Settings (Configurações de publicação).
2.
Selecione a guia Flash e clique no botão Settings (Configurações).
3.
Na caixa de texto Export Frame for Classes (Exportar quadro para classes), digite o número
de um novo quadro para determinar quando as classes devem ser carregadas.
4.
Clique em OK.
316
Classes
Você não pode usar classes até que a reprodução atinja o quadro escolhido para o qual as
classes devem ser carregadas. Por exemplo, como os componentes da versão 2 exigem classes
para garantir a funcionalidade, você deve carregar componentes depois de Export frame for
classes (Exportar quadro para classes) no ActionScript 2.0. Se você exportar para o Frame 3
(Quadro 3), não poderá usar nenhuma classe até que a reprodução atinja o Frame 3 e carregue
os dados.
Se você quiser pré-carregar um arquivo que use classes, como as classes de componente da
versão 2, deve pré-carregar os componentes no arquivo SWF. Para isso, você deve definir os
componentes para exportarem para um quadro diferente no arquivo SWF. Por padrão, os
componentes de interface de usuário exportam no Frame 1 do arquivo SWF; portanto,
desmarque a opção Export in First Frame (Exportar no primeiro quadro) da caixa de diálogo
Linkage (Vinculação) do componente.
Se os componentes não forem carregados no primeiro quadro, você pode criar uma barra de
progresso personalizada para o primeiro quadro do arquivo SWF. Não faça referência a
nenhum componente no ActionScript nem inclua componentes no Stage até carregar as
classes para o quadro especificado na caixa de texto Export Frame for Classes (Exportar
quadro para classes).
A T E NÇ Ã O
Você deve exportar componentes após as classes ActionScript que eles usam.
317
318
Classes
CAPÍTULO 8
8
Herança
No Capítulo 7, “Classes,”, você aprendeu a criar arquivos de classes e como as classes podem
ajudá-lo a organizar o código em arquivos externos. Você também viu como organizar
arquivos de classes em pacotes relacionados. O objetivo deste capítulo é mostrar como criar
classes mais avançadas que estendem a funcionalidade de uma classe existente. Este assunto é
útil, pois talvez você precise estender suas classes personalizadas ou as classes existentes para
adicionar novos métodos e propriedades.
Para obter mais informações sobre herança, consulte “Sobre herança” na página 319. Para
obter mais informações sobre métodos e propriedades, consulte Capítulo 6, “Funções e
métodos”, na página 213.
Para obter mais informações sobre herança, consulte os seguintes tópicos:
Sobre herança. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
Sobre a criação de subclasses no Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
Usando o polimorfismo em um aplicativo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
Sobre herança
No Capítulo 7, “Classes,”, você viu como criar um arquivo de classe para criar tipos de dados
personalizados. Aprendendo a criar arquivos de classes personalizados, você saberá como
mover o código da Timeline (Linha de tempo) para arquivos externos. Quando o código é
movido para arquivos externos, é mais fácil editá-lo. Agora que está familiarizado com os
conceitos básicos de criação de classes personalizadas, você aprenderá uma técnica de OOP
(Object-Oriented Programming, Programação orientada a objeto) chamada criação de
subclasses ou extensão de classes, que permite criar novas classes com base em outra existente.
319
Uma das vantagens da OOP é que ela permite criar subclasses de uma classe. A subclasse herda
todas as propriedades e métodos de uma superclasse. Por exemplo, ao estender a classe
MovieClip (ou criar uma subclasse dela), você criará uma classe personalizada que estenderá
essa classe. A subclasse herda todas as propriedades e métodos da classe MovieClip. Também é
possível criar um conjunto de classes como uma extensão de uma superclasse personalizada.
Por exemplo, a classe Lettuce pode ser uma extensão da superclasse Vegetable.
A subclasse geralmente define métodos e propriedades adicionais que podem ser usados em
seu aplicativo; portanto, ela estende a superclasse. As subclasses também substituem (fornecem
suas próprias definições para) os métodos herdados de uma superclasse. Se uma subclasse
substituir um método herdado da superclasse correspondente, você não poderá mais acessar a
definição da superclasse dentro da subclasse. A única exceção à regra acima é que, caso esteja
na função construtura da subclasse, você poderá acessar o construtor da superclasse usando a
instrução super. Para obter mais informações sobre substituição, consulte “Substituindo
métodos e propriedades” na página 324.
Por exemplo, você pode criar uma classe chamada Mammal, que define certas propriedades e
comportamentos comuns a todos os mamíferos e, em seguida, criar uma classe Cat que
estenda essa classe. O uso de subclasses permite reutilizar o código de modo que, em vez de
recriar todo o código comum às duas classes, você poderia simplesmente estender uma classe
existente. Outra subclasse, a classe Siamese, poderia estender a classe Cat e assim por diante.
Em um aplicativo complexo, determinar como estruturar a hierarquia das classes é uma
grande parte do projeto.
A herança e a criação de subclasses são muito úteis em aplicativos maiores, pois permitem criar
várias classes relacionadas que podem compartilhar funcionalidade. Por exemplo, você poderia
criar uma classe Employee que define as propriedades e os métodos básicos de um funcionário
típico de uma empresa. Em seguida, poderia criar uma nova classe chamada Contractor que
estende a classe Employee e herda todos os seus métodos e propriedades. A classe Contractor
poderia adicionar os seus próprios métodos e propriedades ou substituir os métodos e as
propriedades definidos na classe Employee. Depois, você poderia criar uma nova classe
chamada Manager, que também estende a classe Employee e define métodos e propriedades
adicionais, como hire(), fire(), raise() e promote(). Você também poderia estender
uma subclasse, como Manager, e criar uma nova classe chamada Director, que, por sua vez,
adiciona novos métodos ou substitui os métodos existentes.
Toda vez que uma classe é estendida, a nova classe herda todos os métodos e propriedades
atuais da subclasse. Se as classes não estivessem relacionadas, você precisaria recriar cada
método e propriedade em cada arquivo de classe separado, mesmo que as classes relacionadas
tivessem a mesma funcionalidade. Você gastaria muito mais tempo não só codificando, como
também depurando o aplicativo e mantendo um projeto caso uma lógica semelhante fosse
alterada em vários arquivos.
320
Herança
No ActionScript, você usa a palavra-chave extends para estabelecer a herança entre uma
classe e sua superclasse ou para estender uma interface. Para obter mais informações sobre o
uso da palavra-chave extends, consulte “Sobre a criação de subclasses no Flash”
na página 321 e “Sobre a criação de uma subclasse” na página 322. Para obter mais
informações sobre a palavra-chave extends, consulte %{extends statement}% em ActionScript
2.0 Language Reference (Referência da linguagem ActionScript 2.0).
Sobre a criação de subclasses no Flash
Na programação orientada a objeto, uma subclasse pode herdar as propriedades e os métodos
de outra classe, a superclasse. Você pode estender suas classes personalizadas, bem como várias
das classes básicas e do ActionScript do Flash Player, mas não pode estender a classe TextField
nem as classes estáticas, como Math, Key e Mouse.
Para criar esse tipo de relacionamento entre duas classes, use a cláusula extends da instrução
class. Para especificar uma superclasse, use a seguinte sintaxe:
class SubClass extends SuperClass {}
A classe especificada em SubClass herda todas as propriedades e métodos definidos em
SuperClass.
Por exemplo, você pode criar uma classe Mammal, que define propriedades e métodos
comuns a todos os mamíferos. Para criar uma variação da classe Mammal, por exemplo, uma
classe Marsupial, você estenderá a classe Mammal, ou seja, criará uma subclasse dessa classe,
da seguinte maneira:
class Marsupial extends Mammal {}
A subclasse herda todas as propriedades e métodos da superclasse, incluindo as propriedades
ou os métodos declarados como privados usando a palavra-chave private.
Para obter mais informações sobre a extensão de classes, consulte os seguintes tópicos:
■
“Sobre a criação de uma subclasse” na página 322
■
“Substituindo métodos e propriedades” na página 324
Para obter mais informações sobre membros privados, consulte “Sobre propriedades
(membros) e métodos públicos, privados e estáticos” na página 262. Para ver um exemplo que
cria uma subclasse, consulte “Exemplo: Estendendo a classe Widget” na página 322.
321
Sobre a criação de uma subclasse
O código a seguir define a classe personalizada JukeBox, que estende a classe Sound. Ele
define um array chamado song_arr e um método chamado playSong(), que reproduz uma
música e chama o método loadSound(), que herda as características da classe Sound.
class JukeBox extends Sound {
public var song_arr:Array = new Array("beethoven.mp3", "bach.mp3",
"mozart.mp3");
public function playSong(songID:Number):Void {
super.loadSound(song_arr[songID], true);
}
}
Se você não fizer uma chamada para super() na função construtora de uma subclasse, o
compilador gerará automaticamente uma chamada para o construtor da superclasse imediata,
sem parâmetros como a primeira instrução da função. Se a superclasse não tiver um
construtor, o compilador criará uma função vazia e depois gerará a chamada para ela a partir
da subclasse. Entretanto, se a superclasse utilizar parâmetros em sua definição, será necessário
criar um construtor na subclasse e chamar a superclasse com os parâmetros necessários.
A herança múltipla, ou herança de mais de uma classe, não é permitida no ActionScript 2.0.
Entretanto, as classes poderão herdar efetivamente as características de diversas classes se você
utilizar instruções extends individuais, como mostra o seguinte exemplo:
// não permitido
class C extends A, B {} // **Error: Uma classe não pode estender mais do que
uma classe.
// permitido
class B extends A {}
class C extends B {}
Também é possível usar interfaces para implementar uma forma limitada de herança múltipla.
Para obter mais informações sobre interfaces, consulte Capítulo 9, “Interfaces”, na
página 331. Para ver um exemplo que cria uma subclasse, consulte “Exemplo: Estendendo a
classe Widget” na página 322. Para obter mais informações sobre super, consulte %{super
statement}% em ActionScript 2.0 Language Reference.
Exemplo: Estendendo a classe Widget
Os membros da classe propagam-se para as subclasses da superclasse que define esses
membros. O exemplo a seguir demonstra como criar uma classe Widget, que pode ser
estendida (subclasse) com a criação de outra chamada SubWidget.
Para criar a classe Widget e a subclasse SubWidget:
1.
Crie um novo arquivo do ActionScript e salve-o como Widget.as.
322
Herança
2.
Adicione o seguinte código ao novo documento:
class Widget {
}
}
3.
4.
Crie um novo arquivo do ActionScript e salve-o como SubWidget.as no mesmo diretório
que a classe Widget.
5.
Em SubWidget.as, digite o seguinte código na janela Script:
class SubWidget extends Widget {
public function SubWidget() {
trace("Creating subwidget # "+Widget.widgetCount);
}
}
6.
Salve as alterações em SubWidget.as.
7.
Crie um novo arquivo FLA e salve-o como subWidgetTest.fla no mesmo diretório dos
arquivos de classes anteriores do ActionScript.
8.
Nesse arquivo, digite o seguinte código no Frame 1 (Quadro 1) da Timeline (Linha de
tempo) principal:
var sw1:SubWidget = new SubWidget();
trace("Widget.widgetCount = " + Widget.widgetCount);
trace("SubWidget.widgetCount = " + SubWidget.widgetCount);
O código anterior cria duas instâncias da classe SubWidget: sw1 e sw2. Cada chamada do
construtor de SubWidget rastreia o valor atual da propriedade estática
Widget.widgetCount. Como SubWidget é uma subclasse da classe Widget, você poderá
acessar a propriedade widgetCount por meio dessa subclasse, e o compilador recriará a
referência (no bytecode, não no arquivo ActionScript) como Widget.widgetCount. Se
você tentar acessar a propriedade estática widgetCount a partir de instâncias da classe
Widget ou SubWidget, como sw1 ou sw2, o compilador gerará um erro.
9.
Salve as alterações no documento.
10. Selecione
Control (Controlar) > Test Movie (Testar filme) para testar o documento do
Flash.
O painel Output (Saída) exibirá o seguinte:
Creating subwidget #1
Creating subwidget #2
323
Widget.widgetCount = 2
SubWidget.widgetCount = 2
Essa saída é exibida porque, embora o construtor da classe Widget nunca seja chamado
explicitamente, o construtor da classe SubWidget o chama para você. Como resultado, o
construtor da classe Widget incrementa a variável estática widgetCount dessa classe.
O compilador ActionScript 2.0 pode resolver as referências a membros estáticos nas
definições de classes.
Se você não especificar o nome da classe da propriedade Widget.widgetCount, mas fizer
referência somente a widgetCount, o compilador ActionScript 2.0 resolverá a referência
como Widget.widgetCount e exportará corretamente essa propriedade. Da mesma
forma, se você fizer referência à propriedade como SubWidget.widgetCount, o
compilador recriará a referência (no bytecode, e não no arquivo do ActionScript) como
Widget.widgetCount porque SubWidget é uma subclasse da classe Widget.
A TE N Ç Ã O
Se você tentar acessar a variável estática widgetCount da classe Widget usando a
instância sw1 ou sw2, o Flash gerará um erro informando que só é possível acessar
os membros estáticos diretamente através de classes.
Para garantir a legibilidade máxima do seu código, a Macromedia recomenda que você use
sempre referências explícitas a variáveis de membro estático no código, como no exemplo
anterior. O uso de referências explícitas permite identificar facilmente onde a definição de um
membro estático reside.
Substituindo métodos e propriedades
Quando uma subclasse estende uma superclasse, a subclasse herda todos os métodos e as
propriedades da superclasse. Uma das vantagens de se trabalhar com classes e estendê-las é que
isso permite adicionar uma nova funcionalidade às classes existentes, bem como modificar
uma funcionalidade já existente. Por exemplo, considere a classe Widget criada no “Exemplo:
Estendendo a classe Widget” na página 322. Você poderia criar um novo método na
superclasse (Widget) e, em seguida, substituir o método na subclasse (SubWidget) ou
simplesmente usar o método herdado da classe Widget. O exemplo a seguir mostra como
substituir os métodos existentes nas classes.
Para substituir os métodos em uma subclasse:
1.
Crie um novo documento do ActionScript e salve-o como Widget.as.
2.
Em Widget.as, digite o seguinte código ActionScript na janela Script:
Nota: Se tiver criado a classe Widget em um exemplo anterior, modifique o código
existente adicionando o método doSomething(), da seguinte maneira:
324
Herança
class Widget {
}
public function doSomething():Void {
trace("Widget::doSomething()");
}
}
3.
Salve as alterações no documento do ActionScript.
Agora a classe Widget define um construtor e um método público chamado
doSomething().
4.
Crie um novo arquivo do ActionScript chamado SubWidget.as e salve-o no mesmo
diretório que Widget.as.
NO TA
5.
Se tiver criado a classe SubWidget no “Exemplo: Estendendo a classe Widget”
na página 322, você poderá usá-la.
Em SubWidget.as, digite o seguinte código ActionScript na janela Script:
doSomething();
}
}
6.
Salve as alterações em SubWidget.as.
Observe que o construtor da classe SubWidget chama o método doSomething() definido
na superclasse.
7.
Crie um novo documento do Flash e salve-o como subWidgetTest.fla no mesmo diretório
que os documentos do ActionScript.
8.
Em subWidgetTest.fla, digite o seguinte ActionScript no Frame 1 (Quadro 1) da Timeline
(Linha de tempo) principal :
9.
Salve as alterações no documento do Flash.
10. Selecione
Control (Controlar) > Test Movie (Testar filme) para testar o documento do
Flash. Você observa o seguinte no painel Output (Saída):
Creating subwidget # 1
Widget::doSomething()
Widget::doSomething()
325
Essa saída mostra que o construtor da classe SubWidget chama o construtor de sua
superclasse (Widget), que incrementa a propriedade estática widgetCount. O construtor
de SubWidget rastreia a propriedade estática da superclasse e chama o método
doSomething(), que herda as características da superclasse.
11.
Abra a classe SubWidget e adicione um novo método chamado doSomething().
Modifique sua classe de acordo com o seguinte código (adicione o código em negrito):
doSomething();
}
public function doSomething():Void {
trace("SubWidget::doSomething()");
}
}
12. Salve
13.
as alterações no arquivo de classe e, em seguida, abra subwidgetTest.fla novamente.
Selecione Control > Test Movie para testar o arquivo. Você observa o seguinte no painel
Output:
SubWidget::doSomething()
SubWidget::doSomething()
A saída anterior mostra que o método doSomething() do construtor da classe SubWidget
chama o método doSomething() da classe atual, e não da superclasse.
Abra a classe SubWidget novamente e modifique o construtor dessa classe para chamar o
método doSomething() (adicione o código em negrito):
super.doSomething();
}
Como demonstrado, você pode adicionar a palavra-chave super para chamar o método
doSomething() da superclasse, em vez do método doSomething() da classe atual. Para
obter mais informações sobre super, consulte a entrada correspondente em ActionScript
2.0 Language Reference.
14. Salve
o arquivo de classe SubWidget com o construtor modificado e selecione Control >
Test Movie para publicar novamente o documento do Flash.
O painel Output exibe o conteúdo do método doSomething() da classe Widget.
326
Herança
Usando o polimorfismo em um aplicativo
A programação orientada a objeto permite expressar as diferenças entre classes individuais com
uma técnica chamada polimorfismo, pela qual as classes podem substituir os métodos de suas
superclasses e definir implementações especializadas desses métodos.
Por exemplo, você pode criar inicialmente uma classe chamada Mammal com os métodos
play() e sleep() e, em seguida, criar as subclasses Cat, Monkey e Dog para estender essa
classe. As subclasses substituem o método play() da classe Mammal para refletir os hábitos
desses tipos específicos de animais. Monkey implementa o método play() para pendurar-se
nos galhos de árvores; Cat implementa o método play() para avançar em um novelo de lã;
Dog implementa o método play() para apanhar uma bola. Como a funcionalidade sleep()
é semelhante entre os animais, você usaria a implementação de superclasse. O procedimento a
seguir demonstra esse exemplo no Flash.
Para usar o polimorfismo em um aplicativo:
1.
Crie um novo documento do ActionScript e salve-o como Mammal.as.
Esse documento é a classe base de várias classes diferentes de animais que você criará na
etapas subseqüentes.
2.
Em Mammal.as, digite o seguinte código ActionScript na janela Script:
class Mammal {
private var _gender:String;
private var _name:String = "Mammal";
// construtor
public function Mammal(gender:String) {
this._gender = gender;
}
public function toString():String {
return "[object " + speciesName + "]";
}
public function play():String {
return "Chase another of my kind.";
}
public function sleep():String {
return "Close eyes.";
}
public function get gender():String {
return this._gender;
}
public function get speciesName():String {
return this._name;
}
327
public function set speciesName(value:String):Void {
this._name = value;
}
}
A classe anterior define duas variáveis privadas, __gender e __name, que são usadas para
armazenar o tipo de mamífero e o sexo do animal. Em seguida, o construtor Mammal é
definido. O construtor precisa de um único parâmetro, gender, que é usado para definir a
variável privada _gender especificada anteriormente. Três métodos públicos adicionais
também são especificados: toString(), play() e sleep(), sendo que cada um retorna
objetos String. Os três métodos finais são getters e setters das propriedades _gender e
_name do mamífero.
3.
Salve o documento do ActionScript.
Essa classe funciona como a superclasse das classes Cat, Dog e Monkey, que você criará em
breve. Você pode usar o método toString() da classe Mammal para exibir uma
representação de seqüência de caracteres de qualquer instância dessa classe (ou de qualquer
instância que estendesse essa classe).
4.
Crie um novo arquivo do ActionScript e salve-o como Cat.as no mesmo diretório do
arquivo de classe Mammal.as criada na etapa 1.
5.
Em Cat.as, digite o seguinte código ActionScript na janela Script:
class Cat extends Mammal {
// construtor
public function Cat(gender:String) {
super(gender);
speciesName = "Cat";
}
return "Pounce a ball of yarn.";
}
}
Observe que você está substituindo o método play() da superclasse Mammal. A classe
Cat define somente dois métodos, um método construtor e outro play(). Como a classe
Cat estende a classe Mammal, os métodos e as propriedades dessa classe são herdados pela
classe Cat. Para obter mais informações sobre substituição, consulte “Substituindo
métodos e propriedades” na página 324.
6.
7.
Crie um novo documento do ActionScript e salve-o como Dog.as no mesmo diretório que
os dois arquivos de classes anteriores.
8.
Em Dog.as, digite o seguinte código ActionScript na janela Script:
class Dog extends Mammal {
328
Herança
// construtor
public function Dog(gender:String) {
super(gender);
speciesName = "Dog";
}
return "Fetch a stick.";
}
}
Observe que a classe Dog tem uma estrutura muito semelhante à da classe Cat, com
exceção de alguns valores que foram alterados. Mais uma vez, a classe Dog estende a classe
Mammal e herda todos os seus métodos e propriedades. O construtor de Dog utiliza uma
única propriedade, gender, que ele passa à classe pai da classe Dog, Mammal. A variável
speciesName também é substituída e definida como a seqüência de caracteres Dog. O
método play() também é substituído a partir da classe pai.
9.
10. Crie
outro documento do ActionScript no mesmo diretório que os seus outros arquivos e
salve-o como Monkey.as.
11.
Em Monkey.as, digite o seguinte código ActionScript na janela Script:
class Monkey extends Mammal {
// construtor
public function Monkey(gender:String) {
super(gender);
speciesName = "Monkey";
}
return "Swing from a tree.";
}
}
Como as duas classes anteriores, Cat e Dog, a classe Monkey estende a classe Mammal. O
construtor da classe Monkey chama o construtor da classe Mammal, passando a
propriedade gender para ele e definindo speciesName como a seqüência de caracteres
Monkey. A classe Monkey também substitui o comportamento do método play().
12. Salve
13.
as alterações no documento do ActionScript.
Agora que você criou três subclasses da classe Mammal, crie um novo documento do Flash
chamado mammalTest.fla.
14. Em
mammalTest.fla, digite o seguinte código ActionScript no Frame (Quadro) 1 da
Timeline (Linha de tempo) principal:
var mammals_arr:Array = new Array();
329
this.createTextField("info_txt", 10, 10, 10, 450, 80);
info_txt.html = true;
info_txt.multiline = true;
info_txt.border = true;
info_txt.wordWrap = true;
createMammals()
createReport()
function createMammals():Void {
mammals_arr.push(new Dog("Female"));
mammals_arr.push(new Cat("Male"));
mammals_arr.push(new Monkey("Female"));
mammals_arr.push(new Mammal("Male"));
}
function createReport():Void {
var i:Number;
var len:Number = mammals_arr.length;
// Exiba as informações de Mammal em quatro colunas de texto HTML
usando interrupções de tabulação.
info_txt.htmlText = "<textformat tabstops='[110, 200, 300]'>";
info_txt.htmlText += "Mammal\tGender\tSleep\tPlay";
for (i = 0; i < len; i++) {
info_txt.htmlText += "" + mammals_arr[i].speciesName
+ "\t" + mammals_arr[i].gender
+ "\t" + mammals_arr[i].sleep()
+ "\t" + mammals_arr[i].play() + "";
// A instrução trace chama o método Mammal.toString().
trace(mammals_arr[i]);
}
info_txt.htmlText += "</textformat>";
}
O código de mammalTest.fla é um pouco mais complexo do que as classes anteriores.
Primeiro ele importa as três classes de animal.
15.
para testar o documento.
Você verá as informações de Mammal exibidas em um campo de texto no Stage (Palco) e o
seguinte texto no painel Output (Saída):
[object
[object
[object
[object
330
Dog]
Cat]
Monkey]
Mammal]
Herança
CAPÍTULO 9
9
Interfaces
Na OOP (Object-Oriented Programming, Programação orientada a objeto), uma interface é
um documento que permite declarar (porém não definir) os métodos que devem aparecer em
uma classe. Quando você trabalha em equipes de desenvolvedores ou cria aplicativos maiores
no Flash, as interfaces podem ser muito úteis durante o desenvolvimento. Elas permitem que
os desenvolvedores identifiquem facilmente os métodos base das classes do ActionScript. Esses
métodos devem ser implementados quando os desenvolvedores usam cada interface.
Este capítulo examina algumas interfaces de exemplo e, ao concluí-lo, você será capaz de criar
seus próprios arquivos de interface. Se não estiver familiarizado com a criação de classes, leia o
Capítulo 7, “Classes,” antes de tentar fazer os tutoriais e ler os exemplos apresentados neste
capítulo.
Para obter mais informações sobre o trabalho com interfaces, consulte os seguintes tópicos:
Sobre interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
Criando interfaces como tipos de dados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
Noções básicas sobre herança e interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .339
Exemplo: Usando interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
Exemplo: Criando uma interface complexa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .342
Sobre interfaces
Na programação orientada a objeto, as interfaces assemelham-se a classes cujos métodos não
são implementados (definidos), ou seja, elas não “fazem” nada. Portanto, uma interface
consiste em métodos “vazios”. Outra classe poderá implementar os métodos declarados pela
interface. No ActionScript, a distinção entre interface e objeto aplica-se somente à verificação
de erros durante a compilação e à imposição de regras de linguagem.
331
Uma interface não é uma classe; porém, essa afirmativa não é completamente verdadeira no
ActionScript durante a execução pois uma interface é abstrata. As interfaces do ActionScript
realmente existem na execução para permitir a conversão de tipos (a alteração de um tipo
existente de dados em outro tipo). O modelo de objeto do ActionScript 2.0 não oferece
suporte à herança múltipla. Portanto, uma classe pode herdar as características de uma única
classe pai. Essa classe pai pode ser uma classe básica ou do Flash Player ou, ainda, uma classe
definida pelo usuário (personalizada). É possível usar interfaces para implementar uma forma
limitada de herança múltipla, pela qual uma classe herda mais de uma classe.
Por exemplo, em C++, a classe Cat pode estender a classe Mammal, bem como uma classe
Playful, que contém os métodos chaseTail() e eatCatNip(). Como o Java, o ActionScript
2.0 não permite que uma classe estenda várias classes diretamente, mas permite que ela
estenda uma única classe e implemente várias interfaces. Portanto, você pode criar uma
interface Playful que declara os métodos chaseTail() e eatCatNip(). Uma classe Gato, ou
qualquer outra classe, pode implementar essa interface e fornecer definições para esses
métodos.
Uma interface também pode ser considerada como um “contrato de programação” que pode
ser usado para impor os relacionamentos entre classes não relacionadas de outra maneira. Por
exemplo, suponha que você esteja trabalhando com uma equipe de programadores, cada um
responsável por uma classe diferente do mesmo aplicativo. Ao projetar o aplicativo, você
estabelece um conjunto de métodos que as diferentes classes usarão para se comunicar. Você
cria uma interface que declara esses métodos, seus parâmetros e tipos de retorno. Qualquer
classe que implemente essa interface deve fornecer definições para esses métodos; caso
contrário, ocorrerá um erro do compilador. A interface é como um protocolo de comunicação
ao qual todas as classes devem aderir.
Uma maneira de fazer isso é criar uma classe que defina todos esses métodos e, em seguida,
fazer com que cada classe seja estendida a partir dessa superclasse ou herde as características
dela. Como o aplicativo consiste em classes que não estão relacionadas, não faz sentido impor
uma hierarquia de classe comum a elas. Uma solução melhor é criar uma interface que declare
os métodos que essas classes usam para se comunicar e, em seguida, fazer cada classe
implementar (fornecer suas próprias definições para) esses métodos.
Normalmente, você pode programar bem sem usar interfaces. Entretanto, quando usadas
apropriadamente, as interfaces podem tornar o projeto dos aplicativos mais elegante,
dimensionável e fácil de manter.
332
Interfaces
As interfaces do ActionScript existem durante a execução para permitir a conversão de tipos;
consulte Capítulo 4, “Sobre a conversão de objetos”, na página 117. Embora uma interface
não seja um objeto ou uma classe, o fluxo de trabalho é semelhante ao existente quando se
trabalha com classes. Para obter mais informações sobre o fluxo de trabalho de classes,
consulte “Criando arquivos de classes personalizados” na página 249. Para ver um tutorial
sobre como criar um aplicativo com interfaces, consulte “Exemplo: Usando interfaces”
na página 340.
Para obter mais informações sobre o uso de interfaces, consulte as seguintes seções:
■
“Sobre a palavra-chave interface” na página 333
■
“Sobre a atribuição de nomes a interfaces” na página 334
■
“Definindo e implementado interfaces” na página 334
Sobre a palavra-chave interface
A palavra-chave interface define uma interface. Uma interface é semelhante a uma classe,
com as seguintes diferenças relevantes:
■
As interfaces contêm somente descrições de métodos e não sua implementação. Ou seja,
toda classe que implementa uma interface deve fornecer uma implementação para cada
método definido na interface.
■
Somente membros públicos são permitidos em uma definição de interface; membros
estáticos e de classe não são permitidos.
■
As instruções get e set não são permitidas em definições de interface.
■
Para usar a palavra-chave interface, é necessário especificar ActionScript 2.0 e Flash
Player 6 ou uma versão posterior na guia Flash da caixa de diálogo Publish Settings
(Configurações de publicação) do arquivo FLA.
A palavra-chave interface é suportada somente quando usada em arquivos de script
externos, não em scripts criados no painel Actions (Ações).
Sobre interfaces
333
Sobre a atribuição de nomes a interfaces
Como os nomes de classes, os nomes de interfaces iniciam em letra maiúscula. Esses nomes
são geralmente adjetivos como Printable. O nome de interface a seguir, IEmployeeRecords,
usa uma inicial maiúscula e palavras concatenadas em letras maiúsculas e minúsculas:
interface IEmployeeRecords {}
NO TA
Alguns desenvolvedores iniciam os nomes das interfaces com um “I” maiúsculo para
diferenciá-las das classes. A adoção dessa prática é recomendada, pois permite
distinguir rapidamente entre interfaces e classes comuns.
Para obter mais informações sobre convenções de atribuição de nome, consulte Capítulo 19,
Definindo e implementado interfaces
O processo de criação de uma interface é igual ao de criação de uma classe. Assim como as
classes, só é possível definir interfaces nos arquivos externos do ActionScript. O fluxo de
trabalho para a criação de uma interface envolve, no mínimo, as seguintes etapas:
■
Definir uma interface em um arquivo externo do ActionScript.
■
Salvar o arquivo da interface em um diretório de caminho de classe designado (o local em
que o Flash procura as classes) ou no mesmo diretório que o arquivo FLA do aplicativo
■
Criar uma instância da classe em outro script, em um documento do Flash (FLA) ou em
um arquivo de script externo, ou criar subinterfaces com base na interface original
■
Criar uma classe que implemente a interface em um arquivo de script externo
Para declarar uma interface, use a palavra-chave interface, seguida do nome da interface e
de chaves ({}), que definem o corpo da interface, como mostra o seguinte exemplo:
interface IEmployeeRecords {
// declarações de método de interface
}
Uma interface só pode conter declarações de métodos (funções), incluindo parâmetros, tipos
de parâmetro e tipos de retorno de função.
Para obter mais informações sobre convenções de estruturação de classes e interfaces, consulte
Capítulo 19, “Melhores práticas e convenções de codificação para ActionScript 2.0”, na
página 767. Para ver um tutorial sobre a criação de um aplicativo que usa uma interface,
consulte “Exemplo: Usando interfaces” na página 340.
334
Interfaces
Por exemplo, o código a seguir declara uma interface chamada IMyInterface que contém
dois métodos, method1() e method2(). O primeiro método, method1(), não possui
parâmetros e especifica o tipo de retorno Void (que indica que ele não retorna um valor). O
segundo método, method2(), tem um único parâmetro de tipo String e especifica um tipo de
retorno Boolean.
Para criar uma interface simples:
1.
Crie um novo arquivo do ActionScript e salve-o como IMyInterface.as.
2.
interface IMyInterface {
public function method1():Void;
public function method2(param:String):Boolean;
}
3.
Para usar a interface em um aplicativo, é necessário criar primeiro uma classe que
implemente a nova interface.
4.
Crie um novo arquivo do ActionScript e salve-o como MyClass.as no mesmo diretório que
IMyInterface.as.
5.
No arquivo de classe MyClass, digite o seguinte código ActionScript na janela Script:
class MyClass {
}
Para instruir a classe personalizada (MyClass) a usar a interface (IMyInterface), é
necessário usar a palavra-chave implements, a qual especifica que uma classe deve definir
todos os métodos declarados na(s) interface(s) implementada(s).
6.
Modifique o código ActionScript em MyClass.as (adicione o código em negrito) de acordo
com o seguinte trecho:
class MyClass implements IMyInterface {
}
Coloque a palavra-chave implements depois do nome da classe.
7.
Clique no botão Check Syntax (Verificar sintaxe).
O Flash exibe um erro no painel Output (Saída) informando que MyClass deve
implementar o método X da interface IMyInterface. Essa mensagem de erro é exibida
porque toda classe que estende uma interface deve definir cada método listado no
documento da interface.
8.
Modifique o documento MyClass novamente (adicione o código em negrito) e crie o
código ActionScript para os métodos method1() e method2(), como mostra o seguinte
trecho:
Sobre interfaces
335
class MyClass implements IMyInterface {
public function method1():Void {
// ...
};
public function method2(param:String):Boolean {
// ...
return true;
}
}
9.
Salve o documento MyClass.as e clique em Check Syntax.
O painel Output não exibe mais mensagens de erro ou avisos porque agora você definiu os
dois métodos.
O arquivo de classe criado não se limita aos métodos públicos definidos no arquivo de
interface. O arquivo de interface descreve apenas os métodos mínimos que devem ser
implementados, bem como os tipos de retorno e as propriedades desses métodos. As classes
que implementam uma interface quase sempre incluem métodos getter e setter, variáveis e
métodos adicionais.
Os arquivos de interface não podem conter declarações de variáveis nem atribuições. As
funções declaradas em uma interface não podem conter chaves. Por exemplo, a interface a
seguir não é compilada:
interface IBadInterface {
// Erro do compilador. Declarações de variáveis não permitidas em
interfaces.
public var illegalVar:String;
// Erro do compilador. Corpos de função não permitidos em interfaces.
public function illegalMethod():Void {
}
// Erro do compilador. Não são permitidos métodos privados em interfaces.
private function illegalPrivateMethod():Void;
// Erro do compilador. Não são permitidos getters/setters em interfaces.
public function get illegalGetter():String;
}
Para ver um tutorial que demonstra como criar uma interface complexa, consulte “Exemplo:
Usando interfaces” na página 340.
As regras para atribuir nome a interfaces e armazená-las nos pacotes são as mesmas usadas para
as classes; consulte “Sobre a atribuição de nomes a arquivos de classes” na página 280.
336
Interfaces
Criando interfaces como tipos de dados
Como uma classe, uma interface define um novo tipo de dados. Qualquer classe que
implementa uma interface pode ser considerada como sendo do tipo definido pela interface.
Esse recurso é útil para determinar se um objeto específico implementa uma determinada
interface. Por exemplo, considere a interface IMovable, criada no exemplo a seguir.
Para criar uma interface como um tipo de dados:
1.
Crie um novo documento do ActionScript e salve-o no disco rígido como IMovable.as.
2.
Em IMovable.as, digite o seguinte código ActionScript na janela Script:
interface IMovable {
public function moveUp():Void;
public function moveDown():Void;
}
3.
4.
Crie um novo documento do ActionScript e salve-o como Box.as no mesmo diretório que
IMovable.as.
Nesse documento, crie uma classe Box que implementa a interface IMovable criada em
uma etapa anterior.
5.
Em Box.as, digite o seguinte código ActionScript na janela Script:
class Box implements Movable {
public var xPos:Number;
public var yPos:Number;
public function Box() {
}
public function moveUp():Void {
trace("moving up");
// definição de método
}
public function moveDown():Void {
trace("moving down");
// definição de método
}
}
6.
7.
Crie um novo documento do Flash chamado boxTest.fla e salve-o no mesmo diretório que
os dois documentos anteriores do ActionScript.
Criando interfaces como tipos de dados
337
8.
Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo), abra o editor do
ActionScript e digite o seguinte código ActionScript no painel Actions (Ações) (ou janela
Script):
var newBox:Box = new Box();
Esse código ActionScript cria uma instância da classe Box, que você declara como uma
variável do tipo Box.
9.
Salve as alterações no documento do Flash e selecione Control (Controlar) > Test Movie
(Testar filme) para testar o arquivo SWF.
No Flash Player 7 e versões posteriores, você pode converter uma expressão em um tipo de
interface ou em outro tipo de dados durante a execução. Diferentemente das interfaces do
Java, as interfaces do ActionScript existem durante a execução, o permite a conversão de
tipos. Se a expressão for um objeto que implemente a interface ou tenha uma superclasse
que implemente a interface, o objeto será retornado. Caso contrário, será retornado null.
Esse recurso é útil para verificar se determinado objeto implementa uma interface
específica. Para obter mais informações sobre conversão de tipos, consulte Capítulo 4,
“Sobre a conversão de objetos”, na página 117.
10. Adicione
o código a seguir ao final do código ActionScript em boxTest.fla:
if (IMovable(newBox) != null) {
newBox.moveUp();
else {
trace("box instance is not movable");
}
Esse código ActionScript verifica se a instância newBox implementa a interface IMovable
antes da chamada do método moveUp() no objeto.
11.
Salve o documento do Flash e selecione Control > Test Movie para testar o arquivo SWF.
Como a instância Box implementa a interface IMovable, o método Box.moveUp() é
chamado, e o texto “moving up” é exibido no painel Output (Saída).
Para obter mais informações sobre conversão, consulte Capítulo 4, “Sobre a conversão de
objetos”, na página 117.
338
Interfaces
Noções básicas sobre herança e
interfaces
Você pode usar a palavra-chave extends para criar subclasses de uma interface. Isso poderá ser
muito útil em projetos maiores quando se deseja estender uma interface existente (ou criar
uma subclasse dela) e adicionar outros métodos. Esses métodos devem ser definidos por todas
as classes que implementam essa interface.
Uma consideração a ser feita ao estender interfaces é que serão exibidas mensagens de erro no
Flash se vários arquivos de interface declararem funções com os mesmos nomes, mas tiverem
parâmetros ou tipos de retorno diferentes.
O exemplo a seguir demonstra como uma criar uma subclasse de um arquivo de interface com
a palavra-chave extends.
Para estender uma interface:
1.
Crie um novo arquivo do ActionScript e salve-o como Ia.as.
2.
Em Ia.as, digite o seguinte código ActionScript na janela Script:
interface Ia {
public function f1():Void;
}
3.
4.
Crie um novo arquivo do ActionScript e salve-o como Ib.as na mesma pasta que o arquivo
Ia.as criado na etapa 1.
5.
No arquivo Ib.as, digite o seguinte código ActionScript na janela Script:
interface Ib extends Ia {
}
6.
7.
Crie um novo arquivo do ActionScript e salve-o como ClassA.as no mesmo diretório que
os dois arquivos anteriores.
8.
Em ClassA.as, digite o seguinte código ActionScript na janela Script:
class ClassA implements Ib {
// f1() e f2() são definidos na interface Ia.
public function f1():Void {
}
}
Noções básicas sobre herança e interfaces
339
// f8() e f9() são definidos na interface Ib, que estende Ia.
}
}
}
9.
Salve o arquivo de classe e clique no botão Check Syntax (Verificar sintaxe) acima da janela
Script.
O Flash não gerará mensagens de erro desde que todos os quatro métodos sejam definidos
e correspondam às definições de seus respectivos arquivos de interface.
NO T A
No ActionScript 2.0, as classes só podem estender uma classe, embora seja
possível usá-las para implementar tantas interfaces quantas forem desejadas.
Para que a classe ClassA implemente várias interfaces no exemplo anterior, separe
simplesmente as interfaces com vírgulas. Ou, se uma classe estendesse uma superclasse e
implementasse várias interfaces, você usaria um código semelhante ao seguinte:
class ClassA extends ClassB implements Ib, Ic, Id {...}.
Exemplo: Usando interfaces
Neste exemplo, você criará uma interface simples que poderá ser reutilizada entre várias classes
diferentes.
Para criar uma interface:
1.
Crie um novo arquivo do ActionScript e salve-o como IDocumentation.as.
2.
Em IDocumentation.as, digite o seguinte código ActionScript na janela Script:
interface IDocumentation {
public function downloadUpdates():Void;
public function checkForUpdates():Boolean;
public function searchHelp(keyword:String):Array;
}
3.
Salve as alterações efetuadas no arquivo de interface do ActionScript.
4.
Crie um novo arquivo do ActionScript no mesmo diretório que IDocumentation.as e salveo como FlashPaper.as.
5.
Em FlashPaper.as, digite o seguinte código ActionScript na janela Script:
class FlashPaper implements IDocumentation {
}
6.
Salve as alterações efetuadas no arquivo do ActionScript.
340
Interfaces
7.
Clique no botão Check Syntax (Verificar sintaxe) referente à classe do ActionScript.
É exibida uma mensagem de erro semelhante a esta:
**Error** path\FlashPaper.as: Line 1: The class must implement method
'checkForUpdates' from interface 'IDocumentation'.
Total ActionScript Errors: 1
Reported Errors: 1
Esse erro aparece porque a classe FlashPaper atual não define nenhum dos métodos
públicos que você definiu na interface IDocumentation.
8.
Abra o arquivo de classe FlashPaper.as novamente e modifique o código ActionScript de
acordo com o seguinte código:
private static var __version:String = "1,2,3,4";
public function downloadUpdates():Void {
};
public function checkForUpdates():Boolean {
return true;
};
public function searchHelp(keyword:String):Array {
return []
};
}
9.
Salve as alterações no arquivo do ActionScript e clique em Check Syntax novamente.
Desta vez, nenhum erro é exibido no painel Output (Saída).
N OT A
Você pode adicionar ao arquivo de classe FlashPaper quantas variáveis ou métodos
estáticos, públicos ou privados desejar. O arquivo de interface define somente um
conjunto de métodos mínimos que devem aparecer em qualquer classe que
implemente essa interface.
10. Abra o documento de interface IDocumentation novamente e adicione a seguinte linha de
código em negrito (abaixo do método searchHelp()):
interface IDocumentation {
public function downloadUpdates():Void;
public function checkForUpdates():Boolean;
public function searchHelp(keyword:String):Array;
public function addComment(username:String, comment:String):Void;
}
11.
Salve as alterações no arquivo de interface e reabra o documento FlashPaper.as.
Exemplo: Usando interfaces
341
12. Ao
clicar no botão Check Syntax, você vê uma nova mensagem de erro no painel Output:
**Error** path\FlashPaper.as: Line 1: The class must implement method
'addComment' from interface 'IDocumentation'.
Total ActionScript Errors: 1
Reported Errors: 1
O erro anterior aparece porque o arquivo de classe FlashPaper.as não define mais todas as
classes descritas no arquivo de interface. Para corrigir esse erro, adicione o método
addComment() à classe FlashPaper ou remova a definição do método do arquivo de
interface IDocumentation.
13.
Adicione o seguinte método à classe FlashPaper:
public function addComment(username:String, comment:String):Void {
/* Envie parâmetros para a página do servidor, que insere um
comentário no banco de dados. */
}
14. Salve as alterações em FlashPaper.as e clique no botão Check Syntax; depois disso, você não
deverá receber mais erros.
Na seção anterior, você criou uma classe com base no arquivo de interface IDocumentation.
Nesta seção, você criará uma nova classe que também implementará a interface
IDocumentation, embora ela adicione alguns outros métodos e propriedades.
Este tutorial demonstra a utilidade de usar interfaces quando você deseja criar outra classe que
estenda a interface IDocumentation, pois será possível identificar facilmente os métodos
necessários na nova classe.
Exemplo: Criando uma interface
complexa
O exemplo a seguir mostra várias maneiras de definir e implementar interfaces. Neste tutorial,
você aprenderá a criar um arquivo de interface simples e uma classe que implemente várias
interfaces. Aprenderá também a fazer com que as interfaces estendam outras interfaces para
criar estruturas de dados mais complexas.
Para criar uma interface complexa:
1.
Crie um novo documento do ActionScript e salve-o como InterfaceA.as.
2.
Crie uma nova pasta chamada complexInterface e salve InterfaceA.as nesse diretório.
Salve todos os arquivos criados para este tutorial nesse diretório.
342
Interfaces
3.
Em Interface.as, digite o seguinte código ActionScript na janela Script:
// nome do arquivo: InterfaceA.as
interface InterfaceA {
public function k():Number;
public function n(z:Number):Number;
}
4.
Salve o documento do ActionScript; em seguida, crie um novo documento do ActionScript
chamado ClassB.as e salve-o no diretório complexInterface.
ClassB.as implementa a interface InterfaceA criada anteriormente.
5.
Em ClassB.as, digite o seguinte código ActionScript na janela Script:
// nome do arquivo: ClassB.as
class ClassB implements InterfaceA {
public function k():Number {
return 25;
}
public function n(z:Number):Number {
return (z + 5);
}
}
6.
Salve as alterações no documento ClassB.as; em seguida, crie um novo documento do Flash
e salve-o como classbTest.fla no diretório complexInterface.
Esse arquivo de classe testa a classe ClassB criada anteriormente.
7.
Em classbTest.fla, digite o seguinte código ActionScript no Frame 1 (Quadro 1) da
Timeline (Linha de tempo):
// nome do arquivo: classbTest.fla
import ClassB;
var myB:ClassB = new ClassB();
trace(myB.k()); // 25
trace(myB.n(7)); // 12
8.
Salve as alterações no documento do Flash e selecione Control (Controlar) > Test Movie
(Testar filme) para testar o documento.
O painel Output (Saída) exibe dois números, 25 e 12, que são os resultados dos métodos
k() e n() da classe ClassB.
9.
Crie um novo arquivo do ActionScript e salve-o como ClassC.as no diretório
complexInterface.
Esse arquivo de classe implementa a interface InterfaceA criada na etapa 1.
Exemplo: Criando uma interface complexa
343
10. Em
ClassC.as, digite o seguinte código ActionScript na janela Script:
// nome do arquivo: ClassC.as
class ClassC implements InterfaceA {
return 25;
}
// **Erro** A classe também deve implementar o método 'n' da interface
'InterfaceA'.
}
Se você clicar no botão Check Syntax (Verificar sintaxe) referente ao arquivo de classe
ClassC, o Flash exibirá uma mensagem de erro no painel Output informando que a classe
atual deve implementar o método n() definido na interface InterfaceA. Ao criar classes
que implementam uma interface, é importante definir métodos para cada entrada da
interface.
11.
Crie um novo documento do ActionScript e salve-o como InterfaceB.as no diretório
complexInterface.
12. Em
InterfaceB.as, digite o seguinte código ActionScript na janela Script:
// nome do arquivo: InterfaceB.as
interface InterfaceB {
public function o():Void;
}
13.
Salve as alterações no documento InterfaceB.as; em seguida, crie um novo documento do
ActionScript e salve-o como classD.as no diretório complexInterface.
Essa classe implementa as interfaces InterfaceA e InterfaceB criadas em etapas anteriores. A
ClassD deve incluir implementações de cada um dos métodos listados em cada arquivo de
interface.
14. Em
ClassD.as, digite o seguinte código ActionScript na janela Script:
// nome do arquivo: ClassD.as
class ClassD implements InterfaceA, InterfaceB {
return 15;
}
return (z * z);
}
public function o():Void {
trace("o");
}
}
344
Interfaces
15.
Salve as alterações no arquivo ClassD.as; em seguida, crie um novo documento do Flash e
salve-o como classdTest.fla.
Esse documento do Flash testa a classe ClassD criada anteriormente.
16.
Em classdTest.fla, adicione o seguinte código ActionScript ao Frame 1 da Timeline:
// nome do arquivo: classdTest.fla
import ClassD;
var myD:ClassD = new ClassD();
trace(myD.k()); // 15
trace(myD.n(7)); // 49
myD.o(); // o
17.
Salve as alterações no arquivo classdTest.fla e selecione Control > Test Movie para testar o
arquivo.
Os valores 15, 49 e a letra o devem ser exibidos no painel Output. Esses valores são os
resultados dos métodos ClassD.k(), ClassD.n() e ClassD.o() respectivamente.
18.
Crie um novo documento do ActionScript e salve-o como InterfaceC.as.
Essa interface estende a interface InterfaceA criada anteriormente e adiciona uma nova
definição de método.
19. Em
InterfaceC.as, digite o seguinte código ActionScript na janela Script:
// nome do arquivo: InterfaceC.as
interface InterfaceC extends InterfaceA {
public function p():Void;
}
20.Salve
as alterações no arquivo do ActionScript; em seguida, crie um novo arquivo do
ActionScript e salve-o como ClassE.as no diretório complexInterface.
Essa classe implementa duas interfaces, InterfaceB e InterfaceC.
21. No
arquivo ClassE.as, digite o seguinte código ActionScript na janela Script:
// nome do arquivo: ClassE.as
class ClassE implements InterfaceB, InterfaceC {
return 15;
}
return (z + 5);
}
public function o():Void {
trace("o");
}
public function p():Void {
trace("p");
}
}
Exemplo: Criando uma interface complexa
345
22.Salve
as alterações no documento do ActionScript; em seguida, crie um novo documento
do Flash e salve-o como classeTest.fla no diretório complexInterface.
23.No
arquivo classeTest.fla, digite o seguinte código ActionScript no Frame 1 da Timeline:
// nome do arquivo: classeTest.fla
import ClassE;
var myE:ClassE = new ClassE();
trace(myE.k()); // 15
trace(myE.n(7)); // 12
myE.o(); // o
myE.p(); // p
24.Salve o documento do Flash e selecione Control > Test Movie para
testar o arquivo SWF.
Os valores 15, 12, o e p são exibidos no painel Output. Esses valores são retornados pelos
métodos ClassE.k(), ClassE.n(), ClassE.o() e ClassE.p(). Como a classe ClassE
implementou as interfaces InterfaceB e InterfaceC, cada método dos dois arquivos de
interface deve ser definido. Embora as interfaces InterfaceB e InterfaceC definam somente
os métodos o() e p(), a InterfaceC estende a InterfaceA. Isso significa que todos os
métodos definidos por ela, k() e n(), também devem ser implementados.
346
Interfaces
CAPÍTULO 10
10
Manipulando eventos
Eventos são ações que ocorrem enquanto um arquivo SWF é reproduzido. Um evento, como
um clique com o mouse ou um pressionamento de tecla, é chamado de evento do usuário, já
que é o resultado de uma interação direta com o usuário. Um evento gerado automaticamente
pelo Flash Player, como a aparência inicial de um clipe de filme no Stage (Palco), chama-se
evento do sistema, porque não é gerado diretamente pelo usuário.
Para que seu aplicativo reaja a eventos, você deve usar manipuladores de eventos, um código
ActionScript associado a um objeto e a um evento específicos. Por exemplo, quando um
usuário clicar em um botão no Stage (Palco), você poderá avançar a reprodução até o próximo
quadro. Ou, depois que um arquivo XML for carregado pela rede, o seu conteúdo poderá ser
exibido em um campo de texto.
Você pode manipular eventos no ActionScript de várias maneiras:
■
“Usando métodos manipuladores de eventos” na página 348
■
“Usando ouvintes de eventos” na página 351
■
“Usando manipuladores de eventos de botão e de clipe de filme” na página 355,
especificamente, %{on handler}% e %{onClipEvent handler}%.
■
“Transmitindo eventos de instâncias de componentes” na página 360
O uso de manipuladores de eventos com %{loadMovie (MovieClip.loadMovie method)}%
pode ser imprevisível. Se você anexar um manipulador de eventos a um botão usando on(),
ou se criar um manipulador dinâmico usando um método como %{onPress
(MovieClip.onPress handler)}% e, em seguida, chamar loadMovie(), o manipulador de
eventos não estará disponível depois que o novo conteúdo for carregado. Entretanto, se você
usar %{onClipEvent handler}% ou %{on handler}% para anexar um manipulador de eventos
a um clipe de filme e, em seguida, chamar loadMovie() nesse clipe, o manipulador de
eventos ainda estará disponível depois que o novo código for carregado.
347
Para obter mais informações sobre a manipulação de eventos, consulte as seguintes seções:
Usando métodos manipuladores de eventos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .348
Usando ouvintes de eventos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351
Usando ouvintes de eventos com componentes . . . . . . . . . . . . . . . . . . . . . . . . . . . .353
Usando manipuladores de eventos de botão e de clipe de filme. . . . . . . . . . . . . . .355
Transmitindo eventos de instâncias de componentes . . . . . . . . . . . . . . . . . . . . . . . 360
Criando clipes de filme com estados de botão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
Escopo do manipulador de eventos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .362
Escopo da palavra-chave this . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .365
Usando a classe Delegate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .366
Usando métodos manipuladores de
eventos
Um método manipulador de eventos é o método de uma classe que é chamado quando ocorre
um evento em uma instância dessa classe. Por exemplo, a classe MovieClip define um
manipulador de eventos onPress que é chamado sempre que o botão do mouse é pressionado
em um objeto de clipe de filme. Ao contrário de outros métodos de classe, porém, o
manipulador de eventos não é chamado diretamente; o Flash Player chama esse manipulador
automaticamente quando ocorre o evento apropriado.
As seguintes classes do ActionScript são exemplos de classes que definem manipuladores de
exemplos: Button, ContextMenu, ContextMenuItem, Key, LoadVars, LocalConnection,
Mouse, MovieClip, MovieClipLoader, Selection, SharedObject, Sound, Stage, TextField,
XML e XMLSocket. Para obter mais informações sobre os manipuladores de eventos
fornecidos por elas, consulte as entradas correspondentes a cada classe em ActionScript 2.0
Language Reference (Referência da linguagem ActionScript 2.0). A palavra handler é
adicionada ao título de cada manipulador de eventos.
Por padrão, os métodos manipuladores de eventos são indefinidos: quando ocorre um evento
específico, o manipulador correspondente é chamado, mas o aplicativo não responde mais ao
evento. Para que seu aplicativo responda ao evento, defina uma função com a instrução de
função e atribua essa função ao manipulador de eventos apropriado. A função atribuída ao
manipulador de eventos é chamada automaticamente sempre que o evento ocorre.
348
Manipulando eventos
Um manipulador de eventos consiste em três partes: o objeto ao qual se aplica o evento, o
nome do método manipulador de eventos do objeto e a função atribuída ao manipulador de
eventos. O exemplo a seguir mostra a estrutura básica de um manipulador de eventos:
object.eventMethod = function () {
// Insira seu código aqui em resposta ao evento.
}
Por exemplo, imagine que exista um botão chamado next_btn no Stage (Palco). O código a
seguir atribui uma função ao manipulador de eventos onPress do botão; essa função avança a
reprodução até o próximo quadro na linha de tempo atual:
next_btn.onPress = function () {
nextFrame();
}
Atribuindo uma referência de função No código anterior, a função nextFrame() é
atribuída diretamente a um manipulador de eventos onPress. Também é possível atribuir
uma referência de função (nome) a um método manipulador de eventos e, posteriormente,
definir a função, como mostra este exemplo:
// Atribua uma referência de função ao manipulador de eventos onPress do
botão.
next_btn.onPress = goNextFrame;
// Defina a função goNextFrame().
function goNextFrame() {
nextFrame();
}
No exemplo a seguir, observe que você atribui a referência da função, e não seu valor de
retorno, ao manipulador de eventos onPress:
// Incorreto!
next_btn.onPress = goNextFrame();
// Correto.
next_btn.onPress = goNextFrame;
Alguns manipuladores de eventos recebem parâmetros
passados com informações sobre o evento ocorrido. Por exemplo, o manipulador de eventos
TextField.onSetFocus é chamado quando uma instância de campo de texto ganha o foco
do teclado. Esse manipulador de eventos recebe uma referência ao objeto de campo de texto
que tinha o foco do teclado.
Recebendo parâmetros passados
Usando métodos manipuladores de eventos
349
Por exemplo, o código a seguir insere um texto em um campo de texto que não tem mais o
foco do teclado:
this.createTextField("my_txt", 99, 10, 10, 200, 20);
my_txt.border = true;
my_txt.type = "input";
this.createTextField("myOther_txt", 100, 10, 50, 200, 20);
myOther_txt.border = true;
myOther_txt.type = "input";
myOther_txt.onSetFocus = function(my_txt:TextField) {
my_txt.text = "I just lost keyboard focus";
};
Também é possível
atribuir funções a manipuladores de eventos de objetos criados durante a execução. Por
exemplo, o código a seguir cria uma nova instância de clipe de filme (newclip_mc) e atribui
uma função ao manipulador de eventos onPress do clipe.
Manipuladores de eventos de objetos criados durante a execução
this.attachMovie("symbolID", "newclip_mc", 10);
newclip_mc.onPress = function () {
trace("You pressed me");
}
Para obter mais informações, consulte “Criando clipes de filme durante a execução”
na página 378.
A criação de uma classe que estenda
uma classe do ActionScript permite substituir os métodos manipuladores de eventos pelas
funções criadas. Você pode definir um manipulador de eventos em uma nova subclasse que
poderá ser reutilizada para diversos objetos, vinculando qualquer símbolo da biblioteca da
classe estendida à nova subclasse. O código a seguir substitui o manipulador de eventos
onPress da classe MovieClip por uma função que diminui a transparência do clipe de filme:
Substituindo métodos manipuladores de eventos
// Classe FadeAlpha – define a transparência quando você clica no clipe de
filme.
class FadeAlpha extends MovieClip {
function onPress() {
this._alpha -= 10;
}
}
Para obter instruções específicas sobre a extensão de uma classe do ActionScript e a vinculação
a um símbolo da biblioteca, consulte os exemplos fornecidos em “Atribuindo uma classe a
símbolos no Flash” na página 295. Para obter informações sobre a criação e o trabalho com
classes personalizadas, consulte Capítulo 7, “Classes.”
350
Manipulando eventos
Usando ouvintes de eventos
Os ouvintes de eventos permitem que um objeto, chamado objeto ouvinte, receba eventos
transmitidos por outro objeto, chamado objeto transmissor. O objeto transmissor registra o
objeto ouvinte para que receba eventos gerados por ele. Por exemplo, você pode registrar um
objeto de clipe de filme para que receba notificações onResize do Stage (Palco), ou uma
instância de botão pode receber notificações onChanged de um objeto de campo de texto. É
possível registrar vários objetos ouvintes, para que recebam eventos de um único transmissor, e
registrar um único objeto ouvinte, para que receba eventos de vários transmissores.
Diferentemente dos métodos manipuladores de eventos, o modelo de ouvinte/transmissor de
eventos permite que vários códigos ouçam o mesmo evento sem que haja conflito. Os modelos
de eventos que não usam o modelo de ouvinte/transmissor, como XML.onLoad(), podem
criar problemas quando vários códigos ouvem o mesmo evento; os diversos códigos entram
em conflito ao tentarem controlar essa referência única da função de retorno de chamada
XML.onLoad. Com o modelo de ouvinte/transmissor, é possível adicionar facilmente ouvintes
ao mesmo evento sem que haja gargalos de código.
As seguintes classes do ActionScript podem transmitir eventos: %{Key}%, %{Mouse}%,
%{MovieClipLoader}%, %{Selection}%, %{Stage}% e %{TextField}%. Para ver os ouvintes
disponíveis para uma classe, consulte a entrada correspondente a cada classe no ActionScript
Para obter mais informações sobre ouvintes de eventos, consulte os seguintes tópicos:
■
“Modelo de ouvinte de evento” na página 351
■
“Exemplo de ouvinte de eventos” na página 352
A classe Stage podem transmitir eventos. É possível encontrar um arquivo de origem de
exemplo, stagesize.fla, na pasta Samples no disco rígido. Esse exemplo demonstra como a
propriedade Stage.scaleMode afeta os valores de Stage.width e Stage.height quando a
janela do navegador é redimensionada.
■
8\Samples and Tutorials\Samples\ActionScript\StageSize.
■
No Macintosh, navegue até HD do Macintosh/Applications/Macromedia Flash 8/Samples
and Tutorials/Samples/ActionScript/StageSize.
Modelo de ouvinte de evento
O modelo de evento para ouvintes de eventos é semelhante ao de manipuladores de eventos
(consulte “Usando métodos manipuladores de eventos” na página 348), com duas diferenças
principais:
Usando ouvintes de eventos
351
■
O manipulador de eventos é atribuído ao objeto ouvinte, e não ao objeto que transmite o
evento.
■
Você chama um método especial do objeto transmissor, addListener(), que registra o
objeto ouvinte para receber seus eventos.
O código a seguir descreve o modelo de ouvinte de eventos:
var listenerObject:Object = new Object();
listenerObject.eventName = function(eventObj:Object) {
// Aqui entra o seu código
};
broadcasterObject.addListener(listenerObject);
O código inicia com um objeto, listenerObject, com a propriedade eventName. O objeto
ouvinte pode ser qualquer objeto, como uma instância de um objeto, clipe de filme ou botão
existente no Stage (Palco); ele também pode ser uma instância de uma classe do ActionScript.
Por exemplo, um clipe de filme personalizado poderia implementar os métodos ouvintes para
os ouvintes do Stage. Também poderia existir um objeto que ouvisse vários tipos de ouvintes.
A propriedade eventName é um evento que ocorre em broadcasterObject, o qual transmite
o evento para listenerObject. Você pode registrar vários ouvintes para um transmissor de
eventos.
Atribua uma função ao ouvinte de eventos que responda de alguma forma ao evento.
Finalmente, chame o método addListener() no objeto transmissor, passando para ele o
objeto ouvinte.
Para cancelar o registro de um objeto ouvinte para o recebimento de eventos, chame o método
do objeto transmissor, passando para ele o nome do evento a ser
removido e do objeto ouvinte.
removeEventListener()
broadcasterObject.removeListener(listenerObject);
Exemplo de ouvinte de eventos
O exemplo a seguir mostra como usar o ouvinte de eventos onSetFocus na classe Selection
para criar um gerenciador de foco simples para um grupo de campos de texto de entrada.
Nesse caso, a borda do campo de texto que recebe o foco do teclado é ativada (exibida), e a
borda do campo de texto que perdeu o foco é desativada.
Para criar um gerenciador de foco simples com ouvintes de eventos:
1.
Com a ferramenta Text (Texto), crie um campo de texto no Stage (Palco).
2.
Selecione o campo de texto e, no inspetor Properties (Propriedades), selecione Input
(Entrada) no menu pop-up Text Type (Tipo de texto) e selecione a opção Show Border
Around Text (Mostrar borda em torno do texto).
352
Manipulando eventos
3.
Crie outro campo de texto de entrada abaixo do primeiro.
Verifique se a opção Show Border Around Text não está selecionada para esse campo de
texto. Você pode continuar a criar os campos de texto de entrada.
4.
Selecione Frame 1 (Quadro 1) na Timeline (Linha de tempo) e abra o painel Actions
(Ações), em Window (Janela) > Actions.
5.
Para criar um objeto que ouça a notificação de foco da classe Selection, digite o seguinte
código no painel Actions:
// Cria um objeto ouvinte, focusListener.
var focusListener:Object = new Object();
// Define a função do objeto ouvinte.
focusListener.onSetFocus = function(oldFocus_txt:TextField,
newFocus_txt:TextField) {
oldFocus_txt.border = false;
newFocus_txt.border = true;
}
Esse código cria um objeto chamado focusListener que define a propriedade
onSetFocus e atribui uma função a ela. A função usa dois parâmetros: uma referência ao
campo de texto que perdeu o foco, e outra ao campo de texto que ganhou o foco. A função
define a propriedade border do campo de texto que perdeu o foco como false e a
propriedade border do campo de texto que ganhou o foco como true.
6.
Para registrar o objeto focusListener para receber eventos do objeto Selection, adicione
o seguinte código ao painel Actions:
// Registra focusListener no transmissor.
Selection.addListener(focusListener);
7.
Teste o aplicativo em Control (Controlar) > Test Movie (Testar filme), clique no primeiro
campo de texto e pressione a tecla Tab para alternar o foco entre os campos.
Usando ouvintes de eventos com
componentes
A sintaxe do ouvinte de eventos é ligeiramente diferente quando se trabalha com
componentes. Os componentes geram eventos que devem ser ouvidos por meio de um objeto
ouvinte ou de uma função personalizada.
O exemplo a seguir mostra como usar ouvintes de eventos para monitorar o andamento do
download de uma imagem carregada dinamicamente.
Usando ouvintes de eventos com componentes
353
Para ouvir eventos do componente Loader:
1.
Arraste uma instância do componente Loader do painel Components (Componentes) para
o Stage (Palco).
2.
Selecione o carregador e digite my_ldr na caixa de texto Instance Name (Nome da
instância) no inspetor Properties (Propriedades).
3.
Adicione o código a seguir ao Frame 1 (Quadro 1) da Timeline (Linha de tempo) principal;
System.security.allowDomain("http://www.helpexamples.com");
var loaderListener:Object = new Object();
loaderListener.progress = function(evt_obj:Object):Void {
trace(evt_obj.type); // progress
trace("\t" + evt_obj.target.bytesLoaded + " of " +
evt_obj.target.bytesTotal + " bytes loaded");
}
loaderListener.complete = function(evt_obj:Object):Void {
trace(evt_obj.type); // complete
}
my_ldr.addEventListener("progress", loaderListener);
my_ldr.addEventListener("complete", loaderListener);
my_ldr.load("http://www.helpexamples.com/flash/images/image1.jpg");
Esse código ActionScript define um objeto ouvinte chamado loaderListener, que ouve
dois eventos: progress e complete. Quando cada um desses eventos for disparado, o
código correspondente será executado e o texto de depuração será exibido no painel
Output (Saída), se você testar o arquivo SWF na ferramenta de criação.
Em seguida, instrua a instância my_ldr a ouvir cada um dos dois eventos especificados
(progress e complete) e especifique a função ou o objeto ouvinte a ser executado quando
o evento é disparado. Finalmente, o método Loader.load() é chamado e ativa o
download da imagem.
4.
O download da imagem é feito na instância Loader no Stage, e várias mensagens são
exibidas no painel Output. Dependendo do tamanho da imagem para download, e se a
imagem tiver sido armazenada em cache no sistema local do usuário, o evento progress
poderá ser disparado várias vezes, enquanto o evento complete só será disparado depois
que o download da imagem tiver sido concluído.
Ao trabalhar com componentes e disparar eventos, você usará uma sintaxe ligeiramente
diferente daquelas mostradas nos exemplos anteriores para os ouvintes de eventos. A
principal diferença é que você deverá usar o método addEventListener() em vez de
chamar addListener(). Depois, especifique o evento que deseja ouvir bem como a
função ou o objeto ouvinte de eventos.
354
Manipulando eventos
Em vez de usar um objeto ouvinte, como no primeiro procedimento em “Usando ouvintes de
eventos com componentes” na página 353, é possível usar uma função personalizada. O
código do exemplo anterior poderia ser recriado da seguinte maneira:
my_ldr.addEventListener("progress", progressListener);
my_ldr.addEventListener("complete", completeListener);
my_ldr.load("http://www.helpexamples.com/flash/images/image1.png");
function progressListener(evt_obj:Object):Void {
trace(evt_obj.type); // progress
trace("\t" + evt_obj.target.bytesLoaded + " of " +
evt_obj.target.bytesTotal + " bytes loaded");
}
function completeListener(evt_obj:Object):Void {
trace(evt_obj.type); // complete
}
N OT A
Nos exemplos anteriores, os ouvintes de eventos são sempre adicionados antes da
chamada do método Loader.load(). Se você chamar o método Loader.load() antes
de especificar os ouvintes de eventos, é possível que o carregamento seja concluído
antes da definição completa dos ouvintes. Isso significa que o conteúdo poderá ser
exibido, e o evento complete talvez não seja capturado.
Usando manipuladores de eventos de
botão e de clipe de filme
Você pode anexar manipuladores de eventos diretamente a uma instância de um botão ou
clipe de filme no Stage (Palco) usando os manipuladores de eventos onClipEvent() e on().
O manipulador onClipEvent() transmite eventos de clipes de filme, e o manipulador on()
manipula eventos de botões.
Para anexar um manipulador de eventos a uma instância de um botão ou de um clipe de
filme, clique na instância no Stage para colocá-la em foco e, em seguida, insira o código no
painel Actions (Ações). O título do painel Actions indica se o código será anexado ao botão ou
ao clipe de filme: Actions Panel - Button (Painel Ações - Botão) ou Actions Panel - Movie Clip
(Painel Ações - Clipe de filme). Para obter diretrizes sobre o uso de código anexado a
instâncias de botão ou de clipe de filme, consulte “Anexando código a objetos” na página 783.
N OT A
Não confunda manipuladores de eventos de botão e de clipe de filme com eventos de
componentes, como SimpleButton.click, UIObject.hide e UIObject.reveal, que
devem ser anexados a instâncias de componentes e são abordados em Using
Components (Usando componentes).
Usando manipuladores de eventos de botão e de clipe de filme
355
Você só pode anexar onClipEvent() e on() a instâncias de clipes de filme colocadas no Stage
durante a criação. Não é possível anexar onClipEvent() ou on() a instâncias de clipes de
filme criadas durante a execução (por exemplo, com o método attachMovie()). Para anexar
manipuladores de eventos a objetos criados durante a execução, use métodos manipuladores
de eventos ou ouvintes de eventos. (Consulte “Usando métodos manipuladores de eventos”
na página 348 e “Usando ouvintes de eventos” na página 351.)
NO TA
Anexar os manipuladores onClipEvent() e on() não é uma prática recomendada. Em vez
disso, coloque o código em scripts de quadro ou em um arquivo de classes, como
demonstrado neste manual. Para obter mais informações, consulte “Usando métodos
manipuladores de eventos” na página 348 e “Anexando código a objetos”
na página 783.
Para obter mais informações sobre manipuladores de eventos de botão e de clipe de filme,
■
“Usando on e onClipEvent com métodos manipuladores de eventos” na página 356
■
“Especificando eventos para os métodos on ou onClipEvent” na página 358
■
“Anexando ou atribuindo vários manipuladores a um objeto” na página 359
Usando on e onClipEvent com métodos
manipuladores de eventos
Em alguns casos, você poderá usar diversas técnicas para manipular eventos sem conflito. Não
há conflito entre o uso dos métodos on() e onClipEvent() e dos métodos manipuladores de
eventos definidos por você.
Por exemplo, suponha que um arquivo SWF contenha um botão; o botão pode ter um
manipulador on(press), que instrui o arquivo SWF a ser reproduzido, e pode ter um método
onPress(), para o qual você define uma função que instrui um objeto do Stage (Palco) a
girar. Quando você clica no botão, o arquivo SWF é reproduzido e o objeto gira. Dependendo
dos tipos de eventos que você deseja chamar e de quando eles serão chamados, é possível usar
os métodos on() e onClipEvent(), métodos manipuladores de eventos ou as duas técnicas de
manipulação de eventos.
Entretanto, o escopo de variáveis e objetos em manipuladores on() e onClipEvent() é
diferente daquele em manipuladores e ouvintes de eventos. Consulte “Escopo do manipulador
de eventos” na página 362.
356
Manipulando eventos
Use também on() com clipes de filme para criar clipes que recebem eventos de botão. Para
obter mais informações, consulte “Criando clipes de filme com estados de botão”
na página 361. Para obter informações sobre a especificação de eventos para on() e
onClipEvent(), consulte “Especificando eventos para os métodos on ou onClipEvent”
na página 358.
Para usar um manipulador on e um manipulador de eventos onPress:
1.
Crie um novo documento do Flash e salve-o como handlers.fla.
2.
Selecione a ferramenta Rectangle (Retângulo) e desenhe um quadrado grande no Stage.
3.
Selecione a ferramenta Selection (Seleção), clique duas vezes no quadrado no Stage e
pressione F8 para acessar a caixa de diálogo Convert to Symbol (Converter em símbolo).
4.
Digite o nome de um símbolo para a caixa, defina o tipo de clipe como Movie (Filme) e
clique em OK.
5.
Atribua ao clipe de filme no Stage o nome de instância box_mc.
6.
Adicione o ActionScript a seguir diretamente no símbolo do clipe de filme no Stage:
on(press){
trace("on (press) {...}");
}
7.
principal:
box_mc.onPress = function() {
trace("box_mc.onPress = function() {...};");
};
8.
Flash.
Quando você clica no símbolo do clipe de filme no Stage, a saída a seguir é enviada para o
painel Output:
on (press) {...}
box_mc.onPress = function() {...};
N OT A
Anexar os manipuladores onClipEvent() e on() não é uma prática recomendada. Em
vez disso, coloque o código em scripts de quadro ou em um arquivo de classes,
como demonstrado neste manual. Para obter mais informações, consulte “Usando
métodos manipuladores de eventos” na página 348 e “Anexando código a objetos”
na página 783.
357
Especificando eventos para os métodos on ou
onClipEvent
Para usar um manipulador on() ou onClipEvent(), anexe-o diretamente a uma instância de
um botão ou clipe de filme no Stage (Palco) e especifique o evento a ser manipulado para essa
instância. Para obter uma lista completa de eventos suportados pelos manipuladores de
eventos on() e onClipEvent(), consulte %{on handler}% e %{onClipEvent handler}% em
Por exemplo, o manipulador de eventos on() a seguir é executado sempre que o usuário clica
no botão ao qual ele está anexado.
on (press) {
trace("Thanks for pressing me.");
}
É possível especificar dois ou mais eventos para cada manipulador on(), separados por
vírgulas. O ActionScript em um manipulador é executado quando um dos eventos
especificados pelo manipulador ocorre. Por exemplo, este manipulador on() anexado a um
botão é executado sempre que o mouse passa sobre o botão:
on (rollOver, rollOut) {
trace("You rolled over, or rolled out");
}
Também é possível adicionar eventos de pressionamento de tecla usando manipuladores on().
Por exemplo, o código a seguir rastreia uma seqüência de caracteres quando você pressiona o
número 3 no teclado. Selecione uma instância de botão ou de clipe de filme e adicione o
seguinte código ao painel Actions (Ações):
on (keyPress "3") {
trace("You pressed me");
}
Como alternativa, se quiser rastrear quando a tecla Enter é pressionada por um usuário, use o
formato de código a seguir. Selecione uma instância de botão ou de clipe de filme e adicione o
seguinte código ao painel Actions:
on (keyPress "<Enter>") {
trace("Enter Pressed");
}
358
Manipulando eventos
Selecione Control (Controlar) > Test Movie (Testar filme) e pressione a tecla Enter para ver a
seqüência de caracteres rastreada no painel Output (Saída). Se nenhuma seqüência for
rastreada, selecione Control > Disable Keyboard Shortcuts (Desativar atalhos de teclado) e
tente novamente. Para obter mais informações sobre a adição de interatividade de
pressionamento de tecla a aplicativos, consulte %{Key}%.
NO T A
na página 783.
Anexando ou atribuindo vários manipuladores a um
objeto
Você também poderá anexar mais de um manipulador a um objeto se desejar que scripts
diferentes sejam executados quando ocorrerem eventos distintos. Por exemplo, é possível
anexar os manipuladores onClipEvent() a seguir à mesma instância de clipe de filme. O
primeiro é executado quando o primeiro clipe de filme é carregado, ou quando aparece no
Stage (Palco); o segundo é executado quando o clipe de filme é descarregado do Stage.
on (press) {
this.unloadMovie()
}
onClipEvent (load) {
trace("I've loaded");
}
onClipEvent (unload) {
trace("I've unloaded");
}
N OT A
na página 783.
Para anexar vários manipuladores a um objeto usando o código colocado na Timeline (Linha
de tempo), consulte o exemplo a seguir. O código anexa os manipuladores onPress e
onRelease a uma instância de clipe de filme.
359
Para atribuir vários manipuladores a um objeto:
1.
Crie um novo documento do Flash e atribua o nome assignMulti.fla a ele.
2.
Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) e adicione o seguinte
código ao painel Actions (Ações):
mclListener.onLoadInit = function(target_mc:MovieClip) {
target_mc.onPress = function() {
target_mc.startDrag();
};
target_mc.onRelease = function() {
target_mc.stopDrag();
};
}
mclListener.onLoadError = function(target_mc:MovieClip) {
trace("error downloading image");
}
var img_mcl:MovieClipLoader = new MovieClipLoader();
img_mcl.addListener(mclListener);
img_mcl.loadClip("http://www.helpexamples.com/flash/images/image1.jpg",
img_mc);
3.
A imagem é carregada na instância img_mc e os manipuladores de eventos onPress() e
onRelease() permitem arrastá-la pelo Stage (Palco).
Transmitindo eventos de instâncias de
componentes
Para qualquer instância de componente, é possível especificar como um evento é manipulado.
Os eventos de componentes são manipulados de maneira diferente dos eventos transmitidos
por objetos nativos do ActionScript.
Para obter mais informações, consulte “Handling Component Events” em Using Components
(Usando componentes).
360
Manipulando eventos
Criando clipes de filme com estados de
botão
Quando você anexa um manipulador on() a um clipe de filme ou atribui uma função a um
dos manipuladores de eventos de mouse MovieClip para uma instância de clipe de filme, o
clipe responde aos eventos do mouse da mesma forma que um botão. Também é possível criar
estados de botão automáticos (Up, Over e Down) em um clipe de filme adicionando os
rótulos de quadro _up, _over e _down à Timeline (Linha de tempo) do clipe de filme.
Quando o usuário move o mouse sobre o clipe de filme ou clica nele, a reprodução é enviada
para o quadro com o rótulo de quadro apropriado. Para designar a área sensível utilizada por
um clipe de filme, use a propriedade %{hitArea (MovieClip.hitArea property)}%.
Para criar estados de botão em um clipe de filme:
1.
Crie um novo documento do Flash e salve-o como mcbutton.fla.
2.
Com a ferramenta Rectangle (Retângulo), desenhe um pequeno retângulo (de cerca de 100
pixels de largura por 20 pixels de altura) no Stage (Palco).
3.
Clique duas vezes na forma com a ferramenta Selection (Seleção) e pressione F8 para acessar
a caixa de diálogo Convert to Symbol (Converter em símbolo).
4.
Digite o nome de símbolo mcbutton, defina o tipo de símbolo para o clipe de filme e clique
em OK.
5.
Clique duas vezes no símbolo do clipe de filme no Stage para alternar para o modo de
edição de símbolo.
6.
Crie uma nova camada na Timeline (Linha de tempo) do clipe de filme e atribua a ela o
nome labels.
7.
Digite o rótulo de quadro _up no inspetor Property (Propriedade).
8.
Crie uma nova camada acima da camada padrão e da camada labels.
9.
Renomeie a nova camada actions e adicione o ActionScript a seguir ao Frame 1 (Quadro
1) da Timeline do clipe de filme:
stop();
10. Selecione
Frame 10, todas as três camadas e Insert (Inserir) > Timeline > Keyframe
(Quadro-chave).
11.
Adicione a ação stop() ao Frame 10 da camada actions e o rótulo de quadro _over ao
Frame 10 da camada labels.
12. Selecione
o retângulo no Frame 10 e use o inspetor Property para selecionar outra cor de
preenchimento.
Criando clipes de filme com estados de botão
361
13.
Crie novos quadros-chave no Frame 20 de cada uma das três camadas e adicione o rótulo
de quadro _down no inspetor Property.
14. Modifique a cor do retângulo no Frame 20 para que cada estado dos três botões tenha uma
cor diferente.
15.
Retorne à Timeline principal.
16.
Para fazer com que o clipe de filme responda a eventos do mouse, siga um destes
procedimentos:
17.
■
Anexe um manipulador de eventos on() à instância de clipe de filme, como abordado
em “Usando manipuladores de eventos de botão e de clipe de filme” na página 355.
■
Atribua uma função a um dos manipuladores de eventos de mouse do objeto de clipe
de filme (onPress, onRelease etc.), conforme analisado em “Usando métodos
manipuladores de eventos” na página 348.
Flash.
Quando você move o ponteiro do mouse sobre a instância do clipe de filme no Stage, o
estado do clipe é alterado automaticamente para _over. Quando você clica na instância do
clipe de filme, a reprodução é alterada automaticamente para o estado _down do clipe de
filme.
Escopo do manipulador de eventos
O escopo, ou contexto, de variáveis e comandos que você declara e executa em um
manipulador de eventos depende do tipo de manipulador utilizado: manipuladores de eventos
ou ouvintes de eventos, ou manipuladores on() e onClipEvent(). Se você estiver definindo
um manipulador de eventos em uma nova classe do ActionScript, o escopo também
dependerá de como o manipulador de eventos é definido. Esta seção contém exemplos do
ActionScript 1.0 e do ActionScript 2.0.
As funções atribuídas a métodos manipuladores de eventos e
ouvintes de eventos (como todas as funções do ActionScript criadas por você) definem o
escopo de uma variável local, mas os manipuladores on() e onClipEvent() não fazem isso.
Exemplos do ActionScript 1.0
Por exemplo, considere os dois manipuladores de eventos a seguir. O primeiro é um
manipulador de eventos onPress associado a um clipe de filme chamado clip_mc. O
segundo é um manipulador on() anexado à mesma instância de clipe de filme.
// Anexado à Timeline do clipe pai de clip_mc:
clip_mc.onPress = function () {
var shoeColor; // variável de função local
shoeColor = "blue";
362
Manipulando eventos
}
// manipulador on() anexado a clip_mc:
on (press) {
var shoeColor; // sem escopo de variável local
shoeColor = "blue";
}
Embora contenham o mesmo código, os dois manipuladores de eventos produzem resultados
diferentes. No primeiro caso, a variável color é local para a função definida para onPress. No
segundo caso, como o manipulador on() não define um escopo de variável local, a variável é
definida no escopo da Timeline (Linha de tempo) do clipe de filme clip_mc.
Para manipuladores de eventos on() anexados a botões, e não a clipes de filme, as variáveis
(bem como as chamadas de funções e métodos) são chamadas no escopo da Timeline que
contém a instância do botão.
Por exemplo, o manipulador de eventos on() a seguir produzirá resultados diferentes,
dependendo de sua anexação a um objeto de clipe de filme ou de botão. No primeiro caso, a
chamada da função play() inicia a reprodução da Timeline que contém o botão; no segundo
caso, a chamada da mesma função inicia a Timeline do clipe de filme ao qual o manipulador
está anexado.
// Anexado ao botão.
on (press) {
play(); // Reproduz a timeline mãe.
}
// Anexado ao clipe de filme.
on (press) {
play(); // Reproduz a timeline do clipe de filme.
}
Quando anexada a um objeto de botão, a função play() aplica-se à Timeline que contém o
botão, isto é, à Timeline mãe do botão. Entretanto, quando o manipulador on(press) estiver
anexado a um objeto de clipe de filme, a chamada da função play() se aplicará ao clipe de
filme que utiliza o manipulador. Se o código a seguir for anexado a um clipe de filme, a
Timeline mãe será reproduzida:
// Anexado ao clipe de filme.
on (press) {
_parent.play(); // Reproduz a timeline mãe.
}
Em uma definição de manipulador de eventos ou de ouvinte de eventos, a mesma função
play() se aplica à Timeline que contém a definição da função. Por exemplo, suponha que
você declare o método manipulador de eventos my_mc.onPress a seguir na Timeline que
contém a instância de clipe de filme my_mc:
Escopo do manipulador de eventos
363
// Função definida em uma timeline
my_mc.onPress = function () {
play(); // Reproduz a timeline onde ela está definida.
};
Para reproduzir o clipe de filme que define o manipulador de eventos onPress, faça referência
explicitamente ao clipe usando a palavra-chave this, desta forma:
// Função definida na timeline raiz
this.play(); // reproduz a timeline de my_mc clip.
};
Entretanto, o mesmo código colocado na Timeline raiz de uma instância de botão
reproduziria a Timeline raiz:
my_btn.onPress = function () {
this.play(); // reproduz a timeline raiz
};
Para obter mais informações sobre o escopo da palavra-chave this em manipuladores de
eventos, consulte “Escopo da palavra-chave this” na página 365.
Exemplo do ActionScript 2.0 A classe TextLoader a seguir é usada para carregar um
arquivo de texto e exibir um texto após carregar o arquivo com êxito.
// TextLoader.as
class TextLoader {
private var params_lv:LoadVars;
public function TextLoader() {
params_lv = new LoadVars();
params_lv.onLoad = onLoadVarsDone;
params_lv.load("http://www.helpexamples.com/flash/params.txt");
}
private function onLoadVarsDone(success:Boolean):Void {
_level0.createTextField("my_txt", 999, 0, 0, 100, 20);
_level0.my_txt.autoSize = "left";
_level0.my_txt.text = params_lv.monthNames; // undefined
}
}
364
Manipulando eventos
Esse código não funciona corretamente, pois há um problema envolvendo o escopo dos
manipuladores de eventos e não está claro se a palavra-chave this faz referência à classe ou ao
manipulador de eventos onLoad. O comportamento esperado nesse exemplo é que o método
onLoadVarsDone() seja chamado no escopo do objeto TextLoader; porém, ele é chamado no
escopo do objeto LoadVars porque o método foi extraído do objeto TextLoader e inserido no
objeto LoadVars. Em seguida, o objeto LoadVars chama o manipulador de eventos
this.onLoad depois que o arquivo de texto é carregado, e a função onLoadVarsDone() é
chamada com a palavra-chave this definida como LoadVars, e não como TextLoader. O
objeto params_lv reside no escopo dessa palavra-chave quando chamado, embora a função
onLoadVarsDone() dependa desse objeto por referência. Portanto, a função
onLoadVarsDone() espera uma instância params_lv.params_lv que não existe.
Para chamar corretamente o método onLoadVarsDone() no escopo do objeto TextLoader,
use a seguinte estratégia: use um literal de função para criar uma função anônima que chame a
função desejada. O objeto owner ainda está visível no escopo da função anônima e, portanto,
pode ser usado para localizar o objeto TextLoader que está fazendo a chamada.
// TextLoader.as
class TextLoader {
private var params_lv:LoadVars;
public function TextLoader() {
params_lv = new LoadVars();
var owner:TextLoader = this;
params_lv.onLoad = function (success:Boolean):Void {
owner.onLoadVarsDone(success);
}
params_lv.load("http://www.helpexamples.com/flash/params.txt");
}
private function onLoadVarsDone(success:Boolean):Void {
_level0.createTextField("my_txt", 999, 0, 0, 100, 20);
_level0.my_txt.autoSize = "left";
_level0.my_txt.text = params_lv.monthNames; //
janeiro,fevereiro,março,...
}
}
Escopo da palavra-chave this
A palavra-chave this refere-se ao objeto do escopo em execução no momento. Dependendo
do tipo de técnica de manipulação de eventos usada, this poderá se referir a objetos
diferentes.
Em uma função de manipulador de eventos ou de ouvinte de eventos, this
refere-se ao
objeto que define o método manipulador de eventos ou ouvinte de eventos. Por exemplo, no
código a seguir, this refere-se a my_mc:
Escopo da palavra-chave this
365
// Manipulador de eventos onPress() anexado à timeline principal:
trace(this); // _level0.my_mc
}
Em um manipulador on() anexado a um clipe de filme, this
refere-se ao clipe de filme ao
qual o manipulador on() está anexado, como mostra o código a seguir:
// Anexado ao clipe de filme my_mc na timeline principal
on (press) {
trace(this); // _level0.my_mc
}
Em um manipulador on() anexado a um botão, this
refere-se à Timeline que contém o
botão, como mostra o seguinte código:
// Anexado ao botão na timeline principal
on (press) {
trace(this); // _level0
}
Usando a classe Delegate
A classe Delegate permite executar uma função em um escopo específico. Essa classe é
fornecida para disparar o mesmo evento em duas funções diferentes, consulte “Delegating
events to functions” em Using Components (Usando componentes), e para chamar funções no
escopo da classe em que está contida.
Quando você passa uma função como um parâmetro para
a função é chamada no escopo da instância do
componente transmissor, e não no objeto em que ela está declarada. Consulte “Delegating the
scope of a function” in Using Components (Usando componentes). É possível usar
Delegate.create() para chamar a função dentro do escopo do objeto declarante.
EventDispatcher.addEventListener(),
O exemplo a seguir mostra os três métodos de audição de eventos de uma instância do
componente Button. Dependendo da forma como você adiciona ouvintes de eventos a uma
instância do componente Button, o evento é disparado em um escopo diferente.
Para usar a classe Delegate para ouvir eventos:
1.
Crie um novo documento do Flash e salve-o como delegate.fla.
2.
Arraste um componente Button da pasta User Interface do painel Components
(Componentes) para a biblioteca.
Adicione e posicione a instância do botão no Stage (Palco) usando ActionScript em uma
etapa posterior.
366
Manipulando eventos
3.
principal:
import mx.controls.Button;
import mx.utils.Delegate;
function clickHandler(eventObj:Object):Void {
trace("[" + eventObj.type + "] event on " + eventObj.target + "
instance.");
trace("\t this -> " + this);
}
var buttonListener:Object = new Object();
buttonListener.click = function(eventObj:Object):Void {
trace("[" + eventObj.type + "] event on " + eventObj.target + "
instance.");
trace("\t this -> " + this);
};
this.createClassObject(Button, "one_button", 10, {label:"One"});
one_button.move(10, 10);
one_button.addEventListener("click", clickHandler);
this.createClassObject(Button, "two_button", 20, {label:"Two"});
two_button.move(120, 10);
two_button.addEventListener("click", buttonListener);
this.createClassObject(Button, "three_button", 30, {label:"Three"});
three_button.move(230, 10);
three_button.addEventListener("click", Delegate.create(this,
clickHandler));
O código anterior é dividido em seis seções (separadas por uma linha em branco). A
primeira seção importa a classe Button (para o componente Button) e a classe Delegate. A
segunda seção do código define uma função chamada quando o usuário clica em alguns
dos botões. A terceira seção do código cria um objeto usado como um ouvinte de evento e
o objeto ouve um único evento, click.
As três seções restantes do código criam uma nova instância do componente Button no
Stage, reposicionam a instância e adicionam um ouvite de evento para o evento click. O
primeiro botão adiciona um ouvinte para o evento click e passa uma referência
diretamente a uma função manipuladora click. O segundo botão adiciona um ouvinte
para o evento click e passa uma referência para um objeto ouvinte, que contém um
manipulador para esse evento. Por fim, a terceira função adiciona um ouvinte para o
evento click, usa a classe Delegate para disparar esse evento no escopo this (em que
this equivale a _level0) e passa uma referência para a função manipuladora click.
Usando a classe Delegate
367
4.
Flash.
5.
Clique em cada instância do botão no Stage para ver o escopo em que o evento é
manipulado.
a.
Clique no primeiro botão no Stage para rastrear o texto a seguir no painel Output
(Saída):
[click] event on _level0.one_button instance.
this -> _level0.one_button
Quando você clica na instância one_button, o escopo this faz referência à própria
instância do botão.
b.
Clique no segundo botão no Stage para rastrear o texto a seguir no painel Output:
[click] event on _level0.two_button instance.
this -> [object Object]
Quando você clica na instância two_button, o escopo this faz referência ao objeto
buttonListener.
c.
Clique no terceiro botão no Stage para rastrear o texto a seguir no painel Output:
[click] event on _level0.three_button instance.
this -> _level0
Quando você clica na instância three_button, o escopo this faz referência ao escopo
especificado na chamada do método Delegate.create() ou, neste caso, a _level0.
368
Manipulando eventos
CAPÍTULO 11
11
Trabalhando com clipes de
filme
Os clipes de filme assemelham-se a arquivos SWF que funcionam de maneira independente
uns dos outros e da Timeline (Linha de tempo) que os contém. Por exemplo, se a Timeline
principal possuir somente um quadro, e um clipe de filme nesse quadro possuir dez quadros,
cada quadro do clipe de filme será reproduzido quando o arquivo SWF principal for
reproduzido. Um clipe de filme pode, por sua vez, conter outros clipes de filme ou clipes
aninhados. Os clipes de filme aninhados dessa maneira têm um relacionamento hierárquico,
no qual o clipe pai contém um ou mais clipes filho.
É possível atribuir nomes a instâncias de clipes de filme para identificá-las de forma exclusiva
como objetos que podem ser controlados com o ActionScript. Quando um nome de instância
é atribuído a uma instância de clipe de filme, esse nome a identifica como um objeto do tipo
de classe MovieClip. Use as propriedades e os métodos da classe MovieClip para controlar a
aparência e o comportamento dos clipes de filme durante a execução.
Pense nos clipes de filme como objetos autônomos que podem responder aos eventos, enviar
mensagens para outros objetos do clipe de filme, manter seu estado e gerenciar seus clipes
filho. Dessa maneira, os clipes de filme fornecem o alicerce da arquitetura baseada em
componente no Macromedia Flash Basic 8 e no Macromedia Flash Professional 8. Na verdade,
os componentes disponíveis no painel Components (Componentes), em Window (Janela) >
Components, são clipes de filme sofisticados que foram projetados e programados para se
parecerem e se comportarem de certos modos.
Para obter informações sobre o uso da API (Application Programming Interface, Interface de
programação de aplicativos) Drawing (métodos de desenho da classe MovieClip), bem como
de filtros, mesclagens, animação com script e muito mais, consulte o Capítulo 13, “Animação,
filtros e desenhos.”
369
Para obter mais informações sobre clipes de filme, consulte os seguintes tópicos:
Sobre o controle de clipes de filme com o ActionScript . . . . . . . . . . . . . . . . . . . . . .370
Chamando vários métodos em um único clipe de filme. . . . . . . . . . . . . . . . . . . . . . . 372
Carregando e descarregando arquivos SWF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373
Alterando a posição e a aparência de um clipe de filme . . . . . . . . . . . . . . . . . . . . . . 376
Arrastando clipes de filme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377
Criando clipes de filme durante a execução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
Adicionando parâmetros aos clipes de filme criados dinamicamente . . . . . . . . . .383
Gerenciando profundidades do clipe de filme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .385
Sobre o armazenamento em cache e a rolagem de clipes de filme com o
ActionScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .389
Usando clipes de filme como máscaras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .397
Manipulando eventos de clipes de filme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
Atribuindo uma classe a um símbolo de clipe de filme . . . . . . . . . . . . . . . . . . . . . . . 399
Inicializando as propriedades de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
Sobre o controle de clipes de filme com o
ActionScript
É possível usar as funções globais do ActionScript ou os métodos da classe MovieClip para
realizar tarefas nos clipes de filme. Alguns métodos da classe MovieClip realizam as mesmas
tarefas que as funções de mesmo nome; outros, como hitTest() e swapDepths(), não têm
nomes de função correspondentes.
O exemplo a seguir mostra a diferença entre usar um método e usar uma função. Cada
instrução duplica a instância my_mc, atribui o nome newClip ao novo clipe e o coloca na
profundidade 5.
my_mc.duplicateMovieClip("new_mc", 5);
duplicateMovieClip(my_mc, "new_mc", 5);
Quando uma função e um método apresentam comportamentos semelhantes, é possível
controlar os clipes de filme usando qualquer um dos dois. A opção escolhida dependerá de sua
preferência e familiaridade com a criação de scripts no ActionScript. Se você usar uma função
ou um método, a Timeline (Linha de tempo) de destino deverá ser carregada no Flash Player
quando a função ou o método for chamado.
370
Trabalhando com clipes de filme
Para usar um método, ative-o usando o caminho de destino do nome da instância, seguido
de um ponto e do nome do método e dos parâmetros, como nas instruções a seguir:
myMovieClip.play();
parentClip.childClip.gotoAndPlay(3);
Na primeira instrução, play() move a reprodução na instância myMovieClip. Na segunda
instrução, o método gotoAndPlay() envia a reprodução em childClip (que é filho da
instância parentClip) para o quadro 3 e continua a mover a reprodução.
As funções globais que controlam uma Timeline têm um parâmetro target que permite
especificar o caminho de destino para a instância a ser controlada. Por exemplo, no script a
seguir, startDrag() destina-se à instância em que o código foi colocado e torna-a arrastável:
my_mc.onPress = function() {
startDrag(this);
};
my_mc.onRelease = function() {
stopDrag();
};
As funções a seguir destinam-se aos clipes de filme: loadMovie(), unloadMovie(),
loadVariables(), setProperty(), startDrag(), duplicateMovieClip() e
removeMovieClip(). Para usar essas funções, insira um caminho de destino no parâmetro
target da função para indicar seu destino.
Os métodos MovieClip a seguir podem controlar clipes de filme ou níveis carregados, e não
têm funções equivalentes: MovieClip.attachMovie(),
MovieClip.createEmptyMovieClip(), MovieClip.createTextField(),
MovieClip.getBounds(), MovieClip.getBytesLoaded(), MovieClip.getBytesTotal(),
MovieClip.getDepth(), MovieClip.getInstanceAtDepth(),
MovieClip.getNextHighestDepth(), MovieClip.globalToLocal(),
MovieClip.localToGlobal(), MovieClip.hitTest(), MovieClip.setMask(),
MovieClip.swapDepths().
Para obter mais informações sobre essas funções e métodos, consulte as entradas
correspondentes em ActionScript 2.0 Language Reference (Referência da linguagem
ActionScript 2.0).
Para obter um exemplo de animação com script no Flash, navegue até a pasta Samples no
disco rígido onde é possível encontrar um arquivo de origem de exemplo, animation.fla.
■
8\Samples and Tutorials\Samples\ActionScript\Animation.
■
and Tutorials/Samples/ActionScript/Animation.
Sobre o controle de clipes de filme com o ActionScript
371
É possível encontrar exemplos de aplicativos de galeria de fotografias no disco rígido. Esses
arquivos contêm exemplos do uso do ActionScript para controlar clipes de filme
dinamicamente e carregar arquivos de imagem em um arquivo SWF, que inclui a animação
com script. Os arquivos de origem de exemplo, gallery_tree.fla e gallery_tween.fla,
encontram-se na pasta Samples no disco rígido.
■
8\Samples and Tutorials\Samples\ActionScript\Galleries.
■
and Tutorials/Samples/ActionScript/Galleries.
Chamando vários métodos em um único
clipe de filme
É possível usar a instrução with para endereçar um clipe de filme uma vez e executar uma série
de métodos nesse clipe. Essa instrução funciona com todos os objetos do ActionScript (por
exemplo, Array, Color e Sound), e não somente com clipes de filme.
A instrução with requer um clipe de filme como parâmetro. O objeto especificado é
adicionado ao final do caminho de destino atual. Todas as ações aninhadas em uma instrução
with são executadas no novo caminho de destino ou escopo. Por exemplo, no script a seguir, o
objeto donut.hole é passado à instrução with para alterar as propriedades de hole:
with (donut.hole) {
_alpha = 20;
_xscale = 150;
_yscale = 150;
}
O script comporta-se como se as instruções contidas na instrução with fossem chamadas na
Timeline (Linha de tempo) da instância hole. O código anterior é equivalente ao seguinte
exemplo:
donut.hole._alpha = 20;
donut.hole._xscale = 150;
donut.hole._yscale = 150;
O código anterior também é equivalente ao seguinte exemplo:
with (donut) {
hole._alpha = 20;
hole._xscale = 150;
hole._yscale = 150;
}
372
Carregando e descarregando arquivos
SWF
Para reproduzir arquivos SWF adicionais sem fechar o Flash Player ou para alternar os
arquivos SWF sem carregar outra página HTML, use uma das seguintes opções:
■
A função loadMovie() global ou o método loadMovie() da classe MovieClip.
■
O método loadClip() da classe MovieClipLoader. Para obter mais informações sobre a
classe MovieClipLoader, consulte %{MovieClipLoader}% em ActionScript 2.0 Language
Reference (Referência da linguagem ActionScript 2.0).
Também é possível usar o método loadMovie() para enviar variáveis a um script CGI, que
gera um arquivo SWF como sua saída CGI. Por exemplo, use esse procedimento para carregar
arquivos de imagem ou SWF dinâmicos com base nas variáveis especificadas em um clipe de
filme. Ao carregar um arquivo SWF, é possível especificar um nível ou um destino de clipe de
filme no qual o arquivo SWF será carregado. Se você carregar um arquivo SWF em um
destino, o SWF carregado herdará as propriedades do clipe de filme de destino especificado.
Uma vez carregado o filme do Flash, é possível alterar essas propriedades.
O método unloadMovie() remove um arquivo SWF carregado anteriormente pelo método
Descarregar explicitamente um arquivo SWF com unloadMovie() assegura
uma transição suave entre arquivos SWF e pode reduzir o volume de memória exigido pelo
Flash Player. Em algumas situações, talvez seja mais eficiente definir a propriedade _visible
do clipe de filme como false em vez de descarregar o clipe. Se você reutilizar o clipe
posteriormente, defina a propriedade _visible como false e, depois, como true quando
necessário.
loadMovie().
Use loadMovie() para efetuar qualquer uma das seguintes ações:
■
Reproduzir uma seqüência de faixas de propaganda que sejam arquivos SWF, colocando
uma função loadMovie() em um arquivo SWF recipiente que carrega e descarrega
seqüencialmente os arquivos SWF de faixas.
■
Desenvolver uma interface ramificada com links para permitir que o usuário escolha entre
diversos arquivos SWF usados para exibir o conteúdo de um site.
■
Criar uma interface de navegação com controles de navegação no nível 0 que carregue
conteúdo em outros níveis. Carregar o conteúdo em níveis ajuda a produzir transições
mais suaves entre páginas de conteúdo do que carregar novas páginas HTML em um
navegador.
Para obter mais informações sobre o carregamento de arquivos SWF, consulte “Carregando
arquivos SWF e de imagem externos” na página 621.
Carregando e descarregando arquivos SWF
373
■
“Especificando uma Timeline raiz para arquivos SWF carregados” na página 374
■
“Carregando arquivos de imagem em clipes de filme” na página 375
Especificando uma Timeline raiz para arquivos SWF
carregados
A propriedade _root do ActionScript especifica ou contém uma referência à Timeline (Linha
de tempo) raiz de um arquivo SWF. Se um arquivo SWF possuir vários níveis, a Timeline raiz
estará no nível que contém o script atualmente em execução. Por exemplo, se um script no
nível 1 avaliar _root, será retornado _level1. Entretanto, a Timeline especificada por _root
poderá mudar dependendo de o arquivo SWF estar sendo executado independentemente (em
seu próprio nível) ou de ter sido carregado em uma instância de clipe de filme por meio de
uma chamada de loadMovie() .
No exemplo a seguir, considere um arquivo chamado container.swf que contenha uma
instância de clipe de filme chamada target_mc em sua Timeline principal. O arquivo
container.swf declara uma variável chamada userName na Timeline principal; o mesmo script
carrega outro arquivo contents.swf no clipe de filme target_mc:
// Em container.swf:
_root.userName = "Tim";
target_mc.loadMovie("contents.swf");
my_btn.onRelease = function():Void {
trace(_root.userName);
};
No exemplo a seguir, o arquivo SWF carregado, contents.swf, também declara uma variável
chamada userName em sua Timeline raiz:
// Em contents.swf:
_root.userName = "Mary";
Quando contents.swf for carregado no clipe de filme no arquivo container.swf, o valor de
userName que estiver anexado à Timeline raiz do arquivo SWF hospedeiro (container.swf )
será definido como "Mary" em vez de "Tim". Esse procedimento pode fazer com que o código
de container.swf (bem como de contents.swf ) funcione inadequadamente.
374
Para forçar _root a avaliar sempre na Timeline do arquivo SWF carregado, em vez de na
Timeline raiz real, use a propriedade _lockroot. É possível definir essa propriedade no
arquivo SWF em carga ou no arquivo SWF que esteja sendo carregado. Quando _lockroot é
definida como true em uma instância de clipe de filme, esse clipe de filme funciona como
_root para qualquer arquivo SWF carregado nele. Quando _lockroot é definida como true
em um arquivo SWF, esse arquivo funciona como sua própria raiz, não importando o outro
arquivo SWF que o carrega. Qualquer clipe de filme e número de clipe de filme pode definir
_lockroot como true. Por padrão, essa propriedade é false.
Por exemplo, o autor de container.swf poderia colocar o seguinte código no Frame 1 (Quadro
1) da Timeline principal:
// Adicionado ao Frame 1 em container.swf:
target_mc._lockroot = true;
Esta etapa garante que todas as referências a _root em contents.swf — ou em qualquer
arquivo SWF carregado em target_mc — serão feitas à sua própria Timeline, e não à
Timeline raiz de container.swf. Agora, quando você clicar no botão, será exibido "Tim".
Opcionalmente, o autor de contents.swf pode adicionar o seguinte código à Timeline
principal:
// Adicionado ao Frame 1 em contents.swf:
this._lockroot = true;
Esse procedimento garantirá que, independentemente de onde contents.swf for carregado,
qualquer referência que ele faça a _root estará relacionada à sua própria Timeline principal, e
não àquela do arquivo SWF hospedeiro.
Para obter mais informações, consulte %{_lockroot (MovieClip._lockroot property)}%.
Carregando arquivos de imagem em clipes de filme
Você pode usar a função loadMovie() ou o método MovieClip de mesmo nome para carregar
arquivos de imagem em uma instância de clipe de filme. Também pode usar a função
loadMovieNum() para carregar um arquivo de imagem em um nível.
Quando você carrega uma imagem em um clipe de filme, o canto superior esquerdo da
imagem é colocado no ponto de registro do clipe de filme. Como geralmente esse ponto de
registro é o centro do clipe de filme, a imagem carregada pode não aparecer centralizada. Além
disso, quando você carrega uma imagem em uma Timeline raiz, o canto superior esquerdo da
imagem é colocado no Stage. A imagem carregada herda a rotação e o dimensionamento do
clipe de filme, mas o conteúdo original do clipe do filme é removido.
Carregando e descarregando arquivos SWF
375
Para obter mais informações, consulte %{loadMovie function}%, %{loadMovie
(MovieClip.loadMovie method)}% e %{loadMovieNum function}% em ActionScript 2.0
Language Reference e “Carregando arquivos SWF e de imagem externos” na página 621.
Alterando a posição e a aparência de um
clipe de filme
Para alterar as propriedades de um clipe de filme durante sua reprodução, escreva uma
instrução que atribua um valor a uma propriedade ou use a função setProperty(). Por
exemplo, o código a seguir define a rotação da instância mc como 45:
my_mc._rotation = 45;
Esse código é equivalente ao apresentado a seguir, que usa a função setProperty():
setProperty("my_mc", _rotation, 45);
Algumas propriedades, chamadas somente leitura, possuem valores que podem ser lidos, porém
não definidos. (Essas propriedades são especificadas como somente leitura nas entradas
correspondentes em ActionScript 2.0 Language Reference). As seguintes propriedades são
somente leitura: _currentframe, _droptarget, _framesloaded, _parent, _target,
_totalframes, _url, _xmouse e _ymouse.
Você pode criar instruções para definir qualquer propriedade que não seja somente leitura. A
instrução a seguir define a propriedade _alpha da instância de clipe de filme wheel_mc, que é
filha da instância car_mc:
car_mc.wheel_mc._alpha = 50;
Além disso, você pode criar instruções que obtenham o valor de uma propriedade do clipe de
filme. Por exemplo, a instrução a seguir obtém o valor da propriedade _xmouse na Timeline
(Linha de tempo) do nível atual e define a propriedade _x da instância my_mc como esse
valor:
this.onEnterFrame = function() {
my_mc._x = _root._xmouse;
};
Esse código é equivalente ao apresentado a seguir, que usa a função getProperty():
this.onEnterFrame = function() {
my_mc._x = getProperty(_root, _xmouse);
};
376
As propriedades _x, _y, _rotation, _xscale, _yscale, _height, _width, _alpha e
_visible são afetadas pelas transformações do pai do clipe de filme e transformam o clipe e
todos os seus filhos. As propriedades _focusrect, _highquality, _quality e
_soundbuftime são globais; elas pertencem somente à Timeline principal de nível 0. Todas as
outras propriedades pertencem aos clipes de filme ou níveis carregados.
Para obter uma lista de propriedades de clipes de filme, consulte o resumo de propriedades da
classe %{MovieClip}% em ActionScript 2.0 Language Reference.
Para obter um exemplo de animação com script no Flash, navegue até a pasta Samples no
disco rígido onde é possível encontrar um arquivo de origem de exemplo, animation.fla.
■
■
É possível encontrar exemplos de aplicativos de galeria de fotografias no disco rígido. Esses
arquivos contêm exemplos do uso do ActionScript para controlar clipes de filme
dinamicamente e carregar arquivos de imagem em um arquivo SWF, que inclui a animação
com script. Os arquivos de origem de exemplo, gallery_tree.fla e gallery_tween.fla,
encontram-se na pasta Samples no disco rígido.
■
■
Arrastando clipes de filme
Você pode usar a função global startDrag() ou o método MovieClip.startDrag() para
tornar um clipe de filme arrastável. Por exemplo, você pode criar um clipe de filme arrastável
para jogos, funções do tipo arrastar e soltar, interfaces personalizáveis, barras de rolagem e
controles deslizantes.
Um clipe de filme pode ser arrastado até ser parado explicitamente por stopDrag() ou até
que outro clipe de filme seja definido por startDrag(). Só é possível arrastar um clipe de
filme de cada vez em um arquivo SWF.
Arrastando clipes de filme
377
Para criar um comportamento arrastar e soltar mais complexo, você pode avaliar a propriedade
_droptarget do clipe de filme que está sendo arrastado. Por exemplo, você pode examinar a
propriedade _droptarget para verificar se o clipe de filme foi arrastado para um clipe
específico (por exemplo, um clipe de filme “lata de lixo”) e, em seguida, ativar outra ação,
como mostra este exemplo:
// Arraste o lixo.
garbage_mc.onPress = function() {
this.startDrag(false);
};
// Quando o lixo for arrastado para a lixeira, torne-o invisível.
garbage_mc.onRelease = function() {
this.stopDrag();
// Converta a notação de barra em notação de ponto usando eval.
if (eval(this._droptarget) == trashcan_mc) {
garbage_mc._visible = false;
}
};
Para obter mais informações, consulte %{startDrag function}% ou %{startDrag
(MovieClip.startDrag method)}% em ActionScript 2.0 Language Reference.
É possível encontrar um aplicativo de galeria de fotografias de exemplo no disco rígido. Esse
arquivo contêm um exemplo do uso do ActionScript para controlar clipes de filme
dinamicamente e carregar arquivos de imagem em um arquivo SWF, o que inclui tornar cada
clipe de filme arrastável. O arquivo de origem de exemplo, gallery_tween.fla, está localizado
na pasta Samples no disco rígido.
■
■
Criando clipes de filme durante a
execução
Além de criar instâncias de clipe de filme no ambiente de criação do Flash, é possível criar
instâncias de clipe de filme durante a execução das seguintes maneiras:
■
“Criando um clipe de filme vazio” na página 379
■
“Duplicando ou removendo um clipe de filme” na página 381
■
“Anexando um símbolo de clipe de filme ao Stage” na página 381
378
Cada instância de clipe de filme criada durante a execução deve ter um nome e um valor de
profundidade (pilha ou ordem z). A profundidade especificada determina como o novo clipe
substitui os outros clipes na mesma Timeline (Linha de tempo). Ela também permite
substituir clipes de filme que residam na mesma profundidade. (Consulte “Gerenciando
profundidades do clipe de filme” na página 385.)
dinamicamente e carregar arquivos de imagem em um arquivo SWF, o que inclui criar clipes
de filme durante a execução. O arquivo de origem de exemplo, gallery_tween.fla, está
localizado na pasta Samples no disco rígido.
■
■
Um arquivo de origem de exemplo, animation.fla, que cria e remove vários clipes de filme
durante a execução, encontra-se na pasta Samples do disco rígido
■
■
■
“Criando um clipe de filme vazio” na página 379
■
“Duplicando ou removendo um clipe de filme” na página 381
■
“Anexando um símbolo de clipe de filme ao Stage” na página 381
Criando um clipe de filme vazio
Para criar uma nova instância de clipe de filme vazia no Stage (Palco), use o método
createEmptyMovieClip() da classe MovieClip. Este método cria um clipe de filme como
filho do clipe que chamou o método. O ponto de registro de um clipe de filme vazio recémcriado é o canto superior esquerdo.
Por exemplo, o código a seguir cria um novo clipe de filme filho chamado new_mc na
profundidade10 do clipe de filme parent_mc.
parent_mc.createEmptyMovieClip("new_mc", 10);
Criando clipes de filme durante a execução
379
O código a seguir cria um novo clipe de filme chamado canvas_mc na Timeline (Linha de
tempo) raiz do arquivo SWF no qual o script é executado; em seguida, ele ativa loadMovie()
para carregar um arquivo JPEG externo nele mesmo.
this.createEmptyMovieClip("canvas_mc", 10);
canvas_mc.loadMovie("http://www.helpexamples.com/flash/images/image1.jpg");
Como mostra o exemplo a seguir, é possível carregar a imagem image2.jpg em um clipe de
filme e usar o método MovieClip.onPress() para fazê-la funcionar como um botão. O
carregamento de uma imagem com loadMovie() substitui o clipe de filme pela imagem, mas
não fornece acesso aos métodos de clipe de filme. Para obter acesso a esses métodos, é
necessário criar um clipe de filme pai vazio e um clipe de filme filho recipiente. Carregue a
imagem no recipiente e coloque o manipulador de eventos no clipe de filme pai.
// Cria um clipe de filme pai para armazenar o recipiente.
this.createEmptyMovieClip("my_mc", 0);
// Cria um clipe de filme filho em "my_mc".
// Esse é o clipe de filme que será substituído pela imagem.
my_mc.createEmptyMovieClip("container_mc",99);
// Use MovieClipLoader para carregar a imagem.
var my_mcl:MovieClipLoader = new MovieClipLoader();
my_mcl.loadClip("http://www.helpexamples.com/flash/images/image2.jpg",
my_mc.container_mc);
// Coloque o manipulador de eventos no clipe de filme pai my_mc.
my_mc.onPress = function():Void {
trace("It works");
};
Para obter mais informações, consulte %{createEmptyMovieClip
(MovieClip.createEmptyMovieClip method)}% em ActionScript 2.0 Language Reference.
■
■
380
Duplicando ou removendo um clipe de filme
Para duplicar ou remover instâncias de clipe de filme, use as funções globais
duplicateMovieClip() ou removeMovieClip(),ou os métodos da classe MovieClip de
mesmo nome. O método duplicateMovieClip() cria uma nova instância de uma instância
de clipe de filme existente, atribui a ela um novo nome e define sua profundidade ou ordem z.
Um clipe de filme duplicado sempre começa no Frame 1 (Quadro 1), mesmo que o clipe
original esteja em outro quadro durante a duplicação, e está sempre na frente de todos os
clipes definidos anteriormente e colocados na Timeline (Linha de tempo).
Para excluir um clipe de filme criado com duplicateMovieClip(), use removeMovieClip().
Os clipes de filme duplicados também serão removidos se o clipe pai for excluído.
Para obter mais informações, consulte %{duplicateMovieClip function}% e
%{removeMovieClip function}% em ActionScript 2.0 Language Reference.
■
■
Anexando um símbolo de clipe de filme ao Stage
A última maneira de criar instâncias de clipe de filme durante a execução é usar o método
attachMovie(). O método attachMovie() anexa a instância de um símbolo de clipe de
filme na biblioteca do arquivo SWF ao Stage (Palco). O novo clipe torna-se um clipe filho do
clipe que o anexou.
Para usar o ActionScript para anexar um símbolo de clipe de filme da biblioteca, você deve
exportar o símbolo do ActionScript e atribuí-lo a um identificador de vinculação exclusivo.
Para isso, use a caixa de diálogo Linkage Properties (Propriedades de vinculação).
O padrão é que todos os clipes de filme exportados para uso com o ActionScript sejam
carregados antes do primeiro quadro do arquivo SWF que os contêm. Isso pode criar um
atraso antes da reprodução do primeiro quadro. Ao atribuir um identificador de vinculação a
um elemento, você também pode especificar se o conteúdo deverá ser adicionado antes do
primeiro quadro. Se esse conteúdo não for adicionado ao primeiro quadro, será necessário
incluir uma instância dele em algum outro quadro do arquivo SWF. Caso contrário, o
elemento não será exportado para o arquivo SWF.
Criando clipes de filme durante a execução
381
Para atribuir um identificador de vinculação a um clipe de filme:
1.
Selecione Window > Library (Biblioteca) para abrir o painel Library.
2.
Selecione um clipe de filme no painel Library.
3.
No menu pop-up do painel Library, selecione Linkage (Vinculação).
A caixa de diálogo Linkage Properties é exibida.
4.
Em Linkage, selecione Export for ActionScript (Exportar para ActionScript).
5.
Em Identifier (Identificador), insira uma ID para o clipe de filme.
O padrão é que o identificador seja igual ao nome do símbolo.
Opcionalmente, você pode atribuir uma classe do ActionScript ao símbolo de clipe de
filme. Isso permite que o clipe de filme herde os métodos e as propriedades de uma classe
especificada. (Consulte “Atribuindo uma classe a um símbolo de clipe de filme”
na página 399.)
6.
Para não carregar o clipe de filme antes do primeiro quadro, desmarque a opção Export in
First Frame (Exportar no primeiro quadro).
Se você desmarcar essa opção, insira uma instância do clipe de filme no quadro da
Timeline (Linha de tempo) onde deseja que ela esteja disponível. Por exemplo, se o script
que você está criando não fizer referência ao clipe de filme até o Frame 10 (Quadro 10),
coloque uma instância do símbolo nesse quadro ou antes dele na Timeline.
7.
Clique em OK.
Depois de atribuir um identificador de vinculação a um clipe de filme, você pode anexar uma
instância do símbolo ao Stage durante a execução usando attachMovie().
Para anexar um clipe de filme a outro:
1.
Atribua um identificador de vinculação a um símbolo da biblioteca de clipes de filme, como
descrito no exemplo anterior.
2.
Com o painel Actions (Ações) aberto, a partir de Window (Janela) > Actions, selecione um
quadro na Timeline.
3.
No painel Script do painel Actions, digite o nome do clipe de filme ou nível ao qual você
deseja anexar o novo clipe de filme.
Por exemplo, para anexar o clipe de filme à Timeline raiz, digite this.
4.
Na caixa de ferramentas Actions (à esquerda do painel Actions), selecione ActionScript 2.0
Classes (Classes do ActionScript 2.0) > Movie (Filme) > MovieClip > Methods (Métodos)
e selecione attachMovie().
5.
Usando as referências de código que aparecem como guia, insira os valores dos seguintes
parâmetros:
382
■
Para idName, especifique o nome do identificador inserido na caixa de diálogo Linkage
Properties.
■
Para newName, insira um nome de instância para o clipe anexado de modo que você
possa especificá-lo como destino.
■
Para depth, insira o nível no qual o filme duplicado será anexado ao clipe de filme.
Cada filme anexado possui sua própria ordem de empilhamento, sendo que o nível 0 é
o nível do clipe do filme de origem. Os clipes de filme anexados estão sempre sobre o
clipe de filme original, como mostra o seguinte exemplo:
this.attachMovie("calif_id", "california_mc", 10);
Para obter mais informações, consulte %{attachMovie (MovieClip.attachMovie method)}%
em ActionScript 2.0 Language Reference.
Adicionando parâmetros aos clipes de
filme criados dinamicamente
Ao usar MovieClip.attachMovie() e MovieClip.duplicateMovie() para criar ou duplicar
um clipe de filme dinamicamente, você pode preencher o clipe de filme com os parâmetros de
outro objeto. O parâmetro initObject de attachMovie() e duplicateMovie() permite
que os clipes de filme criados dinamicamente recebam parâmetros de clipe.
Para obter mais informações, consulte %{attachMovie (MovieClip.attachMovie method)}% e
em ActionScript
%{duplicateMovieClip (MovieClip.duplicateMovieClip method)}%
Para preencher um clipe de filme criado dinamicamente com parâmetros de
um objeto especificado:
■
Use a sintaxe a seguir com o attachMovie():
myMovieClip.attachMovie(idName, newName, depth [, initObject]);
■
Use a sintaxe a seguir com duplicateMovie():
myMovieClip.duplicateMovie(idName, newName, depth [, initObject]);
O parâmetro initObject especifica o nome do objeto cujos parâmetros você deseja usar para
preencher o clipe de filme criado dinamicamente.
Para preencher um clipe de filme com parâmetros usando attachMovie():
1.
Em um novo documento do Flash, crie um símbolo de clipe de filme selecionando Insert
(Inserir) > New Symbol (Novo símbolo).
Adicionando parâmetros aos clipes de filme criados dinamicamente
383
2.
Digite dynamic_mc na caixa de texto Symbol Name (Nome do símbolo) e selecione o
comportamento Movie Clip (Clipe de filme).
3.
Dentro do símbolo, crie um campo de texto dinâmico no Stage com um nome de instância
name_txt.
Verifique se esse campo de texto está abaixo e à direita do ponto de registro.
4.
Selecione o Frame 1 da Timeline do clipe de filme e abra o painel Actions, a partir de
Window > Actions.
5.
Crie uma nova variável chamada name_str e atribua seu valor à propriedade text de
name_txt, como mostra o seguinte exemplo:
var name_str:String;
name_txt.text = name_str;
6.
Selecione Edit (Editar)> Edit Document (Editar documento) para voltar à Timeline
principal.
7.
Selecione o símbolo de clipe de filme na biblioteca e Linkage (Vinculação) no menu popup Library (Biblioteca).
8.
Selecione as opções Export for ActionScript (Exportar para ActionScript) e Export in first
frame (Exportar no primeiro quadro).
9.
Digite dynamic_id na caixa de texto Identifier (Identificador) e clique em OK.
10. Selecione
o primeiro quadro da Timeline principal e adicione o seguinte código ao painel
Script do painel Actions:
/* Anexa um novo clipe de filme e move-o para a coordenada x e y 50 */
this.attachMovie("dynamic_id", "newClip_mc", 99, {name_str:"Erick",
_x:50, _y:50});
11.
Teste o documento do Flash em Control (Controlar) > Test Movie (Testar filme).
O nome especificado em attachMovie() é exibido no novo campo de texto do clipe de
filme.
dinamicamente e carregar arquivos de imagem em um arquivo SWF, o que inclui criar clipes
de filme durante a execução. O arquivo de origem de exemplo, gallery_tween.fla, está
localizado na pasta Samples no disco rígido.
■
384
■
■
■
Gerenciando profundidades do clipe de
filme
Cada clipe de filme tem seu próprio espaço de ordem z que determina como os objetos são
sobrepostos no clipe de filme ou arquivo SWF pai. Cada clipe de filme tem um valor de
profundidade associado, que determina se ele será renderizado na frente ou atrás de outros
clipes de filme na mesma Timeline (Linha de tempo) de clipe de filme. Ao criar um clipe de
filme durante a execução usando %{attachMovie (MovieClip.attachMovie method)}%,
%{duplicateMovieClip (MovieClip.duplicateMovieClip method)}% ou
%{createEmptyMovieClip (MovieClip.createEmptyMovieClip method)}%, especifique
sempre uma profundidade para o novo clipe como um parâmetro do método. Por exemplo, o
código a seguir anexa um novo clipe de filme à Timeline de um clipe de filme chamado
container_mc com um valor de profundidade 10.
container_mc.attachMovie("symbolID", "clip1_mc", 10);
Esse exemplo cria um novo clipe de filme com a profundidade 10 no espaço de ordem z de
container_mc.
O código a seguir anexa dois novos clipes de filme ao container_mc. O primeiro clipe,
chamado clip1_mc, é renderizado atrás do clip2_mc porque um valor de profundidade
inferior foi atribuído a ele.
Os valores de profundidade de clipes de filme podem variar de -16384 a 1048575. Se você
criar ou anexar um novo clipe de filme em uma profundidade em que já existe um clipe de
filme, o clipe novo ou anexado substituirá o conteúdo existente. Para evitar esse problema, use
o método MovieClip.getNextHighestDepth(), mas não com componentes que usam um
sistema de gerenciamento de profundidade diferente. Em vez disso, use “DepthManager class”
com o componente instances.evelyn
Gerenciando profundidades do clipe de filme
385
A classe MovieClip fornece diversos métodos de gerenciamento de profundidades de clipes de
filmes; para obter mais informações, consulte %{getNextHighestDepth
(MovieClip.getNextHighestDepth method)}%, %{getInstanceAtDepth
(MovieClip.getInstanceAtDepth method)}%, %{getDepth (MovieClip.getDepth
method)}% e %{swapDepths (MovieClip.swapDepths method)}% em ActionScript 2.0
Language Reference.
Para obter mais informações sobre profundidades de clipes de filme, consulte os seguintes
tópicos:
■
“Determinando a próxima profundidade mais alta disponível” na página 386
■
“Determinando a instância em uma profundidade particular” na página 387
■
“Determinando a profundidade de uma instância” na página 387
■
“Trocando profundidades de clipes de filme” na página 388
Determinando a próxima profundidade mais alta
disponível
Para determinar a próxima profundidade mais alta disponível em um clipe de filme, use
MovieClip.getNextHighestDepth(). O valor inteiro retornado por esse método indica a
próxima profundidade disponível que será renderizada na frente de todos os outros objetos no
clipe de filme.
O código a seguir anexa um novo clipe de filme, chamado file_mc, com profundidade 10, na
Timeline (Linha de tempo) raiz. Depois, ele determina a próxima profundidade mais alta
disponível no mesmo clipe de filme e cria um novo clipe chamado edit_mc nessa
profundidade.
this.attachMovie("menuClip","file_mc", 10, {_x:0, _y:0});
trace(file_mc.getDepth()); // 10
var nextDepth:Number = this.getNextHighestDepth();
this.attachMovie("menuClip", "edit_mc", nextDepth, {_x:200, _y:0});
trace(edit_mc.getDepth()); // 11
Nesse caso, a variável nextDepth contém o valor 11 porque essa é a próxima profundidade
mais alta disponível para o clipe de filme edit_mc.
Não use MovieClip.getNextHighestDepth() com componentes; em vez disso, use o
gerenciador de profundidade. Para obter mais informações, consulte “DepthManager class”
em Component Language Reference (Referência da linguagem de componentes). Para obter
mais informações sobre MovieClip.getNextHighestDepth(), consulte
%{getNextHighestDepth (MovieClip.getNextHighestDepth method)}%.
386
Para obter a profundidade ocupada mais alta atual, subtraia 1 do valor retornado por
getNextHighestDepth(), como descrito na próxima seção.
Determinando a instância em uma profundidade
particular
Para determinar a instância em uma profundidade específica, use
MovieClip.getInstanceAtDepth(). Esse método retorna uma referência para a instância de
MovieClip na profundidade especificada.
O código a seguir combina getNextHighestDepth() e getInstanceAtDepth() para
determinar o clipe de filme na profundidade ocupada mais alta (atual) na Timeline (Linha de
tempo) raiz.
var highestOccupiedDepth:Number = this.getNextHighestDepth() - 1;
var instanceAtHighestDepth:MovieClip =
this.getInstanceAtDepth(highestOccupiedDepth);
Para obter mais informações, consulte %{getInstanceAtDepth
(MovieClip.getInstanceAtDepth method)}%
Determinando a profundidade de uma instância
Para determinar a profundidade de uma instância de clipe de filme, use
MovieClip.getDepth().
O código a seguir faz a iteração de todos os clipes de filme na Timeline (Linha de tempo)
principal de um arquivo SWF e exibe o nome da instância e o valor da profundidade de cada
clipe no painel Output (Saída):
for (var item:String in _root) {
var obj:Object = _root[item];
if (obj instanceof MovieClip) {
var objDepth:Number = obj.getDepth();
trace(obj._name + ":" + objDepth)
}
}
Para obter mais informações, consulte %{getDepth (MovieClip.getDepth method)}% em
Gerenciando profundidades do clipe de filme
387
Trocando profundidades de clipes de filme
Para trocar as profundidades de dois clipes de filme na mesma Timeline, use
MovieClip.swapDepths(). Os exemplos a seguir mostram como duas instâncias de clipes de
filme podem trocar de profundidade durante a execução.
Para trocar profundidades de clipes de filme:
1.
Crie um novo documento do Flash chamado swap.fla.
2.
Desenhe um círculo azul no Stage (Palco).
3.
Selecione o círculo azul e, em seguida, Modify (Modificar) > Convert to Symbol
4.
Selecione a opção Movie clip (Clipe de filme) e clique em OK.
5.
Selecione a instância no Stage e digite first_mc na caixa de texto Instance Name (Nome da
instância) no inspetor Property (Propriedade).
6.
Desenhe um círculo vermelho no Stage e selecione Modify > Convert to Symbol.
7.
8.
Selecione a instância no Stage e digite second_mc na caixa de texto Instance Name no
inspetor Property.
9.
Arraste as duas instâncias para que uma se sobreponha ligeiramente a outra no Stage.
10. Selecione
o Frame 1 (Quadro 1) da Timeline (Linha de tempo) e digite o seguinte código
first_mc.onRelease = function() {
this.swapDepths(second_mc);
};
second_mc.onRelease = function() {
this.swapDepths(first_mc);
};
11.
Quando você clica nas instâncias no Stage, elas trocam de profundidade. Você verá as duas
instâncias alterarem a sobreposição de um clipe por outro.
Para obter mais informações, consulte %{swapDepths (MovieClip.swapDepths method)}%
388
Sobre o armazenamento em cache e a
rolagem de clipes de filme com o
ActionScript
À medida que o tamanho dos seus designs no Flash aumenta, esteja você criando um
aplicativo ou animações complexas com script, é necessário considerar o desempenho e a
otimização. Quando o seu conteúdo permanece estático (como um clipe de filme retangular),
o Flash não otimiza o conteúdo. Portanto, quando você altera a posição do clipe de filme
retangular, o Flash redesenha o retângulo inteiro no Flash Player 7 e em versões anteriores.
No Flash Player 8, é possível armazenar em cache clipes de filme e botões especificados para
melhorar o desempenho do arquivo SWF. O clipe de filme ou o botão é uma superfície,
essencialmente uma versão de bitmap dos dados vetoriais da instância que não devem sofrer
muitas alterações ao longo do arquivo SWF. Portanto, as instâncias que têm o armazenamento
em cache ativado não são redesenhadas continuamente enquanto o arquivo SWF é
reproduzido, permitindo que ele seja renderizado rapidamente.
N OT A
Você pode atualizar os dados vetoriais e, nesse momento, a superfície é recriada.
Portanto, os dados vetoriais armazenados em cache na superfície não precisam
permanecer inalterados ao longo de todo o arquivo SWF.
Você pode usar o ActionScript para ativar os recursos de armazenamento em cache e rolagem,
bem como para controlar os planos de fundo. Para ativar o recurso de armazenamento em
cache para uma instância de clipe de filme, use o inspetor Properties (Propriedades). Para
armazenar clipes de filme ou botões em cache sem usar o ActionScript, você pode selecionar a
opção Use runtime bitmap caching (Usar cache de bitmap em tempo de execução) no
inspetor Properties.
Sobre o armazenamento em cache e a rolagem de clipes de filme com o ActionScript
389
A tabela a seguir contém breve descrições das novas propriedades para instâncias de clipes de
filme:
Propriedade
Descrição
cacheAsBitmap
Faz com que a instância do clipe de filme armazene em cache sua
própria representação de bitmap. O Flash cria um objeto de superfície
para a instância, que é um bitmap armazenado em cache, em vez de
dados vetoriais. Se você alterar os limites do clipe de filme, a superfície
será recriada em vez de redimensionada. Para obter mais informações
e um exemplo, consulte “Armazenando um clipe de filme em cache”
na página 393.
opaqueBackground Permite especificar uma cor de fundo para a instância do clipe de filme
opaca. Se você definir essa propriedade como um valor numérico, a
instância do clipe de filme terá uma superfície opaca (não
transparente). Um bitmap opaco não tem um canal alfa (transparência)
e é renderizado mais rápido. Para obter mais informações e um
exemplo, consulte “Definindo o plano de fundo de um clipe de filme”
na página 396.
scrollRect
Permite rolar rapidamente o conteúdo do clipe de filme e obter uma
janela que exibe conteúdo maior. O conteúdo do clipe é cortado, e a
instância rola com os deslocamentos de rolagem, altura e largura
especificados. Dessa maneira, o usuário pode rolar rapidamente o
conteúdo do clipe e ter uma janela que exiba conteúdo maior do que o
permitido na área Stage (Palco). É possível rolar mais rápido os
campos de texto e o conteúdo complexo exibidos na instância porque
o Flash não gera novamente todos os dados vetoriais do clipe de filme.
Para obter mais informações e um exemplo, consulte %{scrollRect
(MovieClip.scrollRect property)}%.
Essas três propriedades são independentes umas das outras, mas as propriedades
opaqueBackground e scrollRect funcionam melhor quando um objeto é armazenado em
cache como um bitmap. Você só observa vantagens de desempenho para as propriedades
opaqueBackground e scrollRect quando define cacheAsBitmap como true.
Para criar uma superfície também rolável, defina as propriedades cacheAsBitmap and
para a instância do clipe de filme. É possível aninhar as superfícies umas dentro
das outras. A superfície copia o bitmap para a própria superfície mãe.
scrollRect
390
Para obter informações sobre máscaras de canais alfa, que exigem a definição da propriedade
cacheAsBitmap como true, consulte “Sobre máscaras de canal alfa” na página 398.
NO T A
Não é possível aplicar o armazenamento em cache diretamente a campos de texto. Para
aproveitar esse recurso, é necessário colocar um texto em um clipe de filme. Por obter
um exemplo, consulte o arquivo de exemplo no diretório de instalação do
Flash\Samples and Tutorials\Samples\ActionScript\FlashType.
É possível encontrar um arquivo de origem de exemplo que mostre como aplicar o
armazenamento de bitmap em cache a uma instância. Localize o arquivo denominado
cacheBitmap.fla na pasta Samples no disco rígido.
■
8\Samples and Tutorials\Samples\ActionScript\CacheBitmap.
■
No Macintosh, navegue até HD do Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/CacheBitmap.
Também é possível encontrar um arquivo de origem de exemplo que mostre como aplicar o
armazenamento de bitmap em cache à um texto de rolagem. Localize o arquivo de origem de
exemplo, flashtype.fla, na pasta Samples no disco rígido.
■
8\Samples e Tutorials\Samples\ActionScript\FlashType.
■
Samples and Tutorials/Samples/ActionScript/FlashType.
Quando ativar o armazenamento em cache
A ativação do armazenamento em cache para um clipe de filme cria uma superfície, o que
oferece diversas vantagens, como a renderização mais rápida de animações vetoriais complexas.
Há vários cenários em que será útil ativar o armazenamento em cache. Embora aparentemente
seja sempre desejável ativar esse recurso para melhorar o desempenho dos arquivos SWF, em
algumas situações, ele não melhorará o desempenho ou poderá até mesmo piorá-lo. Esta seção
descreve os cenários em que é recomendável usar o armazenamento em cache e clipes de filme
comuns.
O desempenho geral dos dados armazenados em cache depende da complexidade dos dados
vetoriais de suas instâncias, do volume de dados alterado e da definição ou não da propriedade
opaqueBackground. Se você estiver alterando pequenas regiões, a diferença entre usar uma
superfície e usar dados vetoriais poderá ser irrelevante. Convém testar os dois cenários com o
seu trabalho antes de implantar o aplicativo.
391
Para obter informações sobre máscaras de canais alfa, que exigem a definição da propriedade
Quando usar o armazenamento de bitmap em cache
Veja a seguir os cenários típicos em que a ativação do armazenamento de bitmap em cache
oferece vantagens significativas.
Um aplicativo que contém uma imagem de fundo complexa e
detalhada de dados vetoriais (talvez uma imagem à qual você tenha aplicado o comando Trace
Bitmap (Traçar bitmap) ou uma arte criado no Adobe Illustrator). É possível animar caracteres
dispostos sobre o fundo, o que torna a animação mais lenta pois o fundo precisa gerar
novamente os dados vetoriais de forma contínua. Para melhorar o desempenho, você pode
selecionar o conteúdo, armazená-lo em um clipe de filme e definir a propriedade
opaqueBackground como true. O fundo é renderizado como um bitmap e pode ser
redesenhado rapidamente para que a animação seja reproduzida com muito mais rapidez.
Imagem de fundo complexa
Um aplicativo que exibe um grande volume de texto em um
campo de texto de rolagem. É possível colocar o campo de texto em um clipe de filme
definido como rolável com limites de rolagem (a propriedade scrollRect). Assim a rolagem
rápida de pixels é ativada para a instância especificada. Quando um usuário rola a instância de
clipe de filme, o Flash desloca os pixels rolados para cima e gera a região recém-exposta, em
vez de gerar novamente o campo de texto inteiro.
Campo de texto de rolagem
Sistema de janelas
Um aplicativo com um sistema complexo de janelas sobrepostas. É
possível abrir ou fechar cada janela (por exemplo, as janelas do navegador da Web). Se você
marcar cada janela como uma superfície (defina a propriedade cacheAsBitmap como true),
cada uma será isolada e armazenada em cache. Os usuários podem arrastar as janelas para que
se sobreponham, e as janelas não precisam gerar novamente o conteúdo vetorial.
Todos esses cenários melhoram a resposta e a interatividade do aplicativo otimizando os
gráficos vetoriais.
■
■
392
■
■
Quando evitar o uso do armazenamento de bitmap em cache
O uso inadequado desse recurso pode ter um impacto negativo no arquivo SWF. Ao
desenvolver um arquivo FLA que utilize superfícies, lembre-se das seguintes diretrizes:
■
Não utilize excessivamente superfícies (clipes de filme com o armazenamento em cache
ativado). Como cada superfície usa mais de memória do que um clipe de filme comum, só
ative esse recurso quando precisar melhorar o desempenho da renderização.
Um bitmap armazenado em cache pode ocupar bem mais memória que uma instância de
clipe de filme comum. Por exemplo, se o clipe de filme no Stage (Palco) tiver 250 pixels
por 250 pixels de tamanho, quando armazenado em cache, ele poderá usar 250 KB em vez
de 1 KB no caso de uma instância de clipe de filme comum (não armazenada em cache).
■
Evite aumentar o zoom em superfícies armazenadas em cache. Se você abusar do
armazenamento de bitmap em cache, será consumido um grande volume de memória,
especialmente se o conteúdo for aumentado.
■
Use superfícies para instâncias de clipe de filme que sejam, em grande parte, estáticas (sem
animação). É possível arrastar ou mover a instância, mas o seu conteúdo não deve conter
muita animação nem sofrer muitas alterações. Por exemplo, se você girar ou transformar
uma instância, ela será alterada entre a superfície e os dados vetoriais, o que dificulta o
processamento e afeta negativamente o arquivo SWF.
■
A mistura de superfícies e dados vetoriais aumenta o volume de processamento que o Flash
Player (e, às vezes, o computador) precisa executar. Agrupe ao máximo as superfícies; por
exemplo, ao criar aplicativos com janelas.
Armazenando um clipe de filme em cache
Para armazenar uma instância de clipe de filme em cache, é preciso definir a propriedade
cacheAsBitmap como true. Depois de defini-la, observe que os pixels da instância do clipe
de filme se encaixam automaticamente em coordenadas inteiras. Ao testar o arquivo SWF,
observe que todas as animações vetoriais complexas são renderizadas mais rápido.
393
Uma superfície (um bitmap armazenado em cache) não será criada, mesmo que a propriedade
cacheAsBitmap esteja definida como true nas seguintes situações:
■
Se o bitmap tiver mais de 2880 pixels de altura ou largura.
■
Se houver falha na alocação do bitmap (erro de falta de memória).
Para armazenar um clipe de filme em cache:
1.
Crie um novo documento do Flash e atribua ao arquivo o nome cachebitmap.fla.
2.
Digite 24 na caixa de texto de quadros por segundo no inspetor Properties (Propriedades),
em Window (Janela) > Properties > Properties.
3.
Crie ou importe um gráfico vetorial complexo para o arquivo FLA.
Há um gráfico vetorial complexo no arquivo de origem concluído para este exemplo no
seguinte diretório:
■
■
4.
Selecione o gráfico vetorial e, em seguida, Modify (Modificar) > Convert to Symbol
5.
Digite star na caixa de texto Name (Nome) e clique em Advanced (Avançado) se a caixa de
diálogo ainda não estiver expandida.
6.
Selecione Export for ActionScript (Exportar para ActionScript), que também seleciona
Export in first frame (Exportar no primeiro quadro).
7.
Digite star_id na caixa de texto Identifier (Identificador).
8.
Clique em OK para criar o símbolo do clipe de filme com o identificador de vinculação
Star.
9.
Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) e adicione o seguinte
ActionScript ao painel Actions (Ações):
import mx.transitions.Tween;
var star_array:Array = new Array();
for (var i:Number = 0; i < 20; i++) {
makeStar();
}
function makeStar():Void {
var depth:Number = this.getNextHighestDepth();
var star_mc:MovieClip = this.attachMovie("star_id", "star" + depth,
depth);
star_mc.onEnterFrame = function() {
star_mc._rotation += 5;
394
}
star_mc._y = Math.round(Math.random() * Stage.height - star_mc._height
/ 2);
var star_tween:Tween = new Tween(star_mc, "_x", null, 0, Stage.width,
(Math.random() * 5) + 5, true);
star_tween.onMotionFinished = function():Void {
star_tween.yoyo();
};
star_array.push(star_mc);
}
var mouseListener:Object = new Object();
mouseListener.onMouseDown = function():Void {
var star_mc:MovieClip;
for (var i:Number = 0; i < star_array.length; i++) {
star_mc = star_array[i];
star_mc.cacheAsBitmap = !star_mc.cacheAsBitmap;
}
}
Mouse.addListener(ouvinteMouse);
10. Selecione
11.
Control (Controlar) > Test Movie (Testar filme) para testar o documento.
Clique em qualquer local no Stage para ativar o armazenamento de bitmap em cache.
Você perceberá que a animação deixará de ser animada à taxa de 1 quadro por segundo e
passará a uma animação suave em que as instâncias serão animadas nos dois sentidos de
forma alternada no Stage. Quando você clica no Stage, a definição de cacheAsBitmap é
alternada entre true e false.
Se você alternar entre a ativação e a desativação do armazenamento em cache, como
demonstrado no exemplo anterior, os dados armazenados em cache serão liberados. Também é
possível aplicar esse código para uma instância de botão. Consulte %{cacheAsBitmap
(Button.cacheAsBitmap property)}% em ActionScript 2.0 Language Reference. (Referência
da linguagem ActionScript 2.0)
Para obter exemplos de rolagem de clipes de filme, consulte %{scrollRect
(MovieClip.scrollRect property)}% em ActionScript 2.0 Language Reference. Para obter
informações sobre máscaras de canais alfa, que exigem a definição da propriedade
■
■
395
■
■
Definindo o plano de fundo de um clipe de filme
É possível definir um plano de fundo opaco para um clipe de filme. Por exemplo, quando
tiver um plano de fundo com arte vetorial complexa, você poderá definir a propriedade
opaqueBackground como uma cor específica, em geral, a mesma cor do Stage (Palco). O
plano de fundo é então tratado como um bitmap, que ajuda a otimizar o desempenho.
Quando você define cacheAsBitmap como true e define a propriedade opaqueBackground
como uma cor especificada, essa propriedade permite tornar o bitmap interno opaco e
renderizá-lo com mais rapidez. Quando você não define cacheAsBitmap como true, a
propriedade opaqueBackground adiciona uma forma quadrada vetorial opaca ao plano de
fundo da instância do clipe de filme. Ela não cria um bitmap automaticamente.
O exemplo a seguir mostra como definir o plano de fundo de um clipe de filme para otimizar
o desempenho.
Para definir o plano de fundo de um clipe de filme:
1.
Crie um novo documento do Flash chamado background.fla.
2.
Desenhe um círculo azul no Stage (Palco).
3.
Selecione o círculo azul e, em seguida, Modify (Modificar) > Convert to Symbol
4.
5.
Selecione a instância no Stage e digite my_mc na caixa de texto Instance Name (Nome da
instância) no inspetor Properties (Propriedades).
6.
Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) e digite o seguinte código
/* When you set cacheAsBitmap, the internal bitmap is opaque and renders
faster. */
my_mc.cacheAsBitmap = true;
my_mc.opaqueBackground = 0xFF0000;
396
7.
O clipe de filme aparece no Stage com a cor de fundo especificada.
Para obter mais informações sobre essa propriedade, consulte %{opaqueBackground
(MovieClip.opaqueBackground property)}% em ActionScript 2.0 Language Reference
(Referência da linguagem ActionScript 2.0).
Usando clipes de filme como máscaras
É possível usar um clipe de filme como máscara para criar um furo pelo qual o conteúdo de
outro clipe de filme fica visível. O clipe de filme da máscara reproduz todos os quadros na sua
Timeline (Linha de tempo) como em um clipe de filme comum. Você pode tornar o clipe de
filme da máscara arrastável, animá-lo ao longo de uma guia de movimento, usar formas
separadas dentro de uma única máscara ou redimensionar uma máscara dinamicamente.
Também pode usar o ActionScript para ativar ou desativar uma máscara.
Não é possível usar uma máscara para mascarar outra máscara. Também não é possível definir
a propriedade _alpha de um clipe de filme de máscara. Somente preenchimentos são usados
em um clipe de filme de máscara. Os traços são ignorados.
Para criar uma máscara:
1.
Crie um quadrado no Stage (Palco) com a ferramenta Rectangle (Retângulo).
2.
Selecione o quadrado e pressione F8 para convertê-lo em um clipe de filme.
Essa instância é a sua máscara.
3.
No inspetor Properties (Propriedades), digite mask_mc na caixa de texto Instance Name
(Nome da instância).
O clipe de filme mascarado é revelado em todas as áreas opacas (não transparentes) do
clipe de filme que está funcionando como a máscara.
4.
Selecione Frame 1 (Quadro 1) na Timeline (Linha de tempo).
5.
Abra o painel Actions (Ações), em Window (Janela) > Actions, se ele ainda não estiver
aberto.
6.
No painel Actions, insira o seguinte código:
target_mc.setMask(mask_mc);
}
Usando clipes de filme como máscaras
397
my_mcl.addListener(mclListener);
img_mc);
7.
Uma imagem JPEG externa é carregada no arquivo SWF durante a execução e mascarada
pela forma desenhada anteriormente no Stage.
Para obter informações detalhadas, consulte %{setMask (MovieClip.setMask method)}%
em ActionScript 2.0 Language Reference (Referência da linguagem ActionScript 2.0).
Sobre a máscara de fontes de dispositivo
Você pode usar um clipe de filme para mascarar o texto que é definido em uma fonte de
dispositivo. Para que a máscara do clipe de filme de uma fonte de dispositivo funcione
adequadamente, o usuário deve ter o Flash Player 6 (6.0.40.0) ou versão posterior.
Quando você usa um clipe de filme para mascarar texto definido em uma fonte de dispositivo,
a caixa de delimitação retangular da máscara é usada como a forma de mascaramento. Ou seja,
se você criar uma máscara de clipe de filme não-retangular para o texto da fonte de dispositivo
no ambiente de criação do Flash, a máscara exibida no arquivo SWF terá a forma da caixa de
delimitação retangular da máscara, e não a forma da própria máscara.
As fontes de dispositivo podem ser mascaradas somente usando um clipe de filme como
máscara. Não é possível mascarar fontes de dispositivo usando uma camada de máscara no
Stage (Palco).
Sobre máscaras de canal alfa
Há suporte para máscaras de canal alfa quando o clipe de filme de máscara e o clipe de filme
mascarado usam o armazenamento de bitmap em cache. Esse suporte também permite usar
um filtro no clipe de filme de máscara independentemente do filtro aplicado ao clipe de filme
mascarado.
Para ver um exemplo de máscara alfa, faça o download do arquivo de exemplo de máscara alfa
em www.macromedia.com/go/flash_samples.
Nesse arquivo de exemplo, a máscara é oval (oval_mask) com alfa de 50% e filtro de
embaçamento aplicado a ela. O clipe de filme mascarado (flower_maskee) tem alfa de 100%
e nenhum filtro foi aplicado a ele. O armazenamento de bitmap em cache no tempo de
execução foi aplicado aos dois clipes de filme no inspetor Properties (Propriedades).
No painel Actions (Ações), o seguinte código é inserido no Frame 1 (Quadro 1) da Timeline
(Linha de tempo):
flower_maskee.setMask(oval_mask);
398
Quando você testa o documento, em Control (Controlar) > Test Movie (Testar filme), é feita
a mistura de alfa no clipe mascarado por meio da máscara.
NO T A
As camadas de máscara não suportam as máscaras de canal alfa. Use o código
ActionScript para aplicar uma máscara e o armazenamento de bitmap em cache durante
a execução.
Manipulando eventos de clipes de filme
Os clipes de filme podem responder aos eventos do usuário, como cliques do mouse e
pressionamentos de teclas, bem como aos eventos no nível do sistema, como o carregamento
inicial de um clipe de filme no Stage. O ActionScript fornece duas maneiras de manipular
eventos do clipe de filme: através de métodos manipuladores de eventos e dos manipuladores
de eventos onClipEvent() e on(). Para obter mais informações sobre a manipulação de
eventos de clipes de filme, consulte Capítulo 10, “Manipulando eventos.”.
Atribuindo uma classe a um símbolo de
clipe de filme
Com o ActionScript 2.0, é possível criar uma classe que estenda o comportamento da classe
MovieClip interna e usar caixa de diálogo Linkage Properties (Propriedades de vinculação)
para atribuir essa classe a um símbolo da biblioteca de clipes de filme. Sempre que você criar
uma instância do clipe de filme à qual a classe é atribuída, ela assumirá as propriedades e
comportamentos definidos pela classe atribuída a ela. (Para obter mais informações sobre o
ActionScript 2.0, consulte “Exemplo: Criando classes personalizadas” na página 278.)
Em uma subclasse da classe MovieClip, você pode fornecer definições para os métodos
MovieClip internos e manipuladores de eventos, como onEnterFrame e onRelease. No
procedimento a seguir, você criará uma classe MoveRight que prolonga a classe MovieClip; a
MoveRight define um manipulador onPress que move os 20 pixels do clipe para a direita
sempre que o usuário clica no clipe de filme. No segundo procedimento, você criará um
símbolo de clipe de filme em um novo documento Flash (FLA) e atribuirá a classe MoveRight
a esse símbolo.
Para criar uma subclasse de clipe de filme:
1.
Crie um novo diretório chamado BallTest.
2.
Selecione File (Arquivo) > New (Novo) e, em seguida, ActionScript file (Arquivo do
ActionScript) na lista de tipos de documentos para criar um novo arquivo do ActionScript.
Atribuindo uma classe a um símbolo de clipe de filme
399
3.
Insira o seguinte código no arquivo de script:
// classe MoveRight -- move o clipe para a direita 20 pixels quando ele é
clicado
class MoveRight extends MovieClip {
public function onPress() {
this._x += 20;
}
}
4.
Salve o documento como MoveRight.as no diretório BallTest.
Para atribuir a classe a um símbolo de clipe de filme:
1.
No Flash, selecione File > New, selecione Flash Document (Documento do Flash) na lista
de tipos de arquivo e clique em OK.
2.
Usando a ferramenta Oval, desenhe um círculo no Stage.
3.
Selecione o círculo e, em seguida, Modify (Modificar) > Convert to Symbol (Converter em
símbolo).
4.
Na caixa de diálogo Convert to Symbol, selecione Movie Clip (Clipe de filme) como o
comportamento do símbolo e digite ball_mc na caixa de texto Name (Nome).
5.
Selecione Advanced (Avançado) para mostrar as opções de vinculação, se elas ainda não
estiverem exibidas.
6.
Selecione a opção Export for ActionScript (Exportar para ActionScript) e digite MoveRight
na caixa de texto Class (Classe). Clique em OK.
7.
Salve o arquivo como ball.fla no diretório BallTest (o mesmo diretório que contém o
arquivo MoveRight.as).
8.
Teste o documento do Flash em Control (Controlar) > Test Movie (Testar filme).
Sempre que você clicar no clipe de filme ball, ele se moverá 20 pixels para a direita.
Se você criar propriedades de componente para uma classe e desejar que um clipe de filme
herde essas propriedades, siga esta etapa adicional: com o símbolo do clipe de filme
selecionado no painel Library (Biblioteca), selecione Component Definition (Definição de
componente) no menu de pop-up Library e insira o nome da nova classe na caixa Class
(Classe).
400
Inicializando as propriedades de classe
No exemplo apresentado no segundo procedimento em “Atribuindo uma classe a um símbolo
de clipe de filme”, você adicionou a instância do símbolo Ball ao Stage (Palco) durante a
criação. Como abordado em “Adicionando parâmetros aos clipes de filme criados
dinamicamente” na página 383, é possível atribuir parâmetros aos clipes criados durante a
execução usando o parâmetro initObject de attachMovie() e duplicateMovie(). Você
pode usar esse recurso para inicializar as propriedades de classe que está atribuindo a um clipe
de filme.
Por exemplo, a classe MoveRightDistance a seguir é uma variação da classe MoveRight
(consulte “Atribuindo uma classe a um símbolo de clipe de filme” na página 399). A diferença
é uma nova propriedade chamada distance, cujo valor determina quantos pixels um clipe de
filme se move quando é clicado.
Para passar argumentos para uma classe personalizada:
1.
Crie um novo documento do ActionScript e salve-o como MoveRightDistance.as.
2.
Digite o seguinte ActionScript na janela Script:
// Classe MoveRightDistance -- move o clipe para a direita 5 pixels a
cada quadro.
class MoveRightDistance extends MovieClip {
// A propriedade distance determina quantos
// pixels o clipe deve se mover a cada clique no botão do mouse.
var distance:Number;
function onPress() {
this._x += this.distance;
}
}
3.
Salve as alterações.
4.
Crie um novo documento do Flash e salve-o como MoveRightDistance.fla no mesmo
diretório como o arquivo de classes.
5.
Crie um símbolo de clipe de filme com uma forma vetorial, como oval, e exclua o conteúdo
do Stage (Palco).
Basta um símbolo de clipe de filme da biblioteca para este exemplo.
6.
No painel Library (Biblioteca), clique com o botão direito do mouse (Windows), ou
mantenha pressionada a tecla Control e clique (Macintosh), no símbolo e selecione Linkage
(Vinculação) no menu de contexto.
Inicializando as propriedades de classe
401
7.
Atribua o identificador de vinculação Ball ao símbolo.
8.
Digite MoveRightDistance na caixa de texto AS 2.0 Class (Classe AS 2.0).
9.
this.attachMovie("Ball", "ball50_mc", 10, {distance:50});
this.attachMovie("Ball", "ball125_mc", 20, {distance:125});
Esse código cria duas novas instâncias do símbolo na Timeline raiz do arquivo SWF. A
primeira instância, ball50_mc, é movida 50 pixels sempre que é clicada; a segunda,
ball125_mc, é movida 125 pixels sempre que é clicada.
10. Selecione
402
Control (Controlar) > Test Movie (Testar filme) para testar o arquivo SWF.
CAPÍTULO 12
12
Trabalhando com texto e
seqüências de caracteres
Vários dos aplicativos, apresentações e gráficos criados por você com o Macromedia Flash
Professional 8 ou o Macromedia Flash Basic 8 contêm algum tipo de texto. É possível utilizar
vários tipos de texto. Você pode usar texto estático em seus layouts, porém texto dinâmico
para textos mais longos. Também pode usar texto de entrada para capturar a entrada do
usuário e adicionar texto a uma imagem de fundo. Para criar campos de texto, use a
ferramenta de criação do Flash ou o ActionScript.
Um modo de exibir texto é usar código para manipular como as seqüências de caracteres
aparecerão antes de serem carregadas e exibidas no Stage (Palco) durante a execução. É possível
trabalhar de várias maneiras com seqüências de caracteres em um aplicativo; por exemplo,
você pode enviá-las para um servidor e recuperar uma resposta, pode analisar seqüências de
caracteres em um array ou validar as seqüências de caracteres que o usuário digita em um
campo de texto.
Este capítulo descreve várias maneiras de usar texto e seqüências de caracteres em aplicativos,
com ênfase no uso de código para manipular o texto.
A lista a seguir descreve a terminologia usada neste capítulo.
O texto com serrilhado não utiliza variações de cor para suavizar as bordas
dentadas, ao contrário do texto sem serrilhado (consulte também Sem serrilhado).
Serrilhado
Sem serrilhado Use a eliminação de serrilhado para suavizar o texto, a fim de que as bordas
dos caracteres exibidos na tela pareçam menos dentadas. A opção Anti-Aliasing (Eliminação
de serrilhado) torna o texto mais legível alinhando os contornos do texto nas fronteiras dos
pixels e é especialmente eficiente para renderizar fontes menores com mais nitidez.
Os caracteres são letras, numerais e pontuação combinados para formar
seqüências de caracteres.
Caracteres
403
Fontes de dispositivo
As fontes de dispositivo são fontes especiais no Flash que não são
incorporadas a um arquivo SWF. Em vez disso, o Flash Player usa a fonte disponível no
computador local mais semelhante à fonte de dispositivo. Como os contornos de fontes não
são incorporados, o tamanho de um arquivo SWF é menor do que quando são usados
contornos de fontes incorporadas. Entretanto, como as fontes de dispositivo não são
incorporadas, o texto criado com elas parece diferente do esperado em sistemas de
computadores que não possuem uma fonte instalada correspondente à fonte do dispositivo. O
Flash contém três fontes de dispositivo: _sans (semelhante à Helvetica ou Arial), _serif
(semelhante à Times Roman) e _typewriter (semelhante à Courier).
Fontes
String
Conjuntos de caracteres com tipo de fonte, estilo e tamanho semelhantes.
Uma seqüência de caracteres.
Texto
Uma ou mais seqüências de caracteres que podem ser exibidas em um campo de
texto ou dentro de um componente de interface de usuário.
Um elemento visual no Stage (Palco) que permite exibir texto para um
usuário. Semelhante a um campo de texto de entrada ou controle de formulário da área de
texto em HTML, o Flash permite definir campos de texto como editáveis (somente leitura),
formatar como HTML, ativar suporte com várias linhas, mascarar senhas ou aplicar uma folha
de estilos CSS ao texto em formato HTML.
Campos de texto
É possível aplicar formatação a um campo de texto ou a
determinados caracteres dentro de um campo de texto. Alguns exemplos de opções de
formatação de texto que podem ser aplicadas ao texto são: alinhamento, recuos, negrito, cor,
tamanho de fonte, larguras de margens, itálicos e espaçamento entre letras.
Formatação de texto
Para obter mais informações sobre texto, consulte os seguintes tópicos:
Sobre campos de texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
Usando a classe TextField . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
Sobre o carregamento de texto e variáveis em campos de texto . . . . . . . . . . . . . . 415
Usando fontes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
Sobre a renderização de fontes e texto sem serrilhado. . . . . . . . . . . . . . . . . . . . . . 430
Sobre o layout e a formatação de texto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439
Formatando texto com estilos CSS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .447
Criando um objeto de folha de estilos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449
Usando texto em formato HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
Exemplo: Criando texto de rolagem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .475
404
Trabalhando com texto e seqüências de caracteres
Sobre campos de texto
Um campo de texto dinâmico ou de entrada é um objeto TextField (uma instância da classe
TextField). Ao criar um campo de texto no ambiente de criação, você pode atribuir a ele um
nome de instância no inspetor Properties (Propriedades). É possível usar o nome de instância
em instruções do ActionScript para definir, alterar e formatar o campo de texto e seu conteúdo
usando as classes TextField e TextFormat.
É possível utilizar a interface de usuário para criar vários tipos de campos de texto; outra opção
é utilizar o ActionScript para criar campos de texto. Os seguintes tipos de campos de texto
podem ser criados no Flash:
Texto estático
Use texto estático para exibir caracteres que não precisam ser alterados,
pequenas quantidades de texto ou, ainda, fontes especiais não disponíveis na maioria dos
computadores. Também é possível exibir fontes não convencionais com a incorporação de
caracteres para campos de texto dinâmico.
Use campos de texto dinâmico quando precisar exibir caracteres que são
atualizados ou alterados durante a execução. Além disso, você pode carregar texto em campos
de texto dinâmico.
Texto dinâmico
Texto de entrada
Use campos de texto de entrada quando precisar capturar a entrada do
usuário. Os usuários podem digitar texto nesses campos.
Use os componentes TextArea ou TextInput para exibir ou
capturar texto em seus aplicativos. O componente TextArea é semelhante a um campo de
texto dinâmico com barras de rolagem internas. O componente TextInput é semelhante a um
campo de texto de entrada. Ambos os componentes têm maior funcionalidade do que os
campos de texto equivalentes; entretanto, eles tornam o tamanho dos arquivos maior para o
aplicativo.
Componentes de texto
NO T A
Todos os campos de texto oferecem suporte para Unicode. Para obter informações
sobre Unicode, consulte “Sobre seqüências de caracteres e a classe String”
na página 477.
Os métodos da classe TextField permitem definir, selecionar e manipular o texto de um campo
de texto dinâmico ou de entrada gerado durante a criação ou execução. Para obter mais
informações, consulte “Usando a classe TextField” na página 406. Para obter informações
sobre depuração de campos de texto durante a execução, consulte “Sobre como exibir as
propriedades do campo de texto para depuração” na página 763.
405
O ActionScript também oferece várias maneiras de formatar o texto durante a execução. A
classe TextFormat permite definir a formatação de caractere e parágrafo dos objetos TextField
(consulte “Usando a classe TextFormat” na página 444). O Flash Player também oferece
suporte a um subconjunto de marcas HTML que você pode usar para formatar o texto
(consulte “Usando texto em formato HTML” na página 461). O Flash Player 7 e versões
posteriores oferecem suporte à marca HTML img, que permite incorporar não apenas
imagens externas, mas também arquivos SWF externos e clipes de filme que residam na
biblioteca (consulte “Marca de imagem” na página 465).
No Flash Player 7 e versões posteriores, você pode aplicar os estilos CSS (Cascading
StyleSheet, Folha de estilos em cascata) aos campos de texto usando a classe
TextField.StyleSheet. Você pode usar estilos CSS para atribuir estilo às marcas HTML
internas, definir novas marcas de formatação ou aplicar estilos. Para obter mais informações
sobre o uso de estilos CSS, consulte “Formatando texto com estilos CSS” na página 447.
Também é possível atribuir um texto em formato HTML, que pode usar estilos CSS,
diretamente a um campo de texto. No Flash Player 7 e versões posteriores, o texto HTML que
você atribui a um campo de texto pode conter mídia incorporada (clipes de filme, arquivos
SWF e arquivos JPEG). No Flash Player 8, você também pode carregar dinamicamente
imagens PNG, GIF e JPEG progressivas (o Flash Player 7 não oferece suporte a imagens JPEG
progressivas). O texto é envolvido em torno da mídia incorporada de maneira semelhante a
um navegador da Web que envolve o texto em torno da mídia incorporada a um documento
HTML. Para obter mais informações, consulte “Marca de imagem” na página 465.
Para obter informações sobre a terminologia que compara texto, seqüências de caracteres e
muito mais, consulte a introdução deste capítulo “Trabalhando com texto e seqüências de
caracteres” na página 403.
Usando a classe TextField
A classe TextField representa qualquer campo de texto dinâmico ou de entrada (editável)
criado com a ferramenta Text (Texto) no Flash. Use os métodos e as propriedades dessa classe
para controlar os campos de texto durante a execução. Os objetos TextField oferecem suporte
às mesmas propriedades que os objetos MovieClip, com exceção das propriedades
_currentframe, _droptarget, _framesloaded e _totalframes. Você pode obter e definir
as propriedades, e chamar os métodos dos campos de texto dinamicamente.
Para utilizar o ActionScript para controlar um campo de texto dinâmico ou de entrada,
atribua a campo de texto um nome de instância no inspetor Properties (Propriedades). Em
seguida, você pode fazer referência ao campo de texto com o nome da instância, e usar os
métodos e propriedades da classe TextField para controlar o conteúdo ou a aparência básica do
campo de texto.
406
Pode também criar objetos TextField durante a execução e atribuir a eles nomes de instâncias,
usando o método MovieClip.createTextField(). Para obter mais informações, consulte
“Criando campos de texto durante a execução” na página 410.
Para obter mais informações sobre o uso da classe TextField, consulte os seguintes tópicos:
■
“Atribuindo texto a um campo de texto durante a execução” na página 407
■
“Sobre a instância do campo de texto e os nomes de variáveis” na página 409
É possível localizar arquivos de origem de exemplo para demonstrar como trabalhar com
campos de texto usando o ActionScript. Os arquivos de origem são chamados textfieldsA.fla e
textfieldsB.fla e encontram-se na pasta Samples, no seu disco rígido.
■
8\Samples and Tutorials\Samples\ActionScript\TextFields.
■
and Tutorials/Samples/ActionScript/TextFields.
Atribuindo texto a um campo de texto durante a
execução
Ao criar aplicativos com o Flash, talvez você queira carregar o texto de uma origem externa,
como um arquivo de texto, um arquivo XML ou até mesmo um serviço remoto da Web. O
Flash possibilita um grande controle sobre o modo de criação e exibição de texto no Stage
(Placo), como suporte a texto em formato HTML, texto simples, texto em formato XML e
folhas de estilo externas. Você também pode usar o ActionScript para definir uma folha de
estilo.
Para atribuir texto a um campo de texto, é possível usar a propriedade TextField.text ou
TextField.htmlText. Ou, se você digitar um valor no campo de texto da variável no
inspetor Property (Propriedades), poderá atribuir um valor ao campo de texto criando uma
variável com o nome especificado. Caso utilize a versão 2 da Arquitetura de Componentes
Macromedia no documento do Flash, também será possível atribuir valores criando
vinculações entre os componentes.
O exercício a seguir atribui texto a um campo de texto durante a execução.
Para atribuir texto a um campo de texto durante a execução:
1.
Com a ferramenta Text (Texto), crie um campo de texto no Stage (Palco).
2.
Com o campo de texto selecionado, no inspetor Properties (Propriedades) (Window
[Janela] > Properties > Properties), selecione Input Text (Texto de entrada) no menu popup Text Type (Tipo de texto) e digite headline_txt na caixa de texto Instance Name (Nome
da instância).
407
Os nomes de instâncias devem conter apenas letras, números, sublinhados (_) e cifrões ($).
3.
Selecione Frame 1 (Quadro 1) da Timeline (Linha de tempo) e abra o painel Actions
(Ações) (Window > Actions).
4.
Insira o seguinte código no painel Actions:
headline_txt.text = "New articles available on Developer Center";
5.
Flash.
Você também pode criar um campo de texto com o ActionScript e atribuir texto a ele. Digite
o seguinte ActionScript no Frame 1 (Quadro 1) da Timeline (Linha de tempo):
this.createTextField("headline_txt", this.getNextHighestDepth(), 100, 100,
300, 20);
headline_txt.text = "New articles available on Developer Center";
Esse código cria um novo campo de texto com o nome de instância headline_txt. O campo
de texto é criado na próxima profundidade mais alta, nas coordenadas x e y de 100, 100, com
largura de 200 pixels e altura de 20 pixels. Ao testar o arquivo SWF (Control > Test Movie),
você verá o texto “New articles available on Developer Center” (Novos artigos
disponíveis no Centro de Desenvolvedores) no Stage.
Para criar um campo de texto em formato HTML:
Utilize uma das duas etapas a seguir para ativar a formatação HTML para o campo de texto:
■
Selecione um campo de texto e clique em Render Text as HTML (Renderizar texto como
HTML) no inspetor Property.
■
Defina a propriedade html do campo de texto como true usando o ActionScript
(consulte o código de exemplo a seguir).
Para aplicar formatação HTML a um campo de texto usando o ActionScript, digite o seguinte
código ActionScript no Frame 1 (Quadro 1) da Timeline (Linha de tempo):
this.createTextField("headline_txt", this.getNextHighestDepth(), 100, 100,
300, 20);
headline_txt.html = true;
headline_txt.htmlText = "New articles available on Developer Center.";
408
O código anterior cria, de forma dinâmica, um novo campo de texto, ativa a formatação
HTML e exibe o texto “New articles available on Developer Center” (Novos artigos
disponíveis no Centro de Desenvolvedores) no Stage, exibindo o termo “Developer Center”
em itálico.
A T E NÇ Ã O
Ao usar texto em formato HTML com um campo de texto (e não com componentes) no
Stage, é preciso atribuir o texto à propriedade htmlText do campo de texto, em vez da
propriedade de texto.
Você pode localizar arquivos de origem de exemplo que demonstrem como trabalhar com
arquivos de texto usando o ActionScript. Os arquivos de origem são chamados textfieldsA.fla
e textfieldsB.fla e encontram-se na pasta Samples, no seu disco rígido.
■
■
Sobre a instância do campo de texto e os nomes de
variáveis
Na caixa de texto Instance Name (Nome da instância) do inspetor Properties (Propriedades),
você deve atribuir um nome de instância a um campo de texto para chamar métodos, bem
como para obter e definir propriedades nesse campo.
Na caixa de texto Var do inspetor Properties, você pode atribuir um nome de variável a um
campo de texto dinâmico ou de entrada e, em seguida, atribuir valores à variável. Esta é uma
funcionalidade obsoleta que pode ser usada durante a criação de aplicativos para versões mais
antigas do Flash Player (como o Flash Player 4). Para versões mais recentes do Flash Player,
defina o texto de um campo de texto usando o nome de instância correspondente e o
ActionScript.
Entretanto, não confunda o nome de instância de um campo de texto com seu nome de
variável. Um nome de variável de um campo de texto é uma referência variável ao texto
contido nesse campo, e não uma referência a um objeto.
Por exemplo, se você tiver atribuído a um campo de texto o nome de variável myTextVar,
poderá usar o código a seguir para definir o conteúdo do campo de texto.
var myTextVar:String = "This is what will appear in the text field";
Entretanto, você não poderá usar o nome de variável myTextVar para definir a propriedade
text do campo de texto. Você deve usar o nome de instância, como mostra o seguinte código:
409
// Este exemplo não funcionará.
myTextVar.text = "A text field variable is not an object reference";
// Para um campo de texto de entrada com o nome de instância "myField", isso
funcionará.
myField.text = "This sets the text property of the myField object";
Use a propriedade TextField.text para controlar o conteúdo de um campo de texto, a
menos que pretenda usar uma versão do Flash Player que não ofereça suporte à classe
TextField. Isso diminui as chances de um conflito de nome de variável, o qual poderá resultar
em um comportamento inesperado durante a execução.
■
■
Criando campos de texto durante a execução
Você pode usar o método createTextField() da classe MovieClip para criar um campo de
texto vazio no Stage durante a execução. O novo campo de texto é anexado à linha de tempo
do clipe de filme que chama o método.
Para criar dinamicamente um campo de texto com o ActionScript:
1.
Selecione File (Arquivo) > New (Novo) e depois selecione Flash Document (Documento
do Flash) para criar um arquivo FLA.
2.
this.createTextField("test_txt", 10, 0, 0, 300, 100);
Esse código cria um campo de texto de 300 x 100 pixels, chamado test_txt, com o local
(0, 0) e a profundidade (ordem z) 10.
3.
Para acessar os métodos e as propriedades do campo de texto recém-criado, use o nome de
instância especificado no primeiro parâmetro do método createTextField().
Por exemplo, o código a seguir cria um novo campo de texto, test_txt, e modifica suas
propriedades para torná-lo um campo de texto com quebra automática e várias linhas, que
se expande para acomodar o texto inserido. Depois, ele atribui um texto usando a
propriedade text do campo.
test_txt.multiline = true;
test_txt.wordWrap = true;
410
test_txt.autoSize = "left";
test_txt.text = "Create new text fields with the
MovieClip.createTextField() method.";
4.
Selecione Control (Controlar) > Test Movie (Testar filme) para ver o campo de texto.
O texto é criado durante a execução e aparece no Stage (Palco).
Você pode usar o método TextField.removeTextField() para remover um campo de texto
criado com createTextField(). O método removeTextField() não funciona em um
campo de texto colocado pela linha de tempo durante a criação.
Para obter mais informações, consulte %{createTextField (MovieClip.createTextField
method)}% e %{removeTextField (TextField.removeTextField method)}% em ActionScript
N OT A
Algumas propriedades de TextField, como _rotation, não estão disponíveis para a
criação de campos de texto durante a execução. Só é possível girar um campo de texto
se ele utilizar fontes incorporadas. Consulte “Para incorporar um símbolo de fonte:”
na página 423.
■
■
Sobre a manipulação de campos de texto
É possível manipular campos de texto de várias maneiras ao criar um arquivo FLA. Você
poderá manipular um campo de texto desde que atribua um nome de instância no inspetor
Properties (Propriedades) ou com código se usar código para criar o campo. O exemplo
simples apresentado a seguir cria um campo de texto, atribui texto a ele e altera a propriedade
border do campo:
this.createTextField("pigeon_txt", this.getNextHighestDepth(), 100, 100,
200, 20);
pigeon_txt.text = "I like seeds";
pigeon_txt.border = true;
Para obter uma lista completa das propriedades da classe TextField, consulte o ActionScript 2.0
Language Reference.
411
Para ver exemplos de manipulação de campos de texto, consulte as seguintes seções:
■
“Alterando a posição de um campo de texto” na página 412
■
“Alterando as dimensões de um campo de texto durante a execução” na página 413
■
■
Alterando a posição de um campo de texto
É possível alterar a posição de um campo de texto no Stage (Palco) durante a execução. É
necessário definir novos valores para as propriedades _x e _y do campo de texto, como mostra
o seguinte exemplo.
Para reposicionar um campo de texto usando o ActionScript:
1.
Crie um novo arquivo FLA e salve-o como positionText.fla.
2.
my_txt.text = "Hello world";
my_txt._x = (Stage.width - my_txt._width) / 2;
my_txt._y = (Stage.height - my_txt._height) / 2;
3.
para ver o campo de texto centralizado no Stage.
■
■
412
Alterando as dimensões de um campo de texto durante a
execução
Você poderá precisar obter ou definir as dimensões de um campo de texto dinamicamente
durante a execução, em vez de no ambiente de criação. O próximo exemplo cria um campo de
texto na linha de tempo principal e define suas dimensões iniciais como 100 pixels de largura
por 21 pixels de altura. Posteriormente, o campo de texto é redimensionado para 300 pixels de
largura por 200 pixels de altura e é reposicionado no centro do Stage (Palco).
Para redimensionar um campo de texto com o ActionScript:
1.
Crie um novo documento do Flash e salve-o como resizeText.fla.
2.
my_txt.multiline = true;
my_txt.text = "Hello world";
my_txt.wordWrap = true;
my_txt._width = 300;
my_txt._height = 200;
my_txt._x = (Stage.width - my_txt._width) / 2;
my_txt._y = (Stage.height - my_txt._height) / 2;
3.
para ver os resultados no ambiente de criação.
O exemplo anterior redimensionou um campo de texto criado dinamicamente para 300 pixels
por 200 pixels durante a execução; porém, quando você carrega conteúdo de um site externo e
não sabe exatamente qual o volume de conteúdo que será retornado, essa técnica poderá não
ser adequada às suas necessidades. O Flash inclui a propriedade TextField.autoSize(), que
permite redimensionar automaticamente um campo de texto para acomodar o seu conteúdo.
O exemplo a seguir demonstra como usar a propriedade TextField.autoSize() para
redimensionar o campo de texto após seu preenchimento com texto.
Para redimensionar automaticamente campos de texto com base no
conteúdo:
1.
Crie um novo documento do Flash e salve-o como resizeTextAuto.fla.
2.
principal:
my_txt.autoSize = "left";
413
my_txt.text = "Lorem ipsum dolor sit amet, consectetur adipisicing elit,
sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut
enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi
ut aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla
pariatur. Excepteur sint occaecat cupidatat non proident, sunt in
culpa qui officia deserunt mollit anim id est laborum.";
N OT A
3.
Se você colar esse código diretamente no painel Actions (Ações) de algumas
versões da Ajuda do Flash, é possível que encontre quebras de linha na seqüência
de caracteres de texto longa. Nesse caso, o código não será compilado. Caso
encontre essa situação, ative Hidden Characters (Caracteres ocultos) no menu popup do painel Actions e depois remova os caracteres de quebra de linha na seqüência
de caracteres de texto longa.
para exibir o documento do Flash no ambiente de criação.
O Flash redimensionará o campo de texto verticalmente para que todo o conteúdo possa
ser exibido sem ser cortado pelos limites do campo. Se você definir a propriedade
my_txt.wordWrap como false, o campo será redimensionado horizontalmente para
acomodar o texto.
Para impor uma altura máxima no campo de texto dimensionado automaticamente, a fim
de que a sua altura não exceda os limites do Stage (Palco), use o código a seguir.
if (my_txt._height > 160) {
my_txt.autoSize = "none";
my_txt._height = 160;
}
Adicione alguma funcionalidade de rolagem, como uma barra de rolagem, a fim de permitir
que os usuários visualizem o restante do texto. Uma alternativa é mover o ponteiro do mouse
sobre o texto; geralmente, esse método é adequado ao testar esse código.
■
■
414
Sobre o carregamento de texto e
variáveis em campos de texto
Você pode carregar texto em um documento do Flash de várias maneiras, incluindo (mas
certamente não limitado a) FlashVars, LoadVars, XML ou serviços da Web. Talvez o método
mais simples de passar texto para um documento do Flash seja usar a propriedade FlashVars,
que passa seqüências de texto curtas para um documento do Flash por meio das marcas
object e embed contidas no código HTML usado para incorporar o SWF a uma página
HTML. Uma outra maneira fácil de carregar texto ou variáveis em um documento do Flash é
usar a classe LoadVars, que pode carregar grandes blocos de texto ou uma série de variáveis
codificadas em URL a partir de um arquivo de texto.
Com base nos exemplos anteriores desta seção, você pode observar que algumas formas de
carregar texto em um arquivo SWF são mais simples do que outras. Entretanto, se você
publicar dados de sites externos, é possível que não haja uma opção para o formato dos dados
que precisam ser carregados.
Cada método de carregamento e/ou envio de dados para/de um arquivo SWF oferece
vantagens e desvantagens. As opções XML, serviços da Web e Flash Remoting são as mais
versáteis para carregar dados externos, mas também são as mais difíceis de se aprender. Para
obter informações sobre o Flash Remoting, consulte www.macromedia.com/support/
flashremoting.
As opções FlashVars e LoadVars são bem mais simples, como demonstrado em “Usando
FlashVars para carregar e exibir texto” na página 416 e “Usando LoadVars para carregar e
exibir texto” na página 417, mas podem ser muito mais limitadas em termos dos tipos e dos
formatos de dados que podem ser carregados. Além disso, é preciso seguir restrições de
segurança ao enviar e carregar dados. Para obter informações sobre segurança, consulte o
Capítulo 17, “Noções básicas de segurança.” Para obter mais informações o carregamento de
dados externos, consulte o Capítulo 16, “Trabalhando com dados externos.”
As seguintes seções mostram diversas maneiras de carregar texto e variáveis em documentos:
■
“Usando FlashVars para carregar e exibir texto” na página 416
■
“Usando LoadVars para carregar e exibir texto” na página 417
■
“Carregando variáveis ao usar LoadVars” na página 418
■
“Carregando e exibindo texto de um documento XML” na página 419
arquivos de texto usando o ActionScript. Os arquivos de origem são chamados loadText.fla e
formattedText.fla e encontram-se na pasta Samples, no seu disco rígido.
Sobre o carregamento de texto e variáveis em campos de texto
415
■
8\Samples and Tutorials\Samples\ActionScript\LoadText.
■
and Tutorials/Samples/ActionScript/LoadText.
Também é possível localizar um arquivo de origem que carrega texto e aplica formatação sem
serrilhado, além de cache de bitmap. O arquivo de origem de exemplo chamado flashtype.fla e
encontra-se na pasta Samples do disco rígido:
■
8\Samples and Tutorials\Samples\ActionScript\FlashType.
■
and Tutorials/Samples/ActionScript/FlashType.
Usando FlashVars para carregar e exibir texto
Embora o uso de FlashVars seja simples, você precisará publicar seus arquivos SWF junto com
documentos HTML. Você modifica o código gerado em HTML e inclui as propriedades
FlashVars nas marcas object e embed. É possível testar o documento do Flash visualizando o
documento HTML modificado no navegador da Web.
Para usar FlashVars a fim de passar variáveis do documento HTML para o
documento do Flash:
1.
Crie um novo documento do Flash e salve-o como flashvars.fla.
2.
my_txt.text = _level0.username;
3.
Salve o documento do Flash e selecione File (Arquivo) > Publish (Publicar) para gerar os
arquivos HTML e SWF.
N OT A
Os documentos HTML são publicados, por padrão, no mesmo diretório que os
arquivos FLA. Se um documento HTML não for publicado, selecione File > Publish
Settings (Configurações de publicação) e depois selecione a guia Formats
(Formatos). Certifique-se de selecionar HTML.
4.
Abra o documento flashvars.html em um editor HTML ou de texto.
5.
No documento HTML, modifique o código contido na tag object conforme mostrado a
seguir.
O código a ser adicionado está em negrito.
416
swflash.cab#version=8,0,0,0" width="550" height="400" id="flashvars"
align="middle">
<param name="movie" value="flashvars.swf" />
<param name="FlashVars" value="username=Thomas" />
<embed src="flashvars.swf" FlashVars="username=Thomas" quality="high"
bgcolor="#ffffff" width="550" height="400" name="flashvars"
align="middle" allowScriptAccess="sameDomain" type="application/xshockwave-flash" pluginspage="http://www.macromedia.com/go/
getflashplayer" />
</object>
6.
Salve as alterações no documento HTML.
7.
Abra o documento HTML modificado em um navegador da Web.
O arquivo SWF exibe o nome “Thomas” no campo de texto criado dinamicamente no
Stage (Palco).
Para obter informações sobre segurança, consulte o Capítulo 17, “Noções básicas de
segurança.”
Usando LoadVars para carregar e exibir texto
Você também pode usar a classe LoadVars para carregar conteúdo em um arquivo SWF, que
carrega texto ou variáveis de um arquivo externo no mesmo servidor ou até mesmo conteúdo
de outro servidor. O exemplo a seguir demonstra como criar dinamicamente um campo de
texto e preenchê-lo com o conteúdo de um arquivo de texto remoto.
Para usar LoadVars para preencher um campo de texto com texto externo:
1.
Crie um novo documento do Flash e salve-o como loadvarsText.fla.
2.
var lorem_lv:LoadVars = new LoadVars();
lorem_lv.onData = function (src:String):Void {
if (src != undefined) {
my_txt.text = src;
} else {
my_txt.text = "Unable to load external file.";
417
}
}
lorem_lv.load("http://www.helpexamples.com/flash/lorem.txt");
O primeiro bloco de código do trecho anterior cria um novo campo de texto no Stage
(Palco) e ativa os recursos de quebra automática de texto e várias linhas. O segundo bloco
de código define um novo objeto LoadVars que é usado para carregar um arquivo de texto
(lorem.txt) de um servidor Web remoto e exibe o seu conteúdo no campo de texto my_txt
criado anteriormente.
3.
para testar o arquivo SWF.
Após um pequeno intervalo, o Flash exibirá o conteúdo do arquivo remoto no campo de
texto no Stage.
segurança.”
Carregando variáveis ao usar LoadVars
A classe LoadVars também permite carregar variáveis em um formato codificado em URL, de
maneira semelhante a quando você passa variáveis na seqüência de caracteres de consulta em
um navegador da Web . O exemplo a seguir demonstra como carregar um arquivo de texto
remoto em um arquivo SWF e exibir suas variáveis, monthNames e dayNames.
Para carregar variáveis de um arquivo de texto com LoadVars:
1.
Crie um novo documento do Flash e salve-o como loadvarsVariables.fla.
2.
lorem_lv.onLoad = function (success:Boolean):Void {
if (success) {
my_txt.text = "dayNames: " + lorem_lv.dayNames + "\n\n";
my_txt.text += "monthNames: " + lorem_lv.monthNames;
} else {
}
}
/* contents of params.txt:
&monthNames=January,February,...&dayNames=Sunday,Monday,...
418
*/
lorem_lv.load("http://www.helpexamples.com/flash/params.txt");
3.
no menu principal.
Como você está usando o método LoadVars.onLoad() em vez de LoadVars.onData(),
o Flash analisa as variáveis e cria variáveis na instância do objeto LoadVars. O arquivo de
texto externo contém duas variáveis, monthNames e dayNames, sendo que ambas contêm
seqüências de caracteres.
segurança.”
Carregando e exibindo texto de um documento XML
Os dados XML são uma forma popular de distribuir conteúdo na Internet, em parte porque
esse é um padrão amplamente aceito para a organização e a análise de dados. Portanto, o XML
é uma excelente opção para o envio e o recebimento de dados do Flash; entretanto, ele é de
aprendizado um pouco mais difícil do que a utilização de LoadVars e FlashVars para carregar
dados e exibir texto.
Para carregar texto no Flash a partir de um documento XML externo:
1.
Crie um novo documento do Flash e salve-o como xmlReviews.fla.
2.
var reviews_xml:XML = new XML();
reviews_xml.ignoreWhite = true;
reviews_xml.onLoad = function (success:Boolean):Void {
if (success) {
var childItems:Array = reviews_xml.firstChild.childNodes;
for (var i:Number = 0; i < childItems.length; i++) {
my_txt.text += childItems[i].firstChild.firstChild.nodeValue +
"\n";
}
} else {
}
}
reviews_xml.load("http://www.helpexamples.com/flash/xml/reviews.xml");
419
O primeiro bloco de código do trecho anterior cria um novo campo de texto no Stage
(Palco). Esse campo é usado para exibir várias partes do documento XML que será
carregado posteriormente. O segundo bloco de código cria um objeto XML que será
usado para carregar o conteúdo XML. Depois que a data é totalmente carregada e
analisada pelo Flash, o manipulador de eventos XML.onLoad() é chamado e exibe o
conteúdo do pacote XML no campo de texto.
3.
O Flash exibe a seguinte saída no campo de texto no Stage:
Item 1
Item 2
...
Item 8
segurança.”
Usando fontes
As fontes são conjuntos de caracteres com tipo de fonte, estilo e tamanho semelhantes. Não
importa o que você crie com o Flash Basic 8 ou o Flash Professional 8: seus aplicativos
provavelmente usarão texto com pelo menos uma ou duas fontes. Se você criar animações e
não tiver certeza de que os usuários finais terão uma fonte específica instalada em seus
sistemas, é importante ter noções básicas sobre a incorporação de fontes.
As seções a seguir mostram como incorporar caracteres, fontes inteiras, fontes compartilhadas,
além de outras técnicas para se trabalhar com fontes no Flash 8.
Para obter mais informações sobre fontes, consulte as seguintes seções:
■
“Incorporando caracteres” na página 421
■
“Incorporando fontes” na página 423
■
“Criando conjuntos de caracteres personalizados” na página 425
■
“Usando métodos TextField com fontes incorporadas” na página 427
■
“Sobre o compartilhamento de fontes” na página 429
O exemplo a seguir mostra como adicionar e remover caracteres e conjuntos de caracteres
incorporados a um documento do Flash.
Para adicionar e remover caracteres e conjuntos de caracteres:
1.
Crie um novo documento do Flash e salve-o como embedding.fla.
2.
Crie um campo de texto dinâmico no Stage (Palco) usando a ferramenta Text (Texto).
420
3.
Clique no botão Embed (Incorporar) para iniciar a caixa de diálogo Character Embedding
(Incorporação de caracteres).
4.
Selecione um conjunto de caracteres específico para incorporar, clicando nele com o
ponteiro do mouse.
Para selecionar vários conjuntos de caracteres, use a tecla Shift ou Control enquanto
seleciona os itens com o ponteiro do mouse. Para selecionar um bloco de conjuntos de
caracteres, selecione um conjunto de caracteres com o ponteiro do mouse, pressione e
mantenha pressionada a tecla Shift e clique em um novo conjunto de caracteres. Ao usar a
tecla Shift, serão selecionados todos os conjuntos de caracteres que estiverem entre os dois
conjuntos escolhidos. Para selecionar vários conjuntos de caracteres não seqüenciais,
pressione e mantenha pressionada a tecla Control enquanto seleciona os conjuntos de
caracteres. Também é possível selecionar rapidamente vários conjuntos de caracteres ao
selecionar um conjunto de caracteres com o mouse e, mantendo o botão do mouse
pressionado, arrastar o mouse passando sobre vários conjuntos de caracteres.
5.
Para remover um conjunto de caracteres específico adicionado anteriormente, pressione e
mantenha pressionada a tecla Control e desmarque o conjunto de caracteres ao clicar nele.
6.
Para remover todos os caracteres selecionados e qualquer caractere especificado no campo
de entrada de texto Include These Characters (Incluir esses caracteres), clique em Don’t
Embed (Não incorporar).
A opção Don’t Embed limpa quaisquer caracteres individuais ou conjuntos de caracteres
previamente definidos.
A T E N ÇÃ O
Ao clicar em Don’t Embed na caixa de diálogo Character Embedding (Incorporação
de caracteres), serão removidos quaisquer caracteres e conjuntos de caracteres
incorporados especificados que foram selecionados previamente sem sua
confirmação.
Incorporando caracteres
Se você estiver trabalhando com fontes incorporadas e souber exatamente de quais caracteres
necessita, poderá reduzir o tamanho do arquivo, incorporando apenas os caracteres
necessários, em vez de incluir contornos de fontes adicionais não utilizadas. Para incorporar
determinados caracteres em um campo de texto sem incorporar um conjunto de caracteres
inteiro, use a caixa de diálogo Character Embedding (Incorporação de caracteres) para
especificar quais caracteres específicos você deseja incorporar.
Usando fontes
421
Para incorporar caracteres específicos para uso em um campo de texto:
1.
Crie um novo documento do Flash e salve-o como charembed.fla.
2.
Com a ferramenta Text (Texto), crie um campo de texto no Stage (Palco) e, no campo de
texto, defina o tipo de texto como dinâmico ou de entrada.
3.
Com o campo de texto ainda selecionado no Stage, clique em Embed (Incorporar) no
inspetor Property (Propriedades) para abrir a caixa de diálogo Character Embedding.
A caixa de diálogo Character Embedding permite definir quais conjuntos de caracteres
serão incorporados no documento do Flash (bem como quantos glifos por conjunto de
caracteres) e determinar caracteres específicos a serem incorporados, além de informar o
número total de glifos que estão sendo incorporados para este campo de texto.
4.
Digite a seqüência de caracteres olá mundo na caixa de texto Include these characters
(Incluir esses caracteres).
A caixa de diálogo indica que serão incorporados 8 glifos no total para este campo de
texto. Apesar de a seqüência de caracteres “olá mundo” conter 9 caracteres, como o Flash
só incorpora glifos exclusivos, a letra 'o' é incorporada apenas uma vez, e não várias vezes.
5.
Clique em OK para aplicar as alterações e retornar ao documento.
6.
Com a ferramenta Text (Texto), crie um campo de texto novo no Stage (Palco).
7.
Defina o tipo de texto do campo como dinâmico no inspetor Property.
8.
Digite a seqüência de caracteres olá mundo no campo de texto no Stage.
9.
Clique no botão Embed no inspetor Properties para abrir a caixa de diálogo Character
Embedding novamente.
10. Clique em Auto Fill (Preenchimento automático) para preencher automaticamente a caixa
de texto Include These Characters (Incluir esses caracteres).
Você verá a seqüência de caracteres “olá mund”. Não é preciso informar ao Flash quais
caracteres devem ser incluídos; ele pode determinar para você quais são os caracteres
exclusivos do campo de texto especificado.
DICA
11.
O Flash poderá determinar que os caracteres sejam incorporados automaticamente
apenas se o campo de texto contiver texto no Stage. Se o campo de texto for
preenchido usando o ActionScript, especifique quais caracteres devem ser
incorporados ao campo de texto.
Clique em OK.
422
Incorporando fontes
Quando você incorpora fontes, o Flash armazena todas as informações sobre as fontes no
arquivo SWF para que elas sejam exibidas corretamente mesmo que não estejam instaladas no
computador do usuário. Se você usar em seu arquivo FLA uma fonte que não esteja instalada
no sistema do usuário e não incorporá-la no arquivo SWF, o Flash Player selecionará
automaticamente outra fonte para ser usada em seu lugar.
NO T A
Você só precisará incorporar uma fonte se estiver usando campos de texto dinâmico ou
de entrada. Para campos de texto estáticos, não será necessário incorporar a fonte.
Para incorporar um símbolo de fonte:
1.
Selecione Window (Janela) > Library (Biblioteca) para abrir a biblioteca do arquivo FLA
atual.
Abra a biblioteca à qual deseja adicionar um símbolo de fonte.
2.
Selecione New Font (Nova fonte) no menu pop-up da biblioteca (no canto superior direito
do painel Library).
3.
Digite um nome para o símbolo de fonte na caixa de texto Name (Nome) da caixa de
diálogo Font Symbol Properties (Propriedades do símbolo de fonte).
4.
Selecione uma fonte no menu Font (Fonte) ou digite o nome de uma fonte na caixa de
texto Font.
5.
Selecione texto Bold (Negrito), Italic (Itálico) ou Alias (Serrilhado) para aplicar um estilo
à fonte.
6.
Digite o tamanho da fonte a ser incorporada e clique em OK para aplicar as alterações e
retornar ao documento.
Agora sua fonte é exibida na biblioteca do documento atual.
Depois de incorporar uma fonte à biblioteca, você poderá usá-la com um campo de texto no
Stage (Palco).
Para usar um símbolo de fonte incorporado no documento do Flash:
1.
Sigas as etapas indicadas no procedimento que se encontra em “Incorporando fontes”
na página 423 para incorporar uma fonte em sua biblioteca.
2.
Use a ferramenta Text (Texto) para criar um campo de texto no Stage (Palco).
3.
Digite um texto no campo de texto.
4.
Selecione o campo de texto e abra o inspetor Properties (Propriedades).
a.
Defina o campo de texto para que tenha uma só linha.
b.
Selecione o nome da fonte incorporada usando o menu suspenso Font (Fonte).
Usando fontes
423
Após o nome das fontes incorporadas, é exibido um asterisco (*).
5.
Clique no botão Embed (Incorporar) no inspetor Properties (Propriedades) para iniciar a
caixa de diálogo Character Embedding (Incorporação de caracteres).
Na caixa de diálogo Character Embedding, é possível selecionar os caracteres individuais
ou os conjuntos de caracteres a serem incorporados no campo de texto selecionado. Para
especificar quais caracteres devem ser incorporados, digite-os na caixa de texto da caixa de
diálogo ou clique em Auto Fill (Preenchimento automático) para preencher
automaticamente o campo de texto com os caracteres exclusivos contidos no campo de
texto no momento. Se não souber exatamente quais caracteres serão necessários (por
exemplo, se o texto for carregado de um arquivo externo ou de um serviço da Web), você
poderá selecionar conjuntos inteiros de caracteres para serem incorporados, como
Maiúsculas [A-Z], Minúsculas [a-z], Numerais [0-9], Pontuação [!@#%...] e conjuntos de
caracteres de diversos idiomas.
N OT A
Cada conjunto de caracteres selecionado aumenta o tamanho final do arquivo SWF
porque o Flash precisa armazenar todas as informações de fonte para cada conjunto
usado.
6.
Selecione os caracteres individuais ou os conjuntos de caracteres que deseja incorporar e
clique em OK para aplicar as alterações e retornar ao documento.
7.
Flash no ambiente de criação.
A fonte incorporada é exibida no campo de texto no Stage. Para testar de forma adequada
se a fonte está incorporada, convém fazer o teste em um computador separado que não
tenha a fonte incorporada instalada.
Você também pode definir as propriedades TextField._alpha ou
TextField._rotation para o campo de texto com fontes incorporadas, pois essas
propriedades funcionam somente com essas fontes (consulte as etapas a seguir).
8.
Feche o arquivo SWF e retorne à ferramenta de criação.
9.
Selecione o campo de texto no Stage e abra o inspetor Properties.
a.
Defina o tipo de texto do campo como Dynamic Text (Texto dinâmico).
b.
Digite font_txt na caixa de texto Instance Name (Nome da instância).
10. Adicione
o seguinte código ao Frame 1 (Quadro 1) da Timeline (Linha de tempo):
font_txt._rotation = 45;
11.
Selecione Control > Test Movie novamente para exibir as alterações no ambiente de
criação.
424
A fonte incorporada gira 45 graus no sentido horário, e você ainda pode ver o texto
porque ele está incorporado ao arquivo SWF.
A T E NÇ Ã O
Se você não incorporar uma fonte no documento do Flash, e o Flash Player escolher
automaticamente uma fonte substituta no computador do usuário, a propriedade
TextField.font retornará a fonte original usada no FLA, e não o nome da fonte
substituída.
NO TA
Se você usa fontes incorporadas com uma variedade de estilos nos campos de
texto, deve incorporar o estilo que deseja usar. Por exemplo, se estiver usando uma
fonte incorporada chamada Times e desejar colocar uma palavra em itálico,
certifique-se de incorporar os contornos de caracteres normais e itálicos. Caso
contrário, o texto não aparecerá no campo de texto.
Criando conjuntos de caracteres personalizados
Além de usar os conjuntos de caracteres padrão do Flash, você também pode criar seus
próprios conjuntos de caracteres e adicioná-los na caixa de diálogo Character Embedding
(Incorporação de caracteres). Por exemplo, talvez seja necessário permitir que alguns campos
incluam Latim Estendido, a fim de suportar vários caracteres acentuados. Entretanto, talvez
você não precise de numerais e de pontuação ou talvez precise apenas de caracteres
maiúsculos. Em vez de incorporar conjuntos de caracteres inteiros, é possível criar um
conjunto de caracteres personalizado que contenha apenas os caracteres de que precisa. Desse
modo, é possível reduzir ao máximo o tamanho do arquivo SWF porque não são armazenadas
informações sobre fontes extras para os caracteres dos quais você não precisa.
Para criar um conjunto de caracteres personalizado, edite o arquivo UnicodeTable.xml,
localizado no diretório C:\Program Files\Macromedia\Flash 8\<idioma>\First
Run\FontEmbedding\. Esse arquivo define os conjuntos de caracteres padrão e os intervalos
de caracteres e caracteres que eles contêm.
Antes de criar um conjunto de caracteres personalizado, é preciso compreender a estrutura
XML necessária. Os seguintes nós XML definem o conjunto de caracteres Maiúsculas [A-Z]:
<glyphRange name="Uppercase [A..Z] " id="1" >
<range min="0x0020" max ="0x0020" />
<range min="0x0041" max ="0x005A" />
</glyphRange>
Observe que o nó glyphRange inclui name e Uppercase [A..Z], e que o nó id. A
glyphRange pode ter quantos nós filhos range (intervalo) você precisar. Um intervalo pode ser
um único caractere, como 0x0020 (caractere de espaço), visto no trecho anterior, ou um
intervalo de caracteres, como o segundo nó filho range. Para incorporar apenas um caractere,
defina os valores min e max para o mesmo valor de caractere Unicode.
Usando fontes
425
Um outro exemplo de nó glyphRange XML é o nó Numerals [0..9] :
<glyphRange name="Numerals [0..9] " id="3" >
<range min="0x0030" max ="0x0039" />
<range min="0x002E" max ="0x002E" />
</glyphRange>
Esse intervalo de caracteres inclui os valores Unicode de 0x0030 (zero) até 0x0039 (9), bem
como 0x002E (.).
Antes da criação de um conjunto de caracteres personalizado, é preciso conhecer os caracteres
e seus respectivos valores Unicode. O melhor local para encontrar os valores Unicode é o site
de Padrões Unicode na Web, www.unicode.org, que contém o gráfico Unicode Character
Code (Código de caracteres Unicode) para dezenas de idiomas.
A T E NÇ Ã O
Para adicionar conjuntos de caracteres personalizados, é preciso editar um arquivo
XML na pasta de instalação do Flash. Antes de editar esse arquivo, deve-se fazer uma
cópia backup para o caso de precisar voltar a usar a tabela Unicode original.
A TE N Ç Ã O
A Macromedia recomenda que você não modifique os conjuntos de caracteres
existentes instalados com o Flash e que, em vez disso, crie seus próprios conjuntos de
caracteres personalizados com os caracteres e a pontuação necessários.
Para criar e usar um conjunto de caracteres personalizado:
1.
Abra o documento UnicodeTable.xml, localizado em <diretório de instalação do
Flash>\<idioma>\First Run\FontEmbedding\, usando um editor XML ou de texto, como
Bloco de notas ou TextEdit.
N OT A
2.
Lembre-se de salvar uma cópia backup desse documento, para o caso de precisar
voltar a usar o arquivo original que é instalado com o Flash.
Role o documento XML até o final e adicione o seguinte código XML imediatamente antes
do nó de fechamento </fontEmbeddingTable>:
<glyphRange name="Uppercase and Numerals [A..Z,0..9] " id="100" >
<range min="0x0020" max ="0x0020" />
<range min="0x002E" max ="0x002E" />
<range min="0x0030" max ="0x0039" />
<range min="0x0041" max ="0x005A" />
</glyphRange>
3.
Salve as alterações em UnicodeTable.xml.
Se o Flash estiver aberto, reinicie o aplicativo para poder usar o novo conjunto de
caracteres.
426
4.
Abra ou reinicie o Flash e depois crie um novo documento do Flash.
5.
Adicione uma nova instância TextField no Stage (Palco) usando a ferramenta Text (Texto).
6.
Defina o tipo Text da instância TextField como Dynamic (Dinâmico) no inspetor
Property (Propriedades) e depois clique em Embed Character Options (Opções de
incorporação de caracteres) para abrir a caixa de diálogo Character Embedding
(Incorporação de caracteres).
7.
Role a caixa de diálogo Character Embedding até o final e selecione o novo conjunto de
caracteres personalizados, Maiúsculas e Numerais [A-Z,0-9] (38 glifos).
8.
Selecione quaisquer outros conjuntos de caracteres e clique em OK.
Se você selecionar o conjunto de caracteres personalizado, Maiúsculas e Numerais [A-Z,09], bem como o conjunto de caracteres padrão Maiúsculas [A-Z] ou Numerais [0-9],
observe que o número de glifos incorporados não muda. Isso ocorre porque todos os
caracteres maiúsculos são incluídos no conjunto de caracteres personalizado, e o Flash não
inclui caracteres duplicados, o que mantém o tamanho do arquivo o menor possível. Se
você selecionar o conjunto de caracteres Pontuação, que inclui 52 glifos, bem como o
conjunto de caracteres personalizado, que inclui 38 glifos, o Flash só armazenará
informações de 88 glifos, em vez de 90. Isso ocorre porque dois caracteres coincidentes —
o espaço e o ponto — já foram incluídos no conjunto de caracteres personalizado.
DICA
A posição de um conjunto de caracteres na caixa de diálogo Character Embedding é
determinada pela sua localização no documento XML. É possível reordenar os
conjuntos de caracteres, inclusive os conjuntos de caracteres personalizados,
movendo os pacotes <glyphRange> no arquivo XML.
Usando métodos TextField com fontes incorporadas
Os métodos da classe TextField oferecem uma funcionalidade útil para os seus aplicativos. Por
exemplo, você pode controlar a espessura de um campo de texto usando o ActionScript como
demonstrado no exemplo a seguir.
Para definir a espessura de um campo de texto com o ActionScript:
1.
Crie um novo documento do Flash e salve-o como textfieldThickness.fla.
2.
Abra o painel Library (Biblioteca) e selecione New Font (Nova fonte) no menu pop-up (no
canto superior direito do painel Library).
Usando fontes
427
A caixa de diálogo Font Symbol Properties (Propriedades do símbolo de fonte) é aberta.
Essa caixa permite selecionar uma fonte para ser incorporada no arquivo SWF (incluindo
um estilo e um tamanho de fonte). Você também poderá atribuir um nome de fonte
exibido na biblioteca do documento e no menu suspenso Font (Fonte) no inspetor
Properties (Propriedades), se houver um campo de texto selecionado no Stage (Palco).
3.
a.
Selecione a fonte Times New Roman no menu suspenso Font.
b.
Verifique se desmarcou as opções Bold (Negrito) e Italic (Itálico).
c.
Defina o tamanho como 30 pixels.
d.
Insira o nome de fonte Times (embedded)
e.
Clique em OK.
Na biblioteca, clique com o botão direito do mouse no símbolo de fonte e selecione
Linkage (Vinculação) no menu de contexto.
O Flash abrirá a caixa de diálogo Linkage Properties (Propriedades de vinculação).
4.
Selecione as opções Export for ActionScript (Exportar para ActionScript) e Export in first
frame (Exportar no primeiro quadro) e clique em OK.
5.
// 1
this.createTextField("thickness_txt", 10, 0, 0, Stage.width, 22);
this.createTextField("lorem_txt", 20, 0, 20, Stage.width, 0);
lorem_txt.autoSize = "left";
lorem_txt.embedFonts = true;
lorem_txt.antiAliasType = "advanced";
lorem_txt.text = "Lorem ipsum dolor sit amet, consectetur adipisicing
elit, sed do eiusmod tempor incididunt ut labore et dolore magna
aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco
laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor
in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla
pariatur. Excepteur sint occaecat cupidatat non proident, sunt in
culpa qui officia deserunt mollit anim id est laborum.";
lorem_txt.wordWrap = true;
// 2
var style_fmt:TextFormat = new TextFormat();
style_fmt.font = "Times (embedded)";
style_fmt.size = 30;
lorem_txt.setTextFormat(style_fmt);
428
// 3
mouseListener.onMouseMove = function():Void {
// Os valores de TextField.thickness podem variar de -200 a +200.
lorem_txt.thickness = Math.round(_xmouse * (400 / Stage.width) - 200);
thickness_txt.text = "TextField.thickness = " + lorem_txt.thickness;
};
Mouse.addListener(mouseListener);
O primeiro bloco de código cria dois campos de texto, thickness_txt e lorem_txt, e
posiciona-os no Stage. O campo de texto lorem_txt define sua propriedade embedFonts
como true e preenche o campo com um bloco de texto.
O segundo bloco de código define um formato de texto com o tipo de fonte Times New
Roman, define o tamanho da fonte como 30 pixels e aplica o formato de texto ao campo
lorem_txt.
O terceiro e último bloco de código define e atribui um ouvinte de mouse para o evento
Quando o ponteiro do mouse é movido horizontalmente no Stage, a
propriedade TextField.thickness é alterada para um valor entre -200 e +200,
dependendo do valor atual de _xmouse.
onMouseMove.
6.
Salve as alterações no arquivo FLA.
7.
Flash.
Ao mover o ponteiro do mouse para o lado esquerdo do Stage, a espessura da fonte
diminui. Ao mover o ponteiro do mouse para o lado direito do Stage, a espessura da fonte
aumenta.
Sobre o compartilhamento de fontes
Para usar uma fonte como um item de uma biblioteca compartilhada, crie um símbolo de
fonte no painel Library (Biblioteca) e atribua os seguintes atributos ao símbolo de fonte:
■
Uma seqüência de caracteres de identificação
■
O URL onde o documento que contém o símbolo de fonte será postado
Dessa maneira, é possível vincular à fonte e usá-la em um aplicativo Flash sem que ela seja
armazenada no arquivo FLA.
Usando fontes
429
Sobre a renderização de fontes e texto
sem serrilhado
A renderização de fontes no Flash controla a maneira como o texto aparece em um arquivo
SWF, ou seja, como ele é renderizado (ou desenhado) durante a execução. A tecnologia
avançada de renderização de fontes usada no Flash Player 8 se chama FlashType. O FlashType
utiliza tecnologia avançada de renderização para ajudar a tornar o texto mais legível e nítido
com tamanhos de fontes pequenos ou médios, como quando se aplica eliminação de
serrilhado avançada a campos de texto. Essa tecnologia será analisada com mais detalhes mais
adiante nesta seção.
O recurso de eliminação de serrilhado permite suavizar o texto de modo que as bordas dos
caracteres exibidos na tela pareçam menos dentadas; isso poderá ser útil principalmente para
exibir texto em tamanho pequeno. A opção Anti-Alias (Sem serrilhado) torna os caracteres
mais legíveis, alinhando contornos de texto ao longo dos limites dos pixels, e é muito eficiente
para a renderização mais nítida de fontes de tamanho pequeno.Você pode aplicar esse recurso
a cada campo de texto do aplicativo, em vez de aplicá-lo a caracteres individuais.
O recurso de eliminação de serrilhado poderá ser usado com texto de entrada, dinâmico e
estático, se o usuário tiver o Flash Player 7 ou versão posterior. Se o usuário tiver uma versão
anterior do Flash Player, esse recurso só poderá ser usado com texto estático. Opções
avançadas de eliminação de serrilhado estão disponíveis para o Flash Player 8.
O Flash Basic 8 e o Flash Professional 8 contêm um recurso bem avançado de rasterização e
renderização de fontes, chamado FlashType, para se trabalhar com fontes sem serrilhado. O
Flash 8 oferece cinco métodos de renderização de fontes, os quais só estão disponíveis para
publicação de arquivos SWF no Flash Player 8. Se estiver publicando arquivos para uso com o
Flash Player 7 ou versões anteriores, somente a opção Anti-Alias for Animation (Sem
serrilhado para animação) estará disponível para uso com os campos de texto.
O FlashType é uma tecnologia de renderização de fontes de alta qualidade que pode ser
ativada com o uso da ferramenta de criação do Flash 8 ou do ActionScript. A tecnologia do
FlashType permite renderizar tipos de fontes com saída de alta qualidade em tamanhos
pequenos e com um controle maior. É possível aplicar o FlashType à renderização de fontes
incorporadas para campos de texto estáticos, dinâmicos e de entrada. Os recursos aprimorados
permitem que o texto incorporado apareça no mesmo nível de qualidade que o texto de
dispositivo e que as fontes tenham a mesma aparência em plataformas diferentes.
430
Os métodos de renderização de fontes disponíveis para o Flash Player 8 são Device Fonts
(Fontes de dispositivo), Bitmap Text (no anti-alias) (Texto em bitmap - sem a eliminação de
serrilhado), Anti-Alias for Animation (Sem serrilhado para animação), Anti-Alias for
Readability (Sem serrilhado para legibilidade) e Custom Anti-Alias (Eliminação de serrilhado
personalizada), que permite definir um valor personalizado para espessura e definição. Para
obter mais informações sobre essas opções, consulte “Opções de renderização de fontes do
Flash” na página 432.
N OT A
Quando você abre arquivos FLA no Flash 8, seu texto não é atualizado
automaticamente para a opção Anti-Alias for Readability (Sem serrilhado para
legibilidade); é preciso selecionar campos de texto individuais e alterar manualmente as
configurações de eliminação de serrilhado para tirar proveito da tecnologia de
renderização do FlashType.
Os recursos de eliminação de serrilhado avançada e personalizada oferecem suporte a:
■
Texto dimensionado e girado
■
Todas as fontes (simples, negrito ou itálico) com tamanho de até 255 pontos
■
Exportação de arquivos para a maioria dos formatos (como JPEG ou GIF).
Os recursos de eliminação de serrilhado avançada e personalizada não oferecem suporte a:
■
Flash Player 7 ou versões anteriores
■
Texto inclinado ou invertido
■
Impressão
■
Exportação de arquivos para o formato PNG.
N OT A
Quando o texto é animado, o Flash Player desativa a opção avançada de eliminação
de serrilhado para melhorar a aparência do texto à medida que ele se move. Quando
a animação termina, a opção de eliminação de serrilhado é novamente ativada.
Um arquivo de exemplo no seu disco rígido mostra como aplicar e manipular texto sem
serrilhado em um aplicativo. Use a tecnologia de renderização do FlashType para criar um
pequeno texto que seja extremamente legível. Esse exemplo também demonstra como os
campos de texto podem ser rolados de forma rápida e suave com a utilização da propriedade
cacheAsBitmap.
O arquivo de origem de exemplo, flashtype.fla, encontra-se na pasta Samples do disco rígido.
No Macintosh, navegue até HD do Macintosh/Applications/Macromedia Flash 8/Samples and
Tutorials/Samples/ActionScript/FlashType.
Sobre a renderização de fontes e texto sem serrilhado
431
Opções de renderização de fontes do Flash
Há cinco opções de renderização de fontes disponíveis no Flash 8. Para escolher uma opção,
selecione o campo de texto e abra o inspetor Properties (Propriedades). Selecione uma opção
no menu pop-up de métodos de renderização de fontes.
Device Fonts (Fontes de dispositivo) Produz um tamanho de arquivo SWF menor. A opção
renderiza as fontes instaladas no computador do usuário final.
Bitmap Text (no anti-alias) (Texto em bitmap – sem a eliminação de serrilhado) Produz
bordas de texto com ângulo agudo, sem usar o recurso de eliminação de serrilhado. Esta opção
produz um tamanho de arquivo SWF maior, pois os contornos das fontes são incluídos nesse
arquivo.
Anti-alias for Animation (Sem serrilhado para animação)
Produz texto sem serrilhado que é
animado gradativamente. O texto também é animado mais rápido em algumas situações, pois
os recursos de alinhamento e de eliminação de serrilhado não são aplicados durante a
animação. Não se observa aumento de desempenho quando são usadas fontes grandes com
muitas letras ou fontes dimensionadas. Esta opção produz um tamanho de arquivo SWF
maior, pois os contornos das fontes são incluídos nesse arquivo.
Anti-Alias for Readability (Sem serrilhado para legibilidade) Usa o mecanismo avançado de
eliminação de serrilhado, bem como oferece texto com qualidade e legibilidade máximas. Ela
também produz o maior tamanho de arquivo SWF, pois os contornos das fontes e
informações especiais sobre o recurso de eliminação de serrilhado são incluídos no arquivo.
(Eliminação de serrilhado personalizada) É igual à Anti-Alias for
Readability, mas permite manipular visualmente os parâmetros de eliminação de serrilhado
para produzir uma aparência específica. Ela é útil quando se deseja produzir a melhor
aparência possível para fontes novas ou não convencionais.
Custom Anti-alias
Para obter um exemplo de como usar a opção sem serrilhado com o ActionScript, consulte
“Definindo a opção sem serrilhado com o ActionScript” na página 433.
432
Sobre a modulação de traço contínua
A tecnologia de renderização de fontes do FlashType explora as propriedades inerentes dos
campos de distância para fornecer CSM (Continuous Stroke Modulation, Modulação de
traço contínua); por exemplo, a modulação contínua da espessura do traço e da definição da
borda do texto. A CSM utiliza dois parâmetros de renderização para controlar o mapeamento
de distâncias ADF (Adaptively Sampled Distance Field, Campo de distância de exemplo de
forma adaptável) para valores de densidade de glifos. Os valores ideais para esses parâmetros
são extremamente subjetivos; podem depender das preferências do usuário, condições de
luminosidade, propriedades de exibição, tipo da fonte, cores de primeiro plano e de fundo e
tamanho do ponto. A função que mapeia as distâncias ADF para valores de densidade possui
um limite externo, abaixo do qual os valores são definidos com 0, e um limite interno, acima
do qual os valores são definidos com um valor de densidade máxima, como 255.
Definindo a opção sem serrilhado com o ActionScript
O Flash 8 oferece dois tipos de eliminação de serrilhado: normal e avançada. A eliminação de
serrilhado avançada encontra-se disponível apenas no Flash Player 8 e versões posteriores, e só
poderá ser usada se você incorporar a fonte na biblioteca e definir a propriedade embedFonts
do campo de texto como true. No Flash Player 8, a configuração padrão para campos de
texto criados com o ActionScript é normal.
Para definir valores para a propriedade TextField.antiAliasType, use os seguintes valores
de seqüência de caracteres:
Aplica a eliminação de serrilhado de texto regular. Corresponde ao tipo de
eliminação de serrilhado que o Flash Player usava na versão 7 ou em versões anteriores.
normal
avançado Aplica eliminação de serrilhado avançada para melhorar a legibilidade do texto,
que se encontra disponível no Flash Player 8. A eliminação de serrilhado avançada permite
que os tipos de fontes sejam renderizados com alta qualidade e em tamanhos menores.
Apresenta melhor utilização com aplicativos que têm muito texto de tamanho pequeno.
DICA
A Macromedia não recomenda a eliminação de serrilhado avançada para fontes com
mais de 48 pontos.
Para usar o ActionScript com o intuito de definir texto sem serrilhado, veja o exemplo a seguir.
Para usar eliminação de serrilhado avançada:
1.
Crie um novo documento do Flash e salve-o como antialiastype.fla.
2.
Crie dois clipes de filme no Stage (Palco) e atribua a eles os nomes de instâncias normal_mc
e avançado_mc.
433
Use esses clipes de filme para alternar entre os dois tipos de eliminação de serrilhado:
normal e avançada.
3.
Abra o painel Library (Biblioteca) e selecione New Font (Nova fonte) no menu pop-up no
canto superior direito do painel Library.
A caixa de diálogo Font Symbol Properties (Propriedades do símbolo de fonte) é aberta e
permite selecionar uma fonte para ser incorporada no arquivo SWF (incluindo um estilo e
um tamanho de fonte). Você também poderá atribuir um nome de fonte exibido na
biblioteca do documento e no menu suspenso Font (Fonte) no inspetor Properties
(Propriedades), se houver um campo de texto selecionado no Stage (Palco).
4.
a.
Selecione a fonte Arial no menu suspenso Font.
b.
Certifique-se de que as opções Bold (Negrito) e Italic (Itálico) não estão selecionadas.
c.
Defina o tamanho como 10 pixels.
d.
Insira o nome de fonte Arial-10 (embedded).
e.
Clique em OK.
Na biblioteca, clique com o botão direito do mouse no símbolo de fonte e selecione
Linkage (Vinculação) no menu de contexto.
5.
Selecione as opções Export for ActionScript (Exportar para ActionScript) e Export in First
Frame (Exportar no primeiro quadro), digite o identificador de vinculação Arial-10 e
clique em OK.
6.
principal:
var text_fmt:TextFormat = new TextFormat();
text_fmt.font = "Arial-10";
text_fmt.size = 10;
my_txt.embedFonts = true;
my_txt.selectable = false;
my_txt.setNewTextFormat(text_fmt);
lorem_lv.onData = function(src:String) {
my_txt.text = src;
} else {
my_txt.text = "unable to load text file.";
}
434
};
normal_mc.onRelease = function() {
my_txt.antiAliasType = "normal";
};
advanced_mc.onRelease = function() {
my_txt.antiAliasType = "advanced";
};
O código anterior é dividido em quatro áreas-chave. O primeiro bloco de código cria um
novo objeto TextFormat, que especifica uma fonte e um tamanho de fonte a serem usados
em um campo de texto que será criado em breve. A fonte especificada, Arial-10, é o
identificador de vinculação do símbolo de fonte incorporado em uma etapa anterior.
O segundo bloco de código cria um novo campo de texto com o nome de instância
my_txt. A fim de que a fonte seja incorporada de forma adequada, defina embedFonts
como true para a instância de campo de texto. O código também define a formatação de
texto do novo campo de texto do objeto TextFormat criado anteriormente.
O terceiro bloco de código define uma instância LoadVars que preenche o campo de texto
no Stage (Palco) com o conteúdo de um arquivo de texto externo. Depois que o
documento está totalmente carregado (mas não analisado), o conteúdo inteiro do arquivo
é copiado para a propriedade my_txt.text, a fim de ser exibido no Stage.
O quarto e último bloco de código define manipuladores de eventos onRelease para os
clipes de filme normal_mc e avançado_mc. Quando o usuário clica e libera uma dessas
opções, o tipo de eliminação de serrilhado do campo de texto no Stage muda.
7.
Salve as alterações no arquivo FLA.
8.
Flash.
9.
Clique no clipe de filme avançado_mc no Stage.
Quando você clica no clipe de filme, o tipo de eliminação de serrilhado alterna de normal
(padrão) para avançado. Quando se trata de campos de texto com um tamanho de fonte
menor, a definição da eliminação de serrilhado como avançada pode melhorar
consideravelmente a legibilidade do texto.
DICA
A eliminação de serrilhado avançada permite que os tipos de fontes sejam
renderizados com alta qualidade e em tamanhos menores. Sua utilização é melhor
com aplicativos que têm muito texto de tamanho pequeno. A Macromedia não
recomenda a eliminação de serrilhado avançada para fontes com mais de 48
pontos.
435
Para obter mais informações sobre a formatação de texto sem serrilhado, consulte “Usando
um tipo de ajuste à grade” na página 442 e “Sobre a formatação de texto sem serrilhado”
na página 440.
cacheAsBitmap.
Definindo tabelas para fontes
Se você criar fontes para usar com arquivos SWF ou para distribuição a desenvolvedores de
Flash, talvez seja necessário definir tabelas para fontes, a fim de controlar como elas são
renderizadas no Stage (Palco).
A eliminação de serrilhado avançada usa ADFs (Adaptively Sampled Distance Field, Campos
de distância de exemplo de forma adaptável) para representar os contornos que determinam
um glifo (um caractere). O Flash utiliza dois valores:
■
Um valor de limite externo, abaixo do qual as densidades são definidas como 0.
■
Um valor de limite interno, acima do qual as densidades são definidas com um valor de
densidade máxima, como 255.
Entre esses dois valores-limite, a função de mapeamento é uma curva linear variando de 0 no
limite externo até a densidade máxima no limite interno.
O ajuste dos valores-limite externo e interno afeta a espessura do traço e a definição da borda.
O espaçamento entre esses dois parâmetros é comparável ao dobro do raio do filtro dos
métodos clássicos de eliminação de serrilhado; um espaçamento menor proporciona uma
borda mais nítida, enquanto que um espaçamento maior fornece uma borda mais suave e
filtrada. Quando o espaçamento é igual a 0, a imagem da densidade resultante é um bitmap de
dois níveis. Quando o espaçamento é muito largo, a imagem da densidade resultante tem uma
borda semelhante a uma aquarela.
Geralmente, os usuários preferem bordas bem definidas e com grande contraste em tamanhos
de pontos pequenos e bordas mais suaves para texto animado e pontos de tamanho maior.
436
O limite externo geralmente tem um valor negativo, o limite interno tem um valor positivo, e
seu ponto médio fica próximo ao 0. O ajuste desses parâmetros para deslocar o ponto médio
para o infinito negativo aumenta a espessura do traço; o deslocamento do ponto médio para o
infinito positivo diminui a espessura do traço.
N OT A
O limite externo deve ser sempre inferior ou igual ao limite interno.
O Flash Player inclui configurações avançadas de eliminação de serrilhado para dez fontes
básicas. Para essas fontes, são fornecidas configurações avançadas de eliminação de serrilhado
apenas para os tamanhos de fonte de 6 a 20. Nessas fontes, os tamanhos abaixo de 6 utilizam
as configurações do tamanho 6, e os tamanhos acima de 20 utilizam as configurações do 20.
As demais fontes são mapeadas para os dados das fontes fornecidas. O método
setAdvancedAntialiasingTable() permite definir dados de eliminação de serrilhado
personalizada para outras fontes e tamanhos de fontes ou substituir as configurações padrão
para as fontes fornecidas. Para obter mais informações sobre a criação de uma tabela de
eliminação de serrilhado, veja o seguinte exemplo:
Para criar uma tabela de eliminação de serrilhado avançada para uma fonte
incorporada:
1.
Crie um novo documento do Flash e salve-o como advancedaatable.fla.
2.
Selecione New Font (Nova fonte) no menu pop-up do painel Library (Biblioteca).
3.
Selecione Arial no menu pop-up Font (Fonte) e depois defina o tamanho da fonte com 32
pontos.
4.
Selecione as opções Bold (Negrito) e Italics (Itálico).
5.
Digite o nome da fonte Arial (embedded) na caixa de texto Name (Nome) e clique em OK.
6.
Clique com o botão direito do mouse (Windows) ou, pressionando Control, clique
(Macintosh) no símbolo de fonte na biblioteca e selecione Linkage (Vinculação).
7.
Na caixa de diálogo Linkage Properties (Propriedades de vinculação):
8.
a.
Digite Arial-embedded na caixa de texto Identifier (Identificador).
b.
Selecione Export for ActionScript (Exportar para ActionScript) e Export in First
Frame (Exportar no primeiro quadro).
c.
Clique em OK.
Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) principal e adicione o
seguinte ActionScript ao painel Actions (Ações):
import flash.text.TextRenderer;
var arialTable:Array = new Array();
437
arialTable.push({fontSize:16.0, insideCutoff:0.516,
outsideCutoff:0.416});
arialTable.push({fontSize:32.0, insideCutoff:2.8, outsideCutoff:-2.8});
TextRenderer.setAdvancedAntialiasingTable("Arial", "bolditalic", "dark",
arialTable);
var my_fmt:TextFormat = new TextFormat();
my_fmt.align = "justify";
my_fmt.font = "Arial-embedded";
my_fmt.size = 32;
this.createTextField("my_txt", 999, 10, 10, Stage.width-20,
Stage.height-20);
my_txt.antiAliasType = "advanced";
my_txt.embedFonts = true;
my_txt.setNewTextFormat(my_fmt);
my_txt.sharpness = 0;
my_txt.thickness = 0;
lorem_lv.onData = function(src:String):Void {
my_txt.text = src + "\n\n" + src;
} else {
trace("error downloading text file");
}
};
O código anterior é dividido em quatro seções. A primeira seção de código importa a
classe TextRenderer e define uma nova tabela de eliminação de serrilhado para dois
tamanhos diferentes da fonte Arial. A segunda seção de código define um novo objeto
TextFormat, utilizado para aplicar formatação de texto ao campo de texto (criado na
próxima seção de código). A próxima seção de código cria um novo campo de texto com
um nome de instância my_txt, ativa a eliminação de serrilhado avançada, aplica o objeto
de formato de texto (criado anteriormente) e ativa os recursos de quebra automática de
texto e várias linhas. O último bloco de código define um objeto LoadVars utilizado para
carregar texto de um arquivo de texto externo e preencher o campo de texto no Stage
(Palco).
9.
Flash.
438
Depois que o texto é carregado do servidor remoto, o Flash exibe algum texto no campo
de texto, e é possível ver as propriedades da tabela de eliminação de serrilhada avançada
aplicadas ao campo de texto. A fonte incorporada no Stage deve aparecer como se tivesse
um leve efeito de embaçamento, por causa dos atuais valores insideCutoff e
outsideCutoff.
Sobre o layout e a formatação de texto
Você pode controlar o layout e a formatação do texto com o ActionScript. A classe
TextFormat fornece um grande controle sobre o modo como o texto aparece durante a
execução, além de outras formas de formatação como folhas de estilos (consulte “Formatando
texto com estilos CSS” na página 447) e texto HTML (consulte “Usando texto em formato
HTML” na página 461).
Também é possível controlar o modo como os caracteres se ajustam à grade, usando o
ActionScript ao utilizar texto sem serrilhado em um arquivo SWF. Isso ajuda a controlar a
aparência dos caracteres durante a execução. Para obter um exemplo de como usar um tipo de
ajuste à grade nos aplicativos, consulte “Usando um tipo de ajuste à grade” na página 442.
Para obter informações gerais sobre campos de texto, consulte “Sobre campos de texto”
na página 405. Para obter informações sobre formatação de texto, consulte “Sobre a
formatação de texto sem serrilhado” na página 440. Para obter mais informações sobre a classe
TextFormat, consulte “Usando a classe TextFormat” na página 444 e %{TextFormat}% em
Para obter mais informações sobre layout e formatação de texto usando a classe TextFormat,
■
“Sobre a formatação de texto sem serrilhado” na página 440
■
“Usando um tipo de ajuste à grade” na página 442
■
“Usando a classe TextFormat” na página 444
■
“Propriedades padrão dos novos campos de texto” na página 446
439
Sobre a formatação de texto sem serrilhado
O Flash 8 introduz duas novas propriedades que podem ser usadas ao formatar campos de
texto com a eliminação de serrilhado avançada: sharpness (definição) e thickness
(espessura). A definição refere-se à quantidade de serrilhado aplicado à instância do campo de
texto. Uma definição com valor alto faz com que a borda da fonte incorporada pareça dentada
e nítida. Uma definição com um valor mais baixo faz com que a fonte pareça mais suave, mais
embaçada. A definição da espessura de uma fonte é semelhante à ativação da formatação de
negrito para um campo de texto. Quanto maior a espessura, mais forte aparecerá o negrito da
fonte.
O exemplo a seguir carrega um arquivo de texto de forma dinâmica e exibe texto no Stage
(Palco). Ao mover o ponteiro do mouse ao longo do eixo x, a definição é estabelecida entre 400 e 400. Ao mover o ponteiro do mouse ao longo do eixo y, a espessura é definida entre 200 e 200.
Para modificar a definição e a espessura de um campo de texto:
1.
Crie um novo documento do Flash e salve-o como sharpness.fla.
2.
Selecione New Font (Nova fonte) no menu pop-up no canto superior direito do painel
Library (Biblioteca).
3.
Selecione Arial no menu suspenso Font (Fonte) e depois defina o tamanho da fonte com
24 pontos.
4.
Digite o nome da fonte Arial-24 (embedded) na caixa de texto Name (Nome) e clique em
OK.
5.
Clique com o botão direito do mouse no símbolo de fonte na biblioteca e selecione Linkage
(Vinculação) para abrir a caixa de diálogo Linkage Properties (Propriedades de vinculação).
6.
Defina o identificador de vinculação com Arial-24, marque as caixas de seleção Export for
ActionScript (Exportar para ActionScript) e Export in First Frame (Exportar no primeiro
quadro) e clique em OK.
7.
principal:
my_fmt.size = 24;
my_fmt.font = "Arial-24";
this.createTextField("lorem_txt", 10, 0, 20, Stage.width, (Stage.height
- 20));
lorem_txt.setNewTextFormat(my_fmt);
lorem_txt.text = "loading...";
lorem_txt.wordWrap = true;
lorem_txt.autoSize = "left";
440
lorem_txt.embedFonts = true;
lorem_txt.antiAliasType = "advanced";
this.createTextField("debug_txt", 100, 0, 0, Stage.width, 20);
debug_txt.autoSize = "left";
debug_txt.background = 0xFFFFFF;
lorem_lv.onData = function(src:String) {
lorem_txt.text = src;
}
lorem_txt.sharpness = (_xmouse * (800 / Stage.width)) - 400;
lorem_txt.thickness = (_ymouse * (400 / Stage.height)) - 200;
debug_txt.text = "sharpness=" + Math.round(lorem_txt.sharpness) +
", thickness=" + Math.round(lorem_txt.thickness);
};
Esse código do ActionScript pode ser dividido em cinco seções básicas. A primeira seção
de código define uma nova instância TextFormat que será aplicada a um campo de texto
criado de forma dinâmica. As duas seções a seguir criam dois novos campos de texto no
Stage (Palco). O primeiro campo de texto, lorem_txt, aplica o objeto de formatação de
texto personalizado criado anteriormente, ativa fontes incorporadas e define a propriedade
antiAliasType como true. O segundo campo de texto, debug_txt,exibe os valores
atuais de definição e espessura do campo de texto lorem_txt. A quarta seção de código
cria um objeto LoadVars, responsável pelo carregamento do arquivo de texto externo e
preenchimento do campo de texto lorem_txt. A quinta e última seção de código define
um ouvinte de mouse, chamado sempre que o ponteiro do mouse se movimenta pelo
Stage. Os valores atuais de definição e espessura são calculados com base na posição
atual do ponteiro do mouse no Stage. As propriedades definição e espessura são
definidas para o campo de texto lorem_txt, e os valores atuais são exibidos no campo de
texto debug_txt.
8.
Mova o ponteiro do mouse ao longo do eixo x para alterar a definição do campo de texto.
Mova o ponteiro do mouse da esquerda para a direita, a fim de que a definição aumente e
pareça mais dentada. Mova o ponteiro do mouse ao longo do eixo y, a fim de que a
espessura do campo de texto seja alterada.
441
Para obter mais informações sobre o uso de texto sem serrilhado em um arquivo SWF,
consulte “Definindo a opção sem serrilhado com o ActionScript” na página 433, “Opções de
renderização de fontes do Flash” na página 432 e “Usando um tipo de ajuste à grade”
na página 442.
cacheAsBitmap.
Usando um tipo de ajuste à grade
Quando você utiliza eliminação de serrilhado avançada em um campo de texto, há três tipos
de ajuste à grade disponíveis:
Não especifica nenhum ajuste à grade. As linhas horizontais e verticais dos
glifos não são forçadas na grade de pixels. Essa configuração geralmente é boa para animação e
fontes de tamanhos grandes.
none (nenhum)
pixel Especifica que as linhas horizontais e verticais fortes são ajustadas à grade de pixels.
Essa configuração só funciona para campos de texto alinhados à esquerda. Geralmente, oferece
a melhor legibilidade para textos alinhados à esquerda.
Especifica que as linhas horizontais e verticais fortes são ajustadas à grade de
subpixels em um monitor LCD. A configuração de subpixel geralmente é boa para textos
dinâmicos alinhados à direita e alinhados ao centro, e às vezes é um equilíbrio útil entre
qualidade de texto versus animação.
subpixel
O exemplo a seguir mostra como definir um tipo de ajuste à grade em um campo de texto
usando o ActionScript.
Para definir um tipo de ajuste à grade em um campo de texto:
1.
Crie um novo documento do Flash e salve-o como gridfittype.fla.
2.
Selecione New Font (Nova fonte) no menu pop-up no canto superior direito do painel
Library (Biblioteca).
442
3.
Selecione a fonte Arial no menu suspenso Font (Fonte) e depois defina o tamanho da fonte
com 10 pontos.
4.
Digite o nome da fonte Arial-10 (embedded) na caixa de texto Name (Nome) e clique em
OK.
5.
Clique com o botão direito do mouse no símbolo de fonte na biblioteca e selecione Linkage
(Vinculação) para abrir a caixa de diálogo Linkage Properties (Propriedades de vinculação).
6.
Defina o identificador de vinculação com Arial-10 e marque as caixas de seleção Export for
ActionScript (Exportar para ActionScript) e Export in First Frame (Exportar no primeiro
quadro).
7.
Clique em OK.
8.
principal:
my_fmt.size = 10;
my_fmt.font = "Arial-10";
var h:Number = Math.floor(Stage.height / 3);
this.createTextField("none_txt", 10, 0, 0, Stage.width, h);
none_txt.antiAliasType = "advanced";
none_txt.embedFonts = true;
none_txt.gridFitType = "none";
none_txt.multiline = true;
none_txt.setNewTextFormat(my_fmt);
none_txt.text = "loading...";
none_txt.wordWrap = true;
this.createTextField("pixel_txt", 20, 0, h, Stage.width, h);
pixel_txt.antiAliasType = "advanced";
pixel_txt.embedFonts = true;
pixel_txt.gridFitType = "pixel";
pixel_txt.multiline = true;
pixel_txt.selectable = false;
pixel_txt.setNewTextFormat(my_fmt);
pixel_txt.text = "loading...";
pixel_txt.wordWrap = true;
this.createTextField("subpixel_txt", 30, 0, h*2, Stage.width, h);
subpixel_txt.antiAliasType = "advanced";
subpixel_txt.embedFonts = true;
subpixel_txt.gridFitType = "subpixel";
subpixel_txt.multiline = true;
subpixel_txt.setNewTextFormat(my_fmt);
subpixel_txt.text = "loading...";
subpixel_txt.wordWrap = true;
443
lorem_lv.onData = function(src:String):Void {
none_txt.text = "[antiAliasType=none]\n" + src;
pixel_txt.text = "[antiAliasType=pixel]\n" + src;
subpixel_txt.text = "[antiAliasType=subpixel]\n" + src;
} else {
trace("unable to load text file");
}
};
O ActionScript anterior pode ser dividido em cinco seções. A primeira seção define um
novo objeto de formato de texto que especifica duas propriedades: tamanho e fonte. A
propriedade font (fonte) refere-se ao identificador de vinculação do símbolo de fonte que
está atualmente na biblioteca de documentos. A segunda, terceira e quarta seções de
código criam um novo campo de texto dinâmico no Stage (Palco) e definem algumas
propriedades comuns: antiAliasType (que deve ser definido com advanced [avançado]),
embedFonts (definido com true [verdadeiro]), multiline e wordWrap. Cada seção
também aplica o objeto de formato de texto criado em um seção anterior e define o tipo
de ajuste à grade com normal, pixel ou subpixel. A quinta e última seção cria uma
instância LoadVars, que carrega o conteúdo de um arquivo de texto externo para cada um
dos campos de texto criados com código.
9.
Salve o documento e selecione Control (Controlar) > Test Movie (Testar filme) para testar
o arquivo SWF.
Cada arquivo de texto deve ser inicializado com o valor “loading...”. Após o
carregamento bem-sucedido do arquivo de texto externo, cada campo de texto exibirá um
texto de exemplo formatado usando um tipo diferente de ajuste à grade.
DICA
A tecnologia de renderização do FlashType utiliza o ajuste à grade apenas na
rotação 0º.
Usando a classe TextFormat
Você pode usar a classe TextFormat para definir as propriedades de formatação de um campo
de texto. A classe TextFormat incorpora as informações de formatação de caractere e
parágrafo. As informações de formatação de caracteres descrevem a aparência de caracteres
individuais: nome da fonte, tamanho do ponto, cor e URL associado. As informações de
formatação de parágrafos descrevem a aparência de um parágrafo: margem esquerda, margem
direita, recuo da primeira linha e alinhamento à esquerda, à direita ou centralizado.
444
Para usar a classe TextFormat, crie primeiro um objeto TextFormat e defina seus estilos de
formatação de caractere e parágrafo. Aplique o objeto TextFormat a um campo de texto
usando o método TextField.setTextFormat() ou TextField.setNewTextFormat().
O método setTextFormat() altera o formato de texto aplicado a caracteres individuais, a
grupos de caracteres ou a todo o corpo de texto em um campo de texto. No entanto, um texto
inserido posteriormente, por um usuário ou com o ActionScript, não assume a formatação
especificada por uma chamada de setTextFormat(). Para especificar a formatação padrão do
texto inserido posteriormente, use TextField.setNewTextFormat(). Para obter mais
informações, consulte %{setTextFormat (TextField.setTextFormat method)}% and
%{setNewTextFormat (TextField.setNewTextFormat method)}% em ActionScript 2.0
Language Reference.
Para formatar um campo de texto com a classe TextFormat:
1.
Em um novo documento Flash, crie um campo de texto no Stage (Palco) usando a
ferramenta Text.
Digite algum texto no campo de texto no Stage (Palco), como Texto itálico, em negrito,
de 24 pontos.
2.
No inspetor Properties, digite myText_txt na caixa de texto Instance Name (Nome da
instância), selecione Dynamic (Dinâmico) no menu pop-up Text Type (Tipo de texto) e
selecione Multiline (Várias linhas) no menu pop-up Line Type (Tipo de linha).
3.
Selecione Frame 1 (Quadro 1) da Timeline (Linha de tempo) e abra o painel Actions
(Ações) (Window [Janela] > Actions).
4.
Digite o código a seguir no painel Actions para criar um objeto TextFormat e defina as
propriedades bold e italic como true, e a propriedade size como 24:
// Crie um objeto TextFormat.
var txt_fmt:TextFormat = new TextFormat();
// Especifique a formatação de parágrafo e caractere.
txt_fmt.bold = true;
txt_fmt.italic = true;
txt_fmt.size = 24;
5.
Aplique o objeto TextFormat ao campo de texto criado na etapa 1, usando
TextField.setTextFormat():
myText_txt.setTextFormat(txt_fmt);
Essa versão de setTextFormat() aplica a formatação especificada ao campo de texto
inteiro. Duas outras versões desse método permitem a aplicação de formatação a caracteres
individuais ou grupos de caracteres. Por exemplo, o código a seguir aplica a formatação
negrito, itálico, tamanho 24 aos três primeiros caracteres inseridos no campo de texto:
myText_txt.setTextFormat(0, 3, txt_fmt);
445
Para obter mais informações, %{setTextFormat (TextField.setTextFormat method)}% em
6.
Selecione Control (Controlar) > Test Movie (Testar filme) para testar o aplicativo.
Para obter mais informações sobre o uso da classe TextFormat, consulte os seguintes tópicos:
■
“Propriedades padrão dos novos campos de texto” na página 446
■
“Formatando texto com estilos CSS” na página 447
Propriedades padrão dos novos campos de texto
Os campos de texto criados durante a execução com createTextField() recebem um objeto
TextFormat padrão com as seguintes propriedades:
align = "left"
blockIndent = 0
bold = false
bullet = false
color = 0x000000
font = "Times New Roman" (default font is Times on Mac OS X)
indent = 0
italic = false
kerning = false
leading = 0
leftMargin = 0
letterSpacing = 0
rightMargin = 0
size = 12
tabStops = [] (empty array)
target = ""
underline = false
url = ""
N OT A
A propriedade de fonte padrão no Mac OS X é Times.
Para obter uma lista completa dos métodos TextFormat e de suas descrições, consulte
%{TextFormat}% em ActionScript 2.0 Language Reference.
446
Formatando texto com estilos CSS
Os estilos CSSs (Cascading Style Sheets, Folhas de estilos em cascata) permitem trabalhar com
estilos de texto que podem ser aplicados a documentos HTML ou XML. Uma folha de estilos
é uma coleção de regras de formatação que especifica como formatar elementos HTML ou
XML. Cada regra está associada a um nome de estilo, ou seletor, com uma ou mais
propriedades de estilo e seus valores. Por exemplo, o estilo a seguir define um seletor chamado
bodyText:
.bodyText {
text-align: left
}
Você pode criar estilos que redefinam marcas de formatação HTML internas utilizadas pelo
Flash Player (como e <li>). Também é possível criar classes de estilo que podem ser
aplicadas a elementos HTML específicos usando o atributo class da marca ou ,
ou definir novas marcas.
Você usa a classe TextField.StyleSheet para trabalhar com folhas de estilos de texto. Embora a
classe TextField possa ser usada com o Flash Player 6, a classe TextField.StyleSheet exige que os
arquivos SWF se destinem ao Flash Player 7 ou a versões posteriores. É possível carregar estilos
de um arquivo CSS externo ou criá-los de maneira nativa usando o ActionScript. Para aplicar
uma folha de estilos a um campo de texto que contém texto em formato HTML ou XML, use
a propriedade TextField.styleSheet. Os estilos definidos na folha de estilos são mapeados
automaticamente para as marcas definidas no documento HTML ou XML.
O uso de folhas de estilos envolve as seguintes três etapas básicas:
■
Criar um objeto de folha de estilos a partir da classe TextField.StyleSheet (para obter mais
informações, consulte %{StyleSheet (TextField.StyleSheet)}% em ActionScript 2.0
Language Reference).
■
Adicionar estilos ao objeto de folha de estilos, carregando-os de um arquivo CSS externo
ou criando novos estilos com o ActionScript.
■
Atribuir a folha de estilos a um objeto TextField que contém texto em formato HTML ou
XML.
■
“Propriedades CSS suportadas” na página 448
■
“Criando um objeto de folha de estilos” na página 449
■
“Carregando arquivos CSS externos” na página 450
■
“Criando novos estilos com o ActionScript” na página 451
■
“Aplicando estilos a um objeto TextField” na página 452
447
■
“Aplicando uma folha de estilos a um componente TextArea” na página 452
■
“Combinando estilos” na página 453
■
“Usando classes de estilo” na página 454
■
“Atribuindo estilo a marcas HTML internas” na página 454
■
“Um exemplo do uso de estilos com HTML” na página 455
■
“Usando estilos para definir novas marcas” na página 458
■
“Um exemplo do uso de estilos com XML” na página 458
Você pode localizar um arquivo de origem de exemplo, formattedText.fla, na pasta Samples no
disco rígido, que mostra como aplicar a formatação CSS ao texto carregado em um arquivo
SWF durante a execução.
Tutorials/Samples/ActionScript/LoadText.
Propriedades CSS suportadas
O Flash Player suporta um subconjunto de propriedades na especificação CSS1 original
(www.w3.org/TR/REC-CSS1). A tabela a seguir mostra as propriedades e valores CSS
suportados, bem como os nomes de suas propriedades correspondentes no ActionScript. (O
nome de cada propriedade do ActionScript é derivado do nome da propriedade CSS
correspondente; o hífen é omitido e o caractere seguinte fica em letra maiúscula.)
Propriedade
CSS
Propriedade do
ActionScript
Uso e valores suportados
text-align
textAlign
Os valores reconhecidos são left, center, right e
justify.
font-size
fontSize
Apenas a parte numérica do valor é usada. As
unidades (px, pt) não são analisadas; pixels e
pontos são equivalentes.
text-decoration
textDecoration
Os valores reconhecidos são none e underline.
margin-left
marginLeft
margin-right
marginRight
448
Propriedade
CSS
Propriedade do
ActionScript
Uso e valores suportados
font-weight
fontWeight
Os valores reconhecidos são normal e bold.
kerning
kerning
Os valores reconhecidos são true e false.
font-style
fontStyle
Os valores reconhecidos são normal e italic.
letterSpacing
letterSpacing
text-indent
textIndent
font-family
fontFamily
Uma lista de fontes separadas por vírgulas para
usar, em ordem decrescente de interesse.
Qualquer nome de família de fonte pode ser
usado. Se você especificar um nome de fonte
genérica, ela será convertida em uma fonte de
dispositivo apropriada. As seguintes conversões
de fonte estão disponíveis: mono é convertida em
_typewriter, sans-serif, em _sans e serif, em
_serif.
color
color
Apenas valores de cores hexadecimais são
suportados. Cores com nome atribuído (como
blue) não são suportadas. As cores são escritas
no seguinte formato: #FF0000.
Criando um objeto de folha de estilos
As folhas de estilos CSS são representadas no ActionScript pela classe TextField.StyleSheet.
Essa classe só está disponível para arquivos SWF que se destinam ao Flash Player 7 ou versões
posteriores. Para criar um objeto de folha de estilos, chame a função construtora da classe
TextField.StyleSheet:
var newStyle:TextField.StyleSheet = new TextField.StyleSheet();
Para adicionar estilos a um objeto de folha de estilos, você pode carregar um arquivo CSS
externo no objeto ou definir os estilos no ActionScript. Consulte “Carregando arquivos CSS
externos” na página 450 e “Criando novos estilos com o ActionScript” na página 451.
449
Carregando arquivos CSS externos
Você pode definir estilos em um arquivo CSS externo e carregar esse arquivo em um objeto de
folha de estilos. Os estilos definidos no arquivo CSS são adicionados ao objeto de folha de
estilos. Para carregar um arquivo CSS externo, use o método load() da classe
TextField.StyleSheet. Para determinar quando o arquivo CSS finalizou a carga, use o
manipulador de eventos onLoad do objeto de folha de estilos.
No exemplo a seguir, você criará e carregará um arquivo CSS externo e usará o método
TextField.StyleSheet.getStyleNames() para recuperar os nomes dos estilos carregados.
Para carregar uma folha de estilos externa:
1.
Crie um novo arquivo no editor de texto ou CSS de sua preferência.
2.
Adicione as seguintes definições de estilo ao arquivo:
.bodyText {
font-family: Arial,Helvetica,sans-serif;
font-size: 12px;
}
.headline {
font-size: 24px;
}
3.
Salve o arquivo CSS como styles.css.
4.
No Flash, crie um novo arquivo FLA.
5.
Na Timeline (Linha do tempo), em Window (Janela) > Timeline, selecione Layer 1
(Camada 1).
6.
Abra o painel Actions (Ações) (Window > Actions).
7.
Adicione o seguinte código ao painel Actions:
var styles:TextField.StyleSheet = new TextField.StyleSheet();
styles.onLoad = function(success:Boolean):Void {
if (success) {
// exiba nomes de estilos.
trace(this.getStyleNames());
} else {
trace("Error loading CSS file.");
450
}
};
styles.load("styles.css");
NO T A
No trecho de código anterior, this.getStyleNames() refere-se ao objeto styles
criado na primeira linha do ActionScript.
8.
Salve o arquivo FLA no mesmo diretório que contém o arquivo styles.css.
9.
Teste o documento do Flash (Control [Controlar] > Test Movie [Testar filme]).
Você deve ver os nomes dos dois estilos exibidos no painel Output (Saída):
.bodyText,.headline
Se a mensagem “Error loading CSS file.” (Erro ao carregar o arquivo CSS) for exibida no
painel Output, verifique se o arquivo FLA e o arquivo CSS estão no mesmo diretório e se
digitou o nome do arquivo CSS corretamente.
Como com todos os outros métodos do ActionScript que carregam dados pela rede, o arquivo
CSS deve ser estar no mesmo domínio que o arquivo SWF que está carregando o arquivo.
(Consulte “Acesso entre domínios e a subdomínios entre arquivos SWF” na página 729.) Para
obter mais informações sobre o uso de estilos CSS com o Flash, consulte %{StyleSheet
(TextField.StyleSheet)}% em ActionScript 2.0 Language Reference.
Criando novos estilos com o ActionScript
Você pode criar novos estilos de texto com o ActionScript usando o método setStyle() da
classe TextField.StyleSheet. Este método tem dois parâmetros: o nome do estilo e um objeto
que define as propriedades desse estilo.
Por exemplo, o código a seguir cria um objeto de folha de estilos chamado styles que define
dois estilos idênticos aos já importados (consulte “Carregando arquivos CSS externos”
na página 450):
styles.setStyle("bodyText",
{fontFamily: 'Arial,Helvetica,sans-serif',
fontSize: '12px'}
451
);
styles.setStyle("headline",
{fontFamily: 'Arial,Helvetica,sans-serif',
fontSize: '24px'}
);
Aplicando estilos a um objeto TextField
Para aplicar um objeto de folha de estilos a um objeto TextField, atribua esse objeto à
propriedade styleSheet do campo de texto.
textObj_txt.styleSheet = styles;
NO TA
Não confunda a propriedade TextField.styleSheet com a classe TextField.StyleSheet.
O uso de maiúsculas ou minúsculas indica a diferença.
Quando você atribui um objeto de folha de estilos a um objeto TextField, as seguintes
alterações ocorrem no comportamento normal do campo de texto:
■
As propriedades text e htmlText do campo de texto, e qualquer variável associada ao
campo de texto, sempre contêm o mesmo valor e comportam-se de maneira idêntica.
■
O campo de texto torna-se somente leitura e não pode ser editado pelo usuário.
■
Os métodos setTextFormat() e replaceSel() da classe TextField não funcionam mais
com o campo de texto. A única maneira de alterar o campo é alterando as propriedades
text ou htmlText do campo de texto, ou alterando a variável associada ao campo de
texto.
■
Qualquer texto atribuído às propriedades text e htmlText do campo de texto ou à
variável associada é armazenado literalmente; tudo que for escrito em uma dessas
propriedades pode ser recuperado na forma original do texto.
Aplicando uma folha de estilos a um componente
TextArea
Para aplicar uma folha de estilos a um componente TextArea, crie um objeto de folha de
estilos e atribua a ele estilos HTML usando a classe TextField.StyleSheet. Em seguida, atribua
a folha de estilos à propriedade styleSheet do componente TextArea.
Os exemplos a seguir criam um objeto de folha de estilos, styles, e atribuem a ele a instância
do componente myTextArea.
Usando uma folha de estilos com um componente TextArea
1.
Crie um novo documento do Flash e salve-o como textareastyle.fla.
452
2.
Arraste um componente TextArea da pasta User Interface do painel Components
(Componentes) para o Stage (Palco) e atribua a ele o nome de instância myTextArea.
3.
principal:
// Create a new style sheet object and set styles for it.
styles.setStyle("html", {fontFamily:'Arial,Helvetica,sans-serif',
fontSize:'12px',
color:'#0000FF'});
styles.setStyle("body", {color:'#00CCFF',
textDecoration:'underline'});
styles.setStyle("h1",{fontFamily:'Arial,Helvetica,sans-serif',
fontSize:'24px',
color:'#006600'});
/* Assign the style sheet object to myTextArea component. Set html
property to true, set styleSheet property to the style sheet object.
*/
myTextArea.styleSheet = styles;
myTextArea.html = true;
var myVars:LoadVars = new LoadVars();
// Define onData handler and load text to be displayed.
myVars.onData = function(myStr:String):Void {
if (myStr != undefined) {
myTextArea.text = myStr;
} else {
trace("Unable to load text file.");
}
};
myVars.load("http://www.helpexamples.com/flash/myText.htm");
O bloco de código anterior cria uma nova instância TextField.StyleSheet, que define três
estilos para as marcas HTML html, body e h1. A seguir, o objeto de folha de estilos é
aplicado ao componente TextArea, e a formatação HTML é ativada. O restante do
ActionScript define um objeto LoadVars que carrega um arquivo HTML externo e
preenche a área de texto com o texto carregado.
4.
Flash.
Combinando estilos
Os estilos CSS no Flash Player são aditivos; ou seja, quando os estilos são aninhados, cada
nível de aninhamento pode contribuir com informações de estilo, que são acrescentadas juntas
para resultar na formatação final.
453
O exemplo a seguir mostra alguns dados XML atribuídos a um campo de texto:
<sectionHeading>This is a section</sectionHeading>
<mainBody>This is some main body text, with one
<emphasized>emphatic</emphasized> word.</mainBody>
Na palavra enfatizada no texto anterior, o estilo emphasized é aninhado no estilo mainBody.
O estilo mainBody contribui com regras de cor, tamanho de fonte e formatação. O estilo
emphasized adiciona uma regra de espessura de fonte a essas regras. A palavra enfatizada será
formatada usando uma combinação das regras especificadas por mainBody e emphasized.
Usando classes de estilo
Você pode criar “classes” de estilo (diferentes das classes do ActionScript 2.0) que podem ser
aplicadas a uma marca ou usando o atributo class da marca. Quando aplicado a
uma marca , o estilo é aplicado no parágrafo inteiro. Você também pode usar a marca
 para atribuir um estilo a um intervalo de texto que use uma classe de estilo.
Por exemplo, a folha de estilos a seguir define duas classes de estilos: mainBody e emphasis.
.mainBody {
font-size: 24px;
}
.emphasis {
color: #666666;
font-style: italic;
}
No texto HTML que você atribui a um campo de texto, é possível aplicar esses estilos às
marcas e , como mostra o seguinte trecho:
This is really exciting!
Atribuindo estilo a marcas HTML internas
O Flash Player oferece suporte a um subconjunto de marcas HTML. Para obter mais
informações, consulte “Usando texto em formato HTML” na página 461. Você pode atribuir
um estilo CSS a cada instância de uma marca HTML interna que aparece em um campo de
texto. Por exemplo, o código a seguir define um estilo para a marca HTML interna. Todas
as instâncias dessa marca receberão um estilo da maneira especificada pela regra de estilo.
p {
font-size: 12px;
display: inline;
}
454
A tabela a seguir mostra as marcas HTML internas que podem receber um estilo e como cada
estilo é aplicado:
Nome do
estilo
Como o estilo se aplica
p
Afeta todas as marcas .
body
Afeta todas as marcas <body>. O estilo p , se especificado, tem precedência
sobre o estilobody.
li
Afeta todas as marcas de bullet <li>.
a
Afeta todas as marcas de âncora <a>.
a:link
Afeta todas as marcas de âncora <a>. Este estilo é aplicado após qualquer
estilo a.
a:hover
Aplicado a uma marca de âncora <a> quando o ponteiro do mouse está
posicionado sobre o link. Este estilo é aplicado após qualquer estilo a e
a:link.
Quando o ponteiro do mouse sai do link, o estilo a:hover é removido do link.
a:active
Aplicado a uma marca de âncora <a> quando o usuário clica no link. Este
estilo é aplicado após qualquer estilo a e a:link.
Depois que o botão do mouse é liberado, o estilo a:active é removido do link.
Um exemplo do uso de estilos com HTML
Esta seção apresenta um exemplo de uso de estilos com marcas HTML. Você pode criar uma
folha de estilos que atribui um estilo a algumas marcas internas e define algumas classes de
estilo. Em seguida, poderá aplicar essa folha de estilos a um objeto TextField que contém texto
em formato HTML.
Para formatar um texto HTML com uma folha de estilo:
1.
Crie um novo arquivo no editor de texto ou CSS de sua preferência.
2.
Adicione a seguinte definição de folha de estilos ao arquivo:
p {
color: #000000;
font-size: 12px;
display: inline;
}
a:link {
color: #FF0000;
}
455
a:hover{
text-decoration: underline;
}
.headline {
color: #000000;
font-size: 18px;
font-weight: bold;
display: block;
}
.byline {
color: #666600;
font-style: italic;
font-weight: bold;
display: inline;
}
Essa folha de estilos define estilos para duas marcas HTML internas ( e <a>) que serão
aplicadas a todas as instâncias dessas marcas. Ela também define duas classes de estilos
(.headline e .byline) que serão aplicadas a parágrafos específicos e intervalos de texto.
3.
Salve o arquivo como html_styles.css.
4.
Crie um novo arquivo de texto em um editor de texto ou HTML e salve o documento
como myText.htm.
Adicione o código a seguir ao arquivo:
Flash adds FlashType rendering technology!San Francisco, CA--Macromedia Inc.
announced today a new version of Flash that features a brand new font
rendering technology called FlashType, most excellent at rendering
small text with incredible clarity and consistency across platforms.
For more information, visit the <a href='http://
www.macromedia.com'>Macromedia Flash web site.</a>
N OT A
Se você copiar e colar essa seqüência de caracteres de texto, remova todas as
quebras de linha que possam ter sido adicionadas à seqüência de caracteres de
texto.
5.
Crie o novo documento do Flash na ferramenta de criação do Flash.
6.
Selecione o primeiro quadro na Layer 1 da Timeline (Window [Janela] > Timeline).
7.
Abra o painel Actions (Ações) (Window > Actions) e adicione o seguinte código a ele:
this.createTextField("news_txt", 99, 50, 50, 450, 300);
news_txt.border = true;
news_txt.html = true;
news_txt.multiline = true;
news_txt.wordWrap = true;
456
// Create a new style sheet and LoadVars object.
var myVars_lv:LoadVars = new LoadVars();
// Location of CSS and text files to load.
var txt_url:String = "myText.htm";
var css_url:String = "html_styles.css";
// Define onData handler and load text to display.
myVars_lv.onData = function(src:String):Void {
news_txt.htmlText = src;
} else {
trace("Unable to load HTML file");
}
};
myVars_lv.load(txt_url);
// Define onLoad handler and Load CSS file.
styles.onLoad = function(success:Boolean):Void {
if (success) {
/* Se a folha de estilos tiver sido carregada sem erros,
atribua-a ao objeto de texto
e atribua o texto HTML ao campo de texto. */
news_txt.styleSheet = styles;
news_txt.text = storyText;
} else {
trace("Unable to load CSS file.");
}
};
styles.load(css_url);
N OT A
Nesse ActionScript, você está carregando o texto de um arquivo externo. Para obter
informações sobre como carregar dados externos, consulte o Capítulo 15,
“Trabalhando com imagens, som e vídeo.”
8.
Salve o arquivo como news_html.fla no mesmo diretório que contém o arquivo CSS
criado na etapa 3.
9.
Selecione Control (Controlar) > Test Movie (Testar filme) para ver os estilos aplicados ao
texto HTML automaticamente.
457
Usando estilos para definir novas marcas
Se você definir um novo estilo em uma folha de estilos, esse estilo poderá ser usado como
marca, da mesma maneira que você usaria uma marca HTML interna. Por exemplo, se uma
folha de estilos definir um estilo CSS chamado sectionHeading, você poderá usar
<sectionHeading> como elemento em qualquer campo de texto associado à folha de estilos.
Esse recurso permite atribuir qualquer texto em formato XML diretamente ao campo de
texto, de maneira que o texto seja formatado automaticamente usando as regras da folha de
estilos.
Por exemplo, a folha de estilos a seguir cria os novos estilos sectionHeading, mainBody
e emphasized.
.sectionHeading {
font-family: Verdana, Arial, Helvetica, sans-serif;
font-size: 18px;
display: block
}
.mainBody {
color: #000099;
text-decoration: underline;
font-size: 12px;
display: block
}
.emphasized {
font-weight: bold;
display: inline
}
Você pode preencher um campo de texto associado a essa folha de estilos com o seguinte texto
em formato XML:
<sectionHeading>This is a section</sectionHeading>
<mainBody>This is some main body text,
with one <emphasized>emphatic</emphasized> word.
</mainBody>
Um exemplo do uso de estilos com XML
Nesta seção, você criará um arquivo FLA com texto em formato XML. Você criará uma folha
de estilos usando o ActionScript, em vez de importando estilos de um arquivo CSS como
mostrado em “Um exemplo do uso de estilos com HTML” na página 455
Para formatar XML com uma folha de estilo:
1.
No Flash, crie um documento FLA.
458
2.
Usando a ferramenta Text (Texto), crie um campo de texto de aproximadamente 400 pixels
de largura por 300 pixels de altura.
3.
Abra o inspetor Properties (Propriedades) (Window [Janela] > Properties > Properties) e
selecione o campo de texto.
4.
No inspetor Properties, selecione Dynamic Text no menu Text Type, selecione Multiline
no menu Line Type, selecione a opção Render Text as HTML e digite news_txt na caixa
de texto Instance Name.
5.
Na Layer 1 da Timeline (Window > Timeline), selecione o primeiro quadro.
6.
Para criar o objeto de folha de estilos, abra o painel Actions (Window > Actions) e adicione
o seguinte código:
styles.setStyle("mainBody", {
color:'#000000',
fontFamily:'Arial,Helvetica,sans-serif',
fontSize:'12',
display:'block'
});
styles.setStyle("title", {
color:'#000000',
fontFamily:'Arial,Helvetica,sans-serif',
fontSize:'18',
display:'block',
fontWeight:'bold'
});
styles.setStyle("byline", {
color:'#666600',
fontWeight:'bold',
fontStyle:'italic',
display:'inline'
});
styles.setStyle("a:link", {
color:'#FF0000'
});
styles.setStyle("a:hover", {
textDecoration:'underline'
});
Esse código cria um novo objeto de folha de estilos chamado styles que define estilos
usando o método setStyle(). Os estilos correspondem exatamente aos criados em um
arquivo CSS externo, anteriormente neste capítulo.
459
7.
Para criar o texto XML a ser atribuído ao campo de texto, abra um editor de texto e digite
o seguinte texto em um novo documento:
<story><title>Flash now has FlashType</title><mainBody><byline>San
Francisco, CA</byline>--Macromedia Inc. announced today a new version
of Flash that features the new FlashType rendering technology. For
more information, visit the <a href="http://
www.macromedia.com">Macromedia Flash website</a></mainBody></story>
NO TA
Se você copiar e colar essa seqüência de caracteres de texto, remova todas as
quebras de linha que possam ter sido adicionadas à seqüência de caracteres de
texto. Selecione Hidden Characters (Caracteres ocultos) no menu pop-up do painel
Actions para ver e remover quaisquer quebras de linha extras.
8.
Salve o arquivo de texto como story.xml.
9.
No Flash, adicione o código a seguir no painel Actions, de acordo com o código da etapa 6.
Esse código carrega o documento story.xml, atribui o objeto de folha de estilos à
propriedade styleSheet do campo de texto e atribui o texto XML ao campo de texto:
var my_xml:XML = new XML();
my_xml.ignoreWhite = true;
my_xml.onLoad = function(success:Boolean):Void {
if (success) {
news_txt.styleSheet = styles;
news_txt.text = my_xml;
} else {
trace("Error loading XML.");
}
};
my_xml.load("story.xml");
N OT A
10. Salve
11.
Você está carregando dados XML de um arquivo externo nesse ActionScript.
Para obter informações sobre como carregar dados externos, consulte o
Capítulo 15, “Trabalhando com imagens, som e vídeo.”.
o arquivo como news_xml.fla na mesma pasta que story.xml.
Execute o arquivo SWF (Control [Controlar] > Test Movie [Testar filme]) para ver os
estilos aplicados automaticamente ao texto no campo de texto.
460
Usando texto em formato HTML
O Flash Player oferece suporte a um subconjunto de marcas HTML padrão, como e
<li>, que você pode usar para atribuir um estilo a um texto em qualquer campo de texto
dinâmico ou de entrada. No Flash Player 7 e versões posteriores, os campos de texto também
oferecem suporte à marca <img>, o que permite incorporar arquivos de imagem (JPEG, GIF,
PNG), arquivos SWF e clipes de filme nesses campos. O Flash Player envolverá
automaticamente o texto em torno das imagens incorporadas nos campos de texto, de maneira
muito parecida com um navegador da Web que envolve o texto em torno de imagens
incorporadas em uma página HTML. “Sobre a incorporação de imagens, arquivos SWF e
clipes de filme em campos de texto” na página 470Para obter mais informações, consulte .
O Flash Player também oferece suporte à marca <textformat>, que permite a aplicação de
estilos de formatação de parágrafo da classe TextFormat em campos de texto ativados por
HTML. Para obter mais informações, consulte “Usando a classe TextFormat” na página 444.
Para obter mais informações sobre texto em formato HTML, consulte os seguintes tópicos:
■
“Propriedades e sintaxe necessárias para usar texto em formato HTML” na página 461
■
“Sobre marcas HTML suportadas” na página 462
■
“Sobre entidades HTML suportadas” na página 469
■
“Sobre a incorporação de imagens, arquivos SWF e clipes de filme em campos de texto”
na página 470
Propriedades e sintaxe necessárias para usar texto
em formato HTML
Para usar o formato HTML em um campo de texto, você deve definir várias propriedades do
campo no inspetor Properties (Propriedades) ou usando o ActionScript:
■
Ative a formatação HTML do campo de texto selecionando a opção Render Text as
HTML (Renderizar texto como HTML) no inspetor Properties ou definindo a
propriedade html do campo como true.
■
Para usar marcas HTML, como , e <img>, você deve tornar o campo de texto um
campo de várias linhas selecionando a opção Multiline (Várias linhas) no inspetor
Properties ou definindo a propriedade multiline do campo como true.
■
No ActionScript, defina o valor de TextField.htmlText com a seqüência de caracteres
de texto em formato HTML que deseja exibir.
Por exemplo, o código a seguir ativa a formatação HTML em um campo de texto chamado
headline_txt e atribui um código HTML ao campo de texto:
461
this.createTextField("headline_txt", 1, 10, 10, 500, 300);
headline_txt.html = true;
headline_txt.wordWrap = true;
headline_txt.multiline = true;
headline_txt.htmlText = "This is how
you assign HTML text to a text field. It's very useful.";
Para renderizar o HTML corretamente, é necessário usar a sintaxe adequada. Os atributos das
marcas HTML devem estar entre aspas simples (') ou duplas("). Os valores de atributos sem
aspas podem produzir resultados inesperados, como renderização de texto imprópria. Por
exemplo, o trecho de HTML a seguir não pode ser renderizado adequadamente pelo Flash
Player porque o valor atribuído ao atributo align (left) não está entre aspas:
this.createTextField("myField_txt", 10, 10, 10, 400, 200);
myField_txt.html = true;
myField_txt.htmlText = "This is left-aligned text";
Se você colocar os valores do atributo entre aspas duplas, deverá acrescentar um caractere de
escape para fechar as aspas (\"). Há duas maneiras aceitáveis de fazer isso:
myField_txt.htmlText
p>";
p>';
= "This uses single quotes";
= "This uses escaped double quotes</
= 'This uses outer single quotes';
= 'This uses escaped single quotes</
Você não precisará acrescentar um caractere de escape para fechar as aspas duplas se estiver
carregando texto de um arquivo externo; isso só será necessário se você estiver atribuindo uma
seqüência de caracteres de texto no ActionScript.
Sobre marcas HTML suportadas
Esta seção lista as marcas HTML internas que o Flash Player suporta. Você também pode criar
novos estilos e marcas usando folhas de estilos CSS; consulte “Formatando texto com estilos
CSS” na página 447.
Para obter mais informações sobre marcas HTML suportadas, consulte os seguintes tópicos:
■
“Marca de âncora” na página 463
■
“Marca de negrito” na página 463
■
“Marca de quebra” na página 464
■
“Marca de fonte” na página 464
■
“Marca de imagem” na página 465
■
“Marca de itálico” na página 466
■
“Marca de item de lista” na página 466
462
■
“Marca de parágrafo” na página 466
■
“Marca de intervalo” na página 467
■
“Marca de formatação de texto” na página 467
■
“Marca de sublinhado” na página 469
Marca de âncora
A marca <a> cria um hiperlink e oferece suporte aos seguintes atributos:
■
href Uma seqüência de até 128 caracteres que especifica o URL da página a ser
carregada no navegador. O URL pode ser absoluto ou relativo ao local do arquivo SWF
que está carregando a página. Um exemplo de referência absoluta a um URL é http://
www.macromedia.com; um exemplo de referência relativa é /index.html.
■
target Especifica o nome da janela de destino na qual a página será carregada. As
opções incluem _self, _blank, _parent e _top. A opção _self especifica o quadro atual
na janela atual, _blank especifica uma nova janela, _parent especifica o pai do quadro
atual e _top especifica o quadro de nível superior na janela atual.
Por exemplo, o código HTML a seguir cria o link “Vá para a página inicial”, que abre o site
www.macromedia.com em uma nova janela do navegador.
urlText_txt.htmlText = "<a href='http://www.macromedia.com'
target='_blank'>Go home</a>";
Você pode usar o protocolo asfunction especial para fazer com que o link execute uma
função do ActionScript em um arquivo SWF, em vez de abrir um URL. Para obter mais
informações sobre o protocolo asfunction, consulte %{asfunction protocol}% em
Você também pode definir os estilos a:link, a:hover e a:active para marcas de âncora
usando a folha de estilos. Consulte “Atribuindo estilo a marcas HTML internas”
na página 454.
NO T A
Os URLs absolutos devem ter o prefixo http://; caso contrário, o Flash os tratará como
URLs relativos.
Marca de negrito
A marca renderiza o texto como negrito, como mostra este exemplo:
text3_txt.htmlText = "He was ready to leave!";
Um tipo em negrito deve estar disponível para a fonte usada para exibir o texto.
463
Marca de quebra
A marca cria uma quebra de linha no campo de texto. Para usar essa marca, defina o
campo de texto como um campo de várias linhas.
No exemplo a seguir, há uma quebra de linha entre as frases:
this.createTextField("text1_txt", 1, 10, 10, 200, 100);
text1_txt.html = true;
text1_txt.multiline = true;
text1_txt.htmlText = "The boy put on his coat. His coat was red plaid.";
Marca de fonte
A marca especifica uma fonte ou lista de fontes para exibir o texto.
A marca font oferece suporte aos seguintes atributos:
■
Apenas valores de cor hexadecimais (#FFFFFF) são suportados. Por exemplo, o
código HTML a seguir cria texto vermelho:
color
myText_txt.htmlText = "This is red text";
■
Especifica o nome da fonte que será usada. Como mostra o exemplo a seguir, você
pode especificar uma lista de nomes de fontes delimitados por vírgula; nesse caso, o Flash
Player selecionará a primeira fonte disponível:
face
myText_txt.htmlText = "Displays as
either Times or Times New Roman...";
Se a fonte especificada não estiver instalada no computador do usuário ou não estiver
incorporada no arquivo SWF, o Flash Player escolherá uma fonte substituta.
Para obter mais informações sobre a incorporação de fontes em aplicativos Flash, consulte
%{embedFonts (TextField.embedFonts property)}% em ActionScript 2.0 Language
Reference e “Definindo opções de texto dinâmico e de entrada” em Usando o Flash.
■
size
Especifica o tamanho da fonte, em pixels, como mostra este exemplo:
myText_txt.htmlText = "This is blue, 24point text";
Você também pode usar tamanhos de ponto relativos em vez de um tamanho de pixel,
como +2 ou -4.
464
Marca de imagem
A marca <img> permite incorporar clipes de filme, arquivos SWF e arquivos de imagem
(JPEG, GIF, PNG) externos em campos de texto e instâncias do componente TextArea. O
texto flui automaticamente em torno das imagens incorporadas nos campos de texto ou nos
componentes. Para usar essa marca, você deve definir o campo de texto dinâmico ou de
entrada como um campo de várias linhas, com quebra automática de texto.
Para criar um campo de texto de várias linhas com quebra automática de
linha, siga um destes procedimentos:
■
No ambiente de criação do Flash, selecione um campo de texto no Stage (Palco) e, no
inspetor Properties (Propriedades), selecione Multiline (Várias linhas) no menu pop-up
Text Type (Tipo de texto).
■
Para um campo de texto criado durante a execução com %{createTextField
(MovieClip.createTextField method)}%, defina as novas propriedades %{multiline
(TextField.multiline property)}% e %{multiline (TextField.multiline property)}% da
instância do campo de texto como true.
A marca <img> tem um atributo obrigatório, src, que especifica o caminho para um arquivo
de imagem, um arquivo SWF ou o identificador de vinculação de um símbolo de clipe de
filme da biblioteca. Todos os outros atributos são opcionais.
As marcas <img> oferecem suporte aos seguintes atributos:
■
src
Especifica o URL para um arquivo de imagem ou SWF ou para o identificador de
vinculação de um símbolo de clipe de filme da biblioteca. Este atributo é obrigatório;
todos os outros atributos são opcionais. Os arquivos externos (JPEG, GIF, PNG e SWF)
só serão exibidos após a conclusão do download.
■
id Especifica o nome da instância de clipe de filme (criada pelo Flash Player) que
contém o arquivo de imagem, o arquivo SWF ou o clipe de filme incorporado. É útil para
controlar o conteúdo incorporado com o ActionScript.
■
A largura da imagem, do arquivo SWF ou do clipe de filme que está sendo
inserido, em pixels.
■
A altura da imagem, do arquivo SWF ou do clipe de filme que está sendo
inserido, em pixels.
■
Especifica o alinhamento horizontal da imagem incorporada no campo de texto.
Os valores válidos são left e right. O valor padrão é left.
■
Especifica a quantidade de espaço horizontal em torno da imagem onde
nenhum texto aparecerá. O valor padrão é 8.
■
Especifica a quantidade de espaço vertical em torno da imagem onde nenhum
texto aparecerá. O valor padrão é 8.
width
height
align
hspace
vspace
465
Para obter mais informações e exemplos do uso da marca <img>, consulte “Sobre a
incorporação de imagens, arquivos SWF e clipes de filme em campos de texto” na página 470.
Marca de itálico
A marca exibe o texto marcado em itálico, como mostra o seguinte código:
That is very interesting.
Esse exemplo de código seria renderizado da seguinte maneira:
That is very interesting.
Um tipo itálico deve estar disponível para a fonte usada.
Marca de item de lista
A marca <li> coloca um marcador na frente do texto incluído nela, como mostra o seguinte
código:
Grocery list:
<li>Apples</li>
<li>Oranges</li>
<li>Lemons</li>
Esse exemplo de código seria renderizado da seguinte maneira:
Grocery list:
■
Apples
■
Oranges
■
Lemons
N OT A
As listas ordenadas e não ordenadas (marcas<ol> e <ul>) não são reconhecidas pelo
Flash Player e, portanto, não modificam o modo como sua lista é renderizada. Todos
os itens de lista usam marcadores.
Marca de parágrafo
A marca cria um novo parágrafo. Para usar essa marca, defina o campo de texto como um
campo de várias linhas.
A marca oferece suporte aos seguintes atributos:
Especifica o alinhamento do texto no parágrafo; os valores válidos são left,
right, justify e center.
■
align
■
class
Especifica uma classe de estilo CSS definida em um objeto TextField.StyleSheet.
Para obter mais informações, consulte “Usando classes de estilo” na página 454.
466
O exemplo a seguir usa o atributo align para alinhar o texto no lado direito de um campo
de texto.
this.createTextField("myText_txt", 1, 10, 10, 400, 100);
myText_txt.html = true;
myText_txt.multiline = true;
myText_txt.htmlText = "This text is aligned on the
right side of the text field";
O exemplo a seguir usa o atributo class para atribuir uma classe de estilo de texto a uma
marca :
var myStyleSheet:TextField.StyleSheet = new TextField.StyleSheet();
myStyleSheet.setStyle(".blue", {color:'#99CCFF', fontSize:18});
this.createTextField("test_txt", 10, 0, 0, 300, 100);
test_txt.html = true;
test_txt.styleSheet = myStyleSheet;
test_txt.htmlText = "This is some body-styled text..";
Marca de intervalo
A marca está disponível somente para uso com os estilos de texto CSS. Para obter mais
informações, consulte “Formatando texto com estilos CSS” na página 447. Ela oferece
suporte ao seguinte atributo:
■
Especifica uma classe de estilo CSS definida em um objeto TextField.StyleSheet.
Para obter mais informações sobre a criação de classes de estilo de texto, consulte “Usando
classes de estilo” na página 454.
class
Marca de formatação de texto
A marca <textformat> permite usar um subconjunto das propriedades de formatação de
parágrafo da classe TextFormat nos campos de texto HTML, incluindo entrelinhamento,
recuo, margens e interrupções de tabulação. Você pode combinar as marcas <textformat>
com as marcas HTML internas.
A marca <textformat> tem os seguintes atributos:
■
Especifica o recuo do bloco em pontos; corresponde a
TextFormat.blockIndent. (Consulte %{blockIndent (TextFormat.blockIndent
property)}% em ActionScript 2.0 Language Reference.)
■
indent Especifica o recuo do primeiro caractere no parágrafo em relação à margem
esquerda; corresponde a TextFormat.indent. Permite usar inteiros negativos. (Consulte
%{indent (TextFormat.indent property)}% em ActionScript 2.0 Language Reference.)
blockindent
467
■
Especifica a quantidade de espaço vertical entre as linhas; corresponde ao
Permite usar inteiros negativos. (Consulte %{leading
(TextFormat.leading property)}% em ActionScript 2.0 Language Reference.)
leading
TextFormat.leading.
■
Especifica a margem esquerda do parágrafo, em pontos; corresponde ao
TextFormat.leftMargin. (Consulte %{leftMargin (TextFormat.leftMargin property)}%
em ActionScript 2.0 Language Reference.)
■
Especifica a margem direita do parágrafo, em pontos; corresponde ao
(Consulte %{rightMargin (TextFormat.rightMargin
property)}% em ActionScript 2.0 Language Reference.)
leftmargin
rightmargin
TextFormat.rightMargin.
■
tabstops Especifica as interrupções de tabulação personalizadas como um array de
inteiros não negativos; corresponde ao TextFormat.tabStops. (Consulte %{tabStops
(TextFormat.tabStops property)}% em ActionScript 2.0 Language Reference.)
Esta tabela de dados com cabeçalhos de linha em negrito é o resultado do exemplo de código
no procedimento apresentado a seguir:
Name
Age
Occupation
Rick
33
Detective
AJ
34
Detective
Para criar uma tabela formatada de dados usando interrupções de tabulação:
1.
Crie um novo documento do Flash e salve-o como tabstops.fla.
2.
Na Timeline, selecione o primeiro quadro na Layer 1.
3.
Abra o painel Actions (Ações) (Window (Janela) > Actions) e digite o seguinte código:
// Crie um novo campo de texto.
this.createTextField("table_txt", 99, 50, 50, 450, 100);
table_txt.multiline = true;
table_txt.html = true;
// Crie cabeçalhos de coluna, formatados em negrito, separados por
tabulações.
var rowHeaders:String = "Name\tAge\tOccupation";
// Crie linhas com dados.
var row_1:String = "Rick\t33\tDetective";
var row_2:String = "AJ\t34\tDetective";
// Defina duas interrupções de tabulação nos pontos 50 e 100.
table_txt.htmlText = "<textformat tabstops='[50,100]'>";
table_txt.htmlText += rowHeaders;
table_txt.htmlText += row_1;
table_txt.htmlText += row_2 ;
table_txt.htmlText += "</textformat>";
468
O uso da seqüência de escape do caractere de tabulação (\t) adiciona tabulações entre
cada coluna da tabela. Use o operador += para anexar texto.
4.
Selecione Control (Controlar) > Test Movie (Testar filme) para exibir a tabela formatada.
Marca de sublinhado
A marca sublinha o texto marcado, como mostra o seguinte código:
This is underlined text.
Esse código seria renderizado da seguinte maneira:
Sobre entidades HTML suportadas
As entidades HTML ajudam a exibir determinados caracteres em campos de texto em formato
HTML, a fim de que não sejam interpretados como HTML. Por exemplo, os caracteres
“menor que” (<) e “maior que” (>) servem para delimitar as marcas HTML, como <img> e
. No Flash, para exibir os caracteres “maior que” e “menor que” em campos de texto
em formato HTML, é necessário substituir esses caracteres por entidades HTML. O
ActionScript a seguir cria um campo de texto em formato HTML no Stage (Palco) e usa
entidades HTML para exibir a seqüência de caracteres “” sem que o texto apareça em
negrito:
my_txt.html = true;
my_txt.htmlText = "The tag makes text appear bold.";
Durante a execução, o código de exemplo anterior do Flash exibe o seguinte texto no Stage:
The tag makes text appear bold.
Além dos símbolos “maior que” e “menor que”, o Flash também reconhece outras entidades
HTML listadas na tabela apresentada a seguir.
Entidade
Descrição
<
< (menor que)
>
> (maior que)
&
E comercial (&)
"
" (aspas duplas)
'
' (apóstrofo, aspas simples)
469
O Flash também suporta códigos de caracteres explícitos, como ' (E comercial - ASCII)
e & (E comercial - Unicode).
O ActionScript a seguir demonstra como usar códigos de caracteres ASCII ou Unicode para
incorporar um caractere de til (~):
my_txt.html = true;
my_txt.htmlText = "~"; // tilde (ASCII)
my_txt.htmlText += "\t"
my_txt.htmlText += "~"; // tilde (Unicode)
Sobre a incorporação de imagens, arquivos SWF e
clipes de filme em campos de texto
No Flash Player 7 e versões posteriores, você pode usar a marca <img> para incorporar
arquivos de imagem (JPEG, GIF, PNG), arquivos SWF e clipes de filmes em campos de texto
dinâmico e de entrada, bem como em instâncias do componente TextArea. (Para obter uma
lista completa de atributos da marca <img>, consulte “Marca de imagem” na página 465.)
O Flash exibe a mídia incorporada em um campo de texto em seu tamanho total. Para
especificar as dimensões da mídia que está sendo incorporada, use os atributos height e
width da marca <img>. (Consulte “Sobre a especificação dos valores de altura e largura”
na página 472.)
Em geral, uma imagem incorporada em um campo de texto aparece na linha seguinte à marca
<img>. Entretanto, quando a marca <img> é o primeiro caractere no campo de texto, a
imagem aparece na primeira linha do campo de texto.
Incorporando arquivos SWF e de imagem
Para incorporar um arquivo de imagem ou SWF em um campo de texto, especifique o
caminho absoluto ou relativo para o arquivo da imagem (GIF, JPEG ou PNG) ou SWF no
atributo src da marca <img>. Por exemplo, o exemplo a seguir insere um arquivo GIF
localizado no mesmo diretório que o arquivo SWF (um endereço relativo, on-line ou off-line).
Incorporando uma imagem a um campo de texto:
1.
470
Crie um novo documento do Flash e salve-o como embedding.fla.
2.
principal:
this.createTextField("image1_txt", 10, 50, 50, 450, 150);
image1_txt.html = true;
image1_txt.htmlText = "Here's a picture from my vacation:<img
src='beach.gif'>";
O código anterior cria um novo campo de texto dinâmico no Stage (Palco), ativa a
formatação HTML e adiciona um texto ou imagem local ao campo de texto.
3.
Adicione o seguinte ActionScript abaixo do código adicionado na etapa anterior:
this.createTextField("image2_txt", 20, 50, 200, 400, 150);
image2_txt.html = true;
image2_txt.htmlText = "Here's a picture from my garden:<img
src='http://www.helpexamples.com/flash/images/image2.jpg'>";
Também é possível inserir uma imagem usando um endereço absoluto. O código anterior
insere um arquivo JPEG localizado em um diretório em um servidor. O arquivo SWF que
contém esse código pode estar no disco rígido ou em um servidor.
4.
Salve o documento e selecione Control (Controlar) > Test Movie (Testar filme) para testar
o documento.
O campo de texto superior deveria ter uma frase e, muito provavelmente, uma mensagem
de erro no painel Output (Saída), informando que o Flash não pôde localizar um arquivo
chamado beach.gif no diretório atual. O campo de texto inferior deveria ter uma frase e a
imagem de uma flor carregada do servidor remoto.
Copie uma imagem GIF para o mesmo diretório de FLA, renomeie a imagem como
beach.gif e selecione Control > Test Movie para testar novamente o documento do Flash.
NO T A
Ao usar URLs absolutos, verifique se o URL tem o prefixo http://.
Incorporando símbolos de clipe de filme
Para incorporar um símbolo do clipe de filme a um campo de texto, especifique o
identificador de vinculação do símbolo para o atributo src da marca <img>. (Para obter
informações sobre a definição de um identificador de vinculação, consulte “Anexando um
símbolo de clipe de filme ao Stage” na página 381.)
Por exemplo, o código a seguir insere um símbolo de clipe de filme com o identificador de
vinculação symbol_ID em um campo de texto dinâmico com o nome de instância
textField_txt.
471
Para incorporar um clipe de filme a um campo de texto:
1.
Crie um novo documento do Flash e salve-o como embeddedmc.fla.
2.
Desenhe uma nova forma no Stage (Palco) ou selecione File (Arquivo) > Import (Importar)
> Import to Stage (Importar para o palco) e depois selecione uma imagem com mais ou
menos 100 pixels de largura por 100 pixels de altura.
3.
Converta a forma ou imagem importada na etapa anterior, selecionando-a no Stage e
pressionando F8 para abrir a caixa de diálogo Convert to Symbol (Converter em símbolo).
4.
Defina o comportamento como Movie Clip (Clipe de filme) e digite um nome de símbolo
descritivo. Selecione o quadrado superior esquerdo da grade de ponto de registro e clique
em Advanced (Avançado) para alternar para o modo avançado, caso ainda não o tenha
feito.
5.
Marque as caixas de seleção Export for ActionScript (Exportar para ActionScript) e Export
in First Frame (Exportar no primeiro quadro).
6.
Digite o identificador de vinculação img_id na caixa de texto Identifier (Identificador) e
clique em OK.
7.
principal:
this.createTextField("textField_txt", 10, 0, 0, 300, 200);
textField_txt.html = true;
textField_txt.htmlText = "Here's a movie clip symbol:<img
src='img_id'>";
Para que um clipe de filme incorporado seja exibido adequada e completamente, o ponto
de registro de seu símbolo deve ser no ponto (0,0).
8.
Salve as alterações no documento do Flash.
9.
Flash.
Sobre a especificação dos valores de altura e largura
Se você especificar os atributos width e height para uma marca <img>, será reservado espaço
no campo de texto para o arquivo de imagem, o arquivo SWF ou o clipe de filme. Após o
download completo de um arquivo de imagem ou SWF, ele aparecerá no espaço reservado. O
Flash dimensiona a mídia para cima ou para baixo, de acordo com os valores especificados
para height e width. Para dimensionar a imagem, é necessário inserir valores para os
atributos height e width .
472
Se você não especificar os valores height e width, nenhum espaço será reservado para a mídia
incorporada. Após o download completo de um arquivo de imagem ou SWF, o Flash o insere
no campo de texto em seu tamanho total e "quebra" novamente o texto em torno dele.
NO TA
Se estiver carregando imagens dinamicamente em um campo de texto que contém
texto, é recomendável especificar a largura e a altura da imagem original para dispor o
texto adequadamente em torno do espaço reservado para a imagem.
Controlando a mídia incorporada com o ActionScript
O Flash cria um novo clipe de filme para cada marca <img> e incorpora esse clipe ao objeto
TextField. O atributo id da marca <img> permite atribuir um nome de instância ao clipe de
filme criado. Assim, é possível controlar o clipe de filme com o ActionScript.
O clipe de filme criado pelo Flash Player é adicionado como um clipe de filme-filho ao campo
de texto que contém a imagem.
No exemplo a seguir, um arquivo SWF é incorporado a um campo de texto.
Para incorporar um arquivo SWF a um campo de texto:
1.
2.
Redimensione o tamanho do Stage (Palco) do documento com 100 pixels por 100 pixels.
3.
Use a ferramenta Rectangle (Retângulo) para desenhar um quadrado vermelho no Stage.
4.
Redimensione o quadrado com 80 pixels por 80 pixels, usando o inspetor Properties
(Propriedades), e depois mova a forma para o centro do Stage.
5.
Selecione Frame 20 (Quadro 20) na Timeline (Linha de tempo) e pressione F7 (Windows
ou Macintosh) para inserir um novo quadro-chave em branco.
6.
Use a ferramenta Oval para desenhar um círculo azul no Stage, no Frame 20.
7.
Redimensione o círculo com 80 pixels por 80 pixels, usando o inspetor Properties, e depois
mova-o para o centro do Stage.
8.
Clique em um quadro em branco entre Frame 1 (Quadro 1) e Frame 20 (Quadro 20) e
defina o tipo de interpolação como Shape (Forma) no inspetor Properties.
9.
Salve o documento atual como animation.fla.
10. Selecione
Control (Controlar) > Test Movie (Testar filme) para visualizar a animação.
O arquivo SWF é criado no mesmo diretório que o arquivo FLA. Para que este exercício
funcione corretamente, é preciso gerar o arquivo SWF, a fim de que você possa carregá-lo
em um arquivo FLA separado.
11.
Crie um novo arquivo FLA e salve-o como animationholder.fla.
Salve o arquivo na mesma pasta onde anteriormente foi criado o arquivo animation.fla.
473
12. Adicione
o seguinte código ActionScript ao Frame 1 da Timeline principal:
this.createTextField("textField_txt", 10, 0, 0, 300, 200);
textField_txt.html = true;
textField_txt.htmlText = "Here's an interesting animation: <img
src='animation.swf' id='animation_mc'>";
Nesse caso, o caminho totalmente qualificado para o clipe de filme recém-criado é
textField_txt.animation_mc.
13.
Salve as alterações no documento do Flash e selecione Control > Test Movie para visualizar
a animação no campo de texto.
Para controlar o arquivo SWF durante sua reprodução em um campo de texto, complete o
próximo exercício.
Para controlar um arquivo SWF que está sendo reproduzido em um campo de
texto:
1.
Siga as etapas do primeiro procedimento que se encontra em “Controlando a mídia
incorporada com o ActionScript” na página 473.
2.
Crie uma instância de botão no Stage (Palco) e dê a ela o nome de instância stop_btn no
inspetor Properties (Propriedades).
3.
Adicione o seguinte código ActionScript abaixo do código existente no Frame 1 (Quadro
1) da Timeline (Linha de tempo) principal:
stop_btn.onRelease = function() {
textField_txt.animation_mc.stop();
};
4.
Selecione Control (Controlar) > Test Movie (Testar filme) para testar o aplicativo.
Agora, sempre que você clicar na instância de botão stop_btn, a linha de tempo da
animação aninhada no campo de texto irá parar.
Para obter informações sobre como criar mídias incorporadas em um hiperlink, consulte
“Sobre a criação de hiperlinks a partir de uma mídia incorporada” na página 474.
Sobre a criação de hiperlinks a partir de uma mídia
incorporada
Para criar um hiperlink a partir de um arquivo de imagem, um arquivo SWF ou um clipe de
filme incorporado, inclua a marca <img> em uma marca <a>:
textField_txt.htmlText = "Click the image to return home<a
href='home.htm'><img src='home.jpg'></a>";
474
Quando posicionado sobre uma imagem, um arquivo SWF ou um clipe de filme delimitado
por marcas <a>, o ponteiro do mouse se transforma no ícone de “mão indicadora”, da mesma
forma que quando posicionado em hiperlinks padrão. A interatividade, como cliques no
botão do mouse e pressionamentos de teclas, não é registrada nos arquivos SWF e clipes de
filme delimitados por marcas <a>.
Para obter informações sobre como incorporar mídia, consulte “Sobre a criação de hiperlinks a
partir de uma mídia incorporada” na página 474.
Exemplo: Criando texto de rolagem
Há vários métodos para criar texto de rolagem no Flash. Você poderá tornar os campos de
texto dinâmico e de entrada roláveis selecionando a opção Scrollable (Rolável) no menu Text
(Texto) ou no menu de contexto, ou clicando duas vezes na alça do campo de texto com a
tecla Shift pressionada.
Você pode usar as propriedades scroll e maxscroll do objeto TextField para controlar a
rolagem vertical, e as propriedades hscroll e maxhscroll para controlar a rolagem
horizontal em um campo de texto. As propriedades scroll e hscroll especificam as posições
de rolagem vertical e horizontal atuais, respectivamente; você pode ler e escrever essas
propriedades. As propriedades maxscroll e maxhscroll especificam as posições de rolagem
vertical e horizontal máximas, respectivamente; você só pode ler essas propriedades.
O componente TextArea permite criar facilmente campos de texto de rolagem com o mínimo
de script. Para obter mais informações, consulte “TextArea component” em Components
Language Reference (Referência da linguagem de componentes).
Para criar um campo de texto dinâmico rolável:
■
Com a tecla Shift pressionada, clique duas vezes na alça do campo de texto dinâmico.
■
Selecione o campo de texto dinâmico com a ferramenta Selection (Seleção) e selecione
Text (Texto) > Scrollable (Rolável).
■
Selecione o campo de texto dinâmico com a ferramenta Selection. Clique com o botão
direito do mouse (Windows) ou, pressionando Control, clique (Macintosh) no campo de
texto dinâmico e selecione Text > Scrollable.
Exemplo: Criando texto de rolagem
475
Para usar a propriedade scroll para criar texto de rolagem:
1.
■
Use a ferramenta Text (Texto) para arrastar um campo de texto no Stage (Palco).
Atribua ao campo de texto o nome de instância textField_txt no inspetor Properties
(Propriedades).
■
Use o ActionScript para criar um campo de texto dinamicamente com o método
MovieClip.createTextField(). Atribua ao campo de texto o nome de instância
textField_txt como parâmetro do método.
NO TA
2.
Se não estiver carregando texto dinamicamente no arquivo SWF, selecione Text
> Scrollable (Rolável) no menu principal.
Crie um botão Up (Para cima) e um botão Down (Para baixo) ou selecione Window
(Janela) > Common Libraries (Bibliotecas comuns) > Buttons (Botões) e arraste os botões
para o Stage.
Esses botões serão usados para rolar o texto para cima e para baixo.
3.
Selecione o botão Down no Stage e digite down_btn na caixa de texto Instance Name
(Nome da instância).
4.
Selecione o botão Up no Stage e digite up_btn na caixa de texto Instance Name.
5.
Selecione o Frame 1 (Quadro 1) na Timeline (Linha de tempo) e, no painel Actions (Ações)
(Window > Actions), digite o seguinte código a fim de rolar o texto para baixo no campo
de texto:
down_btn.onPress = function() {
textField_txt.scroll += 1;
};
6.
Após o ActionScript da etapa 5, digite o código a seguir para rolar o texto para cima:
up_btn.onPress = function() {
textField_txt.scroll -= 1;
};
Os botões up e down podem ser usados para rolar todo texto carregado no campo
textField_txt.
476
Sobre seqüências de caracteres e a
classe String
Em programação, uma seqüência de caracteres é uma série ordenada de caracteres. As
seqüências de caracteres são geralmente usadas nos documentos do Flash e em arquivos de
classes para exibir texto em aplicativos, como, por exemplo, em campos de texto. Além disso,
é possível armazenar valores como seqüências de caracteres que podem ser usadas em um
aplicativo com diversas finalidades. Você pode colocar seqüências de caracteres diretamente no
código ActionScript incluindo os caracteres de dados entre aspas. Para obter mais informações
sobre a criação de seqüências de caracteres, consulte “Criando seqüências de caracteres”
na página 486. Para obter informações sobre o uso de campos de texto, consulte “Usando a
classe TextField” na página 406.
Você pode associar cada caractere a um código de caractere especificado, que também pode ser
usado para exibir texto. Por exemplo, o caractere “A” é representado pelo código de caractere
Unicode 0041 ou 65 em ASCII (American Standard Code for Information Interchange,
Código padrão americano para intercâmbio de informações). Para obter mais informações
sobre códigos de caractere e gráficos de código, consulte www.unicode.org/charts. Como você
pode observar, a maneira como as seqüências de caracteres são representadas em um
documento do Flash depende, em grande parte, do conjunto de caracteres escolhido e do
método de codificação dos caracteres.
A codificação de caracteres refere-se ao código, ou método, usado para representar um conjunto
de caracteres em um idioma com códigos representativos, como valores numéricos. O código
de caractere (mencionado no parágrafo anterior) é a tabela de valores mapeados (como a tabela
ASCII, onde A é igual a 65). O método de codificação o decifra em um programa de
computador.
Por exemplo, cada letra do idioma inglês teria um código numérico representativo em uma
codificação de caractere. O ASCII codifica cada letra, número e alguns símbolos em versões
binárias de 7 bits de cada inteiro. O ASCII é um conjunto de caracteres composto de 95
caracteres imprimíveis e de vários caracteres de controle; ele é usado por computadores para
representar texto.
Sobre seqüências de caracteres e a classe String
477
Como o ASCII, o Unicode é outra maneira de associar um código a cada letra do alfabeto.
Como o ASCII não oferece suporte a conjuntos de caracteres grandes, como o alfabeto chinês,
o Padrão Unicode é valioso para a codificação de idiomas. Unicode é o padrão para conjuntos
de caracteres, que pode representar qualquer idioma definido. O Unicode é um padrão útil
para o desenvolvimento em vários idiomas. O código de caractere designa qual caractere ele
representa, e o padrão tenta fornecer um modo universal de codificar os caracteres que fazem
parte de qualquer idioma. As seqüências de caracteres podem ser exibidas em qualquer
computador, plataforma ou software usado. Depois, caberá ao programa envolvido (como o
Flash ou um navegador da Web) exibir o glifo do caractere (sua aparência visual).
Ao longo dos anos, o número de caracteres com suporte no Unicode foi expandido para que
mais (e maiores) idiomas sejam aceitos. As codificações de caracteres são denominadas UTF
(Unicode Transformation Format, Formato de transformação Unicode) e UCS (Universal
Character Set, Conjunto de caracteres universais), que incluem UTF-8, UTF-16 e UTF-32.
Na codificação UTF, os números representam o número de bits em uma unidade e, na
codificação UCS, os números representam bytes.
■
O UTF-8 é a codificação padrão para a troca de texto, como em sistemas de email on-line.
O UTF é um sistema de 8 bits.
■
O UTF-16 é normalmente usado para processamento interno.
Seus aplicativos podem conter seqüências de caracteres de diversos tamanhos. Você pode
determinar o tamanho da seqüência de caracteres, embora isso possa variar dependendo do
idioma usado. Além disso, uma seqüência poderá conter um caractere de encerramento, e esse
caractere nulo não possui nenhum valor. Embora não seja efetivamente um caractere, o
caractere de encerramento pode ser usado para determinar o fim de uma seqüência. Por
exemplo, se estiver trabalhando com conexões de soquete, você poderá observar o caractere de
encerramento para determinar o fim de uma seqüência de caracteres (como em um programa
de bate-papo).
O arquivo de origem de exemplo, strings.fla, encontra-se na pasta Samples do disco rígido.
Esse arquivo mostra como criar um processador de texto simples que compare e recupere
seleções de seqüências e de subseqüências de caracteres.
■
8\Samples and Tutorials\Samples\ActionScript\Strings.
■
and Tutorials/Samples/ActionScript/Strings.
478
Para obter mais informações sobre seqüências de caracteres e a classe String (Seqüência de
caracteres), consulte os seguintes tópicos:
■
“Sobre o painel Strings” na página 479
■
“Usando a classe Locale” na página 480
■
“Usando um editor de método de entrada” na página 482
■
“Sobre a classe String” na página 485
■
“Criando seqüências de caracteres” na página 486
■
“Sobre o caractere de escape” na página 487
■
“Analisando e comparando caracteres em seqüências de caracteres” na página 488
■
“Convertendo e concatenando seqüências de caracteres” na página 491
■
“Retornando subseqüências de caracteres” na página 494
Sobre o painel Strings
O painel Strings (Seqüências de caracteres) permite criar e atualizar conteúdo multilíngüe. É
possível especificar conteúdo para campos de texto que cobrem vários idiomas e fazer com que
o Flash determine automaticamente o conteúdo que deve aparecer em um determinado
idioma, com base no idioma do computador que está executando o Flash Player.
Para obter informações gerais sobre o painel Strings e como usá-lo nos aplicativos, consulte os
seguintes tópicos em Using Flash (Usando o Flash):
■
“Criando texto multilíngüe com o painel Strings” na página 415
■
“Sobre a edição de seqüências de caracteres no painel Strings” na página 419
■
“Traduzindo texto no painel Strings ou em um arquivo XML” na página 425
■
“Importando um arquivo XML para o painel Strings” na página 426
É possível usar a classe Locale para controlar a exibição de textos multilíngües. Para obter mais
informações, consulte “Usando a classe Locale” na página 480 e %{Locale
(mx.lang.Locale)}% em ActionScript 2.0 Language Reference.
479
Usando a classe Locale
A classe Locale (mx.lang.Locale) permite controlar a exibição de textos multilíngües em um
aplicativo Flash durante a execução. Com o painel Strings (Seqüências de caracteres), você
pode usar IDs de seqüências de caracteres em vez de literais de seqüências de caracteres em
campos de texto dinâmicos, o que permite criar um arquivo SWF que exiba texto carregado
de um arquivo XML específico de um idioma. É possível usar os seguintes métodos para exibir
as seqüências de caracteres específicas do idioma, contidas nos arquivos XLIFF (XML
Localization Interchange File Format, Formato de arquivo de intercâmbio de localização
XML).
Automatically at runtime (Automaticamente durante a execução)
O Flash Player
substitui IDs de seqüências de caracteres por seqüências de caracteres do arquivo XML, que
corresponde ao código do idioma padrão do sistema retornado por %{language
(capabilities.language property)}%.
Manually using stage language (Usando manualmente o idioma do palco) As IDs de
seqüências de caracteres são substituídas por seqüências de caracteres na compilação do
arquivo SWF, e o Flash Player não pode alterá-las.
É possível
controlar a substituição de IDs de seqüências de caracteres usando o ActionScript, que é
controlado durante a execução. Essa opção permite controlar o tempo e o idioma da
substituição de IDs de seqüências de caracteres.
Using ActionScript at runtime (Usando o ActionScript durante a execução)
Você pode usar as propriedades e os métodos da classe Locale quando quiser substituir as IDs
de seqüências de caracteres usando o ActionScript, a fim de controlar o aplicativo durante a
reprodução no Flash Player. Para obter uma demonstração de como usar a classe Locale, veja o
procedimento a seguir.
Para usar a classe Locale para criar sites multilíngües:
1.
Crie um novo documento do Flash e salve-o como locale.fla.
2.
Abra o painel Strings (Seqüências de caracteres) (Window [Janela] > Other Panels [Outros
painéis] > Strings) e clique em Settings (Configurações).
3.
Selecione dois idiomas, en (inglês) e fr (francês), e clique em Add (Adicionar) para
acrescentar os idiomas ao painel Active Languages (Idiomas ativos).
4.
Selecione a opção Via ActionScript at Runtime (Via ActionScript durante a execução),
defina o idioma de execução padrão como francês e clique em OK.
5.
Arraste um componente de ComboBox (Caixa de combinação) da pasta User Interface
(Interface do usuário) do painel Components (Componentes) (Window > Components)
para o Stage (Palco) e atribua a ele o nome de instância lang_cb.
480
6.
Crie um campo de texto dinâmico no Stage usando a ferramenta Text (Texto) e atribua a
ele o nome de instância greeting_txt.
7.
Com o campo de texto selecionado no Stage, digite o identificador de seqüência de
caracteres greeting na caixa de texto ID do painel Strings e clique em Apply (Aplicar).
O Flash converterá a seqüência de caracteres em IDS_GREETING.
8.
Na grade do painel String, digite a seqüência de caracteres hello na coluna “en”.
9.
Digite a seqüência de caracteres bonjour na coluna “fr”.
Você usará essas seqüências de caracteres ao utilizar a caixa de combinação lang_cb para
alterar o idioma no Stage.
10. Adicione
o seguinte ActionScript ao Frame 1 (Quadro 1) da Timeline (Linha de tempo)
principal:
import mx.lang.Locale;
Locale.setLoadCallback(localeListener);
lang_cb.dataProvider = Locale.languageCodeArray.sort();
lang_cb.addEventListener("change", langListener);
greeting_txt.autoSize = "left";
Locale.loadLanguageXML(lang_cb.value);
function langListener(eventObj:Object):Void {
Locale.loadLanguageXML(eventObj.target.value);
}
function localeListener(success:Boolean):Void {
if (success) {
greeting_txt.text = Locale.loadString("IDS_GREETING");
} else {
greeting_txt.text = "unable to load language XML file.";
}
}
O ActionScript anterior está dividido em duas seções. A primeira seção de código importa
a classe Locale e especifica um ouvinte de retornos de chamadas, que é acionado sempre ao
término do carregamento do arquivo XML de um idioma. Em seguida, a caixa de
combinação lang_cb é preenchida com um array classificado dos idiomas disponíveis.
Sempre que o valor lang_cb muda, o distribuidor de eventos do Flash dispara a função
langListener(), que carrega o arquivo XML do idioma especificado. A segunda seção de
código define duas funções: langListener() e localeListener(). A primeira função,
langListener(), é chamada sempre que o valor da caixa de combinação lang_cb é
alterado pelo usuário. A segunda função, localeListener(), é chamada sempre ao
término do carregamento do arquivo XML de um idioma. A função verifica se o
carregamento foi bem-sucedido e, em caso afirmativo, define a propriedade text da
instância greeting_txt para a saudação do idioma selecionado.
481
11.
Flash.
DICA
O arquivo XML utilizado deve usar o padrão XLIFF (XML Localization Interchange
File Format, Formato de arquivo de intercâmbio de localização XML).
AT E N ÇÃ O
A classe Locale é diferente das outras classes do ActionScript 2.0 Language
Reference, pois não faz parte do Flash Player. Como essa classe foi instalada no
caminho de classe Flash Authoring (Criação do Flash), é automaticamente
compilada em arquivos SWF. O uso da classe Locale aumenta o tamanho do
arquivo SWF ligeiramente, porque a classe deve ser compilada no arquivo SWF.
Para obter mais informações, consulte %{Locale (mx.lang.Locale)}% em ActionScript 2.0
Language Reference.
Usando um editor de método de entrada
Um IME (Input Method Editor, Editor de método de entrada) permite digitar caracteres de
texto não-ASCII em idiomas asiáticos, como chinês, japonês e coreano. A classe IME do
ActionScript permite manipular diretamente o IME do sistema operacional que está dentro
do aplicativo Flash Player executado em um computador cliente.
Usando o ActionScript, é possível determinar:
■
Se há um IME instalado no computador do usuário.
■
Se o IME está ativado ou desativado no computador do usuário.
■
Qual é o modo de conversão que o IME atual está utilizando.
A classe IME pode determinar qual é o modo de conversão que o IME está utilizando. Por
exemplo, se o IME de japonês estiver ativo, será possível determinar se o modo de conversão é
Hiragana, Katakana, etc. usando o método System.IME.getConversionMode() . Você pode
defini-lo com o método System.IME.setConversionMode() .
N OT A
No momento, não é possível saber qual IME está ativo (se houver algum) nem mudar de
um IME para outro (por exemplo, de inglês para japonês ou de coreano para chinês).
Também é possível ativar ou desativar o IME usando o aplicativo durante a execução e
executar outras funções, dependendo do sistema operacional do usuário. Você pode verificar
se um sistema possui um IME, utilizando a propriedade System.capabilities.hasIME . O
próximo exemplo mostra como determinar se o usuário possui um IME instalado e ativo.
Para determinar se o usuário possui um IME instalado e ativo:
1.
Crie um novo documento do Flash e salve-o como ime.fla.
482
2.
principal:
if (System.capabilities.hasIME) {
if (System.IME.getEnabled()) {
trace("You have an IME installed and enabled.");
} else {
trace("You have an IME installed but not enabled.");
}
} else {
trace("Please install an IME and try again.");
}
Primeiramente, o código anterior verifica se o sistema atual possui um IME instalado. Se
houver um IME instalado, o Flash verificará se ele está ativo no momento.
3.
Uma mensagem aparece no painel Output (Saída) indicando se há um IME instalado e
ativo no momento.
Também é possível usar a classe IME para ativar e desativar o IME no Flash durante a
execução. O exemplo a seguir requer que exista um IME instalado no sistema. Para obter mais
informações sobre a instalação de um IME na sua plataforma específica, consulte os seguintes
links:
■
www.microsoft.com/globaldev/default.mspx
■
http://developer.apple.com/documentation/
■
http://java.sun.com
É possível ativar e desativar um IME durante a reprodução de um arquivo SWF, conforme
mostrado no exemplo a seguir.
Para ativar e desativar um editor de método de entrada durante a execução:
1.
Crie um novo documento do Flash e salve-o como ime2.fla.
2.
Crie duas instâncias de símbolo de botão no Stage (Palco) e atribua a elas os nomes de
instâncias enable_btn e disable_btn.
3.
principal:
checkIME();
my_fmt.font = "_sans";
this.createTextField("ime_txt", 10, 100, 10, 320, 240);
ime_txt.border = true;
ime_txt.multiline = true;
483
ime_txt.setNewTextFormat(my_fmt);
ime_txt.type = "input";
ime_txt.wordWrap = true;
enable_btn.onRelease = function() {
System.IME.setEnabled(true);
};
disable_btn.onRelease = function() {
System.IME.setEnabled(false);
};
function checkIME():Boolean {
if (System.capabilities.hasIME) {
if (System.IME.getEnabled()) {
trace("You have an IME installed and enabled.");
return true;
} else {
trace("You have an IME installed but not enabled.");
return false;
}
} else {
trace("Please install an IME and try again.");
return false;
}
}
O código anterior é dividido em cinco seções. A primeira seção chama o método
checkIME(), que exibe uma mensagem no painel Output (Saída) se o sistema tiver um
IME instalado ou ativo. A segunda seção define um objeto de formato de texto
personalizado, o qual define a fonte como _sans. A terceira seção cria um campo de texto
de entrada e aplica o formato de texto personalizado. A quarta seção cria alguns
manipuladores de eventos para as instâncias enable_btn e disable_btn criadas em uma
etapa anterior. A quinta e última seção de código define a função personalizada
checkIME(), a qual verifica se o sistema atual possui um IME instalado e, em caso
afirmativo, se o IME está ativo.
4.
Salve o arquivo FLA e selecione Control (Controlar) > Test Movie (Testar filme) para testar
o documento.
N O TA
Este exemplo requer que exista um IME instalado no sistema. Para obter
informações sobre a instalação de um IME, consulte os links que antecedem este
exemplo.
Insira texto no campo de texto de entrada no Stage (Palco). Alterne o IME para um
idioma diferente e digite no campo de texto de entrada novamente. O Flash Player
informa caracteres usando o novo IME. Quando você clica no botão disable_btn no
Stage, o Flash passa a usar o idioma anterior e ignora as atuais definições do IME.
484
Para obter informações sobre System.capabilities.hasIME, consulte %{hasIME
(capabilities.hasIME property)}%
Sobre a classe String
Na linguagem ActionScript básica, uma seqüência de caracteres (String) também se refere a
uma classe e a um tipo de dados. O tipo de dados String representa uma seqüência de
caracteres de 16 bits que pode incluir letras, números e sinais de pontuação. As seqüências de
caracteres são armazenadas como caracteres Unicode, usando o formato UTF-16. Uma
operação em um valor String retorna uma nova instância da seqüência de caracteres. O valor
padrão de uma variável declarada com o tipo de dados String é null.
Para obter mais informações sobre seqüências de caracteres, dados e valores, consulte o
Capítulo 4, “Dados e tipos de dados.”
A classe String contém métodos que permitem trabalhar com seqüências de caracteres de
texto. As seqüências de caracteres são importantes ao se trabalhar com vários objetos, e os
métodos descritos neste capítulo são úteis quando se trabalha com seqüências de caracteres
usadas em vários objetos, como instâncias de TextField, XML, ContextMenu e FileReference.
A classe String (Seqüência de caracteres) é um envoltório para o tipo de dados String primitivo
que fornece métodos e propriedades que permitem manipular valores primitivos de seqüências
de caracteres. É possível converter o valor de qualquer objeto em uma seqüência de caracteres
usando a função String(). Todos os métodos da classe String, exceto concat(),
fromCharCode(), slice() e substr(), são genéricos; isso significa que eles chamam a
função toString() antes de executarem suas operações e que podem ser usados com objetos
diferentes de String.
Como todos os índices de seqüência de caracteres têm zero como base, o índice do último
caractere de qualquer seqüência de caracteres myStr é myStr.length - 1.
■
■
485
Criando seqüências de caracteres
Você pode chamar qualquer método do objeto String usando o método construtor new
String() ou usando o valor de uma seqüência de caracteres literal. Se você especificar o valor
literal de uma seqüência de caracteres, o interpretador do ActionScript automaticamente o
converterá em um objeto String temporário, chamará o método e depois descartará o objeto
String temporário. Você também pode utilizar a propriedade String.length com o valor
literal de uma seqüência de caracteres.
Não confunda o valor literal de uma seqüência de caracteres com um objeto String. Para obter
mais informações sobre valores literais de seqüências de caracteres e o objeto String, consulte o
Capítulo 5, “Sobre literais”, na página 138.
No exemplo a seguir, a linha de código cria o valor literal de seqüência de caracteres firstStr.
Para declarar um valor literal, use uma aspa reta simples (') ou uma aspa reta dupla (") como
delimitador.
Para criar e usar seqüências de caracteres:
1.
Crie um novo documento do Flash e salve-o como strings.fla.
2.
principal:
var firstStr:String = "foo";
var secondStr:String = new String("foo");
trace(firstStr == secondStr); // true
var thirdStr:String;
trace(thirdStr); // undefined (indefinido)
Esse código define três objetos String: um que usa um valor literal de uma seqüência de
caracteres, um que usa o operador new e um outro sem um valor inicial. As seqüências de
caracteres podem ser comparadas usando o operador de igualdade (==), conforme
mostrado na terceira linha de código. Ao fazer referência a variáveis, você só especifica o
tipo de dado quando a variável estiver sendo definida.
3.
Use sempre valores literais de seqüência de caracteres, a menos que seja estritamente necessário
usar um objeto String. Para obter mais informações sobre valores literais de seqüências de
caracteres e o objeto String, consulte o Capítulo 5, “Sobre literais”, na página 138.
Para usar as aspas retas simples (') e aspas retas duplas (") como delimitadores em um valor
literal de seqüência de caracteres, você poderá usar a barra invertida (\) como o caractere de
escape. As duas seqüências de caracteres apresentadas a seguir são equivalentes:
var firstStr:String = "That's \"fine\"";
var secondStr:String = 'That\'s "fine"';
486
Para obter mais informações sobre o uso da barra invertida em seqüências de caracteres,
consulte “Sobre o caractere de escape” na página 487.
Lembre-se de que você não pode usar as “aspas curvas” ou “aspas especiais” no código
ActionScript; esses caracteres são diferentes das aspas retas (') e ("), que podem ser usadas no
código. Ao colar texto de outra origem no ActionScript, como um documento do Word ou da
Web, certifique-se de usar os delimitadores aspas retas.
■
■
Sobre o caractere de escape
Você pode usar o caractere de escape barra invertida (\) para definir outros caracteres em
valores literais de seqüências de caracteres.
Seqüência de
escape
Descrição
\b
O caractere backspace.
\f
O caractere de alimentação de formulário.
\n
O caractere de nova linha (newline).
\r
O caractere de retorno de carro.
\t
O caractere de tabulação.
\unnnn
O caractere Unicode com o código de caractere especificado pelo
número hexidecimal nnnn. Por exemplo, \u263a é o caractere de
sorriso.
\xnn
O caractere ASCII com o código de caractere especificado pelo
número hexadecimal nn.
\'
Uma aspa simples.
\"
Uma aspa dupla.
\\
Um caractere de barra invertida.
487
Para obter mais informações sobre valores literais de seqüências de caracteres, consulte o
Capítulo 5, “Sobre literais”, na página 138 e “Criando seqüências de caracteres”
na página 486.
Analisando e comparando caracteres em seqüências
de caracteres
Cada caractere de uma seqüência de caracteres tem uma posição de índice na seqüência (um
inteiro). A posição de índice do primeiro caractere é 0. Por exemplo, na seqüência azul, o
caractere a está na posição 0, e o caractere l, na posição 4.
Toda seqüência de caracteres tem uma propriedade length, que é igual ao número de
caracteres contido na seqüência:
var companyStr:String = "macromedia";
trace(companyStr.length); // 10
Uma seqüência de caracteres vazia e outra nula têm tamanho igual a zero:
var firstStr:String = new String();
trace(firstStr.length); // 0
var secondStr:String = "";
trace(secondStr.length); // 0
Se uma seqüência de caracteres não contém nenhum valor, o comprimento é definido como
undefined:
var thirdStr:String;
trace(thirdStr.length); // undefined (indefinido)
A VI S O
Se a seqüência de caracteres contiver um caractere de byte nulo (\0), o valor da
seqüência de caracteres será truncado.
Também é possível usar códigos de caracteres para definir uma seqüência de caracteres. Para
obter mais informações sobre códigos de caracteres e codificação de caracteres, consulte “Sobre
seqüências de caracteres e a classe String” na página 477.
O exemplo a seguir cria uma variável chamada myStr e define o valor da seqüência de
caracteres com base em valores ASCII passados ao método String.fromCharCode():
var myStr:String =
String.fromCharCode(104,101,108,108,111,32,119,111,114,108,100,33);
trace(myStr); // olá, mundo!
Cada número listado no método fromCharCode() do código anterior representa um único
caractere. Por exemplo, o valor ASCII 104 representa um h minúsculo, e o valor ASCII 32
representa o caractere de espaço.
488
Também é possível usar o método String.fromCharCode() para converter valores Unicode,
embora o valor Unicode deva ser convertido de valores hexadecimais para decimais, conforme
mostrado no seguinte ActionScript:
// Unicode 0068 == "h"
var letter:Number = Number(new Number(0x0068).toString(10));
trace(String.fromCharCode(letter)); // h
Você pode examinar os caracteres que ocupam várias posições em uma seqüência, como no
seguinte exemplo:
Para repetir uma seqüência de caracteres:
1.
2.
principal:
var myStr:String = "hello world!";
for (var i:Number = 0; i < myStr.length; i++) {
trace(myStr.charAt(i));
}
3.
Selecione Control (Controlar) > Test Movie (Testar filme) para visualizar o documento do
Flash. Você deverá ver cada caractere apresentado no painel Output (Saída) em uma linha
separada.
4.
Modifique o código ActionScript existente, de modo que apresente o valor ASCII de cada
caractere:
var myStr:String = "hello world!";
for (var i:Number = 0; i < myStr.length; i++) {
trace(myStr.charAt(i) + " - ASCII=" + myStr.charCodeAt(i));
}
5.
Salve o documento atual do Flash e selecione Control (Controlar) > Test Movie (Testar
filme) para visualizar o arquivo SWF.
Quando esse código é executado, o painel Output (Saída) exibe o seguinte:
h
e
l
l
o
w
o
r
l
-
ASCII=104
ASCII=101
ASCII=108
ASCII=108
ASCII=111
ASCII=32
ASCII=119
ASCII=111
ASCII=114
ASCII=108
489
d - ASCII=100
! - ASCII=33
DICA
Também é possível dividir uma seqüência de caracteres em um array de caracteres,
usando o método String.split() e inserindo uma seqüência de caracteres vazia ("")
como um delimitador; por exemplo, var charArray:Array = myStr.split("");
Você pode usar operadores para comparar seqüências de caracteres. Para obter informações
sobre o uso de operadores com seqüências de caracteres, consulte “Sobre uso de operadores
com seqüências de caracteres” na página 192.
Também é possível usar esses operadores com instruções condicionais, como if e while. O
exemplo a seguir usa operadores e seqüências de caracteres para fazer uma comparação.
Para comparar duas seqüências de caracteres:
1.
Crie um novo documento do Flash e salve-o como comparestr.fla.
2.
principal:
var str1:String = "Apple";
var str2:String = "apple";
if (str1 < str2) {
trace("Uppercase letters sort first.");
}
3.
Você pode usar os operadores de igualdade (==) e de diferença (!=) para comparar seqüências
de caracteres com outros tipos de objetos, como mostrado no exemplo a seguir.
Para comparar seqüências de caracteres com outros tipos de dados:
1.
Crie um novo documento do Flash e salve-o como comparenum.fla.
2.
principal:
var myStr:String = "4";
var total:Number = 4;
if (myStr == total) {
trace("Types are converted.");
}
3.
Ao comparar dois tipos de dados diferentes (como “strings” e números), o Flash tenta
converter os tipos de dados, de modo a possibilitar a comparação.
490
Use os operadores de igualdade estrita (===) e de diferença estrita (!==) para verificar se os
dois objetos de comparação são do mesmo tipo. O exemplo a seguir usa operadores de
comparação estrita para assegurar que o Flash não tente converter tipos de dados enquanto
tenta comparar valores.
Para forçar comparações estritas de tipos de dados:
1.
Crie um novo documento do Flash e salve-o como comparestrict.fla.
2.
principal:
var str1:String = "4";
var str2:String = "5";
var total:Number = 4;
if (str1 !== total) {
trace("Types are not converted.");
}
if (str1 !== str2) {
trace("Same type, but the strings don't match.");
}
3.
Para obter mais informações sobre o uso de operadores com seqüências de caracteres, consulte
“Sobre uso de operadores com seqüências de caracteres” na página 192.
■
■
Convertendo e concatenando seqüências de
caracteres
É possível usar o método toString() para converter vários objetos em seqüências de
caracteres. A maioria dos objetos internos tem um método toString() com essa finalidade:
var n:Number = 0.470;
trace(typeof(n.toString())); // seqüência de caracteres
Ao usar o operador de adição (+) com uma combinação de instâncias de seqüência de
caracteres e de outros tipos, você não precisa usar o método toString(). Para obter detalhes
sobre concatenação, consulte o segundo procedimento desta seção.
491
Os métodos toLowerCase() e toUpperCase() convertem os caracteres alfabéticos da
seqüência em letras minúsculas e maiúsculas, respectivamente. O exemplo a seguir demonstra
como converter uma seqüência de caracteres de minúsculas em maiúsculas.
Para converter uma seqüência de caracteres de minúsculas em maiúsculas:
1.
Crie um novo documento do Flash e salve-o como convert.fla.
2.
Digite o seguinte código no Frame 1 (Quadro 1) da Timeline (Linha de tempo):
var myStr:String = "Dr. Bob Roberts, #9.";
trace(myStr.toLowerCase()); // dr. bob roberts, #9.
trace(myStr.toUpperCase()); // DR. BOB ROBERTS, #9.
trace(myStr); // Dr. Bob Roberts, #9.
3.
N OT A
Após a execução desses métodos, a seqüência de caracteres de origem permanece
inalterada. Para transformar a seqüência de caracteres de origem, use o seguinte:
myStr = myStr.toUpperCase();
Quando você concatena duas seqüências de caracteres, elas são unidas seqüencialmente em
uma só. Por exemplo, você pode usar o operador de adição (+) para concatenar duas
seqüências de caracteres. O próximo exemplo mostra como fazer isso.
Para concatenar duas seqüências de caracteres:
1.
Crie um novo documento do Flash e salve-o como concat.fla.
2.
var str1:String
var str2:String
trace(str2); //
//
var str3:String
str3 += "ish";
trace(str3); //
= "green";
= str1 + "ish";
verde claro
= "yellow";
amarelo claro
O código anterior mostra dois métodos de concatenar seqüências de caracteres. O
primeiro método usa o operador de adição (+) para unir a seqüência de caracteres str1 à
seqüência " claro". O segundo método usa o operador de adição e atribuição (+=) para
concatenar a seqüência de caracteres " claro" com o valor atual de str3.
3.
Você também pode usar o método concat() da classe String para concatenar seqüências de
caracteres. Esse método é demonstrado neste exemplo.
492
Para concatenar duas seqüências de caracteres com o método concat():
1.
Crie um novo documento do Flash e salve-o como concat2.fla.
2.
var str1:String
var str2:String
var str3:String
var str4:String
trace(str4); //
3.
= "Bonjour";
= "from";
= "Paris";
= str1.concat(" ", str2, " ", str3);
Bonjour from Paris
Flash.
Se você usar o operador de adição (+) (ou o operador de adição e atribuição [+=]) com um
objeto String (Seqüência de caractere) e outro diferente de String, o ActionScript converterá
automaticamente o objeto diferente de String em seqüências de caracteres para avaliar a
expressão. Essa conversão é demonstrada no seguinte código de exemplo:
var version:String = "Flash Player ";
var rel:Number = 8;
version = version + rel;
trace(version); // Flash Player 8
Entretanto, você pode usar parênteses para forçar o operador de adição (+) a fazer uma
avaliação aritmética, conforme demonstrado no seguinte código ActionScript:
trace("Total: $" + 4.55 + 1.46); // Total: $4.551.46
trace("Total: $" + (4.55 + 1.46)); // Total: $6.01
Você pode usar o método split() para criar um array de subseqüências de caracteres de uma
seqüência, que é dividido com base em um caractere delimitador. Por exemplo, você poderia
segmentar uma seqüência delimitada por vírgulas ou tabulações em várias seqüências.
Por exemplo, o código a seguir mostra como dividir um array em subseqüências de caracteres
usando o caractere de E comercial (&) como delimitador.
Para criar uma array de subseqüências de caracteres segmentado por
delimitador:
1.
Crie um novo documento do Flash e salve-o como strsplit.fla.
2.
principal:
var queryStr:String = "first=joe&last=cheng&title=manager&startDate=3/6/
65";
var params:Array = queryStr.split("&", 2);
trace(params); // first=joe,last=cheng
/* params is set to an array with two elements:
params[0] == "first=joe"
493
params[1] == "last=cheng"
*/
3.
Flash.
D IC A
O segundo parâmetro do método split() define o tamanho máximo do array. Se
você não quiser limitar o tamanho do array criado pelo método split(), poderá
omitir osegundo parâmetro.
DICA
O modo mais fácil de analisar uma seqüência de caracteres de consulta (uma
seqüência de caracteres delimitada por caracteres & e =) é usar o método
LoadVars.decode(), conforme mostrado no seguinte ActionScript:
var queryStr:String = "first=joe&last=cheng&title=manager&startDate=3/6/
65";
my_lv.decode(queryStr);
trace(my_lv.first); // joe
Para obter mais informações sobre o uso de operadores com seqüências de caracteres, consulte
“Sobre uso de operadores com seqüências de caracteres” na página 192.
■
■
Retornando subseqüências de caracteres
Os métodos substr() e substring() da classe String são semelhantes. Ambos retornam
uma subseqüência de uma seqüência de caracteres e ambos usam dois parâmetros. Nos dois
métodos, o primeiro parâmetro é a posição do caractere inicial na seqüência especificada.
Entretanto, no método substr(), o segundo parâmetro é o tamanho da subseqüência a ser
retornada e, no método substring(), o segundo parâmetro é a posição do caractere
localizado no fim da subseqüência (que não está incluído na seqüência retornada). Este
exemplo mostra a diferença entre os dois métodos:
Para localizar um subseqüência por posição de caractere:
1.
Crie um novo documento do Flash e salve-o como substring.fla.
494
2.
principal:
var myStr:String = "Hello from Paris, Texas!!!";
trace(myStr.substr(11,15)); // Paris, Texas!!!!!!
trace(myStr.substring(11,15)); // Pari
O primeiro método, substr(), retorna uma seqüência com 15 caracteres, começando no
décimo-primeiro caractere. O segundo método, substring(), retorna uma seqüência de
caracteres com quatro caracteres, retendo todos os caracteres entre o décimo-primeiro e o
décimo-quinto.
3.
Adicione o seguinte ActionScript abaixo do código criado na etapa anterior:
trace(myStr.slice(11,
trace(myStr.slice(-3,
15)); // Pari
-1)); // !!
26)); // !!!
myStr.length)); // !!!
-3)); // Texas
O método slice() funciona de forma semelhante ao método substring(). Quando
dois inteiros não negativos são fornecidos como parâmetros, ele funciona de forma
idêntica. No entanto, o método slice() pode ter inteiros negativos como parâmetros.
4.
Flash.
N OT A
É possível combinar inteiros não negativos e negativos como os parâmetros do
método slice().
Você pode usar os métodos indexOf() e lastIndexOf() para localizar subseqüências
correspondentes em uma seqüência de caracteres, como no exemplo apresentado a seguir.
Para localizar a posição de caractere de uma subseqüência correspondente:
1.
Crie um novo documento do Flash e salve-o como indexof.fla.
2.
principal:
var myStr:String = "The moon, the stars, the sea, the land";
trace(myStr.indexOf("the")); // 10
trace(myStr.indexOf("the", 11)); // 21
O primeiro índice da palavra the começa no décimo caractere, porque o método
indexOf() faz distinção entre maiúsculas e minúsculas; portanto, a primeira instância de
The não será levada em consideração. Você pode especificar um segundo parâmetro para o
método indexOf(), a fim de indicar em qual posição de índice na seqüência de caracteres
a pesquisa deve iniciar: No código anterior, o Flash pesquisa o primeiro índice da palavra
the que ocorre após o décimo-primeiro caractere.
495
3.
Adicione o seguinte ActionScript abaixo do código criado na etapa anterior:
trace(myStr.lastIndexOf("the")); // 30
trace(myStr.lastIndexOf("the", 29)); // 21
O método lastIndexOf() localiza a última ocorrência de uma subseqüência na seqüência
de caracteres: Por exemplo, em vez de pesquisar um caractere ou subseqüência desde o
início de uma seqüência de caracteres, o método lastIndexOf() começa no fim de uma
seqüência de caracteres e trabalha de forma retroativa. De maneira semelhante ao método
indexOf(), se você incluir um segundo parâmetro com o método lastIndexOf(), a
pesquisa será conduzida a partir dessa posição de índice, sendo que a seqüência de
caracteres será pesquisada de forma retroativa (da direita para a esquerda).
4.
Flash.
DICA
Os métodos indexOf() e lastIndexOf() fazem distinção entre maiúsculas e
minúsculas.
■
■
496
CAPÍTULO 13
13
Animação, filtros e desenhos
Este capítulo descreve como adicionar animação aos aplicativos Macromedia Flash Basic 8 e
Macromedia Flash Professional 8 com o ActionScript em vez de (ou além de) animações
baseadas na timeline que usam interpolações de movimento ou de forma. O uso de código
para criar animação e efeitos normalmente reduz o tamanho de arquivo do aplicativo
concluído, além de poder melhorar o desempenho e a consistência da animação em si.
Algumas vezes, as animações baseadas em ActionScript podem até mesmo reduzir sua carga de
trabalho: escrever o código pode ser um procedimento mais rápido, além da facilidade de
aplicá-lo a várias instâncias de uma vez ou reutilizá-lo em outros aplicativos. Este capítulo
também mostra como animar usando os conceitos básicos fundamentais do ActionScript, as
classes Tween e TransitionManager, a API (Application Programming Interface, Interface de
programação de aplicativos) de desenho, as classes de filtro e os modos de mistura.
Use a API de desenho, que consiste nos métodos de desenho da classe MovieClip, para
adicionar animação e desenhar. Esses métodos permitem usar código para criar linhas,
preenchimentos e formas, em vez das ferramentas de desenho da ferramenta de criação.
Filtros e outros efeitos expressivos também são importantes em vários aplicativos Flash, para
aplicar rapidamente um efeito e animá-lo. Você pode usar código para adicionar e animar
efeitos de filtro, modos de mistura e imagens de bitmap.
O capítulo contém as seguintes seções, que descrevem o uso do ActionScript para criar
animação e adicionar efeitos, bem como o uso da API de desenho para desenhar no
ActionScript:
Scripts de animação com o ActionScript 2.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
Sobre cache de bitmap, rolagem e desempenho . . . . . . . . . . . . . . . . . . . . . . . . . . . 508
Sobre as classes Tween e TransitionManager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509
Usando efeitos de filtro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .526
Trabalhando com filtros usando ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .534
Manipulando efeitos de filtro com código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .557
Criando bitmaps com a classe BitmapData . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 561
Modos de mistura. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .564
497
Sobre a ordem de operação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567
Desenhando com o ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567
Noções básicas sobre dimensionamento e guias de trecho. . . . . . . . . . . . . . . . . . .583
Scripts de animação com o ActionScript
2.0
Você pode usar o ActionScript 2.0 para adicionar animação aos aplicativos Flash, em vez de
interpolações de movimento ou de forma em uma timeline. As seções a seguir mostram como
usar código para animar instâncias, por exemplo, alterar a transparência e a aparência da
instância e movê-la no Stage (Palco).
Para obter informações sobre como usar as classes Tween e TransitionManager para
automatizar ainda mais as animações baseadas em código, consulte TransitionManager class e
Tween class em Components Language Reference. Essas classes ajudam a adicionar equações de
atenuação avançadas e animações de transição a instâncias de clipe de filme em seu aplicativo.
Vários desses efeitos são difíceis de serem recriados com o ActionScript sem essas classes
predefinidas, pois o código a ser usado envolve a criação de equações matemáticas complexas
para atingir o efeito.
Para obter mais informações sobre como animar desenhos criados com código, consulte
“Desenhando com o ActionScript” na página 567.
As seções a seguir descrevem como usar animações com script:
■
“Sobre animação e taxa de quadros” na página 499
■
“Efeitos de fade em objetos com código” na página 500
■
“Adicionando efeitos de cor e brilho com código” na página 502
■
“Movimentação de objetos com código” na página 505
■
“Efeito de imagem panorâmica com código” na página 506
Para obter um exemplo de animação com script no Flash, localize um arquivo de origem de
exemplo, animation.fla, na pasta Samples do seu disco rígido.
■
■
498
Há exemplos de aplicativos de galeria de fotos em seu disco rígido. Esses arquivos mostram
como usar o ActionScript para controlar clipes de filme dinamicamente ao carregar arquivos
de imagem em um arquivo SWF, que inclui animação com script. Os arquivos de origem de
exemplo, gallery_tree.fla e gallery_tween.fla, podem ser encontrados na pasta Samples do seu
disco rígido.
■
■
Sobre animação e taxa de quadros
Ao adicionar animação a um aplicativo, considere a taxa de quadros definida para o seu
arquivo FLA. Leve em consideração a taxa de quadros ao trabalhar com animações, pois ela
pode afetar o desempenho de seu arquivo SWF e o computador que o executa. A configuração
de uma taxa muito alta pode causar problemas no processador, principalmente quando você
usa vários recursos ou o ActionScript para criar animação.
Entretanto, leve em consideração também a configuração da taxa de quadros, pois ela afeta a
suavidade de reprodução de sua animação. Por exemplo, uma animação definida como 12
quadros por segundo (qps) no inspetor Properties (Propriedades) reproduz 12 quadros a cada
segundo. Se a taxa de quadros do documento estiver definida como 24 qps, a animação dará a
impressão de ser reproduzida com mais suavidade do que se fosse executada a 12 qps.
Entretanto, a animação a 24 qps também é reproduzida com mais rapidez do que a animação
a 12 qps, portanto, a duração total (em segundos) é menor. Desse modo, se precisar criar uma
animação de 5 segundos usando uma taxa de quadros mais alta, você precisará adicionar mais
quadros para preencher esses cinco segundos do que a uma taxa de quadros mais baixa
(aumentando, portanto, o tamanho total do arquivo da animação). Em geral, uma animação
de 5 segundos a 24 qps possui um tamanho de arquivo maior do que uma animação de 5
segundos a 12 qps.
NO T A
Quando você usa um manipulador de eventos onEnterFrame para criar animações com
script, a animação é executada segundo a taxa de quadros do documento, da mesma
forma como se você tivesse criado uma interpolação de movimento em uma timeline.
Uma alternativa para o manipulador de eventos onEnterFrame é a função setInterval
(consulte %{função setInterval}% em ActionScript 2.0 Language Reference
(Referência da linguagem ActionScript 2.0)). Em vez de depender da taxa de quadros,
você pode chamar funções em um intervalo especificado. Da mesma forma que com o
manipulador onEnterFrame, quanto mais você usar setInterval para chamar uma
função, mais recursos terá a animação em seu processador.
Scripts de animação com o ActionScript 2.0
499
O uso da taxa de quadros mais baixa possível que aparentemente faça sua animação ser
reproduzida suavamente durante a execução ajudará a reduzir a sobrecarga no processador do
usuário final. Tente não usar uma taxa de quadros maior que 30 a 40 qps; taxas de quadro
altas sobrecarregam bastante os processadores; não altere também a aparência da animação (ou
não a altere muito) durante a execução.
Além disso e, principalmente se estiver trabalhando com animação baseada na timeline,
selecione uma taxa de quadros para a animação o quanto antes no processo de
desenvolvimento. Ao testar o arquivo SWF, verifique a duração e o tamanho do arquivo SWF
de sua animação. A taxa de quadros afeta bastante a velocidade da animação.
Efeitos de fade em objetos com código
Ao trabalhar com clipes de filme no Stage, você talvez deseje usar o recurso de fade-in ou fadeout no clipe em vez de alternar a propriedade _visible. O procedimento a seguir demonstra
como usar um manipulador de eventos onEnterFrame para animar um clipe de filme.
Para aplicar os efeitos de fade a um clipe de filme usando código:
1.
Crie um novo documento do Flash chamado fade1.fla.
2.
Desenhe alguns gráficos no Stage usando as ferramentas de desenho ou importe uma
imagem para o Stage (File (Arquivo) > Import (Importar) > Import to Stage (Importar para
o palco)).
3.
Selecione o conteúdo no Stage e escolha Modify (Modificar) > Convert to Symbol
4.
Selecione a opção Movie clip (Clipe de filme) e clique em OK para criar o símbolo.
5.
Selecione a instância de clipe de filme no Stage e digite img1_mc na caixa de texto Instance
Name (Nome da instância) do inspetor Properties (Propriedades).
6.
Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) e adicione o código a seguir
ao painel Actions (Ações):
img1_mc.onEnterFrame = function() {
img1_mc._alpha -= 5;
if (img1_mc._alpha <= 0) {
img1_mc._visible = false;
delete img1_mc.onEnterFrame;
}
};
500
Esse código usa um manipulador de eventos onEnterFrame que é chamado repetidamente
de acordo com a taxa de quadros do arquivo SWF. O número de vezes por segundo que o
manipulador de eventos é chamado depende da taxa de quadros definida no documento
do Flash. Se a taxa de quadros for 12 quadros por segundo (qps), o manipulador de
eventos onEnterFrame será chamado 12 vezes por segundo. Da mesma maneira, se a taxa
de quadros do documento do Flash for 30 qps, o manipulador de eventos será chamado
30 vezes por segundo.
7.
O clipe de filme adicionado ao Stage desaparece lentamente.
Você pode modificar a propriedade _alpha usando a função setInterval(), em vez de um
manipulador de eventos onEnterFrame, conforme mostrado no procedimento a seguir.
Para aplicar o efeito de fade a um objeto usando a função setInterval():
1.
Crie um novo documento do Flash chamado fade2.fla.
2.
Desenhe alguns gráficos no Stage ou importe uma imagem para ele (File > Import > Import
to Stage).
3.
Selecione o conteúdo no Stage e escolha Modify > Convert to Symbol.
4.
Selecione a opção Movie clip e clique em OK para criar o símbolo.
5.
Selecione a instância de clipe de filme no Stage e digite img1_mc na caixa de texto Instance
Name do inspetor Properties.
6.
Selecione o Frame 1 da Timeline e adicione o código a seguir ao painel Actions:
var alpha_interval:Number = setInterval(fadeImage, 50, img1_mc);
function fadeImage(target_mc:MovieClip):Void {
target_mc._alpha -= 5;
if (target_mc._alpha <= 0) {
target_mc._visible = false;
clearInterval(alpha_interval);
}
}
A função setInterval() comporta-se de uma maneira ligeiramente diferente do
manipulador de eventos onEnterFrame, pois setInterval() informa ao Flash
precisamente com que freqüência o código deve chamar uma função específica. Nesse
exemplo de código, a função fadeImage() definida pelo usuário é chamada a cada 50
milissegundos (20 vezes por segundo). A função fadeImage() decrementa o valor da
propriedade _alpha do clipe de filme atual. Quando o valor de _alpha for menor que ou
igual a 0, o intervalo será apagado, interrompendo a execução da função fadeImage().
7.
O clipe de filme adicionado ao Stage desaparece lentamente.
501
Para obter mais informações sobre funções definidas pelo usuário, consulte “Definindo
funções globais e de timeline” na página 224. Para obter mais informações sobre o
manipulador de eventos onEnterFrame, consulte %{onEnterFrame (manipulador
MovieClip.onEnterFrame)}% em ActionScript 2.0 Language Reference. Para obter mais
informações sobre a função setInterval(), consulte %{função setInterval}% em
■
■
Adicionando efeitos de cor e brilho com código
Além de usar o ActionScript para definir e animar recursos de fade alfa (consulte “Efeitos de
fade em objetos com código” na página 500), você pode animar diversos efeitos de cor e brilho
usando código em vez do painel Filters (Filtros) no inspetor Properties.
O procedimento a seguir carrega uma imagem JPEG e aplica um filtro de transformação de
cor, que modifica os canais vermelho e verde quando o ponteiro do mouse passa pelos eixos x
e y.
Para alterar os canais de cor de um objeto usando o ActionScript:
1.
Crie um novo documento do Flash chamado colorTrans.fla.
2.
import flash.geom.Transform;
import flash.geom.ColorTransform;
var imageClip:MovieClip = this.createEmptyMovieClip("imageClip", 1);
var clipLoader:MovieClipLoader = new MovieClipLoader();
clipLoader.loadClip("http://www.helpexamples.com/flash/images/
image1.jpg", imageClip);
var transformer:Transform = new Transform(imageClip);
var colorTransformer:ColorTransform = transformer.colorTransform;
colorTransformer.redMultiplier = (_xmouse / Stage.width) * 1;
colorTransformer.greenMultiplier = (_ymouse / Stage.height) * 1;
transformer.colorTransform = colorTransformer;
502
}
3.
Selecione Control > Test Movie para testar o documento e mova o ponteiro do mouse no
Stage.
O arquivo de imagem carregado transforma as cores quando você move o mouse.
Você também pode usar a classe ColorMatrixFilter para converter uma imagem colorida em
uma imagem em preto-e-branco, conforme o procedimento a seguir:
Para usar a classe ColorMatrixFilter e alterar uma imagem para uma imagem
em escala de cinza:
1.
Crie um novo documento do Flash chamado grayscale.fla.
2.
import flash.filters.ColorMatrixFilter;
var mcl_obj:Object = new Object();
mcl_obj.onLoadInit = function(target_mc:MovieClip):Void {
var myElements_array:Array = [0.3, 0.59, 0.11, 0, 0,
0.3, 0.59, 0.11, 0, 0,
0.3, 0.59, 0.11, 0, 0,
0, 0, 0, 1, 0];
var myColorMatrix_filter:ColorMatrixFilter = new
ColorMatrixFilter(myElements_array);
target_mc.filters = [myColorMatrix_filter];
}
this.createEmptyMovieClip("img_mc", this.getNextHighestDepth());
img_mcl.addListener(mcl_obj);
img_mc);
O código anterior começa a importar a classe ColorMatrixFilter e cria um objeto ouvinte
que será usado com uma nova instância MovieClipLoader criada em algum código
posterior. Em seguida, uma nova instância de clipe de filme é criada com o nome img_mc,
e também uma nova instância de clipe de filme carregador cujo nome será img_mcl.
Finalmente, o clipe de filme de origem é carregado no clipe de filme img_mc no Stage.
Depois que a imagem for carregada com êxito, o manipulador de eventos onLoadInit será
chamado e anexará ColorMatrixFilter a ela.
3.
A imagem carregada no Stage é alterada para uma imagem em escala de cinza. Exiba a
imagem on-line (http://www.helpexamples.com/flash/images/image1.jpg) para
ver sua cor original.
503
Você também pode definir o brilho de uma imagem usando o código ActionScript do
procedimento a seguir.
Para alterar o brilho de uma imagem:
1.
Crie um novo documento do Flash chamado brightness.fla.
2.
import flash.filters.ColorMatrixFilter;
System.security.allowDomain("http://www.helpexamples.com/");
mcl_obj.onLoadInit = function(target_mc:MovieClip):Void {
var myElements_array:Array = [1, 0, 0, 0, 100,
0, 1, 0, 0, 100,
0, 0, 1, 0, 100,
0, 0, 0, 1, 0];
var myColorMatrix_filter:ColorMatrixFilter = new
ColorMatrixFilter(myElements_array);
target_mc.filters = [myColorMatrix_filter];
}
this.createEmptyMovieClip("img_mc", this.getNextHighestDepth());
img_mc);
Este bloco de código usa a classe MovieClipLoader para carregar um JPEG externo.
Depois que a imagem for carregada com êxito, o manipulador de eventos onLoadInit da
classe MovieClipLoader será chamado e modificará o brilho da imagem para 100 usando o
filtro ColorMatrixFilter.
3.
A imagem carregada no arquivo SWF muda o brilho quando você testa o arquivo SWF.
Exiba a imagem on-line (http://www.helpexamples.com/flash/images/image2.jpg)
para ver sua aparência original.
■
■
504
Você também pode obter exemplos de aplicativos de galeria de fotos em seu disco rígido. Esses
arquivos fornecem exemplos de como usar o ActionScript para controlar clipes de filme
dinamicamente durante o carregamento de arquivos de imagem em um arquivo SWF, que
inclui animação com script. Os arquivos de origem de exemplo, gallery_tree.fla e
gallery_tween.fla, podem ser encontrados na pasta Samples do seu disco rígido.
■
■
Movimentação de objetos com código
Usar o ActionScript para mover um objeto é semelhante a modificar a propriedade _alpha de
um objeto, embora você esteja modificando a propriedade _x ou _y do objeto.
O procedimento a seguir mostra uma animação de uma imagem JPEG carregada
dinamicamente e desliza-a horizontalmente pelo Stage:
Para mover uma instância no Stage usando código:
1.
Crie um novo documento do Flash chamado moveClip.fla.
2.
Altere a taxa de quadros do documento para 24 qps no inspetor Properties.
A animação ficará muito mais suave se você usar uma taxa de quadros mais alta, por
exemplo, 24 qps.
3.
// Criar uma instância de clipe de filme.
this.createEmptyMovieClip("img1_mc", 10);
mcl_obj.onLoadInit = function (target_mc:MovieClip):Void {
target_mc._x = Stage.width;
target_mc.onEnterFrame = function() {
target_mc._x -= 3; // diminuir para 3 pixels a posição _x atual
if (target_mc._x <= 0) {
target_mc._x = 0;
delete target_mc.onEnterFrame;
}
};
};
// Carregar uma imagem no clipe de filme
img1_mc);
505
Esse exemplo de código carrega uma imagem externa a partir de um servidor Web remoto
e, depois que a imagem é carregada completamente, ela é animada no sentido horizontal
pelo Stage. Em vez de usar um manipulador de eventos onEnterFrame, você poderia usar
a função setInterval() para animar a imagem.
4.
A imagem é carregada e, em seguida, animada desde o lado direito do Stage até seu canto
superior esquerdo.
Para obter informações sobre como usar um manipulador de eventos onEnterFrame ou a
função setInterval() para animar a imagem, consulte “Efeitos de fade em objetos com
código” na página 500.
■
■
Também há exemplos de aplicativos de galeria de fotos em seu disco rígido. Esses arquivos
mostram como usar o ActionScript para controlar clipes de filme dinamicamente ao carregar
arquivos de imagem em um arquivo SWF, que inclui animação com script. Os arquivos de
origem de exemplo, gallery_tree.fla e gallery_tween.fla, podem ser encontrados na pasta
Samples do seu disco rígido.
■
■
Efeito de imagem panorâmica com código
Com o ActionScript, é fácil utilizar grandes imagens panorâmicas em seus documentos do
Flash. Isso é útil quando a imagem não cabe no Stage ou quando você deseja criar um efeito de
animação, movendo um clipe de filme em panorâmica de um lado a outro do Stage. Por
exemplo, se você possui uma grande imagem panorâmica maior do que o tamanho do Stage e
não deseja reduzir as dimensões da imagem ou aumentar as dimensões do Stage, poderá criar
um clipe de filme que funcionará como uma máscara para a imagem maior.
O procedimento a seguir demonstra como mascarar um clipe de filme dinamicamente e usar o
manipulador de eventos onEnterFrame para animar uma imagem atrás da máscara.
506
Para mover uma instância em panorâmica no Stage usando código:
1.
Crie um novo documento do Flash chamado pan.fla.
2.
Altere a taxa de quadros do documento para 24 qps no inspetor Properties.
A animação ficará muito mais suave se você usar uma taxa de quadros mais alta, por
exemplo, 24 qps.
3.
System.security.allowDomain("http://www.helpexamples.com/");
// inicializar variáveis
var direction:Number = -1;
var speed:Number = 5;
// criar clipe para carregar uma imagem nele
// criar um clipe para usar como máscara
this.createEmptyMovieClip("mask_mc", 20);
// usar a API de desenho para desenhar/criar uma máscara
with (mask_mc) {
beginFill(0xFF0000, 0);
moveTo(0, 0);
lineTo(300, 0);
lineTo(300, 100);
lineTo(0, 100);
lineTo(0, 0);
endFill();
}
mcl_obj.onLoadInit = function(target_mc:MovieClip) {
// definir a máscara do clipe de filme de destino como mask_mc
target_mc.setMask(mask_mc);
target_mc.onEnterFrame = function() {
target_mc._x += speed * direction;
// se target_mc estiver em uma borda, inverta a direção da animação
if ((target_mc._x <= -(target_mc._width-mask_mc._width)) ||
(target_mc._x >= 0)) {
direction *= -1;
}
};
};
my_mcl.addListener(mcl_obj);
img_mc);
507
A primeira seção de código neste exemplo define duas variáveis: direction e speed. A
variável direction controla se a imagem mascarada rolará da esquerda para a direita (1)
ou da direita para a esquerda (-1). A variável speed controla quantos pixels são movidos
cada vez que o manipulador de eventos onEnterFrame é chamado. Números maiores
fazem a animação mover-se mais rapidamente, embora ela seja exibida com um pouco
menos de suavidade.
A próxima seção de código cria dois clipes de filme vazios: img_mc e mask_mc. Um
retângulo de 300 X 100 pixels é desenhado dentro do clipe de filme mark_mc usando a
API de desenho. Em seguida, um novo objeto (mcl_obj) é criado e será usado como
ouvinte para uma instância MovieClipLoader criada no bloco de código final. Esse objeto
define um ouvinte de eventos para o evento onLoadInit, mascara a imagem carregada
dinamicamente e configura a animação de rolagem. Quando a imagem estiver na borda
esquerda ou direita da máscara, a animação será invertida.
O bloco de código final define uma instância MovieClipLoader, especifica o objeto
ouvinte criado anteriormente e começa a carregar a imagem JPEG no clipe de filme
img_mc.
4.
A imagem é carregada e animada em um movimento panorâmico (de um lado para o
outro). Ela é mascarada durante a execução. Para ver a imagem original, você poderá exibila on-line (http://www.helpexamples.com/flash/images/image1.jpg).
Sobre cache de bitmap, rolagem e
desempenho
O Flash Player 8 introduz o recurso de cache de bitmap, que ajuda a melhorar o desempenho
de clipes de filme imutáveis nos aplicativos. Quando você define a propriedade
MovieClip.cacheAsBitmap ou Button.cacheAsBitmap como true, o Flash Player
armazena em cache uma representação de bitmap interna da instância de botão ou de clipe de
filme. Isso pode melhorar o desempenho de clipes de filme que contêm conteúdo vetorial
complexo. Todos os dados vetoriais de um clipe de filme com bitmap armazenado em cache
são desenhados no bitmap, e não no Stage principal.
N OT A
508
O bitmap é copiado para o Stage principal como pixels não esticados e não girados,
encaixados nos limites dos pixels mais próximos. Os pixels são mapeados de um para
um com o objeto pai. Se os limites do bitmap forem alterados, o bitmap será recriado, e
não esticado.
Para obter informações detalhadas sobre como armazenar em cache instâncias de botões ou de
clipes de filme, consulte as próximas seções no Capítulo 11, “Trabalhando com clipes de
filme”:
■
“Sobre o armazenamento em cache e a rolagem de clipes de filme com o ActionScript”
na página 389
■
“Armazenando um clipe de filme em cache” na página 393
■
“Definindo o plano de fundo de um clipe de filme” na página 396
É ideal usar a propriedade cacheAsBitmap com clipes de filme que possuem, na maioria,
conteúdo estático e que não são dimensionados e girados com freqüência. O uso dessa
propriedade com esses clipes de filme poderá resultar em aumento de desempenho quando o
clipe de filme for convertido (quando sua posição x e y for alterada). Para obter informações
detalhadas sobre quando usar esse recurso, consulte “Quando ativar o armazenamento em
cache” na página 391.
Há um arquivo de origem de exemplo, cacheBitmap.fla, que mostra como o cache de bitmap
pode ser aplicado a uma instância. O arquivo está localizado na pasta Samples do seu disco
rígido.
■
■
and Tutorials/Samples/ActionScript/CacheBitmap.
Também há um arquivo de origem de exemplo, flashtype.fla, que mostra como aplicar cache
de bitmap a um texto de rolagem. O arquivo está localizado na pasta Samples do seu disco
rígido.
■
■
and Tutorials/Samples/ActionScript/FlashType.
Sobre as classes Tween e
TransitionManager
Ao instalar o Flash Basic 8 ou Flash Professional 8, você também instala duas classes
poderosas: as classes Tween e TransitionManager. Esta seção descreve como usar essas classes
com clipes de filme e componentes do Macromedia V2 (incluídos no Flash MX 2004 e no
Flash 8) para adicionar animação facilmente aos arquivos SWF.
Sobre as classes Tween e TransitionManager
509
Se você criar uma apresentação de slides ou aplicativo de formulário com o Flash Professional
8 (somente ActionScript 2.0), pode selecionar comportamentos que adicionam diferentes
tipos de transição entre slides, semelhante ao que é feito em apresentações do PowerPoint.
Você adiciona essa funcionalidade a um aplicativo de tela usando as classes Tween e
TransitionManager, que geram um ActionScript que anima as telas dependendo do
comportamento escolhido.
Você também pode usar essas classes fora de documentos com base em tela, no Flash Basic 8
ou no Flash Professional 8. Por exemplo, você pode usar as classes com o conjunto de
componentes da versão 2 da Arquitetura de Componentes Macromedia ou com clipes de
filme. Se desejar alterar a animação de um componente ComboBox (Caixa de combinação),
você poderá usar a classe TransitionManager para adicionar um pouco de atenuação na
abertura do menu. A atenuação refere-se à aceleração ou à desaceleração gradual durante uma
animação, o que confere um aspecto mais realista às animações. Você também pode usar as
classes Tween e TransitionManager, em vez de criar interpolações de movimento na timeline
ou escrever um código personalizado, para criar um sistema próprio de menu animado.
NO TA
As classes Tween e TransitionManager estão disponíveis somente no ActionScript 2.0,
mas estão disponíveis no Flash Basic 8 e no Flash Professional 8.
Para obter informações sobre cada método e propriedade da classe Tween, consulte o Chapter
51, “Tween class” em Components Language Reference (Referência da linguagem de
componentes). Para obter informações sobre cada método e propriedade da classe
TransitionManager, consulte o Chapter 48, “TransitionManager class” em Components
Language Reference. Para obter informações sobre como trabalhar com pacotes, consulte
“Trabalhando com pacotes de filtro” na página 528.
Há um arquivo de origem de exemplo, tweenProgress.fla, que usa essas classes para adicionar
animação com script. Esse arquivo está localizado na pasta Samples do seu disco rígido.
■
8\Samples and Tutorials\Samples\ActionScript\Tween ProgressBar.
■
and Tutorials/Samples/ActionScript/Tween ProgressBar.
Para obter mais informações sobre as classes Tween e TransitionManager , consulte os
seguintes tópicos:
■
“Adicionando interpolações e transições a um arquivo no Flash Professional 8 (somente
Flash Professional 8)” na página 511
■
“Animando com as classes TransitionManager e Tween” na página 513
■
“Sobre classes e métodos de atenuação” na página 516
510
■
“Sobre a classe Tween” na página 517
■
“Usando a classe Tween” na página 518
■
“Combinando as classes TransitionManager e Tween” na página 524
Adicionando interpolações e transições a um arquivo
no Flash Professional 8 (somente Flash Professional
8)
N OT A
Esta seção descreve a adição de interpolações e transições a uma apresentação de
slides do Flash Professional para demonstrar sua aparência para os usuários desse
programa. Entretanto, você poderá adicionar transições e interpolações aos aplicativos
Flash Basic 8 (ou Flash Professional 8) se utilizar código. As seções a seguir incluem
exemplos que mostram esse procedimento.
As classes Tween e TransitionManager foram criadas para permitir a adição de animações a
partes do arquivo SWF usando um ActionScript simples. O ambiente de criação do Flash
contém comportamentos que permitem usar classes predefinidas para transições em um
aplicativo com base em tela. Para criar uma apresentação de slides ou aplicativo de formulário,
você pode selecionar comportamentos que adicionam diferentes tipos de transição entre os
slides.
Antes de você começar a usar essas transições com clipes de filme em Flash, veja o que eles
fazem ao usar um aplicativo com base em tela.
Para exibir o ActionScript que cria uma transição em uma apresentação de
slides:
1.
Selecione File (Arquivo) > New (Novo) para criar uma nova apresentação de slides no Flash
Professional 8.
2.
Selecione Flash Slide Presentation (Apresentação de slides do Flash) na guia General
(Geral) e clique em OK.
3.
Selecione Window (Janela) > Behaviors (Comportamentos) para abrir o painel Behaviors
(Comportamentos).
4.
Clique em Add Behavior (+) (Adicionar comportamento).
5.
Selecione Screen (Tela) > Transition (Transição) no menu pop-up para abrir a caixa de
diálogo Transitions (Transições).
6.
Selecione a transição Zoom.
7.
Digite 1 na caixa de texto Duration (Duração).
8.
Selecione Bounce (Salto) no menu pop-up Easing (Atenuação).
Sobre as classes Tween e TransitionManager
511
9.
Clique em OK para aplicar as configurações e fechar a caixa de diálogo.
Esse procedimento adiciona cerca de 15 linhas de ActionScript diretamente no slide. O
trecho de código a seguir mostra o código de transição relevante:
mx.transitions.TransitionManager.start(eventObj.target,
{type:mx.transitions.Zoom, direction:0, duration:1,
easing:mx.transitions.easing.Bounce.easeOut, param1:empty,
param2:empty});
Esse código chama a classe TransitionManager e, em seguida, aplica a transição Zoom com
o método de atenuação mx.transitions.easing.Bounce.easeOut especificado. Nesse
caso, a transição é aplicada ao slide selecionado. Para aplicar esse efeito a um clipe de filme,
você pode modificar o ActionScript e usá-lo nas animações Flash. É fácil modificar o
código para trabalhar com um símbolo de clipe de filme: altere o primeiro parâmetro de
eventObj.target para o nome de instância do clipe de filme desejado.
O Flash inclui dez transições, que você pode personalizar usando os métodos de atenuação e
diversos parâmetros opcionais. Lembre-se de que a atenuação refere-se à aceleração ou à
desaceleração gradual durante uma animação, o que confere um aspecto mais realista às
animações. Por exemplo, a velocidade de uma bola pode aumentar gradualmente no início de
uma animação, mas pode diminuir antes de parar completamente no final. Há muitas
equações para essa aceleração e essa desaceleração, que alteram a animação da atenuação de
acordo.
A tabela a seguir descreve as transições incluídas no Flash Basic 8 (usando código) e no Flash
Professional 8 (usando código ou comportamentos):
Transição
Descrição
Iris
Revela a tela ou o clipe de filme usando uma máscara de animação de
uma forma que aumenta o zoom.
Wipe
Revela a tela ou o clipe de filme usando uma máscara de animação de
uma forma que move-se horizontalmente.
Pixel Dissolve
Mascara a tela ou o clipe de filme usando retângulos que desaparecem
e aparecem.
Blinds
Revela a próxima tela ou clipe de filme usando retângulos que
desaparecem ou aparecem.
Fade
Faz aparecer e ou desaparecer gradualmente a tela ou o clipe de filme.
Fly
Desliza na tela ou no clipe de filme a partir de uma direção.
Zoom
Aproxima ou diminui o zoom da tela ou do clipe de filme.
Squeeze
Dimensiona horizontalmente ou verticalmente a tela ou o clipe de filme
atual.
512
Transição
Descrição
Rotate
Gira a tela ou o clipe de filme atual.
Photo
Faz a tela ou o clipe de filme aparecer como em um flash fotográfico.
Cada transição possui personalizações ligeiramente diferentes que você pode aplicar à
animação. A caixa de diálogo Transitions permite que você visualize uma animação de
exemplo antes de usar o efeito no slide ou no formulário.
D IC A
Para visualizar o modo de funcionamento de cada transição com os diferentes métodos
nas classes de atenuação, você pode clicar duas vezes em Transition.swf na pasta
unida

Aprendendo ActionScript 2.0 no Flash

Transcrição

Documentos relacionados

O Mar Não Está Pra Peixe 2

Manual do usuário

Relatos selvagens

Casa em Condomínio em Vargem Grande Paulista Ref. : CO 649

Trilha sonora de "Paixão de Cristo" é um sucesso

Walt nos Bastidores de Mary Poppins

C7nema - Doclisboa

Música e imagem, uma nova era com a web

“Velocidade Furiosa” somou e seguiu em mais quatro

(Folheto The Village.pub \(S\363 de leitura\))

Aprendendo o ActionScript® 3.0