Biblia Flash 8 Learning Action Script 2

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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 769
Usando de comentários no código. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 779
Convenções de codificação do ActionScript . . . . . . . . . . . . . . . . . . . . 782
Otimização do ActionScript e do Flash Player . . . . . . . . . . . . . . . . . . 798
Formatando a sintaxe do ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . 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.
Sobre a documentação 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.
Sobre a documentação 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
Novidades do ActionScript
no Flash 8
1
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.

■ 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.

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.

■ 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.

■ 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.

■ 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ó.

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.
View hidden characters (Exibir caracteres ocultos) 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.
Script assist added to Actions panel (Script assist adicionado ao painel Actions) 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.

Reload modified files (Recarregar arquivos modificados) 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.
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.”

CAPÍTULO 2
Escrevendo e editando o
ActionScript 2.0
2
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 quadros-
chave 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"

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.
■ “Sobre o painel Actions” na página 37
■ “Sobre a janela Script” na página 38

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
de ferramentas Navegador Script 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.
Navegador Script 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.
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

Painel Script 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.
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.

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) Menu pop-up*
Find (Localizar) 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

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.
Insert target path (Inserir caminho de destino) 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.
Check Syntax (Verificar sintaxe) 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.
Auto Format (Formatação automática) 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.
Show Code Hint (Mostrar referência de código) 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.
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.

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.
Reference (Referência) 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).
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.

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.
Find again (Localizar novamente) 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.
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.
Export script (Exportar script) 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.
Esc shortcut keys (Teclas de atalho de Esc) 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.
Hidden characters (Caracteres ocultos) 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.
Line numbers (Números de linha) 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.
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.

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).

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.
Code hints (Referências de código) 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.
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.

Use dynamic font mapping (Usar mapeamento dinâmico de fontes) 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.
Encoding (Codificação) 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.
Reload modified files (Recarregar arquivos modificados) 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.
■ Always (Sempre) Nenhum aviso é exibido quando uma alteração é detectada e o
arquivo é automaticamente recarregado.
■ Never (Nunca) Nenhum aviso é exibido quando uma alteração é detectada e o arquivo
permanece no estado atual.
■ Prompt (Padrão) Um aviso é exibido quando uma alteração é detectada e você pode
optar por recarregar ou não o arquivo.
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.
Syntax colors (Cores da sintaxe) 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.
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.

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.

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. 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
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).
2. 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.

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. 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
2. 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.

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.

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. No painel Actions, selecione Preferences no menu pop-up (na parte superior direita do
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.

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).

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).
■ No painel Actions, selecione Preferences no menu pop-up (na parte superior direita do
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).

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.

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 l
duplos
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).

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.

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.

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 pop-
up 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.

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.

■ 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.

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

■ 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:

■ É possível usar os seguintes atalhos de teclado para trabalhar com scripts presos:
Ação tecla de atalho no tecla de atalho no

Windows Macintosh
Prender script Control+= (sinal de igual) Command+=
Liberar script Control+- (sinal de menos) Command+-
Mover o foco para a guia da Control+Shift+. (ponto) Command+Shift+.

direita
Mover o foco para a guia da Control+Shift+, (vírgula) Command+Shift+,

esquerda
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.
■ 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.

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).
■ 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
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).
■ 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.
■ 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.
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.
Arquivo de configuração AsColorSyntax.xml É o arquivo de configuração para realce da
sintaxe por cores do código ActionScript, localizado em:
Data\Macromedia\Flash 8\idioma\Configuration\ActionsPanel\.
idioma/Configuration/ActionsPanel.

CAPÍTULO 3
Sobre o ActionScript 3
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 palavras-
chave 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.
Atribuição estrita de tipos de dados 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).
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 Sobre o ActionScript
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 Sobre o ActionScript
CAPÍTULO 4
Dados e tipos de dados 4

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 Dados e tipos de dados

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.
Sobre tipos de dados 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.

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;

// 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 (.).
Trabalhando com clipes de filme no Stage O exemplo a seguir chama os métodos
startDrag() e getURL() para instâncias diferentes de clipe de filme existentes no Stage:
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));

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

■ 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);

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 (").

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 Caractere
escape
\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.

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;

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.

Atribuindo um tipo de dados

Atribua tipos de dados sempre que definir uma variável, quer você a declare usando a palavra-
chave 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 dois-
pontos 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;
}

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

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;

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

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

■ “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:

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).

■ 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.

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. 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);

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.
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.

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

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); // <em branco>
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 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.

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

<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

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

<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.

Para carregar variáveis de um servidor:
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
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.

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.

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).

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)};

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:

■ “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}%.

CAPÍTULO 5
Fundamentos da sintaxe e da
linguagem
5
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.ecma-
international.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.
Sobre sintaxe, instruções e expressões 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 different variables

var myVar:Number = 10;
var myvar:Number = 10;
var mYvAr:Number = 10;
N O TA
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.
Sobre sintaxe, instruções e expressões 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.

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ância-
alvo. 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.

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.
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.

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.
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");

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.
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;

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.

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.

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):

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
if..else 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:
Sobre pontuadores de linguagem 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");
};
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.

3. Adicione o seguinte ActionScript ao arquivo AS:
// Student.as
class Student {
private var _id:String;
private var _firstName:String;
private var _middleName:String;
private var _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.

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]);
}

/*
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.

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 dois-
pontos (:), 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};

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.

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.

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.

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 myAge:Number = 28; // my age
var myCountry:String = "Canada"; // my country
var myCoffee:String = "Hortons"; // 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.

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.
Sobre constantes e palavras-chave 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:

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:

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.
Global access será exibido no painel Output (Saída).
7. No painel Actions, digite esse código após o código adicionado na etapa 5.

trace(ConstExample.EXAMPLE_PUBLIC); // error
trace(ConstExample.EXAMPLE_PRIVATE); // error

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.

Public access será exibido no painel Output.
12. No painel Actions, exclua a instrução trace adicionada na etapa 10.
trace(myExample.EXAMPLE_PRIVATE); // error
A propriedade EXAMPLE_PRIVATE é privada e, portanto, está disponível somente na

definição da classe.
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:
var myAge:Number = 26;

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 palavras-
chave 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

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

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.

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.

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.

Para usar uma instrução if:
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);
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.

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:

(Documento do Flash) para criar um novo arquivo FLA.
// 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);
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 {

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

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");
}
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.

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:


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);
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.

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:

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;
}
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 {

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:

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")) {}

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:

■ 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.

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).

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.

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:

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.
var i:Number;
for (i = 0; i < 5; i++) {

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]);
}

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:

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)

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:

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.
var users_ds:mx.data.components.DataSet;
//
users_ds.addItem({name:"Irving", age:34});

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();
}
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).

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:

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 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).

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.
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

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.

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.
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.

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).

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.

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.
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:

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:

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

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:

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
É 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.
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.
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.
var monitorInfo:Array = new Array();
monitorInfo["type"] = "Flat Panel";
monitorInfo["resolution"] = "1600 x 1200";
trace(monitorInfo["type"] + ", " + 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.

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.

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:

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

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.

É 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

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

! 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 é Esquerda para
uma instância) direita
Requer Flash Player 6 ou posterior
< Menor que Esquerda para
direita
<= Menor ou igual a Esquerda para
direita
> Maior que Esquerda para
direita

>= 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.

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 + ".");

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

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.
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;

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.

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

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:

++ 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.

Todos os operadores desta tabela possuem a mesma precedência:

* 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:

+ 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.

Para compreender os operadores numéricos no ActionScript:
// 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");
}
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 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:

< 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:

== 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.

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:

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.
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) {

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:

(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);

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 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:

= 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;

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:

&& 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.

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.

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:

<< 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 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:

& 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.

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.

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:

?: 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).

Para usar os operadores no ActionScript:
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.

CAPÍTULO 6
Funções e métodos 6
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 Funções e métodos

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;
}
Sobre funções e métodos 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;

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.

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).

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).
function myMessage() {
trace("mySoundID completed");
}
var my_sound:Sound = new Sound();
my_sound.attachSound("mySoundID");
my_sound.onSoundComplete = myMessage;
my_sound.start();

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 defini-
la, 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();

A largura do clipe de filme é exibida no painel Output (Saída).

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
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 () {

};
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:

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.

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

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!");
};

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.

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
helloWorld(). 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().

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.

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.
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).
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]);

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.
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);
Flash.

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

Para passar um parâmetro para uma função:
1. Crie um novo documento do Flash e salve-o como parameters.fla.
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ê?”.
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.
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.

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.
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;
}

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.
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.
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;
}

// 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.
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.
O código a seguir é exibido no painel Output:
Dan
George
Socks
Noções básicas sobre métodos 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
Ao usar métodos de uma classe interna (além da classe personalizada criada

anteriormente neste procedimento), você usará um método da Timeline.
6. 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().


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.
Noções básicas sobre métodos 237

CAPÍTULO 7
Classes 7
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.

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.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:

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.

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 “caixas-
pretas” 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.
import User;
var user1:User = new User("un1", "pw1");
trace("Before:");
trace("\t username = " + user1.username); // un1
trace("\t password = " + user1.password); // pw1
user1.username = "1nu";
user1.password = "1wp";
trace("After:");
trace("\t username = " + user1.username); // 1nu
trace("\t password = " + user1.password); // 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:
■ Caminho de classe global é 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 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.

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.

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
Para editar um diretório de caminho de classe existente, selecione o caminho na lista

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.

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:

ActionScript). Salve o documento como Picture.as e, em seguida, clique em OK.
Crie sua classe Picture personalizada nesse documento.
/**
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.
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.

O seguinte texto é exibido no painel Output:
[Picture src=http://www.helpexamples.com/flash/images/image1.jpg]

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 palavra-
chave 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.

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().

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:

ActionScript). Salve o documento como Singleton.as.

/**
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.
tempo):
Singleton.getInstance().trackChanges(); // controlando alterações.
var s:Singleton = Singleton.getInstance(); // controlando alterações.

s.trackChanges();

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:

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).

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 start: 0
Creating widget # 1
Creating widget # 2
Creating widget # 3
Widget count at 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:

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.
salve-o como login_test.fla no mesmo diretório que Login.as.
principal:
var user:Login = new Login("RickyM");
// chamando o método getUserName()

var userName:String = user.getUserName();
trace(userName); // RickyM
// chamando o método setUserName()

user.setUserName("EnriqueI");
trace(user.getUserName()); // EnriqueI

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:

class Login2 {
public function Login2(username:String) {
this.__username = username;
}
public function get userName():String {
}
public function set userName(value:String):Void {
}
}
3. Salve o documento do ActionScript como Login2.as.
272 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.
salve-o como login2_test.fla no mesmo diretório que Login2.as.
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.

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:

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'.

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:

2. Selecione File > Save As (Salvar como) e atribua o nome Person2.as ao arquivo. Salve o
arquivo no disco rígido.
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.
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.

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).

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 extends MovieClip {} // A não é dinâmico
dynamic class B extends A {} // B é dinâmico
class C extends B {} // C é dinâmico
class D extends A {} // D não é dinâmico
dynamic class E extends MovieClip{} // E é 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 “caixas-
pretas” 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 palavra-
chave, 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.

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:
Exemplo: Criando classes personalizadas 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.
Você adicionará conteúdo a esse documento do Flash em uma etapa posterior.
4. Selecione File > Save As e crie um novo subdiretório chamado com e, em seguida, faça o
seguinte:

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.
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.
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
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.
282 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.

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.

3. Modifique a classe ClassB e adicione a variável estática para tornar essa classe semelhante
ao código anterior.
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:

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()");
}
}

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:

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() {

}
}
}
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”.
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:

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 ClassA() {

}
public function doSomething():Void {
}
}
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.
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.

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:

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
*/
private static var _className:String = "ClassA";
public function ClassA() {

}
}
}
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.
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();
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.
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:

2. Selecione File > Save As (Salvar como), atribua o nome Animal.as e salve o arquivo no disco
rígido.
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).
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. Selecionea 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 File > Publish Settings (Configurações de publicação).
11. 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

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:

2. Digite ou cole o seguinte código na janela Script:
/**
Classe do produto
Product.as
*/
class Product {
private var productsXml:XML;
// construtor
Noções básicas sobre classes e escopo 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.
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.
tempo):
trace(User.instances); // 0
var user1:User = new User();
Noções básicas sobre classes e escopo 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
Sobre classes de nível superior e internas 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
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}%.

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 A classe Microphone fornece acesso ao microfone do usuário, se

(Microfone) 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
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}%.

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 bate-
papo 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.

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.

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.

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)}%.

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.

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
Rectangle A classe Rectangle é usada para criar e modificar objetos Rectangle.
(Retângulo) Consulte %{Rectangle (flash.geom.Rectangle)}%.
Transform Coleta dados sobre transformações de cores e manipulações
(Transformar) 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.

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.

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.

Locale Essa classe permite controlar como o texto multilíngüe é exibido em um
arquivo SWF. Consulte %{Locale (mx.lang.Locale)}%.

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.

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.

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.
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).
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>

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:
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.

318 Classes
CAPÍTULO 8
Herança 8
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.
Sobre a criação de subclasses no Flash 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 {
}
}

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.
Flash.
O painel Output (Saída) exibirá o seguinte:
Creating subwidget #1
Creating subwidget #2

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 {
}
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
Se tiver criado a classe SubWidget no “Exemplo: Estendendo a classe Widget”

na página 322, você poderá usá-la.
5. 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.

Flash. Você observa o seguinte no painel Output (Saída):
Creating subwidget # 1
Widget::doSomething()
Widget::doSomething()

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();
}
trace("SubWidget::doSomething()");
}
}
12. Salve as alterações no arquivo de classe e, em seguida, abra subwidgetTest.fla novamente.

13. 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;
}
Usando o polimorfismo em um aplicativo 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.
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.
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().
13. 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();
Usando o polimorfismo em um aplicativo 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 += "<b>Mammal\tGender\tSleep\tPlay</b>";
for (i = 0; i < len; i++) {
info_txt.htmlText += "<p>" + mammals_arr[i].speciesName
+ "\t" + mammals_arr[i].gender
+ "\t" + mammals_arr[i].sleep()
+ "\t" + mammals_arr[i].play() + "</p>";
// 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.
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 Dog]
[object Cat]
[object Monkey]
[object Mammal]
330 Herança
CAPÍTULO 9
Interfaces 9
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.
interface IMyInterface {
public function method1():Void;
public function method2(param:String):Boolean;
}

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;
}

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
}
}

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;
}

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 {
}

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 salve-
o 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'.
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
Manipulando eventos 10
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;
Recebendo parâmetros passados 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.
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";
};
Manipuladores de eventos de objetos criados durante a execução 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.
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.
Substituindo métodos manipuladores de eventos 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:
// 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.”

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
removeEventListener() do objeto transmissor, passando para ele o nome do evento a ser
removido e do objeto ouvinte.
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).

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.
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.

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.

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) {...}");
}

principal:
box_mc.onPress = function() {
trace("box_mc.onPress = function() {...};");
};
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.

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");
}

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.

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);
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).

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:
■ 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.
Exemplos do ActionScript 1.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.
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";

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

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
EventDispatcher.addEventListener(), 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.
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.

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

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.

CAPÍTULO 11
Trabalhando com clipes de

filme
11
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;
}

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
loadMovie(). 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.
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.

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);
};

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

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ém-
criado é 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.

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:

■ 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
%{duplicateMovieClip (MovieClip.duplicateMovieClip method)}% em ActionScript
Para preencher um clipe de filme criado dinamicamente com parâmetros de

um objeto especificado:
Siga um destes procedimentos:
■ 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 pop-
up 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.

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)}%.

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)}% em ActionScript 2.0 Language Reference.
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.
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.
first_mc.onRelease = function() {
this.swapDepths(second_mc);
};
second_mc.onRelease = function() {
this.swapDepths(first_mc);
};
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)}%

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
scrollRect 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.

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.

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.
Imagem de fundo complexa 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.
Campo de texto de rolagem 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.
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.

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.

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.
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;

}
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);
11. 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

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
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).
/* When you set cacheAsBitmap, the internal bitmap is opaque and renders
faster. */
my_mc.cacheAsBitmap = true;
my_mc.opaqueBackground = 0xFF0000;

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);
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);

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).

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).
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.

CAPÍTULO 12
Trabalhando com texto e

seqüências de caracteres
12
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.
Serrilhado 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).
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.
Caracteres Os caracteres são letras, numerais e pontuação combinados para formar
seqüências de 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 Conjuntos de caracteres com tipo de fonte, estilo e tamanho semelhantes.
String 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.
Campos de texto 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.
Formatação 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.
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.
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 de entrada Use campos de texto de entrada quando precisar capturar a entrada do
usuário. Os usuários podem digitar texto nesses campos.
Componentes de texto 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.
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.
Sobre campos de texto 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.

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 pop-
up Text Type (Tipo de texto) e digite headline_txt na caixa de texto Instance Name (Nome
da instância).

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).
headline_txt.text = "New articles available on Developer Center";
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 <i>Developer Center</
i>.";

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:

// 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.
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;

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.

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.
my_txt.text = "Hello world";
my_txt._x = (Stage.width - my_txt._width) / 2;
my_txt._y = (Stage.height - my_txt._height) / 2;
para ver o campo de texto centralizado no Stage.

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.
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;
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.
principal:
my_txt.autoSize = "left";

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
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 pop-
up 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.

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.
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.

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/x-
shockwave-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.
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.";

}
}
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.
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.

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,...

*/
lorem_lv.load("http://www.helpexamples.com/flash/params.txt");
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.
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");

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.
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).

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
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.
11. Clique em OK.

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.
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).
font_txt._rotation = 45;
11. Selecione Control > Test Movie novamente para exibir as alterações no ambiente de
criação.

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
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.
2. 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.

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,0-
9], 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).
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.
3. 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.
// 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);

// 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
onMouseMove. 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.
6. Salve as alterações no arquivo FLA.
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.

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 Windows, navegue até a unidade de inicialização\Program Files\Macromedia\Flash
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.
Custom Anti-alias (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.
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.

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:
normal 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.
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.

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).
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.
4. Na biblioteca, clique com o botão direito do mouse no símbolo de fonte e selecione
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.
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.";
}

};
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.
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.

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.

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):
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.
8. 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();

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).
Flash.

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
Sobre o layout e a formatação de texto 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.
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";

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.
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.

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:
none (nenhum) 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.
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.
subpixel 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.
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).

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.
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;

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.

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);

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.

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 <p> 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 <p> ou <span>,
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
Formatando texto com estilos CSS 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 Propriedade do Uso e valores suportados

CSS ActionScript
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 Apenas a parte numérica do valor é usada. As

margin-right marginRight Apenas a parte numérica do valor é usada. As


Propriedade Propriedade do Uso e valores suportados
CSS ActionScript
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 Apenas a parte numérica do valor é usada. As

text-indent textIndent Apenas a parte numérica do valor é usada. As

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.

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.");

}
};
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'}

);
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.

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.
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.
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.

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 <p> ou <span> usando o atributo class da marca. Quando aplicado a
uma marca <p>, o estilo é aplicado no parágrafo inteiro. Você também pode usar a marca
<span> 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 <p> e <span>, como mostra o seguinte trecho:
<p class='mainBody'>This is <span class='emphasis'>really exciting!</
span></p>
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 <p> interna. Todas
as instâncias dessa marca receberão um estilo da maneira especificada pela regra de estilo.
p {
font-size: 12px;
display: inline;
}

A tabela a seguir mostra as marcas HTML internas que podem receber um estilo e como cada
estilo é aplicado:
Nome do Como o estilo se aplica

estilo
p Afeta todas as marcas <p>.
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;
}

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 (<p> 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:
<p class='headline'>Flash adds FlashType rendering technology!</
p><p><span class='byline'>San Francisco, CA</span>--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></p>
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;

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

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.

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.

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:
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
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.”.
10. Salve o arquivo como news_xml.fla na mesma pasta que story.xml.

11. Execute o arquivo SWF (Control [Controlar] > Test Movie [Testar filme]) para ver os
estilos aplicados automaticamente ao texto no campo de texto.

Usando texto em formato HTML
O Flash Player oferece suporte a um subconjunto de marcas HTML padrão, como <p> 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 <p>, <br> 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:
Usando texto em formato HTML 461

this.createTextField("headline_txt", 1, 10, 10, 500, 300);
headline_txt.wordWrap = true;
headline_txt.multiline = true;
headline_txt.htmlText = "<font face='Times New Roman' size='25'>This is how
you assign HTML text to a text field.</font><br>It's very useful.</br>";
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 = "<p align=left>This is left-aligned text</p>";
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 align='left'>This uses single quotes</p>";
myField_txt.htmlText = "<p align=\"left\">This uses escaped double quotes</
p>";
myField_txt.htmlText = '<p align="left">This uses outer single quotes</p>';
myField_txt.htmlText = '<p align=\'left\'>This uses escaped single quotes</
p>';
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

■ “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 <b> renderiza o texto como negrito, como mostra este exemplo:
text3_txt.htmlText = "He was <b>ready</b> to leave!";
Um tipo em negrito deve estar disponível para a fonte usada para exibir o texto.

Marca de quebra
A marca <br> 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.<br />His coat was <font
color='#FF0033'>red</font> plaid.";
Marca de fonte
A marca <font> especifica uma fonte ou lista de fontes para exibir o texto.
A marca font oferece suporte aos seguintes atributos:
■ color Apenas valores de cor hexadecimais (#FFFFFF) são suportados. Por exemplo, o
código HTML a seguir cria texto vermelho:
myText_txt.htmlText = "<font color='#FF0000'>This is red text</font>";
■ face 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:
myText_txt.htmlText = "<font face='Times, Times New Roman'>Displays as
either Times or Times New Roman...</font>";
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 = "<font size='24' color='#0000FF'>This is blue, 24-
point text</font>";
Você também pode usar tamanhos de ponto relativos em vez de um tamanho de pixel,
como +2 ou -4.

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.
■ width A largura da imagem, do arquivo SWF ou do clipe de filme que está sendo
inserido, em pixels.
■ height A altura da imagem, do arquivo SWF ou do clipe de filme que está sendo
inserido, em pixels.
■ align 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.
■ hspace Especifica a quantidade de espaço horizontal em torno da imagem onde
nenhum texto aparecerá. O valor padrão é 8.
■ vspace Especifica a quantidade de espaço vertical em torno da imagem onde nenhum
texto aparecerá. O valor padrão é 8.

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 <i> exibe o texto marcado em itálico, como mostra o seguinte código:
That is very <i>interesting</i>.
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 <p> cria um novo parágrafo. Para usar essa marca, defina o campo de texto como um
campo de várias linhas.
A marca <p> oferece suporte aos seguintes atributos:
■ align Especifica o alinhamento do texto no parágrafo; os valores válidos são left,
right, justify e center.
■ 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.

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 = "<p align='right'>This text is aligned on the
right side of the text field</p>";
O exemplo a seguir usa o atributo class para atribuir uma classe de estilo de texto a uma
marca <p>:
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 = "<p class='blue'>This is some body-styled text.</
p>.";
Marca de intervalo
A marca <span> 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:
■ class 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.
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:
■ blockindent 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.)

■ leading Especifica a quantidade de espaço vertical entre as linhas; corresponde ao
TextFormat.leading. Permite usar inteiros negativos. (Consulte %{leading
(TextFormat.leading property)}% em ActionScript 2.0 Language Reference.)
■ leftmargin Especifica a margem esquerda do parágrafo, em pontos; corresponde ao
TextFormat.leftMargin. (Consulte %{leftMargin (TextFormat.leftMargin property)}%
em ActionScript 2.0 Language Reference.)
■ rightmargin Especifica a margem direita do parágrafo, em pontos; corresponde ao
TextFormat.rightMargin. (Consulte %{rightMargin (TextFormat.rightMargin
property)}% em ActionScript 2.0 Language Reference.)
■ 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 = "<b>Name\tAge\tOccupation</b>";
// 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>";

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 <u> sublinha o texto marcado, como mostra o seguinte código:
This is <u>underlined</u> 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
<span>. 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 “<b>” sem que o texto apareça em
negrito:
my_txt.html = true;
my_txt.htmlText = "The <b> tag makes text appear <b>bold</b>.";
Durante a execução, o código de exemplo anterior do Flash exibe o seguinte texto no Stage:
The <b> 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)

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. Crie um novo documento do Flash e salve-o como embedding.fla.

principal:
this.createTextField("image1_txt", 10, 50, 50, 450, 150);
image1_txt.html = true;
image1_txt.htmlText = "<p>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 = "<p>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.

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.
principal:
this.createTextField("textField_txt", 10, 0, 0, 300, 200);
textField_txt.html = true;
textField_txt.htmlText = "<p>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.
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 .

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:

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.

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

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:

Siga um destes procedimentos:
■ 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:
■ 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
Se não estiver carregando texto dinamicamente no arquivo SWF, selecione Text

> Scrollable (Rolável) no menu principal.
2. 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
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.

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.

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.

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.
Using ActionScript at runtime (Usando o ActionScript durante a execução) É 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.
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.

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.
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.

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.

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.
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.
principal:
checkIME();

my_fmt.font = "_sans";
this.createTextField("ime_txt", 10, 100, 10, 320, 240);

ime_txt.border = true;
ime_txt.multiline = true;

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.

Para obter informações sobre System.capabilities.hasIME, consulte %{hasIME
(capabilities.hasIME property)}% em ActionScript 2.0 Language Reference.
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.

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.
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.
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"';

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 Descrição
escape
\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.

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.

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:

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 - ASCII=104
e - ASCII=101
l - ASCII=108
l - ASCII=108
o - ASCII=111
- ASCII=32
w - ASCII=119
o - ASCII=111
r - ASCII=114
l - ASCII=108

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.
principal:
var str1:String = "Apple";
var str2:String = "apple";
if (str1 < str2) {
trace("Uppercase letters sort first.");
}
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.
principal:
var myStr:String = "4";
var total:Number = 4;
if (myStr == total) {
trace("Types are converted.");
}
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.

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.
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.");
}
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.

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.
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.
var str1:String = "green";
var str2:String = str1 + "ish";
trace(str2); // verde claro
//
var str3:String = "yellow";
str3 += "ish";
trace(str3); // 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.
Você também pode usar o método concat() da classe String para concatenar seqüências de
caracteres. Esse método é demonstrado neste exemplo.

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.
var str1:String = "Bonjour";
var str2:String = "from";
var str3:String = "Paris";
var str4:String = str1.concat(" ", str2, " ", str3);
trace(str4); // 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.
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"

params[1] == "last=cheng"
*/
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.

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, 15)); // Pari
trace(myStr.slice(-3, -1)); // !!
trace(myStr.slice(-3, 26)); // !!!
trace(myStr.slice(-3, myStr.length)); // !!!
trace(myStr.slice(-8, -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.
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.
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.

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).
Flash.
DICA
Os métodos indexOf() e lastIndexOf() fazem distinção entre maiúsculas e

minúsculas.


CAPÍTULO 13
Animação, filtros e desenhos

13
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 Animação, filtros e desenhos

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 fade-
out 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;
}
};

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.
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().
O clipe de filme adicionado ao Stage desaparece lentamente.

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.
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;

}
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.
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.
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.

Você também pode definir o brilho de uma imagem usando o código ActionScript do
Para alterar o brilho de uma imagem:

1. Crie um novo documento do Flash chamado brightness.fla.
System.security.allowDomain("http://www.helpexamples.com/");
var myElements_array:Array = [1, 0, 0, 0, 100,
0, 1, 0, 0, 100,
0, 0, 1, 0, 100,
0, 0, 0, 1, 0];
}
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.
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.

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.
// 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);

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.
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.

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.
// 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);

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.
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á exibi-
la 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
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

■ “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).

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.

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
unidade de inicialização\Program Files\Macromedia\Flash 8\idioma\First
Run\Behaviors\ ou Macintosh HD:Applications:Macromedia Flash 8:First
Run:Behaviors: para abrir o arquivo SWF no exibidor independente.
Animando com as classes TransitionManager e

Tween
Você pode usar as classes TransitionManager e Tween no Flash Basic 8 e no Flash Professional
8 para adicionar animações a clipes de filme, componentes e quadros com o ActionScript. Se
não usar a classe TransitionManager ou Tween, você deverá escrever um código personalizado
para animar clipes de filme ou modificar o nível de transparência (alfa) e as coordenadas
(local). Se você desejar adicionar atenuação à animação, o ActionScript (e a matemática)
poderá se tornar rapidamente complexo. No entanto, se desejar alterar a atenuação em uma
determinada animação e usar essas classes predefinidas, selecione uma classe diferente em vez
de tentar descobrir as novas equações matemáticas necessárias para criar uma animação suave.
O procedimento a seguir anima um clipe de filme de modo que aumente o zoom no Stage
usando a classe TransitionManager.
Para animar um clipe de filme usando a classe TransitionManager:

1. Selecione File > New e escolha Flash Document (Documento do Flash).
2. Clique em OK para criar o novo arquivo FLA.
3. Salve o arquivo FLA como zoom.fla.
4. Selecione File (Arquivo) > Import (Importar)> Import to Stage (Importar para o palco) e
selecione uma imagem no disco rígido a ser importada para o arquivo FLA.
A imagem é importada para o arquivo como bitmap, portanto, é preciso convertê-la
manualmente em um símbolo de clipe de filme.
5. Clique em Open (Abrir) para importar a imagem.

6. Selecione a imagem importada no Stage e escolha Modify (Modificar) > Convert to Symbol
7. Nomeie o símbolo como img1 e verifique se definiu o comportamento como Movie Clip
(Clipe de filme).
Por padrão, o ponto de registro do símbolo está localizado no seu canto superior esquerdo.
8. Clique em OK para converter a imagem bitmap em um clipe de filme.
9. Ainda com a imagem selecionada, abra o inspetor Properties (Window (Janela) > Properties
(Propriedades) > Properties (Propriedades)) e atribua o nome de instância img1_mc ao
clipe de filme.
10. Selecione o Frame 1 da Timeline principal e adicione o seguinte ActionScript ao painel
Actions:
mx.transitions.TransitionManager.start(img1_mc,
{type:mx.transitions.Zoom, direction:0, duration:1,
easing:mx.transitions.easing.Bounce.easeOut, param1:empty,
param2:empty});
N OT A
Para obter informações sobre como trabalhar com pacotes, consulte “Trabalhando
com pacotes de filtro” na página 528.
11. Selecione Control > Test Movie para testar a animação.

A imagem cresce e produz um leve efeito de salto antes de retornar ao tamanho original. Se
a animação se mover rápido demais, aumente sua duração (no trecho de código anterior)
de um para dois ou três segundos (por exemplo, duration:3).
Você talvez perceba que a imagem fica ancorada no canto superior esquerdo e cresce em
direção ao canto inferior direito. Isso é diferente da visualização vista na caixa de diálogo
Transitions (Transições).
É facil criar animações complexas usando as classes Tween e TransitionManager; além
disso, isso não exige a criação de interpolações de forma ou de movimento na timeline. E,
o que é mais importante, você não precisa escrever cálculos matemáticos complexos para
criar métodos de atenuação. Se você desejar que as imagens aumentem o zoom a partir do
centro em vez de ancorar em um canto, modifique o ponto de registro do símbolo ao
converter a imagem de bitmap em símbolo.
Para aumentar o zoom de imagens a partir do centro:

1. Conclua as etapas descritas no procedimento anterior.
2. Abra o arquivo zoom.fla e selecione File (Arquivo) > Save As (Salvar como) para salvar uma
nova cópia do documento.
Salve o arquivo como zoom2.fla.

3. Arraste uma cópia do símbolo do bitmap do painel Library para o Stage ao lado do símbolo
atual do clipe de filme.
4. Ainda com a imagem de bitmap selecionada no Stage, pressione F8 para converter o
símbolo em um clipe de filme.
Nomeie o símbolo como img2.
5. Na caixa de diálogo Convert to Symbol, clique no centro da grade de 3x3 para definir o
centro do bitmap como ponto de registro e clique em OK.
6. Selecione o novo clipe de filme no Stage e atribua a ele o nome de instância img2_mc
usando o inspetor Properties.
7. Selecione o Frame 1 da Timeline principal e adicione o seguinte ActionScript ao código
existente:
mx.transitions.TransitionManager.start(img2_mc,
{type:mx.transitions.Zoom, direction:mx.transitions.Transition.IN,
duration:1, easing:mx.transitions.easing.Bounce.easeOut});
8. Selecione Control (Controlar) > Test Movie (Testar filme) para testar a animação.
O segundo clipe de filme cresce a partir do centro do símbolo, e não a partir do canto.
NO T A
Algumas transições são sensíveis ao local definido para o ponto de registro. Alterar o
ponto de registro pode afetar consideravalmente a aparência da animação em um
arquivo SWF. Por exemplo, se o ponto de registro estiver localizado no canto
superior esquerdo (padrão) quando você usar a transição Zoom, a transição será
iniciada a partir desse local.
51, “Tween class” em Components Language Reference. Para obter informações sobre cada
método e propriedade da classe TransitionManager, consulte o Chapter 48,
“TransitionManager class” em Components Language Reference.

Sobre classes e métodos de atenuação
“Adicionando interpolações e transições a um arquivo no Flash Professional 8 (somente Flash
Professional 8)” na página 511 descreve como usar a classe de atenuação Bounce para
adicionar um efeito de salto ao clipe de filme. Além da classe Bounce, o Flash 8 oferece mais
cinco classes de atenuação, que estão descritas na tabela a seguir:
Back Estende a animação para além do intervalo de transição em uma ponta
ou nas duas uma vez para dar um efeito de transbordamento.
Bounce Adiciona um efeito de salto dentro do intervalo de transição em uma
ponta ou nas duas. O número de saltos refere-se à duração: maior
duração produz mais saltos.
Elastic Adiciona um efeito de elástico que cai para fora do intervalo de

transição em uma ponta ou nas duas. A quantidade de elasticidade não
é afetada pela duração.
Regular Adiciona movimentos mais lentos em uma ponta ou nas duas. Esse
recurso permite adicionar um efeito de aceleração, um efeito de
desaceleração ou ambos.
Strong Adiciona movimentos mais lentos em uma ponta ou nas duas. Esse
efeito é semelhante à atenuação Regular, mas é muito mais destacado.
Nenhum Adiciona um movimento igual do início ao final sem efeitos,

desaceleração ou aceleração. Essa transição também é chamada de
transição linear.
Cada uma dessas seis classes de atenuação possui três métodos de atenuação, que estão
descritos na seguinte tabela:
Método Descrição
easeIn Produz o efeito de atenuação no início da transição.
easeOut Produz o efeito de atenuação no final da transição.
easeInOut Produz o efeito de atenuação no início e no final da transição.
Para abrir essas classes no Flash ou no editor do ActionScript, navegue até a pasta Disco
Rígido\Program Files\Macromedia\Flash 8\idioma\First Run\Classes\mx\transitions\easing\
no Windows (considerando uma instalação padrão) ou HD
Macintosh:Applications:Macromedia Flash 8:First Run:Classes:mx:transitions:easing.

O procedimento sobre como aumentar o zoom de imagens em “Animando com as classes
TransitionManager e Tween” na página 513 usou o método e a classe de atenuação
mx.transitions.easing.Bounce.easeOut. Na pasta localizada no seu disco rígido, o ActionScript
refere-se ao método easeOut() dentro da classe Bounce.as. Esse arquivo do ActionScript está
localizado na pasta de atenuação.
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 em unidade de
inicialização\Program Files\Macromedia\Flash 8\idioma\First Run\Behaviors\ ou HD
Macintosh:Applications:Macromedia Flash 8:First Run:Behaviors: para abrir o arquivo
SWF no exibidor independente.
Sobre a classe Tween

A classe Tween permite movimentar, redimensionar e fazer aparecer clipes de filme com
facilidade no Stage. O construtor da classe mx.transitions.Tween possui os seguintes tipos e
nomes de parâmetro:
function Tween(obj, prop, func, begin, finish, duration, useSeconds) {
// código ...
}
obj O objeto de clipe de filme de destino da instância Tween.

prop Uma seqüência de caracteres que corresponde ao nome de uma propriedade em obj
no qual os valores devem ser interpolados.
func O método de atenuação que calcula um efeito de atenuação para os valores de
propriedade do objeto interpolado.
begin Um número que indica o valor inicial de prop (a propriedade do objeto de destino a
ser interpolada).

finish Um número que indica o valor final de prop (a propriedade do objeto de destino a
ser interpolada).
duration Um número que indica a duração do movimento de interpolação. Se o número
tiver sido omitido, a duração será definida como infinity por padrão.
useSeconds Um valor booleano relacionado ao valor especificado no parâmetro duration,
que indica o uso de segundos se for true ou de quadros se for false.
Por exemplo, imagine que você deseje mover um clipe de filme pelo Stage. Você pode
adicionar quadros-chave a uma timeline e inserir uma interpolação de forma ou de
movimento entre eles, escrever um código em um manipulador de eventos onEnterFrame ou
usar a função setInterval() para chamar uma função em intervalos periódicos. Se usar a
classe Tween, você terá uma outra opção que permite modificar as propriedades _x e _y de um
clipe de filme. Você também pode adicionar os métodos de atenuação descritos
anteriormente. Para aproveitar a classe Tween, você pode usar o ActionScript a seguir:
new mx.transitions.Tween(ball_mc, "_x",
mx.transitions.easing.Elastic.easeOut, 0, 300, 3, true);
Esse trecho de ActionScript cria uma nova instância da classe Tween, que anima o clipe de
filme ball_mc no eixo x (da esquerda para a direita) do Stage. O clipe de filme anima de 0
pixels a 300 pixels em três segundos, e o ActionScript aplica um método de atenuação elástico.
Isso significa que a bola estende-se além de 300 pixels no eixo x antes de usar um efeito de
movimento fluido para animar.
Usando a classe Tween

Se você usar uma classe Tween em mais de um local no documento Flash, você deve usar uma
instrução import. Isso permite importar a classe e métodos de atenuação, em vez de atribuir
nomes de classe totalmente qualificados cada vez que usá-la, conforme o procedimento a
seguir:
Para importar e usar a classe Tween:

1. Crie um novo documento chamado easeTween.fla.

3. Selecione a instância de clipe de filme e digite ball_mc na caixa de texto Instance Name
(Nome da instância) do inspetor Properties.
import mx.transitions.easing.*;
new Tween(ball_mc, "_x", Elastic.easeOut, Stage.width, 0, 3, true);
Este exemplo de código usa duas instruções import. A primeira instrução importa
somente a classe mx.transitions.Tween, e a segunda instrução import usa o atalho de
caractere curinga (*) para importar cada uma das seis classes de atenuação usando uma
única linha de código. A segunda instrução importa um pacote inteiro de classes.
NO T A
Para obter informações sobre como trabalhar com pacotes, consulte “Trabalhando
5. Selecione Control > Test Movie para ver a animação.

A documentação do Flash define pacote como diretórios que contêm um ou mais arquivos de
classe e que residem em um diretório específico de caminho de classe. Neste caso, o pacote
reside n pasta C:\Program Files\Macromedia\Flash 8\language\First
Run\Classes\mx\transitions\easing (Windows) ou em HD:Applications:Macromedia Flash
8:First Run:Classes:mx:transitions:easing (Macintosh). Você deve concordar que importar um
pacote inteiro é muito melhor do que ter que importar seis classes separadamente. Em vez de
referir-se à classe mx.transitions.Tween, o ActionScript refere-se diretamente à classe Tween.
Da mesma maneira, em vez de utilizar o nome de classe totalmente qualificado para as classes
de atenuação, por exemplo, mx.transitions.easing.Elastic.easeOut, você pode digitar
Elastic.easeOut no código ActionScript. Para obter mais informações, consulte “Trabalhando
Usando um código semelhante, você define a propriedade _alpha para fazer aparecer e
desaparecer instâncias, em vez da propriedade _x, conforme mostrado no procedimento a
seguir.
Para fazer aparecer e desaparecer instâncias usando a classe Tween:

1. Crie um novo documento chamado fadeTween.fla.
3. Selecione a instância de clipe de filme e digite ball_mc na caixa de texto Instance Name do
new Tween(ball_mc, "_alpha", Strong.easeIn, 100, 0, 3, true);

Em vez de mover-se pelo Stage, agora ball_mc é alterado de 100% visível a
completamente transparente em três segundos. Para que o símbolo desapareça mais
rapidamente, altere o parâmetro de duração de 3 para 1 ou 2.
Se você alterar a taxa de quadros do documento, a animação aparentemente será
reproduzida com mais suavidade. Para obter informações sobre animação e taxa de
quadros, consulte “Sobre animação e taxa de quadros” na página 499.
Em vez de usar segundos, você pode fazer desaparecer o símbolo usando quadros. Para definir
a duração em quadros em vez de segundos na classe Tween, altere o parâmetro final,
useSeconds, de true para false. Quando você define o parâmetro para true, você informa
ao Flash que a duração especificada é expressa em segundos. Se você definir o parâmetro para
false, a duração é o número de quadros que você deseja usar para a interpolação. O
procedimento a seguir mostra como definir uma interpolação para quadros, e não para
segundos.
Para definir uma duração de quadros em vez de segundos:

1. Crie um novo documento chamado framesTween.fla.
3. Selecione a instância de clipe de filme e digite ball_mc na caixa de texto Instance Name do
new Tween(ball_mc, "_alpha", Strong.easeIn, 100, 0, 24, false);
Este código faz desaparecer a instância ball_mc usando o método de atenuação

Strong.easeIn. Em vez de fazer desaparecer a instância por três segundos, ele o faz em 24
quadros.
Aguarde um momento até a instância desaparecer pelos 24 quadros.
6. Retorne ao ambiente de criação e abra o inspetor Properties.
7. Altere a taxa de quadros do documento para 24 qps.
Se aumentar a taxa de quadros de seu arquivo FLA, você logo verá a instância desaparecer.
Para obter informações sobre animação e taxa de quadros, consulte “Sobre animação e taxa
de quadros” na página 499.

Usar quadros em vez de segundos oferece mais flexibilidade, mas lembre-se de que a duração
corresponde à taxa de quadros do documento do Flash atual. Se o documento do Flash usar
uma taxa de 12 quadros por segundo (qps), o trecho de código anterior fará desaparecer a
instância em dois segundos (24 quadros/12 qps = 2 segundos). No entanto, se a taxa de
quadros for 24 qps, o mesmo código fará a instância desaparecer em um segundo (24 quadros/
24 qps = 1 segundo). Se usar quadros para medir duração, você poderá alterar a velocidade da
animação significativamente ao alterar a taxa de quadros do documento, sem modificar o
ActionScript.
A classe Tween possui vários outros recursos úteis. Por exemplo, você pode escrever um
manipulador de eventos que seja ativado quando a animação for concluída, conforme
mostrado no procedimento a seguir:
Para ativar o código quando uma animação for concluída:

1. Crie um novo documento chamado triggerTween.fla.
3. Selecione a instância de clipe de filme e digite ball_mc na caixa de texto Instance Name
(Nome da instância) do inspetor Properties.
var tween_handler:Object = new Tween(ball_mc, "_alpha", Strong.easeIn,
100, 0, 3, true);
tween_handler.onMotionFinished = function() {
trace("onMotionFinished triggered");
};
Se você testar esse ActionScript no arquivo FLA, a mensagem “onMotionFinished

triggered” (onMotionFinished ativado) será exibida no painel Output (Saída) depois que
ball_mc desaparecer do Stage.
Aguarde um momento até a instância desaparecer. No final da interpolação, a mensagem
será exibida no painel Output.
Para obter mais informações sobre funções, consulte o Capítulo 7, “Classes.”

Sobre animações contínuas com o método continueTo()
A seção “Usando a classe Tween” na página 518 demonstra como usar a classe Tween em
aplicativos. Entretanto, se desejar mover a bola após a conclusão da animação inicial, você
poderá fazer isso pelo menos de duas maneiras. Uma das soluções consiste em reanimar a bola
usando o manipulador de eventos onMotionFinished. No entanto, a classe Tween oferece
uma solução mais simples: o método continueTo(). O método continueTo() instrui a
animação interpolada a continuar a partir do valor atual para um novo valor, conforme
mostrado no ActionScript a seguir:
var ball_tween:Object = new Tween(ball_mc, "_x", Regular.easeIn, 0, 300, 3,
true);
ball_tween.onMotionFinished = function() {
ball_tween.continueTo(0, 3);
};
Após o término da interpolação inicial, o clipe de filme ball_mc interpola para a posição
original de 0 pixels. O trecho de código a seguir (editado para simplificar) mostra o protótipo
da função para o método continueTo():
function continueTo(finish:Number, duration:Number):Void {
/* omitted to save space. */
}
Somente dois argumentos passam para o método continueTo(), em vez dos sete argumentos
para o método construtor Tween, conforme mostrado no trecho a seguir:
function Tween (obj, prop, func, begin, finish, duration, useSeconds) {
/* omitted to save space. */
}
Os cinco parâmetros que não são exigidos pelo método continueTo() (obj, prop, func,
begin e useSeconds) usam os argumentos definidos anteriomente na chamada para a classe
Tween. Ao chamar o método continueTo(), você pressupõe que os argumentos obj, prop,
func (tipo de atenuação) e useSeconds sejam os mesmos usados na chamada anterior para a
classe Tween. O método continueTo() usa o valor finish da chamada para a classe Tween,
em vez de especificar um valor para o argumento begin, conforme mostrado no ActionScript
a seguir:
var ball_tween:Object = new Tween(ball_mc, "_x", Regular.easeIn, 0, 300, 3,
true);
ball_tween.onMotionFinished = function() {
ball_tween.continueTo(0, 3);
};

Esse código move a instância ball_mc pelo eixo x- de 0 a 300 pixels em três segundos. Após o
término da animação, o manipulador de eventos onMotionFinished é ativado e chama o
método continueTo(). O método continueTo() informa ao objeto de destino (ball_mc)
para continuar a partir de sua posição atual, animar por três segundos ao longo do eixo x até 0
pixels e usar o mesmo método de atenuação. Os valores especificados na chamada para o
método construtor Tween são usados para qualquer parâmetro que não seja definido no
método continueTo(). Se a duração não for especificada para o método continueTo(), ele
usará a duração especificada na chamada para o construtor Tween.
Criando animações executadas continuamente

Você pode criar uma animação que se movimente continuamente pelo eixo x sem parar. A
classe Tween acomoda esse tipo de animação com o sugestivo método chamado yoyo(). O
método yoyo() aguarda a execução do manipulador de eventos onMotionFinished e, em
seguida, inverte os parâmetros begin e finish. A animação começa novamente, conforme o
Para criar uma animação contínua:

1. Crie um novo documento do Flash chamado yoyo.fla.
2. Abra o painel Actions e insira o seguinte ActionScript no Frame 1 da Timeline:
this.createEmptyMovieClip("box_mc", this.getNextHighestDepth());
with (box_mc) {
moveTo(0, 0);
lineTo(20, 0);
lineTo(20, Stage.height);
lineTo(0, Stage.height);
lineTo(0, 0);
endFill();
}
A primeira seção de código começa importando a classe Tween, assim como cada classe do
pacote de atenuação. A próxima seção de código cria um novo clipe de filme com uma
instância denominada box_mc e desenha um retângulo de 20 pixels de largura e da mesma
altura que o Stage.
3. Adicione o seguinte ActionScript após o código criado na etapa anterior:
var box_tween:Tween = new Tween(box_mc, "_x", Regular.easeInOut, 0,
Stage.width, 3, true);
box_tween.onMotionFinished = function() {

box_tween.yoyo();
};
Esse código cria uma nova interpolação para animar por 3 segundos o clipe de filme
box_mc ao longo do eixo x- no Stage.
4. Selecione Control > Test Movie para testar a animação.
A caixa é animada da esquerda para a direita e ao contrário. Se a animação não estiver
suave, você poderá aumentar a taxa de quadros do documento de 12 para 24 qps.
À medida que a caixa aproxima-se da borda direita do Stage, ela é animada fora dos limites
do Stage. Embora isso não seja grave, você não vai querer que o retângulo desapareça em
um lado do Stage e, um segundo depois, reapareça para ser animado na outra direção.
Para fazer ajustes, anime o retângulo a partir de 0 pixels até a largura do Stage menos a
largura do clipe de filme box_mc.
5. Para impedir que o retângulo desapareça, revise as linhas correspondentes de código da
etapa 3 para que correspondam ao código a seguir:
var box_tween:Tween = new Tween(box_mc, "_x", Regular.easeInOut, 0,
(Stage.width - box_mc._width), 3, true);
6. Teste a animação novamente (Control > Test Movie).

Agora, a caixa interrompe a atenuação antes de sair dos limites do Stage.
Combinando as classes TransitionManager e Tween

Você pode gerar efeitos interessantes ao combinar as classes TransitionManager e Tween. Você
pode usar a classe TransitionManager para mover um clipe de filme no eixo x enquanto ajusta
a mesma propriedade _alpha do clipe com a classe Tween. Cada classe pode usar um método
de atenuação diferente, ou seja, há muitas possibilidades de animação para objetos nos
arquivos SWF. Você pode tirar proveito dos métodos continueTo() e yoyo() na classe Tween
ou do manipulador de eventos onMotionFinished para criar um efeito exclusivo.
É possível combinar as classes TransitionManager e Tween para animar um clipe de filme
carregado dinamicamente e fazê-lo aparecer no Stage depois de ser completamente carregado
do servidor remoto, conforme o procedimento a seguir.
Para usar as classes TransitionManager e Tween em conjunto:

1. Crie um novo documento do Flash e salve o arquivo como combination.fla.
2. Adicione o seguinte ActionScript no Frame 1 do Timeline:
import mx.transitions.*;

mcl_obj.onLoadInit = function(target_mc:MovieClip) {
new Tween(target_mc, "_alpha", Strong.easeIn, 0, 100, 2, true);
TransitionManager.start(target_mc, {type:Fly,
direction:Transition.IN, duration:3, easing:Elastic.easeInOut,
startPoint:6});
};

my_mcl.addListener(mcl_obj);
this.createEmptyMovieClip("img_mc", this.getNextHighestDepth()));
Esse código é separado em três seções principais.

A primeira seção de código importa as classes dentro dos pacotes de transição assim como
o pacote transitions.easing. Importe o pacote de transição inteiro nesse exemplo para
não precisar informar o nome de classe totalmente qualificado para as classes Tween,
TransitionManager ou a transição selecionada (nesse caso, Fly). Esse processo pode reduzir
a quantidade de código digitada e evitar possíveis erros tipográficos.
A segunda seção do ActionScript cria um objeto ouvinte da instância de classe
MovieClipLoader, que você cria na terceira seção do código. Quando o clipe de filme de
destino for carregado na instância MovieClipLoader, o evento onLoadInit ativará e
executará o bloco de código, que chama as classes Tween e TransitionManager. Esse
manipulador de eventos aparece no clipe de filme de destino porque você modifica a
propriedade _alpha na classe Tween e faz surgir o clipe de filme de destino no eixo x.
A terceira seção do código ActionScript cria uma instância MovieClipLoader e aplica o
objeto ouvinte criado anteriormente (de modo que a instância do clipe de filme carregador
de destino possa ouvir o evento onLoadInit). Em seguida, carregue a imagem JPEG de
destino em um clipe de filme criado dinamicamente chamando o método
createEmptyMovieClip().
3. Salve o documento e selecione Control > Test Movie para exibir a animação no ambiente
de teste.
Após o download da imagem JPEG externa ser feito, a imagem aparece gradualmente e é
animada da direita para a esquerda no Stage.
Para obter informações sobre como usar a classe Tween, consulte “Usando a classe Tween”
na página 518.

Usando efeitos de filtro

Os filtros são efeitos visuais que você pode aplicar a objetos renderizados durante a execução
pelo Flash Player, como instâncias de clipe de filme. Os filtros incluem sombreamento,
embaçamento, brilho, chanfro, brilho gradiente e chanfro gradiente. Também é possível usar
um filtro de ajuste de cor que permita editar o brilho, o contraste, a saturação e o matiz de um
clipe de filme. Você pode aplicar filtros usando a interface de usuário do Flash no Flash
Professional 8 ou usando ActionScript no Flash Basic 8 ou no Flash Professional 8.
É possível aplicar cada um desses efeitos de filtro a clipes de filme, botões ou campos de texto
usando a guia Filters (Filtros) no inspetor Properties ou o ActionScript. Se usar o ActionScript
para aplicar os filtros a uma instância, você também poderá usar um filtro de mapa de
deslocamento (consulte “Usando o filtro de mapa de deslocamento” na página 556) ou um
filtro de convolução (consulte “Usando o filtro de torção” na página 554). Esses filtros são
aplicados às definições vetoriais, o que não causa sobrecarga de armazenamento de uma
imagem de bitmap no arquivo SWF. Você também pode criar um ActionScript que permita
modificar um filtro existente aplicado a um campo de texto, a um clipe de filme ou a um
botão.
O procedimento a seguir demonstra como usar um manipulador de eventos onEnterFrame
para animar um efeito de filtro de brilho em um clipe de filme.
Para animar um efeito de filtro aplicado a uma instância de clipe de filme:

1. Crie um novo documento do Flash e salve-o como animFilter.fla.
this.createEmptyMovieClip("box_mc", 10);
box_mc.lineStyle(20, 0x000000);
box_mc.beginFill(0x000000);
box_mc.moveTo(0, 0);
box_mc.lineTo(160, 0);
box_mc.endFill();

box_mc._x = 100;
box_mc._y = 100;
box_mc.filters = [new flash.filters.GlowFilter()];

var dir:Number = 1;
box_mc.blur = 10;
box_mc.onEnterFrame = function() {
box_mc.blur += dir;
if ((box_mc.blur >= 30) || (box_mc.blur <= 10)) {
dir *= -1;
}
var filter_array:Array = box_mc.filters;
filter_array[0].blurX = box_mc.blur;
filter_array[0].blurY = box_mc.blur;
box_mc.filters = filter_array;
};
Esse código executa duas funcionalidades diferentes. A primeira seção cria e posiciona uma
instância de clipe de filme e, em seguida, desenha um retângulo preto arredondado no
Stage. O segundo bloco de código aplica um filtro de brilho ao retângulo no Stage e define
um manipulador de eventos onEnterFrame, responsável pela animação do efeito de filtro.
O manipulador de eventos onEnterFrame anima o filtro de brilho entre um
embaçamento de 10 e 30 pixels e, quando a animação fica igual ou maior que 30 ou igual
ou menor que 10, a direção dela inverte.
3. Salve as alterações no documento do Flash e selecione Control > Test Movie para testar o
arquivo SWF.
Para obter mais informações sobre como trabalhar com filtros em um aplicativo, consulte os
seguintes tópicos:
■ “Trabalhando com pacotes de filtro” na página 528
■ “Trabalhando com filtros, armazenamento em cache e a classe MovieClip” na página 530
■ “Sobre detecção de cliques e filtros de rotação, inclinação e dimensionamento”
na página 532
■ “Aplicando filtros a instâncias de objeto e instâncias de BitmapData” na página 532
■ “Sobre manipulação de erros, desempenho e filtros” na página 533
Para obter um exemplo de como usar o ActionScript para aplicar filtros, localize um arquivo
de origem de exemplo, Filters.fla, na pasta Samples do seu disco rígido.
8\Samples and Tutorials\Samples\ActionScript\Filters.
and Tutorials/Samples/ActionScript/Filters.
Usando efeitos de filtro 527

Trabalhando com pacotes de filtro
Os pacotes são diretórios que contêm um ou mais arquivos de classe e residem em um
diretório específico de caminho de classe. Por exemplo, o pacote flash.filters é um diretório no
disco rígido que contém vários arquivos de classe para cada tipo de filtro (como BevelFilter,
BlurFilter, DropShadowFilter etc.) no Flash 8. Quando os arquivos de classe estão organizados
dessa maneira, você deve acessar as classes de uma maneira específica. Você importa a classe ou
faz referência a ela usando um nome totalmente qualificado.
NO TA
Para usar a instrução import, especifique 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 que seja necessário especificar seus nomes
totalmente qualificados. Por exemplo, para usar a classe BlurFilter em um script, você deverá
fazer referência a ela pelo seu nome totalmente qualificado (flash.filters.BlurFilter) ou
importá-la. Se a importar, você poderá fazer referência a ela pelo seu nome de classe
(BlurFilter) em seu código. O código ActionScript a seguir demonstra as diferenças entre o
uso da instrução import e o uso de nomes de classe totalmente qualificados.
Se você não importar a classe BlurFilter, o seu código precisará usar o nome de classe
totalmente qualificado (o nome de pacote seguido pelo nome de classe) para usar o filtro:
// sem importar
var myBlur:flash.filters.BlurFilter = new flash.filters.BlurFilter(10, 10,
3);
O mesmo código, escrito com uma instrução import, permite acessar a classe BlurFilter
usando o nome de classe em vez de fazer uma referência contínua a ela com o nome
totalmente qualificado. Isso pode reduzir a quantidade de código digitada e evitar possíveis
erros de digitação:
// com importação
var myBlur:BlurFilter = new BlurFilter(10, 10, 3);
Para importar várias classes de um pacote (como BlurFilter, DropShadowFilter e GlowFilter),

escolha uma das maneiras a seguir para importar cada classe. A primeira maneira usada para
importar várias classes consiste em importar cada uma delas usando uma instrução import
separada, como mostra o trecho de código a seguir:

A utilização de instruções import individuais para cada classe de um pacote pode aumentar
bastante o tempo de criação e resultar em erros de digitação. Para evitar a importação de
arquivos de classe individuais, utilize um caractere curinga de importação, que importa todas
as classes em um nível específico de um pacote. O ActionScript a seguir mostra um exemplo
de como usar um caractere curinga de importação:
import flash.filters.*; // importa cada classe do pacote flash.filters
Por exemplo, suponha que você importe todas as classes do pacote macr.util no Frame 1 de
um documento do Flash. Nesse quadro, você pode fazer referência às classes do pacote usando
seus nomes de classe em vez do nome totalmente qualificado. Para usar o nome de classe em
outro script de quadro, faça referência às classes desse pacote pelos seus nomes totalmente
qualificados ou adicione uma instrução import ao outro quadro que importará as classes desse
pacote.
Ao usar as instruções import, lembre-se de que as classes somente são importadas para o nível
especificado. Por exemplo, se você importar todas as classes do pacote mx.transitions,
somente as classes do diretório /transitions/ serão importadas, e não todas as classes dos
subdiretórios (por exemplo, as classes do pacote mx.transitions.easing ).
DICA
Se você importar uma classe, mas não a usar no script, ela 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
somente será incluído em um arquivo SWF se a classe for realmente usada.

Trabalhando com filtros, armazenamento em cache e
a classe MovieClip
Se um clipe de filme tiver um filtro associado, ele será marcado para fazer o seu próprio
armazenamento em cache como um bitmap transparente quando o arquivo SWF for
carregado. O Flash Player armazena em cache o clipe de filme como um bitmap durante a
execução, forçando a propriedade cacheAsBitmap como true, contanto que o clipe de filme
tenha, no mínimo, um filtro aplicado a ele. O bitmap armazenado em cache é usado como
imagem de origem para os efeitos de filtro. Geralmente, cada clipe de filme possui dois
bitmaps: um bitmap equivale ao clipe de filme de origem sem filtro, e o segundo corresponde
à imagem final após a filtragem. Se você não alterar a aparência do clipe de filme durante a
execução, a imagem final não precisará ser atualizada, o que ajudará a melhorar o
desempenho.
Você pode acessar os filtros aplicados a uma instância chamando a propriedade
MovieClip.filters. Em seguida, um array é retornado contendo cada objeto de filtro
associado no momento à instância de clipe de filme. O próprio filtro possui um conjunto de
propriedades exclusivas, por exemplo:
trace(my_mc.filters[0].angle); // 45.0
trace(my_mc.filters[0].distance); // 4
Você pode acessar e modificar filtros da mesma forma que faria no caso de um objeto de array
comum. O uso da propriedade para definir e obter os filtros retorna uma duplicata do objeto
filters, e não uma referência.
Para modificar um filtro existente, é possível usar um código semelhante ao do procedimento
a seguir.
Para modificar as propriedades de um filtro aplicado a uma instância de clipe

de filme:
1. Crie um novo documento do Flash e salve-o como modifyFilter.fla.
this.createEmptyMovieClip("my_mc", 10);
// desenhar quadrado
with (my_mc) {
moveTo(0, 0);
lineTo(100, 0);
lineTo(100, 100);
lineTo(0, 100);
lineTo(0, 0);
endFill();
}
my_mc._x = 100;

my_mc._y = 100;
// usar valores padrão de DropShadowFilter

my_mc.filters = [new flash.filters.DropShadowFilter()];
var filter_array:Array = my_mc.filters;
filter_array[0].distance = 10;
my_mc.filters = filter_array;
A primeira seção deste código usa a API de desenho para criar um quadrado vermelho e
posiciona a forma no Stage. A segunda seção do código aplica um filtro de sombreamento
ao quadrado. Em seguida, o código cria um array temporário para armazenar os filtros
atuais a serem aplicados ao quadrado vermelho no Stage. A propriedade distance do
primeiro filtro é definida para 10 pixels, e o filtro modificado é reaplicado à instância de
clipe de filme my_mc.
N OT A
No momento, não há suporte disponível para a rotação de qualquer filtro com base
na rotação de seu respectivo pai ou para algum outro tipo de rotação. O filtro de
embaçamento sempre embaça perfeitamente na horizontal ou na vertical,
independentemente da rotação ou da inclinação de qualquer item na árvore de
objetos pai.
DICA
O conteúdo filtrado possui as mesmas restrições de tamanho do conteúdo cuja

propriedade cacheAsBitmap esteja definida como true. Se o autor aumentar o zoom
muito distante no arquivo SWF, os filtros não estarão mais visíveis quando a
representação de bitmap for maior que 2880 pixels em qualquer direção. Quando
você publicar arquivos SWF com filtros, convém desativar as opções do menu de
zoom.

Sobre detecção de cliques e filtros de rotação,
inclinação e dimensionamento
Nenhuma região filtrada (um sombreamento, por exemplo) fora do retângulo da caixa
delimitadora da instância de clipe de filme é considerada parte da superfície para fins de
detecção de cliques (determinando se uma instância substitui ou faz interseção com outra).
Como a detecção de cliques é baseada em vetores, não é possível executar esse tipo de detecção
no resultado de bitmap. Por exemplo, se você aplicar um filtro de chanfro a uma instância de
botão, a detecção de cliques não estará disponível na parte chanfrada da instância.
Os filtros não oferecem suporte a dimensionamento, rotação e inclinação; se a instância for
dimensionada (_xscale e _yscale não forem 100%), o efeito de filtro não será
dimensionado junto com ela. Isso significa que a forma original da instância é girada,
dimensionada ou inclinada; entretanto, o filtro não gira, inclina nem é dimensionado junto
com ela.
Você pode animar uma instância com um filtro para criar efeitos realistas ou aninhar
instâncias e usar a classe BitmapData para animar filtros a fim de atingir esse efeito.
Aplicando filtros a instâncias de objeto e instâncias

de BitmapData
O uso de filtros depende da instância de objeto à qual você aplicará o filtro. Use as diretrizes a
seguir ao aplicar um filtro a uma instância de objeto ou à instância BitmapData:
■ Para aplicar filtros a clipes de filme, campos de texto e botões durante a execução, use a
propriedade filters. A definição da propriedade filters de um objeto não modifica o
objeto e pode ser desfeita desmarcando a propriedade.
■ Para aplicar filtros a instâncias de BitmapData, use o método
BitmapData.applyFilter(). A chamada de applyFilter() em um objeto BitmapData
modifica esse objeto e não pode ser desfeita.
N O TA
(Somente Flash Professional 8) Você também pode aplicar efeitos de filtro a

imagens e vídeo durante a criação através da guia Filters (Filtros) no inspetor
Properties (Propriedades).

Sobre manipulação de erros, desempenho e filtros
Um dos problemas que ocorrem quando você usa uma grande quantidade de filtros em um
aplicativo é a possibilidade de usar muita memória, o que pode causar prejuízo no
desempenho do Flash Player. Como um clipe de filme com filtros anexados possui dois
bitmaps de 32 bits, esses bitmaps podem fazer com que o seu aplicativo utilize muita memória
no caso de vários bitmaps. É possível que seja exibido um erro de falta de memória gerado
pelo sistema operacional do computador. Em um computador moderno, esses erros devem ser
raros, a menos que você esteja usando muitos efeitos de filtro em um aplicativo (por exemplo,
se houver milhares de bitmaps no Stage).
Entretanto, se um erro de falta de memória for realmente exibido, ocorrerá o seguinte:
■ O array de filtros será ignorado.
■ O clipe de filme será desenhado com o renderizador vetorial comum.
■ Nenhum bitmap é armazenado em cache para o clipe de filme.
Após a exibição de um erro de falta de memória, o clipe de filme nunca tentará usar um array
de filtros ou um cache de bitmap. Outro fator que afeta o desempenho do exibidor é o valor
usado para o parâmetro quality no caso de cada filtro aplicado. Valores mais altos exigem
mais consumo de CPU e memória para renderizar o efeito, ao passo que a configuração do
parâmetro quality para um valor mais baixo exige menos recursos do computador. Portanto,
evite usar um número excessivo de filtros e utilize uma configuração mais baixa para quality
quando possível.
A T E NÇ Ã O
Se um objeto de 100 X 100 pixels aumentar o zoom uma vez, ele usará quatro vezes a
memória, pois as dimensões do conteúdo passarão para 200 X 200 pixels. Se você
aumentar o zoom mais duas vezes, a forma será desenhada como um objeto de 800 X
800 pixels, utilizando 64 vezes a memória em comparação ao objeto original de 100 X
100 pixels. Sempre que você usar filtros em um arquivo SWF, convém sempre desativar
as opções do menu de zoom no menu de contexto desse arquivo.
Você também poderá encontrar erros se usar tipos de parâmetro inválidos. Alguns parâmetros
de filtro também possuem um intervalo válido específico. Se você definir um valor fora do
intervalo válido, o valor será alterado para um valor válido dentro do intervalo. Por exemplo,
quality deve ser um valor de 1 a 3 para uma operação padrão e somente pode ser definido
para o intervalo de 0 a 15. Qualquer valor acima de 15 será definido como 15.

Além disso, alguns construtores fazem restrições quanto ao tamanho dos arrays necessários
como parâmetros de entrada. Se um filtro de convolução ou um filtro de matriz de cores for
criado com um array inválido (que não seja do tamanho adequado), o construtor não terá
êxito e o filtro não será criado corretamente. Se o objeto de filtro for usado como entrada no
array de filtros de um clipe de filme, ele será ignorado.
DICA
Com um filtro de embaçamento, utilize potências de 2 para blurX e blurY (por exemplo,
2, 4, 8, 16 e 32), pois eles são calculados de forma mais rápida, além de melhorar o
desempenho em 20% a 30%.
Trabalhando com filtros usando

ActionScript
O pacote flash.filters contém classes para os efeitos de filtro de bitmap, que são novidade no
Flash Player 8. Os filtros permitem usar o ActionScript para aplicar efeitos visuais sofisticados,
como embaçamento, chanfro, brilho e sombreamento, às instâncias de texto, clipe de filme e
botão. Você também pode usar a ferramenta de criação do Flash para aplicar efeitos de filtro a
objetos, como texto, imagens e vídeo. O Flash possui nove efeitos de filtro, embora somente
sete sejam acessíveis através da interface de usuário no Flash Professional 8. Os filtros
ConvolutionFilter e DisplacementMapFilter estão disponíveis apenas através do código
ActionScript.
NO T A
Todos os filtros estão disponíveis usando o ActionScript no Flash Basic 8 e no Flash

Professional 8.
O procedimento a seguir carrega uma imagem PNG semitransparente e aplica um efeito

GlowFilter à parte não transparente da imagem.
Para aplicar filtros a imagens semitransparentes:

1. Crie um novo documento do Flash e salve-o como transparentImg.fla.
var glow:GlowFilter = new GlowFilter();
target_mc.filters = [glow];
};

img_mcl.loadClip("http://www.helpexamples.com/flash/images/logo.png",
img_mc);
Esse código usa uma instância do clipe de filme carregador para carregar uma imagem
PNG semitransparente. Após o carregamento da imagem, ela é movida para o centro do
Stage e um filtro de brilho é aplicado.
O efeito do filtro de brilho somente é aplicado à área opaca (não transparente) da imagem
PNG.
As seções a seguir descrevem como usar os filtros:
■ “Usando o filtro de embaçamento” na página 536
■ “Usando o filtro de sombreamento” na página 538
■ “Usando o filtro de brilho” na página 542
■ “Criando brilhos gradientes” na página 543
■ “Usando o filtro de chanfro” na página 545
■ “Aplicando um filtro de chanfro gradiente” na página 551
■ “Usando o filtro de matriz de cores” na página 552
■ “Usando o filtro de torção” na página 554
■ “Usando o filtro de mapa de deslocamento” na página 556
Trabalhando com filtros usando ActionScript 535

Usando o filtro de embaçamento
A classe BlurFilter permite aplicar um efeito visual de embaçamento a vários objetos no Flash.
O efeito de embaçamento suaviza os detalhes de uma imagem. É possível produzir
embaçamentos que variam desde a criação de uma aparência suavemente desfocada até um
embaçamento gaussiano, ou seja, uma aparência turva como se você estivesse vendo a imagem
através de um vidro semi-opaco. O filtro de embaçamento baseia-se em um filtro de
embaçamento passa-caixa. O parâmetro quality define o número de vezes para repetição do
embaçamento (três passagens aproxima-se de um filtro de embaçamento gaussiano).
N OT A
O filtro de embaçamento dimensiona somente quando você aumenta o zoom no Stage.
Para obter mais informações sobre esse filtro, consulte %{BlurFilter (flash.filters.BlurFilter)}%
O procedimento a seguir embaça uma imagem carregada dinamicamente com base na posição
atual do ponteiro do mouse no Stage. Quanto mais distante o ponteiro estiver do centro do
Stage, mais embaçada estará a imagem.
Para embaçar uma imagem com base na posição do ponteiro do mouse:

1. Crie um novo documento do Flash e salve-o como dynamicblur.fla.
// Centralizar o clipe de filme target_mc no Stage.

};
img_mc);
var blur:BlurFilter = new BlurFilter(10, 10, 2);

/* Moving the pointer to the center of the Stage sets the blurX and
blurY properties to 0%. */
blur.blurX = Math.abs(_xmouse - (Stage.width / 2)) / Stage.width * 2 *
255;
blur.blurY = Math.abs(_ymouse - (Stage.height / 2)) / Stage.height * 2
* 255;
img_mc.filters = [blur];
};
A primeira seção deste código carrega e posiciona uma imagem carregada dinamicamente
no Stage. A segunda seção define um ouvinte que é chamado sempre que o mouse é
movido. Calcule a quantidade de embaçamento horizontal e vertical com base na posição
atual do ponteiro do mouse no Stage. Quanto mais distante você mover o ponteiro do
mouse do centro do Stage, mais embaçamento será aplicado à instância.
Flash.
Mova o ponteiro do mouse ao longo do eixo x para modificar a quantidade de
embaçamento horizontal. A instância ficará mais embaçada quanto mais afastado estiver o
ponteiro do centro horizontal do Stage. Mover o ponteiro ao longo do eixo y faz com que
o embaçamento vertical aumente ou diminua, dependendo da distância do centro vertical
do Stage.
DICA
Com um filtro de embaçamento, utilize potências de dois para blurX e blurY (por
exemplo, 2, 4, 8, 16 e 32), pois eles são calculados de forma mais rápida, além de
melhorar o desempenho em 20% a 30%.
ATENÇÃO
A configuração de um valor de embaçamento menor que 1,03125 desativa o efeito

de embaçamento.

Usando o filtro de sombreamento
A classe DropShadowFilter permite adicionar um sombreamento a vários objetos no Flash. O
algoritmo de sombreamento baseia-se no mesmo filtro de caixa usado pelo filtro de
embaçamento (consulte “Usando o filtro de embaçamento” na página 536). Várias opções
estão disponíveis para o estilo de sombreamento, inclusive sombreamento interno ou externo
e modo vazado.
Para obter mais informações sobre o filtro de sombreamento, consulte %{DropShadowFilter
(flash.filters.DropShadowFilter)}% em ActionScript 2.0 Language Reference.
O procedimento a seguir usa a API de desenho para criar um quadrado no Stage. Quando
você move o ponteiro do mouse horizontalmente no Stage, este código modifica a distância do
quadrado que contém o sombreamento, ao passo que ao mover o cursor verticalmente, você
modifica a quantidade de embaçamento do sombreamento.
Para usar o filtro de sombreamento:

1. Crie um novo documento do Flash e salve-o como dropshadow.fla.
// import the filter classes
// criar um clipe de filme chamado shapeClip
this.createEmptyMovieClip("shapeClip", 1);
// usar a API de desenho para criar uma forma
with (shapeClip) {
moveTo(0, 0);
lineTo(100, 0);
lineTo(100, 100);
lineTo(0, 100);
lineTo(0, 0);
endFill();
}
// posicionar a forma
shapeClip._x = 100;
shapeClip._y = 100;
// clicar no quadrado e aumentar a intensidade do sombreamento
shapeClip.onPress = function():Void {
dropShadow.strength++;
shapeClip.filters = [dropShadow];
};
// criar um filtro
var dropShadow:DropShadowFilter = new DropShadowFilter(4, 45, 0x000000,
0.4, 10, 10, 2, 3);

// criar e aplicar um ouvinte que controla o filtro quando o mouse é
movimentado
dropShadow.distance = (_xmouse / Stage.width) * 50 - 20;
dropShadow.blurX = (_ymouse / Stage.height) * 10;
dropShadow.blurY = dropShadow.blurX;
shapeClip.filters = [dropShadow];
};
A primeira seção do código cria um novo clipe de filme e utiliza a API de desenho para
criar um quadrado vermelho. A segunda seção define um ouvinte de mouse que é
chamado sempre que o mouse é movido. O ouvinte de mouse calcula a distância do
sombreamento e o nível de embaçamento com base nas posições x e y do ponteiro do
mouse e reaplica o filtro de sombreamento. Se você clicar no quadrado vermelho, a
intensidade do sombreamento aumentará.
Flash.
Mova o ponteiro do mouse ao longo do eixo x para alterar o valor da distância do
sombreamento e, em seguida, mova o ponteiro ao longo do eixo y para alterar a
quantidade de embaçamento aplicada à instância do clipe de filme.
Você também pode criar sombreamentos e aplicá-los a imagens carregadas dinamicamente. O

procedimento a seguir demonstra como carregar uma imagem externa e aplicar um
sombreamento que segue o ponteiro do mouse. Quanto mais distante você mover o ponteiro
do canto superior esquerdo da imagem, mais embaçamento horizontal e vertical será aplicado
à imagem.

Para criar um sombreamento que segue o ponteiro do mouse:
1. Crie um novo documento do Flash e salve-o como dropshadowmouse.fla.
var dropShadow:DropShadowFilter = new DropShadowFilter(4, 45, 0x000000,
0.8, 10, 10, 2, 2);
// Carregar e posicionar a imagem no Stage.
};
img_mc);
// Recalcular a posição do sombreamento quando o mouse for movimentado.

var p1:Number = img_mc._y - _ymouse;
var p2:Number = img_mc._x - _xmouse;
var degrees:Number = Math.atan2(p1, p2) / (Math.PI / 180);
dropShadow.distance = Math.sqrt(Math.pow(p1, 2) + Math.pow(p2, 2)) *
0.5;
dropShadow.blurX = dropShadow.distance;
dropShadow.blurY = dropShadow.blurX;
dropShadow.angle = degrees - 180;
img_mc.filters = [dropShadow];
};
A primeira seção deste código define uma instância de sombreamento, carrega uma
imagem externa e reposiciona a imagem no centro do Stage. A segunda seção define um
ouvinte de mouse que é chamado sempre que o usuário movimenta o ponteiro do mouse
no Stage. Sempre que o mouse for movido, o manipulador de eventos recalculará a
distância e o ângulo entre o ponteiro do mouse e o canto superior esquerdo da imagem.
Com base nesse cálculo, o filtro de sombreamento será reaplicado ao clipe de filme.
Flash.

O sombreamento seguirá o ponteiro do mouse quando você executar o arquivo SWF.
Quanto mais você mover o ponteiro do mouse para perto do canto superior esquerdo da
imagem no Stage, menor será o efeito de embaçamento aplicado à imagem. Quanto mais
para longe você move o ponteiro do mouse do canto superior esquerdo da imagem, mais o
efeito de sombreamento torna-se aparente.
Você também pode aplicar sombreamentos e aplicá-los a imagens PNG semitransparentes
carregadas dinamicamente. No procedimento a seguir, o filtro de sombreamento é aplicado
somente à área sólida da imagem PNG, e não à transparência.
Para aplicar um sombreamento a uma imagem semitransparente:

1. Crie um novo documento do Flash e salve-o como dropshadowTransparent.fla.
var dropShadow:DropShadowFilter = new DropShadowFilter(4, 45,
0x000000, 0.5, 10, 10, 2, 3);
target_mc.filters = [dropShadow];
};
trace("unable to load image.");
};
this.createEmptyMovieClip("logo_mc", 10);
my_mcl.loadClip("http://www.helpexamples.com/flash/images/logo.png",
logo_mc);
Este código ActionScript usa a classe MovieClipLoader para carregar uma imagem e
aplicar um filtro de sombreamento quando a imagem estiver completamente carregada do
servidor remoto.
Flash.
O Flash carrega uma imagem PNG com um fundo transparente. Quando você aplicar o
filtro de sombreamento, somente a parte opaca (não transparente) da imagem terá o filtro
aplicado.

Usando o filtro de brilho
A classe GlowFilter permite adicionar um efeito de brilho a vários objetos no Flash. O
algoritmo de brilho baseia-se no mesmo filtro de caixa usado pelo filtro de embaçamento
(consulte “Usando o filtro de embaçamento” na página 536). Você pode definir o estilo do
brilho de várias maneiras, inclusive o brilho interno ou externo e o modo vazado. O filtro de
brilho é semelhante ao filtro de sombreamento, com as propriedades distance e angle do
sombreamento definidas como 0.
Para obter mais informações sobre o filtro de brilho, consulte {GlowFilter
(flash.filters.GlowFilter)}% em ActionScript 2.0 Language Reference.
O procedimento a seguir demonstra como aplicar um filtro de brilho a um clipe de filme
criado dinamicamente no Stage. Mover o ponteiro do mouse no Stage altera o embaçamento
do clipe de filme e clicar na forma criada dinamicamente aumenta a intensidade do filtro.
Para usar o filtro de brilho:

1. Crie um novo documento do Flash e salve-o como glowfilter.fla.
2. Adicione o ActionScript a seguir ao Frame 1 da Timeline:
this.createEmptyMovieClip("shapeClip", 10);
with (shapeClip) {
moveTo(0, 0);
lineTo(100, 0);
lineTo(100, 100);
lineTo(0, 100);
lineTo(0, 0);
endFill();
}
shapeClip._x = 100;
shapeClip._y = 100;
glow.strength++;
shapeClip.filters = [glow];
};
var glow:GlowFilter = new GlowFilter(0xCC0000, 0.5, 10, 10, 2, 3);
glow.blurX = (_xmouse / Stage.width) * 255;
glow.blurY = (_ymouse / Stage.width) * 255;
shapeClip.filters = [glow];
};

Este código usa a API de desenho para criar um quadrado no Stage e aplica um filtro de
brilho à forma. Sempre que você move o ponteiro do mouse ao longo do eixo x ou y, o
embaçamento do filtro é calculado e aplicado à forma.
A quantidade de embaçamento horizontal e vertical é calculada pelas posições _xmouse e
_ymouse atuais do ponteiro do mouse. A quantidade de embaçamento horizontal e
vertical diminui à medida que você move o ponteiro do mouse para o canto superior
esquerdo do Stage. Inversamente, quantidade de embaçamento horizontal e vertical
aumenta à medida que você move o ponteiro do mouse para o canto inferior direito do
Stage.
Criando brilhos gradientes

A classe GradientGlowFilter permite aplicar um efeito de brilho gradiente a vários objetos no
Flash. O brilho gradiente é um brilho de aparência realista com um gradiente de cores possível
de ser especificado. Você pode aplicar um brilho gradiente ao redor da borda interna ou
externa de um objeto ou sobre um objeto.
Para obter mais informações sobre esse filtro, consulte %{GradientBevelFilter

(flash.filters.GradientBevelFilter)}% em ActionScript 2.0 Language Reference.
O procedimento a seguir usa a API de desenho para criar um quadrado no Stage e, em
seguida, aplica um filtro de brilho gradiente à forma. Clicar no quadrado do Stage aumenta a
intensidade do filtro, ao passo que mover o ponteiro do mouse horizontal ou verticalmente
modifica a quantidade de embaçamento ao longo do eixo x ou y.
Para aplicar um filtro de brilho gradiente:

1. Crie um novo documento do Flash e salve-o como loadvarsText.fla.

import flash.filters.GradientGlowFilter;
// criar uma nova instância shapeClip
var shapeClip:MovieClip = this.createEmptyMovieClip("shapeClip", 10);
with (shapeClip) {
moveTo(0, 0);
lineTo(100, 0);
lineTo(100, 100);
lineTo(0, 100);
lineTo(0, 0);
endFill();
}
// posicionar a forma
shapeClip._x = 100;
shapeClip._y = 100;
// definir um brilho gradiente
var gradientGlow:GradientGlowFilter = new GradientGlowFilter(0, 45,
[0x000000, 0xFF0000], [0, 1], [0, 255], 10, 10, 2, 3, "outer");
// definir um ouvinte de mouse, ouvir dois eventos

mouseListener.onMouseDown = function():Void {
gradientGlow.strength++;
shapeClip.filters = [gradientGlow];
};
gradientGlow.blurX = (_xmouse / Stage.width) * 255;
gradientGlow.blurY = (_ymouse / Stage.height) * 255;
shapeClip.filters = [gradientGlow];
};
O código anterior é dividido em três seções. A primeira seção do código usa a API de
desenho para criar um quadrado e posiciona a forma no Stage. A segunda seção define
uma nova instância de filtro de brilho gradiente, que cria um brilho variando de vermelho
a preto. A terceira seção define um ouvinte que ouve dois manipuladores de eventos do
mouse. O primeiro manipulador de eventos é onMouseDown, que aumenta a intensidade
do brilho gradiente. O segundo manipulador de eventos é onMouseMove, que é chamado
sempre que você movimenta o ponteiro do mouse no arquivo SWF. Quanto mais para
longe você move o ponteiro do mouse do canto superior esquerdo do documento do
Flash, mais intenso é o efeito de brilho aplicado.

O embaçamento do filtro de brilho gradiente aumenta e diminui de intensidade quando
você move o ponteiro do mouse no Stage. Clique no botão esquerdo do mouse para
aumentar a intensidade do brilho.
Usando o filtro de chanfro

A classe BevelFilter permite adicionar um efeito de chanfro a vários objetos no Flash. O efeito
de chanfro aplica uma aparência tridimensional aos objetos. Você pode personalizar a
aparência do chanfro usando diferentes cores de sombreamento e de realce, a quantidade de
embaçamento no chanfro, o ângulo do chanfro, a posição do chanfro e o efeito vazado.
Para obter mais informações sobre esse filtro, consulte %{BevelFilter

(flash.filters.BevelFilter)}% em ActionScript 2.0 Language Reference.
O procedimento a seguir usa a API de desenho para criar um quadrado e adiciona um chanfro
à forma.
Para usar o filtro de chanfro:

1. Crie um novo documento do Flash e salve-o como bevel.fla.
import flash.filters.BevelFilter;
// definir um filtro de chanfro
var bevel:BevelFilter = new BevelFilter(4, 45, 0xFFFFFF, 1, 0xCC0000, 1,
10, 10, 2, 3);
// criar uma nova instância shapeClip
with (shapeClip) {

moveTo(0, 0);
lineTo(100, 0);
lineTo(100, 100);
lineTo(0, 100);
lineTo(0, 0);
endFill();
}
// posicionar a forma no Stage
shapeClip._x = 100;
shapeClip._y = 100;
// clicar no mouse para aumentar a intensidade
bevel.strength += 2;
shapeClip.filters = [bevel];
};
// definir um ouvinte para modificar o filtro quando o ponteiro for

movido
bevel.distance = (_xmouse / Stage.width) * 10;
bevel.blurX = (_ymouse / Stage.height) * 10;
bevel.blurY = bevel.blurX;
shapeClip.filters = [bevel];
};
A primeira seção do código define uma instância BevelFilter e utiliza a API de desenho
para criar um quadrado no Stage. Quando você clicar no quadrado do Stage, o valor de
intensidade atual do chanfro será incrementado e aplicará uma aparência mais alta e legível
ao chanfro. A segunda seção define um ouvinte de mouse, que modifica a distância e o
embaçamento do chanfro com base na posição atual do ponteiro do mouse.
Flash.
Quando você move o ponteiro do mouse pelo eixo x, a distância de deslocamento do
chanfro aumenta ou diminui. Quando você move o ponteiro do mouse pelo eixo y, as
coordenadas atuais do ponteiro modificam a quantidade de embaçamento horizontal e
vertical.

Sobre o filtro de chanfro gradiente
O filtro de chanfro gradiente é aplicado a um objeto, por exemplo, um retângulo, com as
cores do gradiente distribuídas por três partes da forma: duas bordas de chanfro (um de realce
e outro de sombreamento) e uma área conhecida como preenchimento de base. Os diagramas a
seguir ilustram o retângulo, com o tipo de chanfro definido como interno No retângulo
esquerdo, as áreas em cinza escuro correspondem às bordas do chanfro, e a área em cinza claro
representa o preenchimento de base. No retângulo direito, é aplicado um chanfro gradiente
em arco-íris, com um chanfro de quatro cores em cada borda.
As diferentes propriedades do filtro de chanfro gradiente controlam o modo de aplicação do

filtro. As cores do chanfro gradiente são definidas no array de cores. A distribuição real de
cores em cada parte do retângulo é determinada pelo array de proporções. A propriedade
distance determina a distância de deslocamento ou a distância em pixels a ser aplicada à borda
de chanfro em relação ao objeto. As propriedades blurX e blurY controlam a nitidez das cores
no chanfro; os valores mais altos tornam o chanfro efetivamente mais largo e suave, ao passo
que os valores mais baixos o tornam mais fino e nítido. A propriedade angle equivale à fonte
de luz teórica que incide sobre o objeto, causando um efeito de realce e sombreamento em
suas bordas. A propriedade strength controla a distribuição das cores: um valor de
intensidade mais baixo obscurece as cores, como pode ser visto no exemplo, enquanto um
valor mais alto torna os números externos no array mais nítidos, forçando um menor realce
das cores intermediárias no array. Finalmente, as propriedades knockout e type determinam
como e onde o filtro de chanfro será aplicado ao objeto inteiro: se o filtro vazará o objeto e
onde ele será posicionado.

Um dos conceitos mais complicados no que se refere à aplicação ao filtro de chanfro gradiente
consiste na distribuição de cores. Para compreender o modo de distribuição das cores em um
chanfro gradiente, pense primeiro nas cores que deseja usar em seu chanfro gradiente. Como
um chanfro simples aplica os conceitos já compreendidos sobre cor de realce e cor de
sombreamento, você pode aplicar os mesmos conceitos para compreender o filtro de chanfro
gradiente: há um gradiente de realce e um gradiente de sombreamento. O realce aparece no
canto superior esquerdo, e o sombreamento, no canto inferior direito. Há quatro cores no
realce e quatro no sombreamento. Entretanto, é necessário adicionar outra cor (a cor do
preenchimento de base), que aparecerá na interseção das bordas do realce e do sombreamento.
O array contém nove cores, conforme ilustrado no diagrama anterior.
O número de cores no array determina o número de elementos no array de valores alfa e de
proporções. O primeiro item no array de cores corresponde ao primeiro item no array de
valores alfa e no array de proporções e assim por diante. Por haver nove cores, também há nove
valores no array de valores alfa e nove no array de proporções. Os valores alfa definem o valor
de transparência alfa das cores.
Os valores de proporção no array de proporções pode variar de 0 a 255 pixels. O valor
intermediário é 128, que é o valor do preenchimento de base. Na maioria das utilizações, para
você obter o efeito de chanfro desejado, atribua os valores de proporção conforme o modo a
seguir, usando o exemplo das nove cores:
■ As quatro primeiras cores variam de 0 a 127 e aumentam de valor, de modo que cada valor
seja maior ou igual ao anterior. Essa é a primeira borda de chanfro, ou seja, nosso realce.
■ A quinta cor (intermediária) corresponde ao preenchimento de base, definida como 128.
O valor de pixel 128 define o preenchimento de base, que aparecerá fora da forma (e ao
redor das bordas de chanfro) se type for definida como outer; ou dentro da fora, cobrindo
efetivamente o preenchimento do próprio objeto se type for definida como inner.
■ As quatro últimas cores variam de 129 a 255 e aumentam de valor, de modo que cada
valor seja maior ou igual ao anterior. Essa é a segunda borda de chanfro, por exemplo, o
seu sombreamento.
Se você imaginar um gradiente como composto de listras de várias cores, que se misturam
umas às outras, cada valor de proporção definirá o número de pixels da cor associada,
definindo, portanto, a largura da listra de cor no gradiente. Se desejar uma distribuição igual
de cores para cada borda:
■ Use um número ímpar de cores, com a cor intermediária como o preenchimento de base.
■ Distribua os valores entre 0 a 127 e 129 a 255 igualmente entre as cores.

■ Ajuste o valor para alterar a largura de cada listra de cor no gradiente.
NO TA
O valor do ângulo determina qual borda será usada como realce e qual será usada
como sombreamento.
O valor do ângulo determina o ângulo usado para aplicar as cores de gradiente ao objeto, ou
seja, o local em que o realce e o sombreamento aparecerão no objeto. As cores são aplicadas na
mesma ordem do array.
O código a seguir usa um quadrado rosa (criado com a API de desenho) e aplica um filtro de
gradiente em arco-íris. As cores são, na ordem apresentada no array: azul, verde, roxo e
amarelo (realce); vermelho (preenchimento de base); amarelo, roxo, verde, preto
(sombreamento). Para determinar os valores de proporção, atribuímos quatro valores de 0 a
127 praticamente iguais para as cores de realce e cores de sombreamento de 129 a 255. As
cores das bordas externas foram azul (16) e preto (235).
var colors:Array = [0x0000FF, 0x00FF00, 0x9900FF, 0xFFFF00, 0xFF0000,
0xFFFF00, 0x9900FF, 0x00FF00,0x000000];
var alphas:Array = [1, 1, 1, 1, 1, 1, 1, 1, 1];
var ratios:Array = [16, 32, 64, 96, 128, 160, 192, 224, 235];
var gradientBevel:GradientBevelFilter = new GradientBevelFilter(8, 225,
colors, alphas, ratios, 16, 16, 1.3, 2, "inner", false);
A figura a seguir mostra o filtro de chanfro gradiente criado pelo código acima, um chanfro
em arco-íris de nove cores aplicado a um clipe de filme de retângulo vermelho:

A linha tracejada mostra como os ângulos são determinados. A figura mostra como o ângulo
de 225° é percebido no filtro e também mostra cada valor de proporção para cada cor. Definir
o ângulo a 225° indica que a primeira cor do array iniciará a 225°, ou seja, no canto superior
esquerdo (o realce). A linha pontilhada mostra onde são aplicados os gradientes de realce e de
sombreamento.
A cor do clipe de filme original é rosa, mas a configuração do valor 128 para vermelho
significa que o valor de 128 pixels é o preenchimento de base e cobre o preenchimento do
clipe de filme original. Entretanto, quando você define a propriedade filters, o objeto original
não é alterado; basta você desmarcar a propriedade filters para restaurar o preenchimento
do clipe de filme original.
As propriedades de todos os filtros afetam uns aos outros, portanto, se ajustar uma
propriedade para alterar o efeito que estiver aplicando, é possível que você também precise
ajustar outra propriedade.
Este é o código ActionScript completo para criar a figura anterior:
import flash.filters.GradientBevelFilter;
// desenha uma forma quadrada preenchida

this.createEmptyMovieClip("square_mc", this.getNextHighestDepth());
square_mc.beginFill(0xFF99CC);
square_mc.endFill();
/* GradientBevelFilter(distance:Number, angle:Number, colors:Array,

alphas:Array, ratios:Array, blurX:Number, blurY:Number, strength:Number,
quality:Number, type:String, knockout:Boolean) */
// criar cores, alfas e arrays de proporções

var colors:Array = [0x0000FF, 0x00FF00, 0x9900FF, 0xFFFF00, 0xFF0000,
0xFFFF00, 0x9900FF, 0x00FF00,0x000000];//blue, green, purple, yellow,
red, yellow, purple, green, black
var alphas:Array = [1, 1, 1, 1, 1, 1, 1, 1, 1];
var ratios:Array = [16, 32, 64, 96, 128, 160, 192, 224, 235];
// criar o objeto de filtro

colors, alphas, ratios, 16, 16, 1.3, 2, "inner", false);
// aplicar o filtro ao clipe de filme quadrado

square_mc.filters = [gradientBevel];

Aplicando um filtro de chanfro gradiente
A classe GradientBevelFilter permite aplicar um efeito de chanfro gradiente aos objetos no
Flash. O chanfro gradiente é uma borda chanfrada aprimorada com cor de gradiente na parte
externa ou interna do objeto ou sobre ele. As bordas chanfradas conferem uma aparência
tridimensional aos objetos, podendo ter resultados coloridos conforme mostrado na figura a
seguir.
Para obter mais informações sobre esse filtro, consulte %{GradientBevelFilter

(flash.filters.GradientBevelFilter)}% em ActionScript 2.0 Language Reference.
O procedimento a seguir usa a API de desenho para criar um quadrado no Stage e, em
seguida, aplica um filtro de chanfro gradiente à forma.
Para usar o filtro de chanfro gradiente:

1. Crie um novo documento do Flash e salve-o como gradientbevel.fla.
import flash.filters.GradientBevelFilter;
var shapeClip:MovieClip = this.createEmptyMovieClip("shape_mc", 1);
with (shapeClip) {
moveTo(0, 0);
lineTo(200, 0);
lineTo(200, 200);
lineTo(0, 200);
lineTo(0, 0);
endFill();
}
shapeClip._x = (Stage.width - shapeClip._width) / 2;
shapeClip._y = (Stage.height - shapeClip._height) / 2;
var colors:Array = new Array(0xFFFFFF, 0xCCCCCC, 0x000000);
var alphas:Array = new Array(1, 0, 1);
var ratios:Array = new Array(0, 128, 255);

colors, alphas, ratios, 4, 4, 5, 3);
mouseListener.onMouseDown = function() {
gradientBevel.strength++;
shapeClip.filters = [gradientBevel];
};
mouseListener.onMouseMove = function() {
gradientBevel.blurX = (_xmouse / Stage.width) * 255;
gradientBevel.blurY = (_ymouse / Stage.height) * 255;
shapeClip.filters = [gradientBevel];
};
Este código usa a API de desenho para criar um quadrado no Stage que é posicionado no
centro do Stage. Quando você mover o ponteiro do mouse no Stage, a quantidade de
embaçamento ao longo dos eixos x e y aumentará ou diminuirá. Quando você mover o
ponteiro para a esquerda do Stage, a quantidade de embaçamento horizontal diminuirá.
Quando você movê-lo para a direita do Stage, o embaçamento aumentará. Da mesma
forma, quanto maior o ponteiro no Stage, menor será a quantidade de embaçamento ao
longo do eixo y.
3. Selecione Control > Test Movie para testar o documento e exibir os resultados.
Usando o filtro de matriz de cores

A classe ColorMatrixFilter permite aplicar uma matriz de transformação 4 x 5 aos valores alfa
e de cor RGBA (vermelho, verde, azul e alfa) de cada pixel na imagem de entrada a fim de
produzir um resultado com um novo conjunto de valores alfa e de cor RGBA. Esse filtro
permite matiz (cor ou tonalidade distinta), rotação, alterações de saturação (intensidade de
uma matiz específica), luminância (brilho ou intensidade de uma cor) para alfa, além de vários
outros efeitos. Você também pode animar esses filtros para criar efeitos em seus aplicativos.
NO T A
Você pode aplicar o filtro de matriz de cores a bitmaps e instâncias de clipes de filme.
Para obter mais informações sobre o filtro de matriz de cores, consulte %{ColorMatrixFilter
(flash.filters.ColorMatrixFilter)}% em ActionScript 2.0 Language Reference.
Você pode usar o filtro de matriz de cores para modificar o brilho de uma instância, conforme
demonstrado no exemplo a seguir.
Para aumentar o brilho de um clipe de filme:

1. Crie um novo documento do Flash e salve-o como brightness.fla.

var myElements_array:Array = [1, 0, 0, 0, 100,
0, 1, 0, 0, 100,
0, 0, 1, 0, 100,
0, 0, 0, 1, 0];
}
img_mc);
Este código carrega dinamicamente uma imagem JPEG usando uma instância
MovieClipLoader. Depois que a imagem estiver completamente carregada e posicionada
no Stage, o brilho da instância será definido como 100% usando um filtro de matriz de
cores.
Você também pode criar um efeito de brilho animado combinando a classe Tween com a
classe ColorMatrixFilter, conforme é mostrado no procedimento a seguir.
Para animar o nível de brilho de uma instância usando a classe Tween:

1. Crie um novo documento do Flash e salve-o como brightnesstween.fla.
// centralizar a instância de clipe de filme no Stage
target_mc.watch("brightness", brightnessWatcher, target_mc);
// animar o clipe de filme target_mc entre o brilho -100 e +100
var t:Object = new Tween(target_mc, "brightness", Elastic.easeOut,
100, -100, 3, true);
t.onMotionFinished = function() {
this.yoyo();
};
};

img_mc);
function brightnessWatcher(prop:String, oldVal:Number, newVal:Number,

target_mc:MovieClip):Number {
var brightness_array:Array = [1, 0, 0, 0, newVal,
0, 1, 0, 0, newVal,
0, 0, 1, 0, newVal,
0, 0, 0, 1, 0];
target_mc.filters = [new ColorMatrixFilter(brightness_array)];
return newVal;
};
A primeira seção de código usa a classe MovieClipLoader para carregar uma imagem JPEG
no Stage. Depois que a imagem estiver completamente carregada, reposicione-a no centro
do Stage. Em seguida, utilize a classe Tween para animar o nível de brilho da imagem. Para
animar o brilho, use o método Object.watch(), que registra um manipulador de eventos
iniciado quando uma propriedade especificada de um objeto do ActionScript é alterado.
Sempre que algum ActionScript tentar definir a propriedade de brilho personalizada da
instância target_mc, você chamará a função brightnessWatcher. A função
brightnessWatcher personalizada cria um novo array, que utiliza um filtro de matriz de
cores a fim de definir o brilho da imagem de destino para uma quantidade especificada.
Depois que a imagem estiver carregada e posicionada no Stage, seu brilho animará entre -
100 e 100. Após a conclusão da interpolação de brilho, a animação será invertida com o
método Tween.yoyo(), que resultará em uma animação constante da interpolação.
Usando o filtro de torção

A classe ConvolutionFilter aplica um efeito de filtro de convolução de matriz. Uma
convolução combina pixels em uma imagem de origem especificada com pixels vizinhos a fim
de produzir uma imagem. O uso do filtro de convolução permite que você obtenha uma
ampla variedade de operações de imagem, que inclui efeitos de embaçamento, detecção de
borda, nitidez, relevo e chanfro.
N OT A
Você pode aplicar esse filtro a bitmaps e instâncias de clipe de filme.

Uma convolução de matriz baseia-se em uma matriz n x m, que descreve como um
determinado valor de pixel na imagem de entrada é combinado com seus valores de pixels
vizinhos para produzir um valor de pixel resultante. Cada pixel resultante é determinado
aplicando a matriz ao pixel de origem correspondente e a seus pixels vizinhos.
Esse filtro somente está disponível quando você utiliza o ActionScript. Para obter mais
informações sobre esse filtro, consulte %{ConvolutionFilter
(flash.filters.ConvolutionFilter)}% em ActionScript 2.0 Language Reference.
O procedimento a seguir aplica o filtro de convolução a uma imagem JPEG carregada
dinamicamente.
Para usar o filtro de convolução e modificar a cor de uma imagem:

1. Crie um novo documento do Flash e salve-o como convolution.fla.
import flash.filters.ConvolutionFilter;
this.createEmptyMovieClip("shape_mc", 1);
shape_mc.createEmptyMovieClip("holder_mc", 1);
var imageLoader:MovieClipLoader = new MovieClipLoader();
imageLoader.loadClip("http://www.helpexamples.com/flash/images/
image1.jpg", shape_mc.holder_mc);
var matrixArr:Array = [1, 4, 6, 4, 1, 4, 16, 24, 16, 4, 16, 6, 24, 36,
24, 6, 4, 16, 24, 16, 4, 1, 4, 6, 4, 1];
var convolution:ConvolutionFilter = new ConvolutionFilter(5, 5,
matrixArr);
shape_mc.filters = [convolution];

convolution.divisor = (_xmouse / Stage.width) * 271;
convolution.bias = (_ymouse / Stage.height) * 100;
shape_mc.filters = [convolution];
};
O código anterior é dividido em três seções. A primeira seção importa duas classes:
ConvolutionFilter e BitmapData. A segunda seção cria um clipe de filme aninhado e usa
um objeto de clipe de filme carregador para carregar uma imagem no clipe de filme
aninhado. Um objeto de filtro de convolução é criado e aplicado ao clipe de filme
shape_mc. A seção final do código define um objeto ouvinte de mouse que modifica as
propriedades divisor e bias do filtro de convolução com base na posição atual do ponteiro
do mouse e reaplica o filtro ao clipe de filme shape_mc.

Flash.
Mover o ponteiro do mouse ao longo do eixo x do Stage modifica o divisor do filtro,
enquanto movê-lo ao longo do eixo y do Stage modifica o seu bias.
Usando o filtro de mapa de deslocamento

A classe DisplacementMapFilter usa os valores de pixel do objeto BitmapData especificado
(chamado imagem de mapa de deslocamento) para deslocar uma instância no Stage, por
exemplo, uma instância de clipe de filme ou uma instância de dados de bitmap. Você pode
usar esse filtro para obter um efeito distorcido ou mosqueado em uma instância especificada.
Esse filtro somente está disponível quando você utiliza o ActionScript. Para obter mais
informações sobre esse filtro, consulte %{DisplacementMapFilter
(flash.filters.DisplacementMapFilter)}% em ActionScript 2.0 Language Reference.
O procedimento a seguir carrega uma imagem JPEG e aplica a ele um filtro de mapa de
deslocamento, que faz com que a imagem tenha uma aparência distorcida. Sempre que o
usuário move o mouse, o mapa de deslocamento é regenerado.
Para distorcer uma imagem com o filtro de mapa de deslocamento:

1. Crie um novo documento do Flash e salve-o como displacement.fla.
import flash.filters.DisplacementMapFilter;
import flash.geom.Point;
var perlinBmp:BitmapData;
var displacementMap:DisplacementMapFilter;
perlinBmp = new BitmapData(target_mc._width, target_mc._height);
perlinBmp.perlinNoise(target_mc._width, target_mc._height, 10,
Math.round(Math.random() * 100000), false, true, 1, false);
displacementMap = new DisplacementMapFilter(perlinBmp, new Point(0,
0), 1, 1, 100, 100, "color");
shapeClip.filters = [displacementMap];
};
shapeClip.createEmptyMovieClip("holderClip", 1);
imageLoader.addListener(mclListener);

image1.jpg", shapeClip.holderClip);

perlinBmp.perlinNoise(shapeClip._width, shapeClip._height, 10,
};
Este código carrega uma imagem JPEG inserindo-a no Stage. Depois que a imagem estiver
completamente carregada, o código criará uma instância BitmapData e usará o método
perlinNoise() para preenchê-la com pixels colocados aleatoriamente. A instância
BitmapData passa para o filtro de mapa de deslocamento, que é aplicado à imagem
fazendo com que ela tenha uma aparência distorcida.
Mova o ponteiro do mouse no Stage para recriar um mapa de deslocamento, chamando o

método perlinNoise(), que altera a aparência da imagem JPEG.
Manipulando efeitos de filtro com código

O Flash Basic 8 e o Flash Professional 8 permitem adicionar dinamicamente diversos filtros a
clipes de filme, campos de texto e botões no Stage, em vez de adicionar filtros no ambiente de
criação do Flash Professional 8 (através da guia Filters no inspetor Properties). Ao adicionar e
manipular filtros durante a reprodução, você pode incluir sombreamentos, embaçamentos e
brilhos realistas que reajam aos movimentos do mouse ou aos eventos do usuário.
Manipulando efeitos de filtro com código 557

Para obter exemplos de manipulação de filtros com código, consulte os seguintes tópicos:
■ “Ajustando propriedades de filtro” na página 558
■ “Animando um filtro com o ActionScript” na página 559
■ “Usando o método clone()” na página 560
Ajustando propriedades de filtro

O array de filtros aplicado a um objeto pode ser acessado através de chamadas do ActionScript
padrão com a propriedade MovieClip.filters. Esse processo retorna um array contendo
cada objeto de filtro associado no momento ao MovieClip. Cada filtro possui um conjunto de
propriedades exclusivo a ele. Os filtros podem ser acessados e modificados da mesma forma
que um objeto de array, embora uma duplicata do objeto filters seja retornada, em vez de uma
referência, se você desejar obter e definir os filtros com a propriedade filters.
Definir a propriedade filters duplica a array de filtros passada e não a armazena como uma
referência. Quando a propriedade filters é obtida, ela retorna uma nova cópia do array. Uma
implicação negativa dessa abordagem é que o código a seguir não funciona:
// não funciona
my_mc.filters[0].blurX = 20;
Como o trecho de código anterior retorna uma cópia do array de filtros, o código modifica a
cópia, em vez do array original. Para modificar a propriedade blurX, você precisaria usar o
seguinte código ActionScript:
// funciona
var filterArray:Array = my_mc.filters;
filterArray[0].blurX = 20;
my_mc.filters = filterArray;
O procedimento a seguir embaça uma imagem com base na posição atual do ponteiro do
mouse no Stage. Sempre que o ponteiro do mouse movimenta-se horizontalmente ou
verticalmente, as propriedades blurX e blurY do filtro de embaçamento são modificadas
adequadamente.
Para ajustar as propriedades de filtro de um clipe de filme:

1. Crie um novo documento do Flash e salve-o como adjustfilter.fla.
this.createEmptyMovieClip("holder_mc", 10);
holder_mc.createEmptyMovieClip("img_mc", 20);
holder_mc.img_mc.loadMovie("http://www.helpexamples.com/flash/images/
image2.jpg");

holder_mc.filters = [new BlurFilter(10, 10, 2)];
holder_mc._x = 75;
holder_mc._y = 75;
holder_mc.onMouseMove = function() {
var tempFilter:BlurFilter = holder_mc.filters[0];
tempFilter.blurX = Math.floor((_xmouse / Stage.width) * 255);
tempFilter.blurY = Math.floor((_ymouse / Stage.height) * 255);
holder_mc.filters = [tempFilter];
};
O código anterior é dividido em três seções. A primeira seção importa a classe

flash.filters.BlurFilter para que você não precise usar o nome de classe totalmente
qualificado quando se referir à classe BlurFilter. A segunda seção de código cria alguns
clipes de filme e carrega uma imagem em um dos clipes aninhados. A terceira seção de
código responde ao movimento do mouse no Stage e ajusta o embaçamento
adequadamente.
Flash.
Mover o ponteiro do mouse ao longo do eixo x modifica a propriedade blurX do filtro de
embaçamento. Mover o ponteiro do mouse ao longo do eixo y modifica a propriedade
blurY do filtro de embaçamento. Quanto mais próximo estiver o ponteiro do mouse do
canto superior esquerdo do Stage, menos embaçamento será aplicado ao clipe de filme.
Animando um filtro com o ActionScript

Você pode usar o ActionScript, como a classe Tween, para animar filtros durante a execução, o
que permitirá aplicar efeitos interessantes e animados aos seus aplicativos Flash.
No exemplo a seguir, você verifica como combinar BlurFilter com a classe Tween para criar
um embaçamento animado que modifica o filtro de embaçamento em um valor entre 0 e 10
durante a execução.
Para animar embaçamentos com a classe Tween:

1. Crie um novo documento do Flash e salve-o como animatedfilter.fla.
this.createEmptyMovieClip("holder_mc", 10);
holder_mc.createEmptyMovieClip("img_mc", 20);
Manipulando efeitos de filtro com código 559

var myTween:Tween = new Tween(target_mc, "blur", Strong.easeInOut, 0,
20, 3, true);
myTween.onMotionChanged = function() {
target_mc._parent.filters = [new BlurFilter(target_mc.blur,
target_mc.blur, 1)];
};
myTween.onMotionFinished = function() {
myTween.yoyo();
}
};
holder_mc.img_mc);
O código anterior é dividido em três seções. A primeira seção importa as classes e os

pacotes necessários. A segunda seção cria um clipe de filme aninhado que é usado para
carregar uma imagem e aplicar filtros ao clipe de filme holder. A seção final do código cria
uma nova instância MovieClipLoader e um ouvinte para o clipe de filme carregador. O
objeto ouvinte define uma única função de manipulador de eventos, onLoadInit, que é
iniciada assim que a imagem é carregada com êxito e disponibilizada no Stage. Primeiro, a
imagem é reposicionada no centro do Stage; em seguida, um novo objeto Tween é criado e
anima o clipe de filme, aplicando um filtro de embaçamento entre 0 e 10.
Flash.
Usando o método clone()

O método clone() em cada classe de filtro retorna uma nova instância de filtro com todas as
mesmas propriedades da instância de filtro original. Ao trabalhar com filtros, convém criar
uma cópia de um filtro e, para isso, você precisará duplicar o filtro usando o método clone().
Se você não usar esse método para duplicar um filtro, o Flash criará uma referência somente ao
filtro original. Se ele criar uma referência ao filtro original, qualquer alteração feita no filtro
duplicado também modificará o objeto de filtro original.
O procedimento a seguir cria uma nova instância DropShadowFilter (greenDropShadow),
chama o método clone() para duplicar o filtro de sombreamento verde e salva um novo filtro
como redDropShadow. O filtro clonado define uma nova cor de sombreamento e ambos os
filtros são aplicados à instância de clipe de filme flower_mc localizada no Stage.

Para usar o método clone:
1. Crie um novo documento do Flash e atribua o nome clone.fla a ele.
3. Selecione a instância de clipe de filme e digite flower_mc na caixa de texto Instance Name
do inspetor Properties.
var greenDropShadow:DropShadowFilter = new DropShadowFilter();
greenDropShadow.color = 0x00FF00; // verde
var redDropShadow:DropShadowFilter = greenDropShadow.clone();
redDropShadow.color = 0xFF0000; // vermelho
flower_mc.filters = [greenDropShadow, redDropShadow];
O código anterior cria uma nova instância do filtro de sombreamento e atribui o nome
greenDropShadow a ele. O objeto de sombreamento verde é duplicado com o método
DropShadowFilter.clone() e cria um novo objeto de filtro denominado
redDropShadow. Os filtros de sombreamento verde e vermelho são aplicados à instância de
clipe de filme flower_mc no Stage. Se você não tiver chamado o método clone(), os dois
sombreamentos serão exibidos em vermelho. O motivo dessa aparência é que a
configuração da propriedade redDropShadow.color altera os objetos de sombreamento
vermelho e verde, pois o sombreamento vermelho contém uma referência ao
sombreamento verde.
Flash.
O filtro é duplicado e clonado, e os dois filtros são aplicados à instância flower_mc.
Para obter mais informações sobre o método clone(), consulte %{clone (método
DropShadowFilter.clone)}% em ActionScript 2.0 Language Reference. Para obter informações
relacionadas, consulte também o método clone() de qualquer classe de filtro.
Criando bitmaps com a classe

BitmapData
A classe BitmapData permite criar imagens de bitmap opacas ou transparentes, dimensionadas
de forma arbitrária e manipulá-las de várias maneiras durante a execução. Ao manipular uma
instância BitmapData diretamente com o ActionScript, você poderá criar imagens bastante
complexas sem precisar redesenhar constantemente o conteúdo a partir de dados vetorias no
Flash Player. Os métodos da classe BitmapData oferecem suporte a vários efeitos não
disponíveis através da guia Filters na área de trabalho do Flash.
Criando bitmaps com a classe BitmapData 561

Um objeto BitmapData contém um array de dados de pixel. Esses dados podem representar
um bitmap totalmente opaco ou um bitmap transparente contendo dados de um canal alfa.
Qualquer um dos tipos de objeto BitmapData é armazenado como um buffer de inteiros de
32 bits. Cada inteiro de 32 bits determina as propriedades de um único pixel no bitmap. Cada
inteiro de 32 bits é uma combinação de quatro valores de canal de 8 bits (de 0 a 255) que
descrevem a transparência alfa e os valores vermelho, verde e azul (RGBA) do pixel.
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, BitmapData.fla, que usa a classe BitmapData para
manipular uma imagem. O arquivo está localizado na pasta Samples do seu disco rígido.
8\Samples and Tutorials\Samples\ActionScript\BitmapData.
and Tutorials/Samples/ActionScript/BitmapData.
O procedimento a seguir carrega dinamicamente uma imagem JPEG no Stage e usa a classe
BitmapData para criar um efeito de ruído, semelhante ao ruído estático que você vê na
televisão. O efeito de ruído é redesenhado com um padrão aleatório a cada 100 milissegundos
(1/10 de segundo). Mover o ponteiro do mouse ao longo dos eixos x e y afeta o volume de
ruído estático desenhado em cada intervalo.
Para criar um efeito de ruído com a classe BitmapData:

1. Crie um novo documento do Flash e salve-o como noise.fla.
this.createTextField("status_txt", 90, 0, 0, 100, 20);
status_txt.selectable = false;
status_txt.background = 0xFFFFFF;
status_txt.autoSize = "left";
function onMouseMove() {
status_txt._x = _xmouse;
status_txt._y = _ymouse-20;
updateAfterEvent();
}
img_mc.loadMovie("http://www.helpexamples.com/flash/images/image1.jpg");
var noiseBmp:BitmapData = new BitmapData(Stage.width, Stage.height,
true);
this.attachBitmap(noiseBmp, 20);
setInterval(updateNoise, 100);
var grayScale:Boolean = true;
function updateNoise():Void {
var low:Number = 30 * _xmouse / Stage.width;

var high:Number = 200 * _ymouse / Stage.height;
status_txt.text = "low:" + Math.round(low) + ", high:" +
Math.round(high);
noiseBmp.noise(Math.round(Math.random() * 100000), low, high, 8,
true);
}
Este código cria um campo de texto com o nome de instância status_txt, que segue o
ponteiro do mouse e exibe os valores atuais dos parâmetros high e low para o método
noise(). A função setInterval() altera o efeito de ruído, que é atualizado a cada 100
milissegundos (1/10 de segundo), chamando continuamente a função updateNoise().
Os parâmetros high e low para o método noise() são determinados calculando a posição
atual do ponteiro no Stage.
Mover o ponteiro do mouse ao longo do eixo x afeta o parâmetrolow, enquanto movê-lo
ao longo do eixo y afeta o parâmetrohigh.
A classe BitmapData permite distorcer uma imagem carregada dinamicamente usando uma
combinação de um efeito do método perlinNoise() com um filtro de mapa de
deslocamento. O procedimento a seguir mostra o seguinte.
Para aplicar um filtro de mapa de deslocamento a uma imagem:

1. Crie um novo documento do Flash e salve-o como displacement.fla.
// Importar classes.
import flash.filters.DisplacementMapFilter;
import flash.geom.Point;
// Criar um clipe e um clipe aninhado.
shapeClip.createEmptyMovieClip("holderClip", 1);
// Carregar JPEG.
image4.jpg", shapeClip.holderClip);
// Criar uma instância BitmapData.
var perlinBmp:BitmapData = new BitmapData(Stage.width, Stage.height);
perlinBmp.perlinNoise(Stage.width, Stage.height, 10,
// Criar e aplicar o filtro de mapa de deslocamento.
var displacementMap:DisplacementMapFilter = new
DisplacementMapFilter(perlinBmp, new Point(0, 0), 1, 1, 100, 100,
"color", 1);
// Criar e aplicar um ouvinte.
Criando bitmaps com a classe BitmapData 563

perlinBmp.perlinNoise(Stage.width, Stage.height, 10,
}
Esse exemplo de código consiste em cinco seções lógicas. A primeira seção importa as
classes necessárias para o exemplo. O segundo bloco de código cria um clipe de filme
aninhado e carrega uma imagem JPEG a partir de um servidor remoto. O terceiro bloco
de código cria uma nova instância BitmapData denominada perlinBmp, cujo tamanho é
igual às dimensões do Stage. A instância perlinBmp contém os resultados de um efeito de
ruído de Perlin e é usada posteriormente como parâmetro para o filtro de mapa de
deslocamento. O quarto bloco de código cria e aplica o efeito de filtro de mapa de
deslocamento à imagem carregada dinamicamente que foi criada anteriormente. O quinto
e último bloco de código cria um ouvinte do mouse que gera novamente o ruído de Perlin
usado pelo filtro de mapa de deslocamento sempre que o usuário movimenta o ponteiro
do mouse.
Flash.
Modos de mistura
Você pode aplicar modos de mistura a objetos de clipe de filme através da área de trabalho do
Flash (Flash Professional 8) ou do ActionScript (Flash Basic 8 e Flash Professional 8). Durante
a execução, vários gráficos são mesclados como uma forma. Por esse motivo, não é possível
aplicar diferentes modos de mistura a diferentes símbolos gráficos.
Para obter mais informações sobre como usar o ActionScript para aplicar modos de mistura,
consulte “Aplicando modos de mistura” na página 565.
Os modos de mistura envolvem a combinação das cores de uma imagem (a imagem base) com
as cores de outra imagem (a imagem de mistura) para produzir uma terceira imagem. Cada
valor de pixel de uma imagem é processado com o valor de pixel correspondente da outra
imagem a fim de produzir um valor de pixel para essa mesma posição no resultado.
A propriedade MovieClip.blendMode oferece suporte aos seguintes modos de mistura:
add Normalmente usado para criar um efeito de dissolução de luminosidade animado entre
duas imagens.
alpha Normalmente usado para aplicar a transparência do primeiro plano no fundo.
darken Normalmente usado para sobrepor um tipo.

difference Normalmente usado para criar cores mais vibrantes.
erase Normalmente usado para remover (apagar) parte do fundo usando o alfa do primeiro
plano.
hardlight Normalmente usado para criar efeitos de sombreado.
invert Usado para inverter o fundo.
layer Usado para forçar a criação de um buffer temporário para a pré-composição de um
clipe de filme específico.
lighten Normalmente usado para sobrepor um tipo.
multiply Normalmente usado para criar efeitos de sombreamento e profundidade.
normal Usado para especificar que os valores de pixel da imagem de mistura substituam os
da imagem base.
overlay Normalmente usado para criar efeitos de sombreado.
screen Normalmente usado para criar realces e reflexos de lentes.
subtract Normalmente usado para criar um efeito de dissolução de escuridão animado entre
duas imagens.
Aplicando modos de mistura

O procedimento a seguir carrega uma imagem dinâmica e permite aplicar diferentes modos de
mistura à imagem selecionando um modo de mistura em uma caixa de combinação no Stage.
Para aplicar diferentes modos de mistura a uma imagem:

1. Crie um novo documento do Flash e salve-o como blendmodes.fla.
2. Arraste uma instância do componente ComboBox para o Stage e atribua o nome
blendMode_cb a ele.
var blendMode_dp:Array = new Array();
blendMode_dp.push({data:"add", label:"add"});
blendMode_dp.push({data:"alpha", label:"alpha"});
blendMode_dp.push({data:"darken", label:"darken"});
blendMode_dp.push({data:"difference", label:"difference"});
blendMode_dp.push({data:"erase", label:"erase"});
blendMode_dp.push({data:"hardlight", label:"hardlight"});
blendMode_dp.push({data:"invert", label:"invert"});
blendMode_dp.push({data:"layer", label:"layer"});
blendMode_dp.push({data:"lighten", label:"lighten"});
blendMode_dp.push({data:"multiply", label:"multiply"});
blendMode_dp.push({data:"normal", label:"normal"});
blendMode_dp.push({data:"overlay", label:"overlay"});
Modos de mistura 565

blendMode_dp.push({data:"screen", label:"screen"});
blendMode_dp.push({data:"subtract", label:"subtract"});
blendMode_cb.dataProvider = blendMode_dp;

var blendModeClip:MovieClip =
target_mc.createEmptyMovieClip("blendModeType_mc", 20);
with (blendModeClip) {
beginFill(0x999999);
moveTo(0, 0);
lineTo(target_mc._width / 2, 0);
lineTo(target_mc._width / 2, target_mc._height);
lineTo(0, target_mc._height);
lineTo(0, 0);
endFill();
}
blendModeClip.blendMode = blendMode_cb.value;
};
img_mc);
function cbListener(eventObj:Object):Void {
img_mc.blendModeType_mc.blendMode = eventObj.target.value;
}
blendMode_cb.addEventListener("change", cbListener);
Este código ActionScript preenche a caixa de combinação com cada tipo de modo de
mistura, para que o usuário possa ver cada efeito na imagem carregada dinamicamente.
Um objeto ouvinte é criado e usado com uma instância MovieClipLoader. O objeto
ouvinte define um único ouvinte de eventos, onLoadInit, que é chamado depois que o
download da imagem tiver sido concluído e ela for inicializada pelo Flash. O ouvinte de
eventos cria um novo clipe de filme denominado blendModeType_mc e usa a API de
desenho para desenhar uma forma retangular sobre a metade esquerda da imagem. Em
seguida, o modo de mistura selecionado no momento para a instância do ComboBox é
aplicado ao clipe de filme blendModeType_mc.
O restante do código configura a instância MovieClipLoader, responsável pelo
carregamento da imagem especificada em um clipe de filme no Stage. Finalmente, um
ouvinte é definido para a instância do ComboBox blendMode_cb, que aplica o modo de
mistura selecionado sempre que um novo item é escolhido na instância do ComboBox.

Sobre a ordem de operação
A lista a seguir relaciona a ordem das operações nas quais arrays de filtros, modos de mistura,
transformações de cores e camadas de máscara são anexados ou executados para uma instância
de clipe de filme:
1. O bitmap do clipe de filme é atualizado a partir do conteúdo vetorial (a propriedade
cacheAsBitmap é definida como true).
2. Se você usar o método setMask() e a máscara tiver um cache de bitmap, o Flash executará
uma mistura alfa entre as duas imagens.
3. Em seguida, são aplicados filtros (embaçamento, sombreamento, brilho etc.)
4. Se você usar a classe ColorTransform, a operação de transformação de classe será executada
e armazenada em cache como um resultado de bitmap.
5. Se você aplicar um modo de mistura, a mistura será executada (através de um renderizador
vetorial).
6. Se você aplicar camadas de máscara externas, elas executarão o mascaramento (através de
um renderizador vetorial).
Desenhando com o ActionScript

Você pode usar métodos da classe MovieClip para desenhar linhas e preenchimentos no Stage.
Isso permite criar ferramentas de desenho para usuários e desenhar formas no arquivo SWF
em resposta a eventos. Estes são os métodos de desenho da classe MovieClip:
■ beginFill()
■ beginGradientFill()
■ clear()
■ curveTo()
■ endFill()
■ lineTo()
■ lineStyle()
■ moveTo()
Você pode usar os métodos de desenho com qualquer clipe de filme. No entanto, se usar os
métodos de desenho com um clipe de filme criado no modo de criação, esses métodos serão
executados antes de o clipe ser desenhado. Ou seja, o conteúdo criado no modo de criação é
desenhado por cima do conteúdo desenhado com os métodos de criação.
É possível usar clipes de filme com métodos de desenho como máscaras, porém, como em
todas as máscaras de clipes de filme, os traços são ignorados.
Desenhando com o ActionScript 567

Para obter mais informações sobre como desenhar com o ActionScript, consulte os seguintes
tópicos:
■ “Usando métodos de desenho para desenhar linhas, curvas e formas” na página 568
■ “Desenhando formas específicas” na página 570
■ “Usando preenchimentos de gradiente complexos” na página 573
■ “Usando estilos de linha” na página 574
■ “Usando métodos de API de desenho e scripts de animação” na página 581
Você pode localizar um arquivo de origem de exemplo, drawingapi.fla, na pasta Samples do
seu disco rígido, que mostra como usar a API de desenho em um aplicativo Flash.
8\Samples and Tutorials\Samples\ActionScript\DrawingAPI.
and Tutorials/Samples/ActionScript/DrawingAPI.
Usando métodos de desenho para desenhar linhas,

curvas e formas
Você pode usar a API de desenho do Flash para criar formas dinamicamente no Stage durante
a execução. Você pode usar essas formas para mascarar um conteúdo dinamicamente, aplicar
filtros a elas ou animá-las no Stage. Você também pode usar a API de desenho para criar
diversas ferramentas de desenho, que permitam aos usuários usar o mouse ou o teclado para
desenhar formas no arquivo SWF.
Para desenhar uma linha:

1. Crie um novo documento do Flash e salve-o como line.fla.
this.createEmptyMovieClip("line_mc", 10);
line_mc.lineStyle(1, 0x000000, 100);
line_mc.moveTo(0, 0);
line_mc.lineTo(200, 100);
line_mc._x = 100;
line_mc._y = 100;
Este código desenha uma linha a partir de 0,0 no Stage até 200,100. Em seguida, as
coordenadas _x e _y da linha são modificadas para reposicionar a linha em 100,100 no
Stage.

Para desenhar uma forma mais complexa, continue chamando o método
MovieClip.lineTo() e desenhe um retângulo, um quadrado ou uma forma oval, conforme
os procedimentos a seguir.
Para desenhar uma curva:

1. Crie um novo documento do Flash e salve-o como curve.fla.
this.createEmptyMovieClip("circle_mc", 1);
with (circle_mc) {
lineStyle(4, 0x000000, 100);
beginFill(0xFF0000);
moveTo(200, 300);
curveTo(300, 300, 300, 200);
curveTo(300, 100, 200, 100);
curveTo(100, 100, 100, 200);
curveTo(100, 300, 200, 300);
endFill();
}
3. Salve o documento do Flash e selecione Control > Test Movie para testá-lo.
Este código usa a API de desenho para criar um círculo no Stage. A forma circular usa
somente quatro chamadas para o método MovieClip.curveTo() e, portanto, pode
apresentar uma aparência um pouco distorcida. Para obter outro exemplo que utilize a API
de desenho para criar um círculo, consulte o procedimento sobre como criar um círculo
em “Desenhando formas específicas” na página 570 no caso de um código que usa oito
chamadas para o método MovieClip.curveTo() a fim de criar um círculo mais realista.
Para desenhar um triângulo:

1. Crie um novo documento do Flash e salve-o como triangle.fla.
this.createEmptyMovieClip("triangle_mc", 1);
Este código utiliza o método MovieClip.createEmptyMovieClip() para criar um clipe

de filme vazio no Stage. O novo clipe de filme é filho de um clipe de filme existente (neste
caos, a timeline principal).
3. Adicione o seguinte ActionScript ao Frame 1 da Timeline, após o código adicionado na
etapa anterior:
with (triangle_mc) {
lineStyle(5, 0xFF00FF, 100);
moveTo(200, 200);
lineTo(300, 300);
lineTo(100, 300);

lineTo(200, 200);
}
Nesse código, o clipe de filme vazio (triangle_mc) chama métodos de desenho. O código
desenha um triângulo com linhas roxas de 5 pixels, sem preenchimento.
Para obter informações detalhadas sobre esses métodos, consulte as respectivas entradas em
%{MovieClip}% em ActionScript 2.0 Language Reference.
Desenhando formas específicas

Esta seção mostra como criar alguns métodos mais flexíveis que possam ser usados para
desenhar formas mais avançadas, como retângulos arredondados e círculos.
Para criar um retângulo:

1. Crie um novo documento do Flash e salve-o como rect.fla.
this.createEmptyMovieClip("rectangle_mc", 10);
rectangle_mc._x = 100;
rectangle_mc._y = 100;
drawRectangle(rectangle_mc, 240, 180, 0x99FF00, 100);
function drawRectangle(target_mc:MovieClip, boxWidth:Number,
boxHeight:Number, fillColor:Number, fillAlpha:Number):Void {
with (target_mc) {
beginFill(fillColor, fillAlpha);
moveTo(0, 0);
lineTo(boxWidth, 0);
lineTo(boxWidth, boxHeight);
lineTo(0, boxHeight);
lineTo(0, 0);
endFill();
}
}

O Flash desenha um retângulo verde simples no Stage e o posiciona em 100,100. Para
alterar as dimensões do retângulo, sua cor de preenchimento ou a transparência, altere
esses valores dentro da chamada para o método drawRectangle(), em vez de modificar o
conteúdo do método MovieClip.beginFill().
Você também pode criar um retângulo com cantos arredondados usando a API de desenho,
conforme o procedimento a seguir.
Para criar um retângulo arredondado:

1. Crie um novo documento do Flash e salve-o como roundrect.fla.
this.createEmptyMovieClip("rectangle_mc", 10);
rectangle_mc._x = 100;
rectangle_mc._y = 100;
drawRoundedRectangle(rectangle_mc, 240, 180, 20, 0x99FF00, 100);
function drawRoundedRectangle(target_mc:MovieClip, boxWidth:Number,
boxHeight:Number, cornerRadius:Number, fillColor:Number,
fillAlpha:Number):Void {
with (target_mc) {
moveTo(cornerRadius, 0);
lineTo(boxWidth - cornerRadius, 0);
curveTo(boxWidth, 0, boxWidth, cornerRadius);
lineTo(boxWidth, cornerRadius);
lineTo(boxWidth, boxHeight - cornerRadius);
curveTo(boxWidth, boxHeight, boxWidth - cornerRadius, boxHeight);
lineTo(boxWidth - cornerRadius, boxHeight);
lineTo(cornerRadius, boxHeight);
curveTo(0, boxHeight, 0, boxHeight - cornerRadius);
lineTo(0, boxHeight - cornerRadius);
lineTo(0, cornerRadius);
curveTo(0, 0, cornerRadius, 0);
lineTo(cornerRadius, 0);
endFill();
}
}
3. Salve o documento do Flash e selecione Control > Test Movie para testar o documento.
Um retângulo verde é exibido no Stage com 240 pixels de largura, 180 pixels de altura e
cantos arredondados de 20-pixels. Você pode criar várias instâncias de retângulos
arredondados criando novos clipes de filme com MovieClip.createEmptyMovieClip()
e chamando sua função drawRoundedRectangle() personalizada.
Você pode criar um círculo perfeito usando a API de desenho, conforme o procedimento a
seguir.

Para criar um círculo:
1. Crie um novo documento do Flash e salve-o como circle2.fla.
this.createEmptyMovieClip("circle_mc", 10);
circle_mc._x = 100;
circle_mc._y = 100;
drawCircle(circle_mc, 100, 0x99FF00, 100);
function drawCircle(target_mc:MovieClip, radius:Number,

fillColor:Number, fillAlpha:Number):Void {
var x:Number = radius;
var y:Number = radius;
with (target_mc) {
moveTo(x + radius, y);
curveTo(radius + x, Math.tan(Math.PI / 8) * radius + y,
Math.sin(Math.PI / 4) * radius + x, Math.sin(Math.PI / 4) * radius +
y);
curveTo(Math.tan(Math.PI / 8) * radius + x, radius + y, x, radius +
y);
curveTo(-Math.tan(Math.PI / 8) * radius + x, radius+ y, -
Math.sin(Math.PI / 4) * radius + x, Math.sin(Math.PI / 4) * radius +
y);
curveTo(-radius + x, Math.tan(Math.PI / 8) * radius + y, -radius +
x, y);
curveTo(-radius + x, -Math.tan(Math.PI / 8) * radius + y, -
Math.sin(Math.PI / 4) * radius + x, -Math.sin(Math.PI / 4) * radius +
y);
curveTo(-Math.tan(Math.PI / 8) * radius + x, -radius + y, x, -radius
+ y);
curveTo(Math.tan(Math.PI / 8) * radius + x, -radius + y,
Math.sin(Math.PI / 4) * radius + x, -Math.sin(Math.PI / 4) * radius +
y);
curveTo(radius + x, -Math.tan(Math.PI / 8) * radius + y, radius + x,
y);
endFill();
}
}
3. Salve o documento do Flash e selecione Control > Test Movie para testar o arquivo SWF.
Este código cria um círculo mais complexo e realista do que o exemplo de círculo anterior. Em
vez de usar apenas quatro chamadas para o método curveTo(), este exemplo usa oito
chamadas para esse método, o que confere uma aparência muito mais arredondada à forma.
Você pode usar a API de desenho para criar um triângulo, conforme o procedimento a seguir.
Para criar um triângulo elaborado:

1. Crie um novo documento do Flash e salve-o como fancytriangle.fla.

this.createEmptyMovieClip("triangle_mc", 10);
triangle_mc._x = 100;
triangle_mc._y = 100;
drawTriangle(triangle_mc, 100, 0x99FF00, 100);
function drawTriangle(target_mc:MovieClip, sideLength:Number,

fillColor:Number, fillAlpha:Number):Void {
var tHeight:Number = sideLength * Math.sqrt(3) / 2;
with (target_mc) {
moveTo(sideLength / 2, 0);
lineTo(sideLength, tHeight);
lineTo(0, tHeight);
lineTo(sideLength / 2, 0);
endFill();
}
}
A API de desenho cria um triângulo eqüilátero no Stage e o preenche com a cor de

preenchimento especificada e a quantidade de alfa (transparência).
Usando preenchimentos de gradiente complexos

A API de desenho do Flash oferece suporte a preenchimentos de gradiente, e também a
preenchimentos sólidos. O procedimento a seguir cria um novo clipe de filme no Stage, usa a
API de desenho para criar um quadrado e, em seguida, preenche o quadrado com um
gradiente radial vermelho e azul.
Para criar um gradiente complexo:

1. Crie um novo documento do Flash e salve-o como radialgradient.fla.
this.createEmptyMovieClip("gradient_mc", 10);
var fillType:String = "radial";
var colors:Array = [0xFF0000, 0x0000FF];
var alphas:Array = [100, 100];

var ratios:Array = [0, 0xFF];
var matrix:Object = {a:200, b:0, c:0, d:0, e:200, f:0, g:200, h:200,
i:1};
var spreadMethod:String = "reflect";
var interpolationMethod:String = "linearRGB";
var focalPointRatio:Number = 0.9;
with (gradient_mc) {
beginGradientFill(fillType, colors, alphas, ratios, matrix,
spreadMethod, interpolationMethod, focalPointRatio);
moveTo(100, 100);
lineTo(100, 300);
lineTo(300, 300);
lineTo(300, 100);
lineTo(100, 100);
endFill();
}
O código ActionScript anterior usa a API de desenho para criar um quadrado no Stage e
chama o método beginGradientFill() para preencher o quadrado com um gradiente
circular vermelho e azul.
3. Salve o documento do Flash e selecione Control > Test Movie para exibir o arquivo do
Flash.
Usando estilos de linha

A API de desenho do Flash permite especificar um estilo de linha usado pelo Flash para
chamadas subseqüentes para MovieClip.lineTo() e MovieClip.curveTo() até que você
chame MovieClip.lineStyle() com diferentes parâmetros, da seguinte maneira:
lineStyle(thickness:Number, rgb:Number, alpha:Number, pixelHinting:Boolean,
noScale:String, capsStyle:String, jointStyle:String, miterLimit:Number)
É possível chamar MovieClip.lineStyle() durante o desenho de um caminho a fim de

especificar estilos diferentes para segmentos de linha distintos em um caminho.
Para obter mais informações sobre como usar o ActionScript para definir estilos de linha,
■ “Definindo estilos de traço e acabamento” na página 574
■ “Definindo parâmetros de estilos de linha” na página 576
Definindo estilos de traço e acabamento

O Flash 8 inclui várias melhorias no desenho de linhas. Novos parâmetros de linha foram
adicionados ao Flash Player 8, como pixelHinting, noScale, capsStyle, jointStyle e
miterLimit.

O procedimento a seguir demonstra a diferença entre os três novos estilos de acabamento no
Flash Player 8: none, round e square.
Para definir estilos de acabamento com o ActionScript:

1. Crie um novo documento do Flash e salve-o como capstyle.fla.
// Configurar o clipe de filme de grade.
this.createEmptyMovieClip("grid_mc", 50);
grid_mc.lineStyle(0, 0x999999, 100);
grid_mc.moveTo(50, 0);
grid_mc.lineTo(50, Stage.height);
grid_mc.moveTo(250, 0);
grid_mc.lineTo(250, Stage.height);
// linha 1 (capsStyle: round)
this.createEmptyMovieClip("line1_mc", 10);
with (line1_mc) {
createTextField("label_txt", 1, 5, 10, 100, 20);
label_txt.text = "round";
lineStyle(20, 0x99FF00, 100, true, "none", "round", "miter", 0.8);
moveTo(0, 0);
lineTo(200, 0);
_x = 50;
_y = 50;
}
// linha 2 (capsStyle: square)
with (line2_mc) {
label_txt.text = "square";
lineStyle(20, 0x99FF00, 100, true, "none", "square", "miter", 0.8);
moveTo(0, 0);
lineTo(200, 0);
_x = 50;
_y = 150;
}
// linha 3 (capsStyle: none)
with (line3_mc) {
label_txt.text = "none";
lineStyle(20, 0x99FF00, 100, true, "none", "none", "miter", 0.8);
moveTo(0, 0);
lineTo(200, 0);
_x = 50;
_y = 250;
}

O código anterior cria dinamicamente quatro clipes de filme e utiliza a API de desenho
para criar uma série de linhas no Stage. O primeiro clipe de filme contém duas linhas
verticais, uma em 50 pixels, e a outra em 250 pixels no eixo x. Os três próximos clipes de
filme desenham cada um uma linha verde no Stage e definem seu capsStyle como round,
square ou none.
Os diferentes estilos de acabamento aparecem no Stage durante a execução.
Definindo parâmetros de estilos de linha

Você pode definir os parâmetros dos estilos de linha para alterar a aparência de seus traços.
Utilize parâmetros para alterar a espessura, a cor, o alfa, a escala e outros atributos do estilo de
linha.
Definindo a espessura da linha

O parâmetro thickness do método MovieClip.lineStyle() permite especificar a espessura
da linha desenhada em pontos como um número. Você pode desenhar uma linha de qualquer
espessura entre 0 e 255 pontos de largura, embora ao definir a espessura como 0, seja criada
uma espessura fina, na qual o traço tem sempre 1 pixel, independentemente de o arquivo SWF
ter sido ampliado ou redimensionado.
O procedimento a seguir demonstra a diferença entre uma linha padrão com espessura de 1
pixel e uma linha com espessura fina.
Para criar um traço fino:

1. Crie um novo documento do Flash e salve-o como hairline.fla.
2. Adicione o seguinte ActionScript ao Frame 1 da sua Timeline:
this.createEmptyMovieClip("drawing_mc", 10);
// criar uma linha vermelha, de espessura fina
drawing_mc.lineStyle(0, 0xFF0000, 100);
drawing_mc.moveTo(0, 0);
drawing_mc.lineTo(200, 0);
// criar uma linha azul com espessura de 1 pixel
drawing_mc.lineStyle(1, 0x0000FF, 100);
drawing_mc._x = 100;
drawing_mc._y = 100;
O código anterior usa a API de desenho para criar duas linhas no Stage. A primeira linha é
vermelha e tem uma espessura igual a 0, indicando uma espessura fina, e a segunda linha é
azul e possui uma espessura de 1 pixel.

Inicialmente, as linhas vermelha e azul têm exatamente a mesma aparência. Se você clicar
com o botão direito do mouse no arquivo SWF e selecionar Zoom In (Mais zoom) no
menu de contexto, a linha vermelha sempre aparecerá como uma linha de 1 pixel;
entretanto, a linha azul ficará maior toda vez que você aumentar o zoom no arquivo SWF.
Definido a cor da linha (rgb)

O segundo parâmetro no método lineStyle(), rgb, permite controlar a cor do segmento de
linha atual como um número. Por padrão, o Flash desenha linhas pretas (#000000), embora
você possa especificar cores diferentes definindo um novo valor de cor hexadecimal com a
sintaxe 0xRRGGBB. Nessa sintaxe, RR é um valor de vermelho (entre 00 e FF), GG é um valor de
verde (00 a FF) e BB é um valor de azul (00 a FF).
Por exemplo, represente uma linha vermelha como 0xFF0000, uma linha verde como
0x00FF00, uma linha azul como 0x0000FF, uma linha roxa como 0xFF00FF (vermelho e azul),
uma linha branca como #FFFFFF, uma linha cinza como #999999 etc.
Definindo o alfa da linha

O terceiro parâmetro no método lineStyle(), alpha, permite controlar o nível de
transparência (alfa) da linha. A transparência é um valor numérico entre 0 e 100, onde 0
representa uma linha completamente transparente, e 100 é uma linha completamente opaca
(visível).
Definindo a referência do pixel de linha (pixelHinting)

A referência de pixel para o parâmetro de traços, pixelHinting, significa que as âncoras de
linhas e curvas são definidas em pixels completos. Os traços são desenhados em pixels
completos para qualquer espessura de traço, o que significa que você nunca verá uma linha
vertical ou horizontal borrada. Defina o parâmetro pixelHinting para um valor booleano
(true ou false).

Definido a escala de linha (noScale)
Defina o parâmetro noScale usando um valor de seqüência de caracteres que permite
especificar um modo de dimensionamento para a linha. Você pode usar um traço não
dimensionável no modo horizontal ou vertical, dimensionar a linha (normal) ou não usar
dimensionamento.
DICA
Convém ativar o dimensionamento para elementos da interface de usuário quando os

usuários aumentarem o zoom, mas não se um clipe de filme for dimensionado apenas
verticalmente ou horizontalmente.
Você pode usar um dos quatro modos diferentes para especificar quando deve ocorrer o
dimensionamento e quando ele não deve ocorrer. Estes são os valores possíveis para a
propriedade noScale:
normal Sempre dimensiona a espessura (padrão).
vertical Não dimensiona a espessura se o objeto for dimensionado verticalmente.
horizontal Não dimensiona a espessura se o objeto for dimensionado horizontalmente.
none Nunca dimensiona a espessura.
Definindo acabamentos de linha (capsStyle) e uniões (jointStyle)

Você pode definir três tipos de estilos de acabamento para o parâmetro capsStyle:
■ round (padrão)
■ square
■ none
O procedimento a seguir demonstra as diferenças entre cada um dos três estilos de

acabamento. Uma representação visual de cada estilo é exibido no Stage quando você testa o
arquivo SWF.
Para definir diferentes estilos de acabamento:

1. Crie um novo documento do Flash e salve-o como capsstyle2.fla.
var lineLength:Number = 100;
// round
this.createEmptyMovieClip("round_mc", 10);
round_mc.lineStyle(20, 0xFF0000, 100, true, "none", "round");
round_mc.moveTo(0, 0);
round_mc.lineTo(lineLength, 0);
round_mc.lineStyle(0, 0x000000);
round_mc.moveTo(0, 0);
round_mc.lineTo(lineLength, 0);
round_mc._x = 50;

round_mc._y = 50;
var lbl:TextField = round_mc.createTextField("label_txt", 10, 0, 10,
lineLength, 20);
lbl.text = "round";
// square
this.createEmptyMovieClip("square_mc", 20);
square_mc.lineStyle(20, 0xFF0000, 100, true, "none", "square");
square_mc.lineTo(lineLength, 0);
square_mc.lineStyle(0, 0x000000);
square_mc.lineTo(lineLength, 0);
square_mc._x = 200;
square_mc._y = 50;
var lbl:TextField = square_mc.createTextField("label_txt", 10, 0, 10,
lineLength, 20);
lbl.text = "square";
// none
this.createEmptyMovieClip("none_mc", 30);
none_mc.lineStyle(20, 0xFF0000, 100, true, "none", "none");
none_mc.moveTo(0, 0);
none_mc.lineTo(lineLength, 0);
none_mc.lineStyle(0, 0x000000);
none_mc.moveTo(0, 0);
none_mc.lineTo(lineLength, 0);
none_mc._x = 350;
none_mc._y = 50;
var lbl:TextField = none_mc.createTextField("label_txt", 10, 0, 10,
lineLength, 20);
lbl.text = "none";
O código anterior usa a API de desenho para criar três linhas, cada uma com um valor
diferente para capsStyle.
Flash.
Você pode definir os três tipos de estilos de união a seguir para o parâmetro jointStyle:
■ round (padrão)
■ miter
■ bevel
O exemplo a seguir demonstra as diferenças entre cada um desses três estilos.
Para definir diferentes estilos de união:

1. Crie um novo documento do Flash e salve-o como jointstyles.fla.

// ponta
this.createEmptyMovieClip("miter_mc", 10);
miter_mc.lineStyle(25, 0xFF0000, 100, true, "none", "none", "miter",
25);
miter_mc.moveTo(0, lineLength);
miter_mc.lineTo(lineLength / 2, 0);
miter_mc.lineTo(lineLength, lineLength);
miter_mc.lineTo(0, lineLength);
miter_mc._x = 50;
miter_mc._y = 50;
var lbl:TextField = miter_mc.createTextField("label_txt", 10, 0,
lineLength + 20, lineLength, 20);
lbl.autoSize = "center";
lbl.text = "miter";
// redondo
this.createEmptyMovieClip("round_mc", 20);
round_mc.lineStyle(25, 0xFF0000, 100, true, "none", "none", "round");
round_mc.moveTo(0, lineLength);
round_mc.lineTo(lineLength / 2, 0);
round_mc.lineTo(lineLength, lineLength);
round_mc.lineTo(0, lineLength);
round_mc._x = 200;
round_mc._y = 50;
var lbl:TextField = round_mc.createTextField("label_txt", 10, 0,
lbl.text = "round";
// chanfro
this.createEmptyMovieClip("bevel_mc", 30);
bevel_mc.lineStyle(25, 0xFF0000, 100, true, "none", "none", "bevel");
bevel_mc.moveTo(0, lineLength);
bevel_mc.lineTo(lineLength / 2, 0);
bevel_mc.lineTo(lineLength, lineLength);
bevel_mc.lineTo(0, lineLength);
bevel_mc._x = 350;
bevel_mc._y = 50;
var lbl:TextField = bevel_mc.createTextField("label_txt", 10, 0,
lbl.text = "bevel";
O Flash usa a API de desenho para criar três triângulos no Stage. Cada triângulo possui
um valor diferente para o seu estilo de união.
3. Salve o documento do Flash e selecione Control > Test Movie para testar o documento.

Definindo a ponta da linha (miterLimit)
A propriedade miterLimit é um valor numérico que indica o limite de corte de uma junta
em ângulo (consulte “Definindo acabamentos de linha (capsStyle) e uniões (jointStyle)”
na página 578). O valor de miterLimit é um multiplicador geral de um traço. Por exemplo,
com base em um valor de 2,5 miterLimit é cortado 2,5 vezes em relação ao tamanho do
traço. Os valores válidos variam de 0 a 255 (se um valor para miterLimit for undefined, o
valor padrão será 3). A propriedade miterLimit somente será usada se jointStyle for
definido como miter.
Usando métodos de API de desenho e scripts de

animação
Você pode combinar a API de desenho com as classes Tween e TransitionManager para criar
alguns resultados animados excelentes e, para isso, só precisa escrever uma pequena
quantidade de ActionScript.
O procedimento a seguir carrega uma imagem JPEG e a mascara dinamicamente para revelá-
la lentamente após o seu carregamento, interpolando sua máscara.
Para animar máscaras dinâmicas:

1. Crie um novo documento do Flash e salve-o como dynmask.fla.
target_mc._visible = false;
// Centralizar a imagem no Stage
var maskClip:MovieClip = target_mc.createEmptyMovieClip("mask_mc",
20);
with (maskClip) {
// Desenhar uma máscara do mesmo tamanho da imagem carregada.
beginFill(0xFF00FF, 100);
moveTo(0, 0);
lineTo(target_mc._width, 0);
lineTo(target_mc._width, target_mc._height);
lineTo(0, target_mc._height);
lineTo(0, 0);
endFill();
}
target_mc.setMask(maskClip);
target_mc._visible = true;

var mask_tween:Object = new Tween(maskClip, "_yscale", Strong.easeOut,
0, 100, 2, true);
};
img_mc);
Este exemplo de código importa a classe Tween e cada uma das classes existentes no pacote
de atenuação. Em seguida, ele cria um objeto que funciona como ouvinte de uma
instância MovieClipLoader, criada em uma seção posterior do código. O objeto ouvinte
define um único ouvinte de eventos, onLoadInit, que centraliza a imagem JPEG
carregada dinamicamente no Stage. Depois que o código reposiciona a imagem, uma nova
instância de clipe de filme é criada no clipe de filme target_mc (que contém a imagem
JPEG carregada dinamicamente). Nesse novo clipe de filme, o código da API de desenho
cria um retângulo com as mesmas dimensões da imagem JPEG. O novo clipe de filme
mascara a imagem JPEG chamando o método MovieClip.setMask(). Depois que a
máscara estiver desenhada e configurada, ela usará a classe Tween para animar, o que
revelará lentamente a imagem.
N OT A
Para animar _alpha no exemplo anterior em vez de _yscale, interpole target_mc

diretamente, em vez do clipe de filme de máscara.


Noções básicas sobre dimensionamento
e guias de trecho
Você pode usar o dimensionamento em 9 trechos (Scale-9) para especificar o
dimensionamento em estilo de componentes para clipes de filme. Isso permite a criação de
símbolos de clipe de filme que são dimensionados adequadamente para serem utilizados como
componentes de interface do usuário, ao contrário do tipo de dimensionamento normalmente
aplicado a gráficos e elementos de design.
Noções básicas sobre o funcionamento do

dimensionamento em 9 trechos
A maneira mais fácil de explicar o funcionamento do dimensionamento em 9 trechos é ver um
exemplo disso no Flash.
Para compreender o dimensionamento no Flash:

1. Crie um novo documento do Flash e salve-o como dynmask.fla.
2. Arraste uma cópia do componente Button, a partir do painel Components (Componentes),
(Window (Janela) > Components), para o Stage.
3. Aumente o nível de zoom do Stage para 400% usando a ferramenta Zoom.
Por padrão, a instância do componente Button possui 100 pixels de largura por 22 pixels
de altura.
Noções básicas sobre dimensionamento e guias de trecho 583

4. Redimensione a instância do componente Button para 200 pixels de largura por 44 pixels
de altura usando o inspetor Properties.
Você perceberá que, apesar do componente redimensionado, a borda e o rótulo de texto de

Button não aparecem distorcidos. O rótulo do botão permaneceu centralizado e manteve
o seu tamanho de fonte. Embora os componentes da versão 2 da Arquitetura de
Componentes Macromedia não utilizem o dimensionamento em 9 trechos, os
componentes usam dimensionamento na arquitetura de componentes da versão 2 para
que os contornos não mudem de tamanho (conforme mostrado na figura a seguir).
Imagine que a instância de botão seja dividida em 9 partes separadas, ou em uma grade de
3 X 3, assim como em um teclado numérico no telefone ou em um teclado de
computador. Quando você redimensionar a instância de botão horizontalmente, somente
os três segmentos verticais no centro (números 2, 5 e 8 em um teclado numérico) serão
esticados, de modo que o conteúdo não pareça distorcido. Se você redimensionasse a
instância de botão verticalmente, somente os três segmentos horizontais no centro
(números 4, 5 e 6 em um teclado numérico) seriam redimensionados. Os quatro cantos da
grade de dimensionamento não são dimensionados, o que permite que os componentes
aumentem sem parecerem esticados (consulte as imagens a seguir).
DICA
Os traços são criados a partir das bordas após a transformação do

dimensionamento em 9 trechos e, portanto, não deformam nem perdem nenhum
detalhe.

No ambiente do Flash, é possível ativar as guias de trecho para o dimensionamento em 9
trechos na caixa de diálogo Convert to Symbol (Converter em símbolo) ou Symbol Properties
(Propriedades do símbolo). A caixa de seleção Enable guides for 9-slice scaling (Ativar guias
para dimensionamento em 9 trechos) somente estará disponível se você estiver publicando
para o Flash Player 8 e o comportamento for definido como movie clip. As guias do
dimensionamento em 9 trechos não estão disponíveis para as versões anteriores do Flash ou se
você estiver criando um botão ou um símbolo gráfico. Para ativar o dimensionamento em 9
trechos no ActionScript, defina a propriedade scale9Grid em uma instância de clipe de
filme.
Independentemente de ter criado as guias de trecho através da interface de usuário ou do
ActionScript, você poderá rastrear a coordenada x, a coordenada y, a largura e a altura,
rastreando a propriedade scale9Grid do clipe de filme.
trace(my_mc.scale9Grid); // (x=20, y=20, w=120, h=120)
Este trecho de código rastreia o valor do objeto Rectangle usado pela propriedade
scale9Grid. O retângulo possui um coordenada x e uma coordenada y de 20 pixels, largura
de 120 pixels e altura de 120 pixels.
Trabalhando com dimensionamento de 9 trechos no

ActionScript
No exemplo a seguir, você utilizará as ferramentas de desenho para criar um quadrado de 300
X 300 pixels que é redimensionado usando o dimensionamento em 9 trechos. O quadrado é
dividido em nove quadrados menores, cada um com aproximadamente 100 pixels de largura
X 100 pixels de altura. Quando você redimensionar o quadrado, cada segmento que não for
canto expandirá para corresponder à largura e à altura especificada.
Para usar o dimensionamento em 9 trechos no ActionScript:

1. Crie um novo documento do Flash e salve-o como ninescale.fla.
2. Arraste um componente Button para a biblioteca do documento atual.
3. Selecione a ferramenta Rectangle (Retângulo) e desenhe um quadrado vermelho (300 X
300 pixels) com um traço preto de 15 pixels no Stage.
4. Selecione a ferramenta Oval e desenhe um círculo roxo (50 X 50 pixels) com um traço preto
de 2 pixels no Stage.

5. Selecione o círculo roxo e arraste-o para o canto superior direito do quadrado vermelho
criado anteriormente.
6. Selecione a ferramenta Oval, desenhe um novo círculo de aproximadamente 200 X 200
pixels e posicione-o fora do Stage.
7. Selecione o novo círculo no Stage e arraste-o, de modo que seu ponto central fique no canto
inferior esquerdo do quadrado.
8. Clique fora da instância de círculo para cancelar a seleção da forma.
9. Clique duas vezes no círculo novamente para selecioná-lo e pressione backspace para excluir
a forma e remover uma parte circular do quadrado.
10. Selecione todo o quadrado vermelho e o círculo roxo interno com o mouse.
11. Pressione F8 para converter a forma em um símbolo de clipe de filme.
12. Atribua o nome de instância my_mc ao clipe de filme no Stage.
13. Adicione o seguinte ActionScript ao Frame 1 da Timeline principal:
import flash.geom.Rectangle;
var grid:Rectangle = new Rectangle(100, 100, 100, 100);
var small_button:Button = this.createClassObject(Button, "small_button",

10, {label:"Small"});
small_button.move(10, 10);
small_button.addEventListener("click", smallHandler);
function smallHandler(eventObj:Object):Void {
my_mc._width = 100;
my_mc._height = 100;
}
var large_button:Button = this.createClassObject(Button, "large_button",

20, {label:"Large"});
large_button.move(120, 10);
large_button.addEventListener("click", largeHandler);
function largeHandler(eventObj:Object):Void {
my_mc._width = 450;
my_mc._height = 300;
}
var toggle_button:Button = this.createClassObject(Button,

"toggle_button", 30, {label:"scale9Grid=OFF", toggle:true,
selected:false});
toggle_button.move(420, 10);
toggle_button.setSize(120, 22);
toggle_button.addEventListener("click", toggleListener);
function toggleListener(eventObj:Object):Void {
if (eventObj.target.selected) {

eventObj.target.label = "scale9Grid=ON";
my_mc.scale9Grid = grid;
} else {
eventObj.target.label = "scale9Grid=OFF";
my_mc.scale9Grid = undefined;
}
}
O código anterior é dividido em cinco seções. A primeira seção de código importa duas
classes: mx.controls.Button (a classe do componente Button) e flash.geom.Rectangle. A
segunda seção de código cria uma nova instância da classe Rectangle e especifica as
coordenadas x e y de 100 pixels, além de uma largura e altura de 100 pixels. Essa instância
de retângulo é usada para configurar a grade de dimensionamento em 9 trechos para uma
forma de clipe de filme criada posteriormente.
Em seguida, crie uma nova instância do componente Button e atribua o nome de instância
small_button a ele. Sempre que você clicar nesse botão, o clipe de filme criado
anteriormente será redimensionado para 100 pixels de largura X 100 pixels de altura. A
quarta seção de código cria dinamicamente uma nova instância da classe Button
denominada large_button, que, quando clicada, redimensiona o clipe de filme de
destino para 450 pixels de largura X 300 pixels de altura. A seção final do código cria uma
nova instância da classe Button, que pode ser ativada e desativada pelo usuário. Quando o
botão está no estado ativado, a grade em 9 trechos é aplicada. Se o botão estiver no estado
desativado, a grade em 9 trechos será desabilitada.
14. Salveo documento do Flash e selecione Control (Controlar) > Test Movie (Testar filme)
Este exemplo de código adiciona e posiciona três instâncias do componente Button no
Stage e cria ouvintes de eventos para cada botão. Se clicar no botão Large (Grande) com a
grade em 9 trechos desativada, você perceberá que a imagem fica distorcida e parece
esticada. Ative a grade clicando no botão de alternância e clique novamente no botão
Large. Com a grade em 9 trechos ativada, o círculo localizado no canto superior esquerdo
não deverá mais apresentar uma aparência distorcida.

CAPÍTULO 14
Criando interação com o

ActionScript
14
Em animações simples, o Macromedia Flash Player reproduz as cenas e os quadros de um
arquivo SWF em seqüência. Em um arquivo SWF interativo, os espectadores usam o teclado e
o mouse para percorrer um arquivo SWF, mover objetos, inserir informações em formulários e
executar muitas outras operações interativas.
Use o ActionScript para criar scripts que informem ao Flash Player qual ação executar na
ocorrência de um evento. Os eventos que ativam um script ocorrem quando a reprodução
atinge um quadro, quando um clipe de filme é carregado ou descarregado, ou quando o
usuário clica em um botão ou pressiona uma tecla.
Um script pode consistir em um único comando, como instruir um arquivo SWF a
interromper a reprodução, ou uma série de comandos e instruções, como avaliar em primeiro
lugar uma condição e depois executar uma ação. Muitos comandos do ActionScript são
simples e permitem criar controles básicos para um arquivo SWF. Outras ações exigem alguma
familiaridade com linguagens de programação e são planejadas para um desenvolvimento
avançado.
Para obter mais informações sobre como criar interação com o ActionScript, consulte os
seguintes tópicos:
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
589
Sobre eventos e interação
Sempre que um usuário clica no mouse ou pressiona uma tecla, essa ação gerado um evento.
Esses tipos de eventos normalmente são chamados eventos do usuário, pois são gerados em
resposta a alguma ação executada pelo usuário. Você pode escrever ActionScript para
responder a esses eventos ou manipulá-los. Por exemplo, quando um usuário clica em um
botão, você pode enviar a reprodução para outro quadro do arquivo SWF ou carregar uma
nova página da Web no navegador.
Em um arquivo SWF, botões, clipes de filme e campos de texto geram eventos aos quais você
pode responder. O ActionScript fornece três formas de manipular eventos: métodos
manipuladores de eventos, ouvintes de eventos e manipuladores on() e onClipEvent(). Para
obter informações sobre eventos e como manipulá-los, consulte Capítulo 10, “Manipulando
eventos.”.
Controlando a reprodução de arquivos

SWF
As funções do ActionScript a seguir permitem controlar a reprodução na timeline (linha de
tempo) e carregar uma nova página da Web em uma janela de navegador:
■ As funções gotoAndPlay() e gotoAndStop() enviam a reprodução para um quadro ou
cena. Essas são funções globais que podem ser chamadas de qualquer script. Use também
os métodos MovieClip.gotoAndPlay() e MovieClip.gotoAndStop() para navegar pela
timeline de um objeto de clipe de filme específico. Consulte “Indo para um quadro ou
uma cena” na página 591.
■ As ações play() e stop() reproduzem e interrompem arquivos SWF. Consulte
“Reproduzindo e interrompendo clipes de filme” na página 591.
■ A ação getURL() vai para outro URL. Consulte “Indo para outro URL” na página 592.
■ “Indo para um quadro ou uma cena” na página 591
■ “Reproduzindo e interrompendo clipes de filme” na página 591
■ “Indo para outro URL” na página 592
590 Criando interação com o ActionScript

Indo para um quadro ou uma cena
Para ir para uma cena ou um quadro específico no arquivo SWF, use as funções globais
gotoAndPlay() e gotoAndStop() ou os métodos MovieClip.gotoAndPlay() e
MovieClip.gotoAndStop() equivalentes da classe MovieClip. Cada função ou método
permite especificar um quadro para o qual ir na cena atual. Se o documento contiver várias
cenas, você poderá especificar uma cena e um quadro para os quais deseja ir.
O exemplo a seguir usa a função global gotoAndPlay() em um manipulador de eventos
onRelease de um objeto de botão para enviar a reprodução da timeline que contém o botão
para o Frame 10 (Quadro 10):
jump_btn.onRelease = function () {
gotoAndPlay(10);
};
No próximo exemplo, o método MovieClip.gotoAndStop() envia a timeline de uma

instância de clipe de filme chamada categories_mc para o Frame 10 e pára. Ao usar os
métodos MovieClip gotoAndPlay() e gotoAndStop(), especifique uma instância para a
aplicação do método.
jump_btn.onPress = function () {
categories_mc.gotoAndStop(10);
};
No exemplo final, a função global gotoAndStop() é usada para mover a reprodução para o
Frame 1 (Quadro 1) de Scene 2 (Cena 2). Se nenhuma cena for especificada, a reprodução
seguirá para o quadro definido na cena atual. Somente é possível usar o parâmetro scene na
timeline raiz, e não nas timelines de clipes de filme ou de outros objetos no documento.
nextScene_mc.onRelease = function() {
gotoAndStop("Scene 2", 1);
}
Reproduzindo e interrompendo clipes de filme

A menos que instruído de outra forma, depois que um arquivo SWF é iniciado, ele é
reproduzido por cada quadro da timeline. Para interromper ou iniciar um arquivo SWF, use as
funções globais play() e stop() ou os métodos MovieClip equivalentes. Por exemplo, você
pode usar stop() para interromper um arquivo SWF no fim de uma cena, antes de passar
para a cena seguinte. Depois que um arquivo SWF pára, ele deve ser reiniciado explicitamente
através da chamada de play() ou de gotoAndPlay().
Você pode usar as funções play() e stop() ou métodos MovieClip para controlar a timeline
principal ou a timeline de qualquer clipe de filme ou arquivo SWF carregado. O clipe de filme
que você deseja controlar deve ter um nome de instância e deve estar presente na timeline.
Controlando a reprodução de arquivos SWF 591

O manipulador on(press) a seguir, anexado a um botão, inicia a reprodução movendo o
arquivo SWF ou o clipe de filme que contém o objeto de botão:
// Anexado a uma instância de botão
on (press) {
// Reproduz a timeline que contém o botão
play();
}
Esse mesmo código do manipulador de eventos on() produzirá um resultado diferente

quando for anexado a um objeto de clipe de filme em vez de um botão. Por padrão, as
instruções incluídas em um manipulador on(), quando anexadas a um objeto de botão, serão
aplicadas à timeline que contém o botão. Entretanto, as instruções incluídas em um
manipulador on(), quando anexadas a um objeto de clipe de filme, serão aplicadas ao clipe de
filme ao qual o manipulador on() está anexado.
Por exemplo, o código do manipulador on() a seguir interrompe a timeline do clipe de filme
à qual o manipulador está anexado, e não a timeline que contém o clipe de filme.
// Anexado à instância de clipe de filme myMovie_mc
myMovie_mc.onPress() {
stop();
};
As mesmas condições são aplicadas aos manipuladores onClipEvent() anexados a objetos de

clipes de filme. Por exemplo, o código a seguir interrompe a timeline do clipe de filme que
contém o manipulador onClipEvent() quando o clipe é carregado pela primeira vez ou
aparece no Stage (Palco).
onClipEvent(load) {
stop();
}
Indo para outro URL

Para abrir uma página da Web em uma janela de navegador ou para passar dados para outro
aplicativo em um URL definido, use a função global getURL() ou o método
MovieClip.getURL(). Por exemplo, é possível ter um botão com links para um novo site da
Web ou enviar variáveis da timeline para um script CGI que seja processado da mesma forma
que um formulário HTML. Você também pode especificar uma janela de destino, como faria
ao especificar uma janela com uma marca de âncora HTML (<a></a>).
Por exemplo, o código a seguir abre a página inicial macromedia.com em uma janela de
navegador em branco quando o usuário clica na instância de botão homepage_btn:
// Anexar ao quadro
homepage_btn.onRelease = function () {

getURL("http://www.macromedia.com", "_blank");
};
Você também pode enviar variáveis junto com o URL, usando o método GET ou POST. Esse
procedimento é útil quando a página carregada de um servidor de aplicativos, como uma
página do ColdFusion Server (CFM), espera receber variáveis de formulário. Por exemplo,
imagine que você deseje carregar uma página CFM chamada addUser.cfm que espera duas
variáveis de formulário, primeiro Name e age. Para isso, você pode criar um clipe de filme
chamado variables_mc que defina essas duas variáveis, como mostrado no exemplo a seguir.
variables_mc.firstName = "Francois";
variables_mc.age = 32;
O código a seguir carrega addUser.cfm em uma janela de navegador em branco e passa para a
página CFM variables_mc.name e variables_mc.age no cabeçalho POST.
variables_mc.getURL("addUser.cfm", "_blank", "POST");
A funcionalidade de getURL() dependerá do navegador usado. A maneira mais confiável de

fazer com que todos os navegadores funcionem da mesma maneira é chamando uma função
JavaScript no código HTML que usa o método JavaScript window.open() para abrir uma
janela. Adicione o HTML e o JavaScript a seguir no seu modelo HTML:
<script language="JavaScript">
<--
function openNewWindow(myURL) {
window.open(myURL, "targetWindow");
}
// -->
</script>
Você pode usar o ActionScript a seguir para chamar openNewWindow de seu arquivo SWF:
var myURL:String = "http://foo.com";
getURL("javascript:openNewWindow('" + String(myURL) + "');");
Para obter mais informações, consulte %{função getURL}% em ActionScript 2.0 Language
Reference (Referência da linguagem ActionScript 2.0).
Criando interatividade e efeitos visuais

Para criar interatividade e outros efeitos visuais, é preciso compreender as seguintes técnicas:
■ “Criando um ponteiro de mouse personalizado” na página 594
■ “Obtendo a posição do ponteiro” na página 595
■ “Capturando pressionamentos de teclas” na página 596
■ “Definindo valores de cores” na página 599
■ “Criando controles de som” na página 601
Criando interatividade e efeitos visuais 593

■ “Detectando colisões” na página 604
■ “Criando uma ferramenta de desenho de linha simples” na página 605
Criando um ponteiro de mouse personalizado

Um ponteiro de mouse padrão é a representação na tela do sistema operacional da posição do
mouse do usuário. Ao substituir o ponteiro padrão por um criado no Flash, você consegue
integrar o movimento do mouse do usuário no arquivo SWF com mais precisão. O exemplo
desta seção usa um ponteiro personalizado com o formato de uma seta grande. Porém, a
eficiência desse recurso está na sua capacidade de transformar o ponteiro personalizado em
qualquer forma, como uma bola de futebol a caminho da linha do gol ou um pedaço de tecido
colocado por cima de um assento para mudar sua cor.
Para criar um ponteiro personalizado, crie o clipe de filme do ponteiro no Stage. Em seguida,
no ActionScript, oculte o ponteiro padrão e controle seu movimento. Para isso, use o método
hide() da classe interna Mouse (consulte %{hide (método Mouse.hide)}% em ActionScript
2.0 Language Reference).
Para criar um ponteiro personalizado:

1. Crie um clipe de filme para ser usado como um ponteiro personalizado e coloque uma
instância do clipe no Stage.
2. Selecione a instância de clipe de filme no Stage.
3. No inspetor Properties (Propriedades), digite cursor_mc na caixa de texto Instance Name
4. Selecione o Frame 1 da Timeline e digite o código a seguir no painel Actions (Ações):
Mouse.hide();
cursor_mc.onMouseMove = function() {
this._x = _xmouse;
this._y = _ymouse;
updateAfterEvent();
};
O método Mouse.hide() oculta o ponteiro quando o clipe de filme é exibido pela

primeira vez no Stage; a função onMouseMove posiciona o ponteiro personalizado no
mesmo local do ponteiro e chama updateAfterEvent() sempre que o usuário move o
mouse.
A função updateAfterEvent() atualiza a tela imediatamente após a ocorrência do evento
especificado, ao contrário do comportamento padrão, que atualiza a tela depois que o
próximo quadro é desenhado. (Consulte %{função updateAfterEvent}% em ActionScript
2.0 Language Reference.)

5. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o ponteiro
personalizado.
Os botões ainda funcionarão quando você usar um ponteiro de mouse personalizado. É
recomendável colocar o ponteiro personalizado na camada superior da timeline para movê-lo
na frente dos botões e dos outros objetos em outras camadas quando você mover o mouse no
arquivo SWF. Além disso, a dica de um ponteiro personalizado é o ponto de registro do clipe
de filme que você usa como o ponteiro personalizado. Assim, se desejar que uma determinada
parte do clipe de filme funcione como a dica do ponteiro, defina as coordenadas do ponto de
registro do clipe para que seja esse ponto.
Para obter mais informações sobre os métodos da classe Mouse, consulte %{Mouse}% em
Obtendo a posição do ponteiro

Você pode usar as propriedades _xmouse e _ymouse para localizar o ponteiro em um arquivo
SWF. Essas propriedades poderiam ser usadas, por exemplo, em um aplicativo de mapa que
obtém os valores das propriedades _xmouse e _ymouse e utiliza-os para calcular a longitude e a
latitude de uma localização específica.
Cada timeline possui uma propriedade _xmouse e _ymouse que retorna a localização do
ponteiro no seu sistema de coordenadas. A posição é sempre relativa ao ponto de registro. No
caso da timeline principal (_level0), o ponto de registro é o canto superior esquerdo. No
caso de um clipe de filme, o ponto de registro depende do ponto de registro definido na hora
de criação do clipe ou de sua posição no Stage.
As propriedades _xmouse e _ymouse na timeline principal e uma timeline de clipe de filme

O procedimento a seguir apresenta várias maneiras de obter a posição do ponteiro na timeline
principal ou em um clipe de filme.
Para obter a posição atual do ponteiro:

1. Crie dois campos de texto dinâmicos e atribua a eles os nomes box1_txt e box2_txt.
2. Adicione rótulos para as caixas de texto: posição x e posição y, respectivamente.
3. Selecione Window (Janela) > Actions (Ações) para abrir o painel Actions (Ações) se ele
ainda não estiver aberto.
4. Adicione o seguinte código ao painel Script:
// retorna as posições X e Y do mouse
box1_txt.text = _xmouse;
box2_txt.text = _ymouse;
};
5. Selecione Control > Test movie para testar o filme do Flash. Os campos box1_txt e
box2_txt mostram a posição do ponteiro durante a sua movimentação no Stage.
Para obter mais informações sobre as propriedades _xmouse e _ymouse, consulte %{_xmouse
(propriedade MovieClip._xmouse)}% e %{_ymouse (propriedade MovieClip._ymouse)}%
Capturando pressionamentos de teclas

Você pode usar o manipulador global on() para interceptar o comportamento interno dos
pressionamentos de teclas no Flash Player, como mostra o exemplo a seguir:
/* Quando você pressiona a tecla de seta para a esquerda ou para a direita,
o clipe de filme ao qual o manipulador está anexado altera a
transparência. */
on (keyPress "<Left>") {
this._alpha -= 10;
}
on (keyPress "<Right>") {
this._alpha += 10;
}
Verifique se selecionou Control (Controlar) > Disable Keyboard Shortcuts (Desativar atalhos
de teclado), caso contrário, determinadas teclas com comportamento interno não serão
substituídas quando você usar Control > Test Movie para testar o aplicativo. Consulte o
parâmetro keyPress de %{manipulador on}% em ActionScript 2.0 Language Reference.

Use os métodos da classe interna Key para detectar a última tecla pressionada pelo usuário. A
classe Key não exige uma função construtora; para usar os métodos dessa classe, basta chamá-
los na própria classe, como mostra o exemplo a seguir:
Key.getCode();
Você pode obter códigos de teclas virtuais ou valores ASCII (American Standard Code for
Information Interchange, Código padrão americano para intercâmbio de informações) de
pressionamentos de teclas:
■ Para obter o código de tecla virtual da última tecla pressionada, use o método getCode().
■ Para obter o valor ASCII da última tecla pressionada, use o método getAscii().
Um código de tecla virtual é atribuído a cada tecla física de um teclado. Por exemplo, a tecla
de seta para a esquerda tem o código de tecla virtual 37. O uso desse código garante que os
controles do arquivo SWF sejam os mesmos em todos os teclados, independentemente de
linguagem ou da plataforma.
Valores ASCII são atribuídos aos primeiros 127 caracteres em cada conjunto de caracteres. Os
valores ASCII fornecem informações sobre um caractere da tela. Por exemplo, a letra “A” e a
letra “a” possuem valores ASCII diferentes.
Decida quais teclas usar e determine seus códigos de teclas virtuais executando um destes
procedimentos:
■ Consulte a lista de códigos de teclas em Apêndice C, “Teclas do teclado e valores de
códigos de teclas.”.
■ Use uma constante da classe Key. (Na caixa de ferramentas Actions, clique em
ActionScript 2.0 Classes (Classes do ActionScript 2.0) > Movie (Filme) > Key (Tecla) >
Constants (Constantes).)
■ Atribua o manipulador onClipEvent() a seguir a um clipe de filme, selecione Control >
Test Movie e pressione a tecla desejada:
onClipEvent(keyDown) {
trace(Key.getCode());
}
O código da tecla desejada é exibido no painel Output (Saída).

Um lugar comum para se usar os métodos da classe Key é em um manipulador de eventos. No
exemplo a seguir, o usuário move o carro usando as teclas de seta. O método Key.isDown()
indica se a tecla pressionada é a seta para a direita, para a esquerda, para cima ou para baixo. O
ouvinte de eventos, Key.onKeyDown, determina o valor Key.isDown(keyCode) a partir de
instruções if. Dependendo do valor, o manipulador instruirá o Flash Player a atualizar a
posição do carro e exibir a direção.

O exemplo a seguir mostra como capturar pressionamentos de teclas para mover um clipe de
filme para cima, para baixo, para a esquerda ou para a direita no Stage, dependendo da tecla
de seta correspondente (para cima, para baixo, para a esquerda ou para a direita) pressionada.
Além disso, um campo de texto exibe o nome da tecla pressionada.
Para criar um clipe de filme ativado por teclado:

1. No Stage, crie um clipe de filme que poderá se mover em resposta às atividades de teclas do
teclado.
Neste exemplo, o nome da instância do clipe de filme é car_mc.
2. Selecione Frame 1 na Timeline; em seguida, escolha Window (Janela) > Actions (Ações)
para abrir o painel Actions caso ele ainda não esteja visível.
3. Para definir a distância percorrida pelo carro na tela com cada pressionamento de tecla,
defina uma variável distance e defina seu valor como 10:
var distance:Number = 10;
4. Adicione o código ActionScript a seguir ao painel Actions, embaixo do código existente:

this.createTextField("display_txt", 999, 0, 0, 100, 20);
5. Para criar o manipulador de eventos para o clipe de filme do carro que verifique qual tecla
de seta (para a esquerda, para a direita, para cima ou para baixo) está pressionada no
momento, adicione este código ao painel Actions:
};
6. Para verificar se a tecla de seta para a esquerda está pressionada e mover o clipe de filme do
carro de forma apropriada, adicione o código ao corpo do manipulador de eventos
onEnterFrame.
O seu código deve ser semelhante ao exemplo a seguir (o novo código está em negrito):
if (Key.isDown(Key.LEFT)) {
car_mc._x = Math.max(car_mc._x - distance, 0);
display_txt.text = "Left";
}
};

Se a tecla de seta para a esquerda estiver pressionada, a propriedade _x do carro será
definida para o valor _x atual menos a distância ou para o valor 0, o que for maior.
Portanto, o valor da propriedade _x não poderá nunca ser menor que 0. Além disso, a
palavra Left deverá aparecer no arquivo SWF.
7. Use um código semelhante para verificar se a tecla para a direita, para cima ou para baixo
está sendo pressionada.
O seu código completo deve ser semelhante ao exemplo a seguir (o novo código está em
negrito):
if (Key.isDown(Key.LEFT)) {
car_mc._x = Math.max(car_mc._x - distance, 0);
display_txt.text = "Left";
} else if (Key.isDown(Key.RIGHT)) {
car_mc._x = Math.min(car_mc._x + distance, Stage.width -
car_mc._width);
display_txt.text = "Right";
} else if (Key.isDown(Key.UP)) {
car_mc._y = Math.max(car_mc._y - distance, 0);
display_txt.text = "Up";
} else if (Key.isDown(Key.DOWN)) {
car_mc._y = Math.min(car_mc._y + distance, Stage.height -
car_mc._height);
display_txt.text = "Down";
}
};

Para obter mais informações sobre os métodos da classe Key, consulte %{Key}% em
Definindo valores de cores

Você pode usar os métodos da classe interna ColorTransform (flash.geom.ColorTransform)
para ajustar a cor de um clipe de filme. A propriedade rgb da classe ColorTransform atribui
valores RGB (vermelho, verde, azul) hexadecimais ao clipe de filme. O exemplo a seguir usa
rgb para alterar a cor de um objeto com base no botão clicado pelo usuário.
Para definir o valor de cor de um clipe de filme:

1. Crie um novo documento do Flash e salve-o como setrgb.fla.

2. Selecione a ferramenta Rectangle (Retângulo) e desenhe um quadrado grande no Stage.
3. Converta a forma em um símbolo de clipe de filme e atribua o nome de instância car_mc
a ele no inspetor Properties.
4. Crie um símbolo de botão chamado colorChip, coloque quatro instâncias do botão no
Stage e atribua a elas os nomes red_btn, green_btn, blue_btn e black_btn.
5. Selecione Frame 1 na Timeline principal e escolha Window > Actions.
principal:
var colorTrans:ColorTransform = new ColorTransform();

var trans:Transform = new Transform(car_mc);
trans.colorTransform = colorTrans;
7. Para que o botão azul altere a cor do clipe de filme car_mc para azul, adicione o código a
seguir ao painel Actions:
blue_btn.onRelease = function() {
colorTrans.rgb = 0x333399; // azul
};
O trecho de código anterior altera a propriedade rgb do objeto de transformação de cor e

reaplica o efeito de transformação de cor ao clipe de filme car_mc sempre que o botão é
pressionado.
8. Repita a etapa 7 para os outros botões (red_btn, green_btn e black_btn) a fim de alterar
a cor do clipe de filme para a cor correspondente.
O seu código agora deve ser semelhante ao exemplo a seguir (o novo código está em
negrito):
var colorTrans:ColorTransform = new ColorTransform();

var trans:Transform = new Transform(car_mc);
blue_btn.onRelease = function() {
colorTrans.rgb = 0x333399; // azul
};
red_btn.onRelease = function() {
colorTrans.rgb = 0xFF0000; // vermelho
};

green_btn.onRelease = function() {
colorTrans.rgb = 0x006600; // verde
};
black_btn.onRelease = function() {
colorTrans.rgb = 0x000000; // preto
};
9. Selecione Control > Test Movie para alterar a cor do clipe de filme.
Para obter mais informações sobre os métodos da classe ColorTransform, consulte
%{ColorTransform (flash.geom.ColorTransform)}% em ActionScript 2.0 Language Reference.
Criando controles de som

Use a classe interna Sound para controlar sons em um arquivo SWF. Para usar os métodos da
classe Sound, primeiro crie um objeto Sound. Depois, use o método attachSound() para
inserir um som da biblioteca em um arquivo SWF enquanto o SWF estiver em execução.
O método setVolume() da classe Sound controla o volume, e o método setPan() ajusta o
balanço da esquerda e da direita de um som.
O procedimento a seguir mostra como criar controles de som.
Para anexar som a uma timeline:

1. Selecione File > Import para importar um som.
2. Selecione o som na biblioteca, clique com o botão direito do mouse (Windows), ou
mantenha pressionada a tecla Control e clique (Macintosh), e selecione Linkage
(Vinculação).
3. Selecione Export for ActionScript (Exportar para ActionScript) e Export in First Frame
(Exportar no primeiro quadro); em seguida, atribua o identificador a_thousand_ways ao
som.
4. Adicione um botão ao Stage e atribua a ele o nome play_btn.
5. Adicione um botão ao Stage e atribua a ele o nome stop_btn.
Adicione o seguinte código ao painel Actions:
song_sound.attachSound("a_thousand_ways");
play_btn.onRelease = function() {
song_sound.start();
};
stop_btn.onRelease = function() {

song_sound.stop();
};
Esse código primeiro interrompe o clipe de filme speaker. Em seguida, ele cria um novo
objeto Sound (song_sound) e anexa o som cujo identificador de vinculação é
a_thousand_ways. Os manipuladores de eventos onRelease associados aos objetos
playButton e stopButton iniciam e interrompem o som usando os métodos
Sound.start() e Sound.stop(), e também iniciam e interrompem o som anexado.
7. Selecione Control > Test Movie para ouvir o som.
Para criar um controle de volume deslizante:

1. Com a ferramenta Rectangle, desenhe um pequeno retângulo no Stage de
aproximadamente 30 pixels de altura X 10 pixels de largura.
2. Selecione a ferramenta Selection (Seleção) e clique duas vezes na forma no Stage.
3. Pressione F8 para abrir a caixa de diálogo Convert to Symbol (Converter em símbolo).
4. Selecione o tipo Button (Botão), digite o nome de símbolo volume e clique em OK.
5. Com o símbolo de botão selecionado no Stage, digite o nome de instância handle_btn no
6. Selecione o botão e escolha Modify (Modificar) > Convert to Symbol (Converter em
símbolo).
Tenha cuidado ao selecionar o comportamento do clipe de filme. Isso criará um clipe de
filme com o botão em Frame 1.
7. Selecione o clipe de filme e digite volume_mc como o nome de instância no inspetor
Properties.
9. Insira o código a seguir no painel Actions:
this.createTextField("volume_txt", 10, 30, 30, 200, 20);
volume_mc.top = volume_mc._y;
volume_mc.bottom = volume_mc._y;
volume_mc.left = volume_mc._x;
volume_mc.right = volume_mc._x + 100;
volume_mc._x += 100;
volume_mc.handle_btn.onPress = function() {
startDrag(this._parent, false, this._parent.left, this._parent.top,
this._parent.right, this._parent.bottom);
};
volume_mc.handle_btn.onRelease = function() {
stopDrag();
var level:Number = Math.ceil(this._parent._x - this._parent.left);
this._parent._parent.song_sound.setVolume(level);

this._parent._parent.volume_txt.text = level;
};
volume_mc.handle_btn.onReleaseOutside = slider_mc.handle_btn.onRelease;
Os parâmetros left, top, right e bottom de startDrag() são variáveis definidas em

uma ação de clipe de filme.
10. Selecione Control > Test Movie para usar o controle deslizante de volume.
Para criar um controle de balanço deslizante:

1. Use a ferramenta Rectangle para desenhar um pequeno retângulo no Stage de
aproximadamente 30 pixels de altura X 10 pixels de largura.
2. Selecione a ferramenta Selection e clique duas vezes na forma no Stage.
3. Pressione F8 para abrir a caixa de diálogo Convert to Symbol.
4. Selecione o tipo Button, digite o nome de símbolo balance e clique em OK.
5. Com o símbolo de botão selecionado no Stage, digite o nome de instância handle_btn no
6. Selecione o botão e escolha Modify > Convert to Symbol.
Tenha cuidado ao selecionar o comportamento do clipe de filme. Isso criará um clipe de
filme com o botão em Frame 1.
7. Selecione o clipe de filme e digite balance_mc como o nome de instância no inspetor
Properties.
8. Insira o código a seguir no painel Actions:
balance_mc.top = balance_mc._y;
balance_mc.bottom = balance_mc._y;
balance_mc.left = balance_mc._x;
balance_mc.right = balance_mc._x + 100;
balance_mc._x += 50;
balance_mc.handle_btn.onPress = function() {
startDrag(this._parent, false, this._parent.left, this._parent.top,
this._parent.right, this._parent.bottom);
};
balance_mc.handle_btn.onRelease = function() {
stopDrag();
var level:Number = Math.ceil((this._parent._x - this._parent.left -
50) * 2);
this._parent._parent.song_sound.setPan(level);
};
balance_mc.handle_btn.onReleaseOutside =
balance_mc.handle_btn.onRelease;
Os parâmetros left, top, right e bottom de startDrag() são variáveis definidas em

uma ação de clipe de filme.

9. Selecione Control > Test Movie para usar o controle deslizante de balanço.
Para obter mais informações sobre os métodos da classe Sound, consulte %{Sound}% em
Detectando colisões
O método hitTest() da classe MovieClip detecta colisões em um arquivo SWF. Ele verifica
se um objeto colidiu com um clipe de filme e retorna um valor booleano (true ou false).
Você deseja saber se houve colisão para testar se o usuário chegou a uma certa área estática no
Stage ou para determinar quando um clipe de filme alcançou outro. Com hitTest(), você
pode determinar esses resultados.
Você pode usar os parâmetros de hitTest() para especificar as coordenadas x e y de uma
área sensível a cliques no Stage ou usar o caminho de destino de outro clipe de filme como
uma área sensível a cliques. Quando você especificar x e y, hitTest() retornará true se o
ponto identificado por (x, y) não for transparente. Quando um destino é passado para
hitTest(), as caixas delimitadoras dos dois clipes de filme são comparadas. Se houver uma
interseção entre elas, hitTest() retornará true. Se não houver uma interseção entre as duas
caixas, hitTest() retornará false.
Você também pode usar hitTest() para testar uma colisão entre dois clipes de filme.
O exemplo a seguir mostra como detectar uma colisão entre um mouse e os clipes de filme no
Stage.
Para detectar uma colisão entre um clipe de filme e o ponteiro do mouse:

1. Selecione o primeiro quadro na Layer 1 (Camada 1) da Timeline.
2. Selecione Window > Actions para abrir o painel Actions se ele ainda não estiver aberto.
3. Adicione este código ao painel Actions:
this.createEmptyMovieClip("box_mc", 10);
with (box_mc) {
moveTo(100, 100);
lineTo(200, 100);
lineTo(200, 200);
lineTo(100, 200);
lineTo(100, 100);
endFill();
}

status_txt.text = _level0.hitTest(_xmouse, _ymouse, true);
}
4. Selecione Control > Test Movie e mova o ponteiro sobre o clipe de filme para testar a
colisão.
O valor true é exibido sempre que o ponteiro está sobre um pixel não transparente.
Para executar a detecção de colisão em dois clipes de filme:

1. Arraste dois clipes de filme para o Stage e atribua a eles os nomes de instância car_mc e
area_mc.
2. Selecione Frame 1 na Timeline.evelyn

3. Selecione Window > Actions para abrir o painel Actions se ele ainda não estiver visível.
4. Insira o código a seguir no painel Actions (Ações):
area_mc.onEnterFrame = function() {
status_txt.text = this.hitTest(car_mc);
};
car_mc.onPress = function() {
this.startDrag(false);
updateAfterEvent();
};
car_mc.onRelease = function() {
this.stopDrag();
};
5. Selecione Control > Test Movie e arraste o clipe de filme para testar a detecção da colisão.
Sempre que a caixa delimitadora do carro formar uma interseção com a caixa delimitadora
da área, o status será true.
Para obter mais informações, consulte %{hitTest (método MovieClip.hitTest)}% em
Criando uma ferramenta de desenho de linha simples

Você pode usar métodos da classe MovieClip para desenhar linhas e preenchimentos no Stage
(Palco) durante a reprodução do arquivo SWF. Isso permite criar ferramentas de desenho para
usuários e desenhar formas no arquivo SWF em resposta a eventos. Os métodos de desenho
são beginFill(), beginGradientFill(), clear(), curveTo(), endFill(), lineTo(),
lineStyle() e moveTo().

É possível aplicar esses métodos a qualquer instância de clipe de filme (por exemplo,
myClip.lineTo()) ou a um nível (_level0.curveTo()).
Os métodos lineTo() e curveTo() permitem desenhar linhas e curvas, respectivamente.
Especifique uma cor de linha, espessura e configuração alfa para uma linha ou curva com o
método lineStyle(). O método de desenho moveTo() define a posição de desenho atual
para as coordenadas x e y do Stage especificadas.
Os métodos beginFill() e beginGradientFill() preenchem um caminho fechado com
um preenchimento sólido ou gradiente, respectivamente, e endFill() aplica o
preenchimento especificado na última chamada a beginFill() ou beginGradientFill().
O método clear() apaga o que foi desenhado no objeto de clipe de filme especificado.
Para criar uma ferramenta de desenho de linha simples:

1. Em um novo documento, crie um botão no Stage e, no inspetor Properties (Propriedades),
digite clear_btn como o nome da instância.
2. Selecione Frame 1 (Quadro 1) na Timeline (Linha de tempo).
3. Selecione Window > Actions para abrir o painel Actions se ele ainda não estiver visível.
4. No painel Actions, insira o seguinte código:
this.createEmptyMovieClip("canvas_mc", 999);
var isDrawing:Boolean = false;
//
clear_btn.onRelease = function() {
canvas_mc.clear();
};
//
mouseListener.onMouseDown = function() {
canvas_mc.lineStyle(5, 0xFF0000, 100);
canvas_mc.moveTo(_xmouse, _ymouse);
isDrawing = true;
};
if (isDrawing) {
canvas_mc.lineTo(_xmouse, _ymouse);
updateAfterEvent();
}
};
mouseListener.onMouseUp = function() {
isDrawing = false;
};
6. Arraste o ponteiro para desenhar uma linha no Stage.

7. Clique no botão para apagar o que você desenhou.
Criando vinculações de dados durante a

execução com o ActionScript
Se você usar componentes para criar aplicativos, normalmente será necessário adicionar
vinculações entre eles para poder interagir com os dados ou para que os componentes
interajam entre si. A interação entre componentes é necessária para criar interfaces ou
formulários utilizáveis com os quais os usuários possam interagir. Utilize a guia Bindings
(Vinculações) no Component inspector (Inspetor de componentes) para adicionar
vinculações entre os componentes no Stage. Você pode utilizar a guia Bindings no
Component inspector para vincular dados entre os componentes no Stage.
Para obter mais informações sobre como usar a guia Bindings, consulte “Trabalhando com
vinculações na guia Bindings (somente Flash Professional)” na página 450 em Usando o Flash.
Você também poderá obter informações adicionais nos seguintes artigos on-line: Building a
Tip of the day Application (Part 2) (Criando um aplicativo de dica do dia - parte 2), Data
Binding in Macromedia Flash MX Professional 2004 (Vinculação de dados no Macromedia
Flash MX Professional 2004) e Building a Google Search Application with Macromedia Flash
MX Professional (Criando um aplicativo de pesquisa no Google com o Macromedia Flash
MX Professional).
Você pode usar o ActionScript em vez da guia Bindings para criar vinculações entre
componentes. A adição de código geralmente é mais rápida e eficiente do que a utilização do
ambiente de criação. O uso do ActionScript para criar vinculações é necessário quando você
utiliza um código para adicionar componentes a um aplicativo. Você pode optar por usar o
método createClassObject() a fim de adicionar componentes dinamicamente no Stage;
entretanto, não poderia usar a guia Bindings para criar uma vinculação, pois os componentes
somente existirão quando ocorrer a execução. O uso do ActionScript para adicionar
vinculação de dados é normalmente conhecido como vinculação de dados durante a execução.
■ Criando vinculações entre componentes de UI com o ActionScript
■ “Usando componentes, vinculações e formatadores personalizados” na página 612
■ “Adicionando e vinculando componentes no Stage” na página 615
Criando vinculações de dados durante a execução com o ActionScript 607

Criando vinculações entre componentes de UI com o
ActionScript
Não é difícil vincular dados entre dois componentes durante a execução. Isso é possível no
Flash Basic 8 ou no Flash Professional 8. Lembre-se de incluir o componente
DataBindingClasses em seu documento para fazê-lo funcionar, pois esse componente contém
as classes com as quais você precisa trabalhar.
Para criar uma vinculação entre dois componentes TextInput com o

ActionScript:
1. Crie um novo documento do Flash chamado panel_as.fla.
2. Arraste duas cópias do componente TextInput para o Stage.
3. Atribua os seguintes nomes de instância aos componentes: in_ti e out_ti.
4. Selecione Window (Janela) > Common Libraries (Bibliotecas comuns) > Classes e abra a
nova biblioteca comum denominada Classes.fla.
5. Arraste uma cópia do componente DataBindingClasses para o painel Library (Biblioteca)
ou arraste o componente para o Stage e, em seguida, exclua-o.
Ao terminar, você poderá fechar a biblioteca comum. Após a exclusão do componente
DataBindingClasses do Stage, o Flash deixará uma cópia na biblioteca.
DICA
Se você se esquecer de excluir o componente DataBindingClasses do Stage, o

ícone do componente estará visível durante a execução.
NO T A
Durante a criação de uma vinculação com o Component inspector no exemplo

anterior, o Flash adicionou o componente DataBindingClasses automaticamente ao
arquivo FLA. Ao usar o ActionScript para criar vinculações de dados, copie essa
classe para a sua biblioteca, como mostra a etapa a seguir.
6. Insira uma nova camada e atribua o nome actions a ela.

7. Adicione o seguinte ActionScript ao Frame 1 da camada Actions:
var src:mx.data.binding.EndPoint = new mx.data.binding.EndPoint();
src.component = in_ti;
src.property = "text";
src.event = "focusOut";
var dest:mx.data.binding.EndPoint = new mx.data.binding.EndPoint();
dest.component = out_ti;
dest.property = "text";
new mx.data.binding.Binding(src, dest);
Se preferir utilizar a versão resumida, importe as classes de vinculação e utilize o código a

seguir:

import mx.data.binding.*;
var src:EndPoint = new EndPoint();
var dest:EndPoint = new EndPoint();
new Binding(src, dest);
Este ActionScript cria dois pontos finais de vinculação de dados, um para cada
componente vinculado. O primeiro ponto final criado define a partir de qual componente
está ocorrendo a vinculação (in_ti), qual propriedade deve ser observada (text) e qual
evento ativará a vinculação (focusOut). O segundo ponto final criado lista apenas o
componente e a propriedade (out_ti e text, respectivamente). Finalmente, você cria a
vinculação entre os dois pontos finais ao chamar o construtor da classe Binding (new
Binding(src, dest)).
Você não precisa usar nomes de classe totalmente qualificados (por exemplo,
mx.data.binding.EndPoint) em seu ActionScript, conforme já viu no primeiro trecho
de código. Se usar a instrução import no início do código, você poderá evitar a utilização
de nomes totalmente qualificados. Ao importar todas as classes do pacote
mx.data.binding usando o caractere curinga (*) (o pacote inclui as classes EndPoint e
Binding), você poderá reduzir o código e fazer referência direta às classes EndPoint e
Binding. Para obter mais informações sobre as instruções import, consulte a entrada
import em ActionScript 2.0 Language Reference.
8. Selecione Control > Test Movie para testar o código no ambiente de teste. Digite um texto
no campo de entrada de texto in_ti .
Depois que a instância in_ti perder o foco (clique no Stage, pressione Tab ou clique no
segundo campo), o Flash copiará qualquer texto digitado em in_ti para o campo de texto
out_ti.
9. Selecione File (Arquivo) > Save (Salvar) para salvar as alterações.
Se desejar modificar o texto do campo de entrada de texto out_ti do exercício anterior, o seu
código poderá ficar bem mais complexo. Por padrão, se usar o Component inspector para
configurar vinculações, você criará uma conexão bidirecional. Isso significa que, se você alterar
o campo de texto no Stage, o outro campo de texto também será alterado. Quando você usa o
ActionScript para criar vinculações, o seu aplicativo funciona da maneira oposta. Por padrão,
as vinculações de dados durante a execução são unidirecionais, a menos que você especifique o
contrário, conforme demonstrado no exemplo a seguir.

Para usar o ActionScript a fim de criar uma vinculação bidirecional, é necessário que você faça
algumas pequenas modificações nos trechos de código do procedimento anterior. Este
exemplo usa o segundo trecho de ActionScript reduzido da etapa 7.
Para criar uma vinculação bidirecional:

1. Abra o documento panel_as.fla do exemplo anterior.
2. Modifique ligeiramente o seu ActionScript (consulte o código em negrito) para que
corresponda ao ActionScript a seguir:
dest.event = "focusOut";
new Binding(src, dest, null, true);
As duas alterações feitas no ActionScript fazem o seguinte:

■ Definem uma propriedade event para a instância EndPoint de destino.
■ Definem dois parâmetros adicionais para o construtor de Binding.
Use o primeiro parâmetro para opções de formatação avançadas; você pode definir esse
valor como null ou undefined. O segundo parâmetro define se a vinculação será
bidirecional (true) ou unidirecional (false).
Você talvez deseje saber a origem do evento focusOut. É nessa parte que o ActionScript
torna-se complicado. Você pode investigar a classe TextInput e usar alguns dos métodos
listados (como change() ou enter()), mas não encontrará o evento focusOut nela. A
classe TextInput é herdada das classes UIObject e UIComponent. Se exibir a classe
UIComponent, que inclui suporte a foco para componentes, você verá quatro eventos
adicionais: focusIn, focusOut, keyDown e keyUp. É possível usar esses eventos com o
componente TextInput.
3. (Opcional) Se desejar que o exemplo anterior atualize o valor do campo de entrada de texto
out_ti, você poderá alterar o evento de focusOut para change.
O Flash altera o segundo valor no campo de entrada de texto in_ti e o atualiza para
out_ti. Uma conexão bidirecional foi criada com êxito.

Você pode usar as classes Binding com a maioria dos componentes de interface de usuário da
versão 2 da Arquitetura de Componentes Macromedia, e não apenas com o componente
TextInput. O exemplo a seguir demonstra como usar o ActionScript para vincular instâncias
CheckBox e componentes Label durante a execução.
Para usar classes de vinculação com o componente CheckBox:

2. Selecione File (Arquivo) > Save As (Salvar como) e atribua o nome checkbox_as.fla ao novo
arquivo.
3. Selecione Window > Common Libraries > Classes.
4. Arraste uma cópia da classe DataBindingClasses para a biblioteca do documento.
5. Arraste uma cópia do componente CheckBox para o Stage e atribua o nome de instância
my_ch a ela.
6. Arraste uma cópia do componente Label para o Stage e atribua o nome de instância my_lbl
a ela.
7. Crie uma nova camada e atribua o nome actions a ela.
8. Adicione o seguinte ActionScript ao Frame 1 da camada Actions:
var srcEndPoint:Object = {component:my_ch, property:"selected",
event:"click"};
var destEndPoint:Object = {component:my_lbl, property:"text"};
new mx.data.binding.Binding(srcEndPoint, destEndPoint);
Use objetos para definir os pontos finais em vez de criar novas instâncias da classe
EndPoint, conforme demonstrado nos exercícios anteriores desta seção. O trecho de
código desta etapa cria dois objetos, que funcionam como pontos finais da vinculação.
Crie a vinculação ao chamar o construtor da classe Binding. Para reduzir ainda mais a
quantidade de código (e a legibilidade), defina os objetos inline, como mostra o trecho a
seguir:
new mx.data.binding.Binding({component:my_ch, property:"selected",
event:"click"}, {component:my_lbl, property:"text"});
Este ActionScript diminui a legibilidade do seu código, mas também a digitação a ser feita.
Se compartilhar seus arquivos FLA (ou ActionScript), é possível que você deseje usar o
primeiro trecho do ActionScript, por ser mais fácil de ser compreendido.

Usando componentes, vinculações e formatadores
personalizados
Os formatadores personalizados o ajudam a formatar dados complexos de uma maneira
específica. Você também pode usar a formatação personalizada para auxiliar na exibição de
imagens, textos em formato HTML ou outros componentes dentro de um componente como
DataGrid. O exemplo a seguir ilustra a utilidade dos formatadores personalizados.
Para usar formatadores personalizados em um documento:

1. Crie um novo arquivo FLA e adicione a classe DataBindingClasses à biblioteca (Window
> Common Libraries > Classes).
2. Arraste uma cópia do componente DateChooser para o Stage e atribua o nome de instância
my_dc a ela.
3. Arraste uma cópia do componente Label para o Stage e atribua o nome de instância my_lbl
a ela.
5. Adicione o seguinte código ActionScript ao Frame 1 da camada Actions:
src.component = my_dc;
src.property = "selectedDate";
src.event = "change";
dest.component = my_lbl;
Este código cria uma vinculação entre a propriedade selectedDate de DateChooser e a

propriedade text do componente Label no Stage. Toda vez que você clica em uma nova
data no calendário, a data selecionada aparece no componente Label.
6. Salve o documento do Flash como customformat.fla em um local conveniente em seu disco
rígido.
(Você o reciclará no próximo exercício.)
Tente alterar as datas no componente Calendar para exibir a data selecionada no momento
no componente Label. O componente Label não tem largura suficiente para exibir a data
inteira, portanto o Flash corta o texto.
8. Feche o arquivo SWF de teste e retorne ao ambiente de criação.

Redimensione o componente Label no Stage ou selecione o componente e defina a
propriedade autoSize como left na guia Parameters (Parâmetros) do inspetor
Properties.
9. Selecione Control > Test Movie para testar o documento novamente.
Agora, o campo de texto exibe a data inteira, embora ela esteja confusa e precise de
formatação. Dependendo do seu fuso horário e da data selecionada, a data poderá ter uma
aparência como esta: Thu Nov 4 00:00:00 GMT-0800 2004
Apesar de a vinculação funcionar corretamente e exibir a propriedade selectedDate,
essas datas não são facilmente compreendidas pelo usuário. Nenhuma pessoa deseja ver
diferenças de fuso horário nem você talvez deseje exibir as horas, os minutos e os segundos.
Você precisa encontrar uma maneira de formatar a data para torná-la mais legível e um
pouco menos mecânica. Os formatadores personalizados são particularmente úteis para a
formatação de texto.
Formatando dados com a classe CustomFormatter

A classe CustomFormatter define dois métodos, format() e unformat(), que permitem
transformar os valores de dados de um tipo de dados específico em um tipo String e vice-versa.
Por padrão, esses métodos não fazem nada; você deve implementá-los em uma subclasse de
mx.data.binding.CustomFormatter. A classe CustomFormatter permite converter os tipos
de dados em seqüências de caracteres e revertê-los. Neste caso, você deseja converter a
propriedade selectedDate do componente DateChooser em uma seqüência de caracteres
bem formatada quando o valor for copiado para o componente Label.
O exemplo a seguir mostra como criar o seu próprio formatador personalizado, que exibe a
data como NOV 4, 2004, em vez de exibir uma seqüência de caracteres de data padrão.
N OT A
Faça o exercício de “Usando componentes, vinculações e formatadores

personalizados” na página 612 antes de começar este.
Para formatar dados com a classe CustomFormatter:

1. Selecione File (Arquivo) > New (Novo) e escolha ActionScript File (Arquivo do
ActionScript) para criar um novo arquivo AS.
2. Selecione File > Save As (Salvar como) e salve o novo arquivo como DateFormat.as.
class DateFormat extends mx.data.binding.CustomFormatter {
function format(rawValue:Date):String {
var returnValue:String;
var monthName_array:Array =
["JAN","FEB","MAR","APR","MAY","JUN","JUL","AUG","SEP","OCT","NOV","D
EC"];

returnValue = monthName_array[rawValue.getMonth()]+"
"+rawValue.getDate()+", "+rawValue.getFullYear();
return returnValue;
}
}
A primeira seção de código define a nova classe DateFormat, que estende a classe
CustomFormatter no pacote mx.data.binding. Lembre-se de que o Flash compila as
classes de vinculação no arquivo de componente DataBindingClasses, para que você pode
vê-las diretamente ou localizá-las na pasta Classes, no diretório de instalação do Flash.
O único método usado é o format(), que converte a instância de data em um formato de
seqüência de caracteres personalizado. A próxima etapa consiste em criar um array de
nomes de meses para que o resultado final tenha uma aparência próxima de NOV 4, 2004,
em vez do formato de data padrão. Lembre-se de que os arrays têm zero como base no
Flash, portanto, se o valor de rawValue.getMonth() retornar 1, ele representará fevereiro,
e não janeiro (pois janeiro corresponde ao mês 0). O código restante cria a seqüência de
caracteres formatada personalizada concatenando valores e retornando a seqüência de
caracteres returnValue.
Poderá ocorrer um problema quando você trabalhar com classes em um clipe compilado,
como pode ser observado no trecho anterior. Como você estende uma classe localizada na
classe DataBindingClasses e ela não está prontamente disponível para o Flash, o erro a
seguir será exibido quando você verificar a sintaxe na classe anterior:
**Error** <path to DateFormat class>\DateFormat.as: Line 1: The class
'mx.data.binding.CustomFormatter' could not be loaded.
class DateFormat extends mx.data.binding.CustomFormatter {
O seu código provavelmente está correto. Esse problema ocorre quando o Flash não
consegue localizar a classe e, portanto, ocorre falha na verificação da sintaxe.
4. Salve o arquivo DateFormat.as.
5. Abra customformat.fla do exercício em “Usando componentes, vinculações e formatadores
personalizados”. Verifique se salvou ou copiou DateFormat.as para o mesmo diretório
desse arquivo.
6. Em customformat.fla, modifique o código ActionScript no Frame 1 da camada Actions de
acordo com o código a seguir:
src.component = my_dc;
src.property = "selectedDate";

new Binding(src, dest, {cls:mx.data.formatters.Custom,
settings:{classname:"DateFormat", classname_class:DateFormat}});
Agora, defina um objeto customFormatter, que informe ao Flash que você está utilizando
a classe DateFormat criada recentemente para formatar o ponto final na vinculação.
7. Salve as alterações no documento e selecione Control > Test Movie para testar o código.
Adicionando e vinculando componentes no Stage

Uma das maiores vantagens de usar as classes de vinculação com o ActionScript é poder criar
vinculações entre componentes adicionados ao Stage pelo Flash durante a execução. Imagine
criar sua própria classe personalizada que adicione os campos de texto apropriados ao Stage
durante a execução e, em seguida, validar os dados necessários e adicionar as devidas
vinculações. Se tiver os componentes em sua biblioteca, você poderá adicioná-los
dinamicamente e usar algumas linhas extras de código para criar vinculações.
Para adicionar e vincular componentes no Stage com o ActionScript:

2. Arraste um componente ComboBox e Label para a biblioteca do documento.
4. Adicione o seguinte código ao Frame 1 da camada Actions:
this.createClassObject(mx.controls.ComboBox, "my_cb", 1, {_x:10,
_y:10});
this.createClassObject(mx.controls.Label, "my_lbl", 2, {_x:10, _y:40});
my_cb.addItem("JAN", 0);
my_cb.addItem("FEB", 1);
my_cb.addItem("MAR", 2);
my_cb.addItem("APR", 3);
my_cb.addItem("MAY", 4);
my_cb.addItem("JUN", 5);
src.component = my_cb;
src.property = "value";

A primeira linha do ActionScript importa as classes do pacote mx.data.binding, de
modo que você não precise usar caminhos totalmente qualificados em seu código. As duas
linhas seguintes do ActionScript anexam os componentes da biblioteca do documento ao
Stage. Em seguida, posicione os componentes no Stage.
Finalmente, adicione dados à instância ComboBox e crie a vinculação entre o componente
ComboBox my_cb e Label my_lbl no Stage.
Desconstruindo um script de exemplo

No arquivo SWF de exemplo file zapper.swf (que pode ser exibido no Using Flash Help
(Ajuda de Usando o Flash)), quando um usuário arrasta a joaninha para a tomada elétrica, a
joaninha cai e a tomada treme. A timeline principal possui apenas um quadro e contém três
objetos: a joaninha, a tomada e um botão de redefinição. Cada objeto é uma instância de clipe
de filme.
O script a seguir é anexado ao Frame 1 da Timeline principal:

var initx:Number = bug_mc._x;
var inity:Number = bug_mc._y;
var zapped:Boolean = false;
reset_btn.onRelease = function() {
zapped = false;
bug_mc._x = initx;
bug_mc._y = inity;
bug_mc._alpha = 100;
bug_mc._rotation = 0;
};
bug_mc.onPress = function() {
this.startDrag();
};
bug_mc.onRelease = function() {
this.stopDrag();
};
bug_mc.onEnterFrame = function() {

if (this.hitTest(this._parent.zapper_mc)) {
this.stopDrag();
zapped = true;
bug_mc._alpha = 75;
bug_mc._rotation = 20;
this._parent.zapper_mc.play();
}
if (zapped) {
bug_mc._y += 25;
}
};
O nome de instância da joaninha é bug_mc, e o nome de instância da tomada é zapper_mc.

No script, a referência à joaninha é feita com this, pois o script está anexado à joaninha, e a
palavra reservada this refere-se ao objeto que o contém.
Há manipuladores de eventos com vários eventos diferentes: onRelease(), onPress() e
onEnterFrame(). Os manipuladores de eventos são definidos no Frame 1 após o
carregamento do arquivo SWF. As ações no manipulador de eventos onEnterFrame() são
executadas sempre que a reprodução entra em um quadro. Mesmo em um arquivo SWF com
apenas um quadro, a reprodução ainda entra nesse quadro repetidamente e o script é
executado também repetidamente.
Duas variáveis, initx e inity, são definidas para armazenar as posições iniciais x e y da
instância de clipe de filme bug_mc. A função é definida e atribuída ao manipulador de eventos
onRelease da instância reset_btn. Essa função é chamada todas as vezes que o botão do
mouse é pressionado e liberado sobre o botão reset_btn. A função recoloca a joaninha na
posição inicial no Stage, redefine seus valores de rotação e alfa e redefine a variável zapped
como false.
Uma instrução if condicional usa o método hitTest() para verificar se a instância da
joaninha entra em contato com a instância da tomada (this._parent.zapper_mc). Há dois
resultados possíveis para a avaliação: true ou false:
■ Se o método hitTest() retornar true, o Flash chamará o método stopDrag(), definirá a
variável zapper_mc como true, modificará as propriedades alpha e rotation e instruirá a
instância zapped para ser reproduzida.
■ Se o método hitTest() retornar false, não será executado nenhum código entre chaves
{} logo após a instrução if.
Desconstruindo um script de exemplo 617

As ações na instrução onPress() são executadas quando o botão do mouse é pressionado
sobre a instância bug_mc. As ações na instrução onRelease() são executadas quando o botão
do mouse é pressionado sobre a instância bug_mc.
A ação startDrag() permite arrastar a joaninha. Como o script está anexado à instância
bug_mc, a palavra-chave this indica que a instância bug é a que pode ser arrastada:
bug_mc.onPress = function() {
this.startDrag();
};
A ação stopDrag() interrompe a ação arrastar:

bug_mc.onRelease = function() {
this.stopDrag();
};

CAPÍTULO 15
Trabalhando com imagens,

som e vídeo
15
Se você importar uma imagem ou um som ao criar um documento no Macromedia Flash
Basic 8 ou no Macromedia Flash Professional 8, a imagem e o som serão empacotados e
armazenados em um arquivo SWF quando ele for publicado. Além de importar mídia durante
a criação, é possível carregar mídia externa, incluindo outros arquivos SWF, durante a
execução. Talvez seja conveniente manter a mídia fora do documento do Flash por vários
motivos.
Reduzir o tamanho do arquivo Mantendo arquivos grandes de mídia fora do documento
do Flash e carregando-os durante a execução, você pode reduzir o tempo de download inicial
dos aplicativos e das apresentações, principalmente em conexões lentas com a Internet.
Criar módulos de apresentações grandes Você pode dividir uma apresentação ou um
aplicativo grande em vários arquivos SWF e depois carregar esses arquivos separados conforme
necessário durante a execução. Esse processo reduz o tempo de download inicial e também
facilita a manutenção e a atualização da apresentação.
Separar o conteúdo da apresentação Este é um tema comum no desenvolvimento de
aplicativos, principalmente aplicativos orientados a dados. Por exemplo, um aplicativo de
carrinho de compras pode exibir uma imagem de cada produto. Ao carregar cada imagem
durante a execução, você pode atualizar facilmente a imagem de um produto sem modificar o
arquivo FLA original.
Aproveitar os recursos específicos de tempo de execução Alguns recursos, como
reprodução de MP3 e FLV (Flash Video) carregado dinamicamente, só estão disponíveis
durante a execução por meio do ActionScript.
619
Esta seção descreve como trabalhar com arquivos de imagem, de som e vídeo FLV em
aplicativos Flash. Para obter mais informações, consulte os seguintes tópicos:
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
Sobre o carregamento e o trabalho com

mídia externa
Vários tipos de arquivos de mídia podem ser carregados em um aplicativo Flash durante a
execução: arquivos SWF, MP3, JPEG, GIF, PNG e FLV. Entretanto, nem todas as versões do
Flash Player oferecem suporte a cada tipo de mídia. Para obter mais informações sobre os tipos
de arquivos de imagens com suporte no Macromedia Flash Player 8, consulte “Carregando
arquivos SWF e de imagem externos” na página 621. Para obter informações sobre o suporte a
vídeo FLV no Flash Player, consulte “Sobre o uso de vídeo FLV” na página 632
O Macromedia Flash Player pode carregar mídia externa de qualquer endereço HTTP ou
FTP, de um disco local usando um caminho relativo ou por meio do protocolo file://.
Para carregar arquivos SWF e de imagem externos, você pode usar a função loadMovie() ou
loadMovieNum() , o método MovieClip.loadMovie() ou o método
MovieClipLoader.loadClip(). Os métodos de classes geralmente fornecem mais
funcionalidade e flexibilidade do que as funções globais e são adequados para a maioria dos
aplicativos complexos. Ao carregar um arquivo SWF ou de imagem, especifique um clipe de
filme ou um nível de arquivo SWF como o destino dessa mídia. Para obter mais informações
sobre como carregar arquivos SWF e de imagem, consulte “Carregando arquivos SWF e de
imagem externos” na página 621.
Para reproduzir um arquivo MP3 externo, use o método loadSound() da classe Sound. Esse
método permite especificar se o download do arquivo MP3 deve ser progressivo ou se deve ser
totalmente concluído antes de ser iniciada a reprodução. Também é possível ler as informações
de ID3 incorporadas nos arquivos MP3, se estiverem disponíveis. Para obter mais
informações, consulte “Lendo marcas de ID3 em arquivos MP3” na página 630.
620 Trabalhando com imagens, som e vídeo

O Flash Video é o formato de vídeo nativo usado pelo Flash Player. Os arquivos FLV podem
ser reproduzidos por meio de HTTP ou do sistema de arquivos local. A reprodução de
arquivos FLV externos oferece diversas vantagens em relação à incorporação de vídeo em um
documento do Flash, como melhor gerenciamento de desempenho e de memória, além de
taxas de quadros de vídeo e do Flash independentes. Para obter mais informações, consulte
“Reproduzindo arquivos FLV externos dinamicamente” na página 635.
Você também pode pré-carregar ou controlar o progresso do download da mídia externa. O
Flash Player 7 apresenta a classe MovieClipLoader, que pode ser usada para controlar o
progresso do download de arquivos SWF ou de imagem. Para pré-carregar arquivos MP3 e
FLV, é possível usar o método getBytesLoaded() da classe Sound e a propriedade
bytesLoaded da classe NetStream. Para obter mais informações, consulte “Pré-carregando
arquivos FLV” na página 639.
de imagem em um arquivo SWF. Os arquivos de origem de exemplo, gallery_tree.fla e
gallery_tween.fla, estão localizados na pasta Samples do disco rígido.
Carregando arquivos SWF e de imagem

externos
Para carregar um arquivo SWF ou de imagem, use a função global loadMovie() ou
loadMovieNum(), o método loadMovie() da classe MovieClip ou o método loadClip() da
classe MovieClipLoader. Para obter mais informações sobre o método loadClip(), consulte
MovieClipLoader.loadClip() em ActionScript 2.0 Language Reference (Referência da
linguagem ActionScript 2.0).
O Flash Player 8 oferece suporte aos seguintes tipos de arquivo de imagem: JPEG (progressivo
e não progressivo), GIF (transparente e não transparente, embora apenas o primeiro quadro
de um GIF animado seja carregado) e PNG (transparente e não transparente).
Para carregar um arquivo SWF ou de imagem em um nível no Flash Player, use a função
loadMovieNum(). Para carregar um arquivo SWF ou de imagem em um destino de clipe de
filme, use a função ou o método loadMovie(). Em qualquer um dos casos, o conteúdo
carregado substitui o conteúdo do nível especificado ou do destino de clipe de filme.
Carregando arquivos SWF e de imagem externos 621

Quando você carrega um arquivo SWF ou de imagem em um destino de clipe de filme, o
canto superior esquerdo do arquivo SWF ou da imagem é posicionado no ponto de registro
do clipe. Como geralmente esse ponto é o centro do clipe de filme, o conteúdo carregado
pode não aparecer centralizado. Além disso, quando um arquivo SWF ou de imagem é
carregado em uma Timeline (Linha de tempo) raiz, o canto superior esquerdo da imagem é
posicionado no canto superior esquerdo do Stage (Palco). O conteúdo carregado herda a
rotação e o dimensionamento do clipe de filme, mas o conteúdo original do clipe do filme é
removido.
Como opção, você pode enviar variáveis do ActionScript com uma chamada loadMovie() ou
loadMovieNum(). Isso será útil, por exemplo, se o URL especificado na chamada do método
for um script de servidor que retorna um arquivo SWF ou de imagem, de acordo com os
dados passados pelo aplicativo Flash.
Ao usar a função global loadMovie() ou loadMovieNum(), especifique o nível ou clipe de
destino como parâmetro. Por exemplo, o código a seguir carrega o aplicativo contents.swf do
Flash na instância de clipe de filme chamada image_mc:
loadMovie("contents.swf", image_mc);
Você pode usar MovieClip.loadMovie() para obter o mesmo resultado:

image_mc.loadMovie("contents.swf");
O exemplo a seguir carrega a imagem JPEG image1.jpg na instância de clipe de filme

image_mc:
image_mc.loadMovie("http://www.helpexamples.com/flash/images/image1.jpg");
Para obter mais informações sobre como carregar arquivos SWF e de imagem externos,
consulte “Sobre o carregamento de arquivos SWF e a Timeline raiz” na página 625.
Para pré-carregar arquivos SWF e JPEG em instâncias de clipe de filme, use a classe
MovieClipLoader. Essa classe fornece um mecanismo de ouvinte de eventos para informar
sobre o status dos downloads de arquivos em clipes de filmes. Para usar um objeto
MovieClipLoader para pré-carregar arquivos SWF e JPEG, você deve seguir estas etapas:
Criar um novo objeto MovieClipLoader Você pode usar um único objeto
MovieClipLoader para controlar o progresso do download de vários arquivos ou criar um
objeto separado para controlar o progresso de cada arquivo. Crie um novo clipe de filme,
carregue o seu conteúdo nele e crie o objeto MovieClipLoader, como mostra o seguinte
código:

Criar um objeto ouvinte e manipuladores de eventos O objeto ouvinte pode ser qualquer
objeto do ActionScript, como um objeto Object genérico, um clipe de filme ou um
componente personalizado.
O exemplo a seguir cria um objeto ouvinte genérico chamado loadListener e define para ele
mesmo as funções onLoadError, onLoadStart, onLoadProgress e onLoadComplete:
// Criar objeto ouvinte:
mclListener.onLoadError = function(target_mc:MovieClip, errorCode:String,
status:Number) {
trace("Error loading image: " + errorCode + " [" + status + "]");
};
mclListener.onLoadStart = function(target_mc:MovieClip):Void {
trace("onLoadStart: " + target_mc);
};
mclListener.onLoadProgress = function(target_mc:MovieClip,
numBytesLoaded:Number, numBytesTotal:Number):Void {
var numPercentLoaded:Number = numBytesLoaded / numBytesTotal * 100;
trace("onLoadProgress: " + target_mc + " is " + numPercentLoaded + "%
loaded");
};
mclListener.onLoadComplete = function(target_mc:MovieClip,
status:Number):Void {
trace("onLoadComplete: " + target_mc);
};
N OT A
O Flash Player 8 permite verificar o status HTTP do download de MovieClipLoader nos

ouvintes de eventos onLoadComplete e onLoadError. Dessa maneira, você pode
verificar por que o download do arquivo não ocorreu, ou seja, se a causa foi um erro do
servidor, se não foi possível localizar o arquivo e assim por diante.
Registrar o objeto ouvinte no objeto MovieClipLoader Para que o objeto ouvinte receba
os eventos de carregamento, registre-o no objeto MovieClipLoader, como mostra o seguinte
código:
Começar a carregar o arquivo (de imagem ou SWF) em um clipe de destino Para iniciar
o download do arquivo de imagem ou SWF, use o método MovieClipLoader.loadClip(),
como mostra o seguinte código:
img_mc);
N O TA
Somente os métodos MovieClipLoader podem ser usados para controlar o progresso

do download de arquivos carregados com o método MovieClipLoader.loadClip(). Não é
possível usar a função loadMovie() nem o método MovieClip.loadMovie().

O exemplo a seguir usa o método setProgress() do componente ProgressBar para exibir o
progresso do download de um arquivo SWF. (Consulte “ProgressBar.setProgress()” em
ActionScript 2.0 Language Reference.)
Para exibir o progresso do download com o componente ProgressBar:

1. Crie um novo documento do Flash e salve-o como progress.fla.
2. Abra o painel Components (Componentes), em Window (Janela) > Components.
3. Arraste um componente ProgressBar do painel Components até o Stage (Palco).
4. No inspetor Properties (Propriedades), em Window > Properties > Properties, atribua o
nome my_pb ao componente ProgressBar.
5. Selecione o Frame 1 (Quadro 1) da Timeline (Linha de tempo) e abra o painel Actions
(Ações), em Window > Actions.
var my_pb:mx.controls.ProgressBar;
my_pb.mode = "manual";

mclListener.onLoadStart = function(target_mc:MovieClip):Void {
my_pb.label = "loading: " + target_mc._name;
};
numBytesLoaded:Number, numBytesTotal:Number):Void {
var pctLoaded:Number = Math.ceil(100 * (numBytesLoaded /
numBytesTotal));
my_pb.setProgress(numBytesLoaded, numBytesTotal);
};
img_mc);
7. Teste o documento selecionando Control (Controlar) > Test Movie (Testar filme).
A imagem é carregada no clipe de filme img_mc.
8. Selecione File (Arquivo) > Publish (Publicar) > Formats (Formatos) e verifique se as opções
SWF e HTML estão selecionadas.
9. Clique em Publish (Publicar) e localize os arquivos HTML e SWF no disco rígido.
Eles estão na mesma pasta do arquivo progress.fla salvo na etapa 1.

10. Clique duas vezes no documento HTML para abri-lo em um navegador e veja a animação
da barra de progresso.
NO T A
Ao carregar arquivos no ambiente de teste, para ver o funcionamento da barra de

progresso, certifique-se de carregar da Internet um arquivo não armazenado em
cache, em vez de um arquivo local. Como os arquivos locais são carregados muito
rápido, não é possível ver o progresso desse processo. Opcionalmente, faça upload
do arquivo SWF e teste o seu documento em um servidor.
Para obter informações relacionadas, consulte “Sobre o carregamento de arquivos SWF e a

Timeline raiz” na página 625. Para obter mais informações sobre a classe MovieClipLoader,
consulte %{MovieClipLoader}% em ActionScript 2.0 Language Reference. Para obter
informações sobre a criação de animação para uma barra de progresso, consulte “Criando uma
animação do progresso para carregar arquivos SWF e de imagem” na página 655.
de imagem em um arquivo SWF. Os arquivos de origem de exemplo, gallery_tree.fla e
gallery_tween.fla, estão localizados na pasta Samples do disco rígido.
Sobre o carregamento de arquivos SWF e a Timeline

raiz
A propriedade _root, do ActionScript especifica ou retorna uma referência para a Timeline
(Linha de tempo) raiz de um arquivo SWF. Se você carregar um arquivo SWF em um clipe de
filme contido em outro arquivo SWF, todas as referências a _root no arquivo SWF carregado
serão resolvidas para a Timeline raiz do arquivo SWF do host, e não para a do arquivo SWF
carregado. Às vezes, isso poderá ocasionar um comportamento inesperado durante a execução
(por exemplo, se tanto o arquivo SWF do host como o carregado usarem _root para
especificar uma variável).

No Flash Player 7 e versões posteriores, é possível usar a propriedade %{_lockroot
(MovieClip._lockroot property)}% para forçar que as referências a _root feitas por um
clipe de filme sejam resolvidas para sua própria Timeline, em vez de para a Timeline do
arquivo SWF que contém esse clipe. Para obter mais informações, consulte “Especificando
uma Timeline raiz para arquivos SWF carregados” na página 374. Para obter mais
informações sobre o uso de _root e _lockroot, consulte Capítulo 19, “Melhores práticas e
convenções de codificação para ActionScript 2.0”, na página 767.
Um arquivo SWF pode carregar outro arquivo SWF de qualquer local da Internet.
Entretanto, para que um arquivo SWF acesse dados (variáveis, métodos etc.) definidos em
outro arquivo SWF, ambos devem ter o mesmo domínio de origem. No Flash Player 7 e
versões posteriores, os scripts entre domínios são proibidos, a menos que o arquivo SWF
carregado indique o contrário chamando System.security.allowDomain().
Para obter mais informações sobre System.security.allowDomain, consulte %{allowDomain
(security.allowDomain method)}% em ActionScript 2.0 Language Reference e “Sobre
domínios, segurança entre domínios e arquivos SWF” na página 727.
Sobre o carregamento e o uso de

arquivos MP3 externos
Para carregar arquivos MP3 durante a execução, use o método loadSound() da classe Sound.
Primeiro, crie um objeto Sound, como mostra o seguinte exemplo:
var song1_sound:Sound = new Sound();
Use o novo objeto para chamar loadSound() e carregar um som de evento ou um fluxo de
som. Os sons de evento são totalmente carregados antes da reprodução; os fluxos de som são
reproduzidos durante o download. Defina o parâmetro isStreaming de loadSound para
especificar um som como um som de evento ou um fluxo de som. Depois de carregar um som
de evento, chame o método start() da classe Sound para reproduzir o som. Os fluxos de
som começam a ser reproduzidos quando há dados suficientes carregados no arquivo SWF;
não é necessário usar start().
Por exemplo, o código a seguir cria um objeto Sound chamado my_sound e, em seguida,
carrega um arquivo MP3 chamado song1.mp3. Coloque o seguinte ActionScript no Frame 1
my_sound.loadSound("http://www.helpexamples.com/flash/sound/song1.mp3",
true);

Na maioria dos casos, defina o parâmetro isStreaming como true, principalmente se estiver
carregando arquivos grandes de som cuja reprodução deve iniciar o mais rápido possível, por
exemplo, ao criar um aplicativo “jukebox” MP3. Contudo, se estiver fazendo download de
clipes de som menores e precisar reproduzi-los em um determinado momento (por exemplo,
quando o usuário clica em um botão), defina isStreaming como false.
Para determinar se o download de um som foi concluído, use o manipulador de eventos
Sound.onLoad. Esse manipulador de eventos recebe automaticamente um valor booleano
(true ou false) que indica se o download do arquivo foi concluído com êxito.
■ “Carregando um arquivo MP3” na página 627
■ “Pré-carregando arquivos MP3” na página 628
■ “Lendo marcas de ID3 em arquivos MP3” na página 630
A pasta Samples do seu disco rígido contém um arquivo de origem de exemplo, jukebox.fla,
que carrega arquivos MP3. Esse exemplo demonstra como criar um jukebox usando tipos de
dados, princípios gerais de codificação e vários componentes:
8\Samples and Tutorials\Samples\Components\Jukebox.
and Tutorials/Samples/Components/Jukebox.
Carregando um arquivo MP3

Suponha que você esteja criando um jogo on-line que utilize diferentes sons dependendo do
nível alcançado pelo usuário no jogo. O código a seguir carrega um arquivo MP3
(song2.mp3) no objeto Sound game_sound e reproduz o som quando o download do arquivo
é concluído.
Para carregar um arquivo MP3:

1. Crie um novo arquivo FLA chamado loadMP3.fla.
var game_sound:Sound = new Sound();
game_sound.onLoad = function(success:Boolean):Void {
if (success) {
trace("Sound Loaded");
game_sound.start();
}
Sobre o carregamento e o uso de arquivos MP3 externos 627

};
game_sound.loadSound("http://www.helpexamples.com/flash/sound/song2.mp3"
false);‘
3. Selecione Control (Controlar) > Test Movie (Testar filme) para testar o som.
O Flash Player oferece suporte somente ao carregamento de arquivos de som do tipo MP3
durante a execução.
Para obter mais informações, consulte Sound.loadSound(), Sound.start() e
Sound.onLoad em ActionScript 2.0 Language Reference. Para obter informações sobre como
pré-carregar arquivos MP3, consulte “Pré-carregando arquivos MP3” na página 628. Para
obter informações sobre a criação de animação para uma barra de progresso ao carregar um
arquivo de som, consulte “Criando uma barra de progresso para carregar arquivos MP3 com o
ActionScript” na página 657.
dados, princípios gerais de codificação e vários componentes.
Pré-carregando arquivos MP3

Ao pré-carregar arquivos MP3, use a função setInterval() a fim de criar um mecanismo de
pesquisa que verifique os bytes carregados para um objeto Sound ou NetStream em intervalos
predeterminados. Para controlar o progresso do download de arquivos MP3, use os métodos
Sound.getBytesLoaded() e Sound.getBytesTotal().
O exemplo a seguir usa a função setInterval() para verificar os bytes carregados para um
objeto Sound em intervalos predeterminados.
Para pré-carregar um arquivo MP3:

1. Crie um novo arquivo FLA chamado preloadMP3.fla.
// Criar um novo objeto Sound para reproduzir o som.
var songTrack:Sound = new Sound();
// Criar a função de pesquisa que controla o progresso do download.
// Esta é a função que é "pesquisada". Ela verifica
// o progresso do download do objeto Sound passado como referência.
function checkProgress (soundObj:Object):Void {

var numBytesLoaded:Number = soundObj.getBytesLoaded();
var numBytesTotal:Number = soundObj.getBytesTotal();
var numPercentLoaded:Number = Math.floor(numBytesLoaded /
numBytesTotal * 100);
if (!isNaN(numPercentLoaded)) {
trace(numPercentLoaded + "% loaded.");
}
};
// Quando o arquivo tiver sido carregado, limpar o intervalo de pesquisa.
songTrack.onLoad = function ():Void {
trace("load complete");
clearInterval(poll);
};
// Carregar o arquivo MP3 de fluxo e começar a chamar checkProgress(),
songTrack.loadSound("http://www.helpexamples.com/flash/sound/song1.mp3",
true);
var poll:Number = setInterval(checkProgress, 100, songTrack);
O painel Output (Saída) mostra o progresso do carregamento.
A técnica de pesquisa pode ser usada para pré-carregar arquivos FLV externos. Para obter o
número total de bytes e o número atual de bytes carregados para um arquivo FLV, use as
propriedades NetStream.bytesLoaded e NetStream.bytesTotal (para obter mais
informações, consulte %{bytesLoaded (NetStream.bytesLoaded property)}% e %{bytesTotal
(NetStream.bytesTotal property)}% ).
Para obter mais informações, consulte MovieClip.getBytesLoaded(),
MovieClip.getBytesTotal(), setInterval(), Sound.getBytesLoaded() e
Sound.getBytesTotal() em ActionScript 2.0 Language Reference.
Para obter informações sobre a criação de animação para uma barra de progresso, consulte
“Criando uma barra de progresso para carregar arquivos MP3 com o ActionScript”
na página 657.
dados, princípios gerais de codificação e vários componentes.
Sobre o carregamento e o uso de arquivos MP3 externos 629

Lendo marcas de ID3 em arquivos MP3
As marcas de ID3 são campos de dados adicionados a um arquivo MP3. Elas contêm
informações sobre o arquivo, como o nome de uma música, de um álbum e de um artista.
Para ler as marcas de ID3 de um arquivo MP3, use a propriedade Sound.id3, cujas
propriedades correspondem aos nomes das marcas de ID3 incluídas no arquivo MP3 que está
sendo carregado. Para determinar quando as marcas de ID3 de um arquivo MP3 que está
sendo carregado estarão disponíveis, use o manipulador de eventos Sound.onID3. O Flash
Player 7 oferece suporte a marcas das versões 1.0, 1.1, 2.3 e 2.4. Não há suporte para marcas
da versão 2.2.
O exemplo a seguir carrega um arquivo MP3 chamado song1.mp3 no objeto Sound
song_sound . Quando as marcas de ID3 do arquivo estiverem disponíveis, o campo de texto
display_txt exibirá o nome do artista e da música.
Para ler marcas de ID3 em um arquivo MP3:

1. Crie um novo arquivo FLA chamado id3.fla.
this.createTextField("display_txt", this.getNextHighestDepth(), 0, 0,
100, 100);
display_txt.autoSize = "left";
display_txt.multiline = true;
song_sound.onLoad = function() {
song_sound.start();
};
song_sound.onID3 = function():Void {
display_txt.text += "Artist:\t" + song_sound.id3.artist + "\n";
display_txt.text += "Song:\t" + song_sound.id3.songname + "\n";
};
song_sound.loadSound("http://www.helpexamples.com/flash/sound/
song1.mp3");
As marcas de ID3 aparecem no Stage (Palco), e o som é reproduzido.
Como as marcas do ID3 2.0 estão localizadas no início do arquivo MP3 (antes dos dados de
som), elas ficam disponíveis assim que o download do arquivo é iniciado. Contudo, as marcas
do ID3 1.0 estão localizadas no final do arquivo (depois dos dados de som) e, portanto, só
ficarão disponíveis quando o download de todo o arquivo MP3 for concluído.

O manipulador de eventos onID3 é chamado sempre que estiverem disponíveis novos dados
ID3. Portanto, se um arquivo MP3 contiver marcas do ID3 2.0 e do ID3 1.0, o manipulador
onID3 será chamado duas vezes, pois as marcas estarão localizadas em partes diferentes do
arquivo.
Para obter uma lista de marcas de ID3 suportadas, consulte %{id3 (Sound.id3
property)}% em ActionScript 2.0 Language Reference.
dados, princípios gerais de codificação e vários componentes:
Atribuindo vinculação a recursos da

biblioteca
Você pode atribuir identificadores de vinculação aos recursos da biblioteca, como clipes de
filme e símbolos de fonte. No Flash Basic 8 e no Flash Professional 8, é possível definir
identificadores de vinculação para recursos de imagem e de som da biblioteca. Isso possibilita
o uso de arquivos de imagem e de som com bibliotecas compartilhadas e com a nova classe
BitmapData.
O exemplo a seguir adiciona uma imagem de bitmap da biblioteca com a vinculação definida
como myImage. Em seguida, a imagem é adicionada ao Stage (Palco) e torna-se arrastável.
Para usar vinculação com arquivos de bitmap:

1. Crie um novo arquivo FLA chamado linkBitmap.fla.
2. Importe uma imagem de bitmap para a biblioteca.
3. Clique com o botão direito do mouse (Windows) ou mantenha pressionada a tecla Control
ao clicar (Macintosh) na imagem na biblioteca e selecione Linkage (Vinculação) no menu
de contexto.
4. Selecione Export for ActionScript (Exportar para ActionScript) e Export in first Frame
(Exportar no primeiro quadro) e digite myImage na caixa de texto Identifier
(Identificador).
5. Clique em OK para definir o identificador de vinculação.
Atribuindo vinculação a recursos da biblioteca 631

// Criar imageBmp e anexar o bitmap da biblioteca.
var imageBmp:BitmapData = BitmapData.loadBitmap("myImage");
// criar o clipe de filme e anexar imageBmp
this.createEmptyMovieClip("imageClip", 10);
imageClip.attachBitmap(imageBmp, 2);
// tornar o clipe arrastável
imageClip.onPress = function() {
this.startDrag();
};
imageClip.onRelease = function() {
this.stopDrag();
}
O bitmap da biblioteca é exibido no Stage (Palco), e a imagem torna-se arrastável.
Sobre o uso de vídeo FLV

O formato de arquivo FLV contém dados de vídeo e áudio codificados para transmissão por
meio do Flash Player. Por exemplo, com um arquivo de vídeo QuickTime ou Windows
Media, você usará um codificador (como o Flash 8 Video Encoder ou o Sorensen Squeeze)
para converter esse arquivo em um arquivo FLV.
O Flash Player 7 oferece suporte a arquivos FLV codificados com o codec de vídeo Sorenson
Spark, e o Flash Player 8 a arquivos FLV codificados com o codificador Sorenson Spark ou
On2 VP6 no Flash Professional 8. O codec de vídeo On2 VP6 oferece suporte a um canal
alfa. O suporte a FLV está disponível de diferentes maneiras nas diversas versões do Flash
Player. Para obter mais informações, consulte a tabela a seguir:
Codec versão do arquivo SWF Versão do Flash Player

(versão de publicação) necessária para
reprodução
Sorenson Spark 6 6, 7 ou 8
7 7, 8
On2 VP6 6 8*
7 8
8 8

* Se o arquivo SWF carregar um arquivo FLV, você poderá usar o vídeo On2 VP6 sem
precisar republicar o arquivo SWF para o Flash Player 8, desde que os usuários utilizem o
Flash Player 8 para exibir esse arquivo. Somente o Flash Player 8 oferece suporte à
publicação e à reprodução de vídeo On2 VP6.
Para obter informações sobre os conceitos básicos de vídeo, como fluxo, download
progressivo, dimensões, codificação, importação e questões de largura de banda, consulte
Capítulo 11, “Trabalhando com vídeo” em Usando o Flash.
Esta seção aborda o uso de vídeo FLV sem componentes. Você também pode usar o
componente FLVPlayback para reproduzir arquivos FLV ou usar a classe VideoPlayback para
criar um exibidor de vídeo personalizado que carregue arquivos FLV dinamicamente (consulte
www.macromedia.com/devnet ou www.macromedia.com/support/documentation/). Para
obter informações sobre o uso de vídeo FLV com os componentes FLVPlayback e Media,
■ “FLVPlayback Component (Flash Professional Only)” na página 505
■ “Media components (Flash Professional only)” na página 831
Como uma alternativa à importação de vídeos diretamente para o ambiente de criação do
Flash, você pode usar o ActionScript para reproduzir dinamicamente arquivos FLV externos
no Flash Player. Os arquivos FLV podem ser reproduzidos a partir de um endereço HTTP ou
do sistema de arquivos local. Para reproduzir arquivos FLV, use as classes NetConnection e
NetStream, bem como o método attachVideo() da classe Video. Para obter mais
informações, consulte %{NetConnection}%, %{NetStream}% e %{attachVideo
(Video.attachVideo method)}% em ActionScript 2.0 Language Reference.
É possível criar arquivos FLV importando o vídeo para a ferramenta de criação do Flash e
exportando-o como um arquivo FLV. Se tiver o Flash Professional 8, você poderá usar o plug-
in FLV Export para exportar arquivos FLV de aplicativos de edição de vídeo suportados.
O uso de arquivos FLV externos oferece certos recursos que não estão disponíveis quando você
usa vídeo importado:
■ É possível usar videoclipes mais longos nos documentos do Flash sem tornar a reprodução
mais lenta. Os arquivos FLV externos são reproduzidos usando a memória cache; isso
significa que arquivos grandes são armazenados em pequenas partes e acessados
dinamicamente, exigindo menos memória do que os arquivos de vídeo incorporados.
■ Um arquivo FLV externo tem uma taxa de quadros diferente do documento do Flash no
qual é reproduzido. Por exemplo, você pode definir a taxa de quadros do documento do
Flash como 30 quadros por segundo (qps) e a taxa de quadros do vídeo como 21 qps. Essa
configuração permite melhor controle do vídeo do que o vídeo incorporado, garantindo
sua reprodução contínua. Ela também permite reproduzir arquivos FLV com taxas de
quadros diferentes, sem a necessidade de alterar o conteúdo existente do Flash.
Sobre o uso de vídeo FLV 633

■ Com arquivos FLV externos, a reprodução do documento do Flash não precisa ser
interrompida enquanto o arquivo de vídeo está sendo carregado. Às vezes, os arquivos de
vídeo importados podem interromper a reprodução do documento para executar
determinadas funções, como, por exemplo, acessar uma unidade de CD-ROM. Os
arquivos FLV podem executar funções independentemente do documento do Flash e,
portanto, não interrompem a reprodução.
■ Com arquivos FLV externos, é mais fácil criar legendas do conteúdo do vídeo, pois você
pode usar manipuladores de eventos para acessar os metadados do vídeo.
D IC A
Para carregar arquivos FLV de um servidor Web, talvez seja necessário registrar o
tipo MIME (Multipurpose Internet Mail Extensions, Extensões multipropósito do
Internet Mail) e a extensão do arquivo nesse servidor; consulte a documentação do
servidor. O tipo MIME dos arquivos FLV é video/x-flv. Para obter mais informações,
consulte “Sobre a configuração de arquivos FLV para hospedagem em um servidor”
na página 652.
Para obter mais informações sobre vídeo FLV, consulte os seguintes tópicos:
■ “Criando um objeto de vídeo” na página 634
■ “Reproduzindo arquivos FLV externos dinamicamente” na página 635
■ “Criando uma faixa de vídeo” na página 636
■ “Pré-carregando arquivos FLV” na página 639
■ “Trabalhando com pontos de início” na página 640
■ “Trabalhando com metadados” na página 650
■ “Sobre a configuração de arquivos FLV para hospedagem em um servidor” na página 652
■ “Sobre a definição de arquivos FLV locais como destino no Macintosh” na página 653
Criando um objeto de vídeo

Antes de carregar e manipular vídeo com o ActionScript, é necessário criar um objeto de
vídeo, arrastá-lo para o Stage (Palco) e atribuir um nome de instância a ele. O exemplo a
seguir descreve como adicionar uma instância de vídeo a um aplicativo.
Para criar um objeto de vídeo:

1. Com um documento aberto na ferramenta de criação do Flash, selecione New Video
(Novo vídeo) no menu pop-up do painel Library (Biblioteca), em Window (Janela) >
Library.
2. Na caixa de diálogo Video Properties (Propriedades de vídeo), atribua um nome ao símbolo
de vídeo e selecione Video (ActionScript controlled) (Vídeo – controlado pelo
ActionScript).

3. Clique em OK para criar um objeto de vídeo.
4. Arraste o objeto de vídeo do painel Library para o Stage (Palco) a fim de criar uma instância
desse objeto.
5. Com o objeto de vídeo selecionado no Stage, digite my_video na caixa de texto Instance
Name (Nome da instância) do inspetor Properties (Propriedades), em Window >
Properties > Properties.
Agora há uma instância do vídeo no Stage, e você pode adicionar um código ActionScript
para carregar o vídeo ou manipular a instância de várias maneiras.
Para obter informações sobre como carregar arquivos FLV dinamicamente, consulte
“Reproduzindo arquivos FLV externos dinamicamente”. Para obter informações sobre a
criação de uma faixa de vídeo, consulte “Criando uma faixa de vídeo” na página 636.
Reproduzindo arquivos FLV externos dinamicamente

Você pode carregar arquivos FLV durante a execução para reproduzi-los em um arquivo SWF.
Esses arquivos podem ser carregados em um objeto de vídeo ou em um componente, como
FLVPlayback. O exemplo a seguir mostra como reproduzir um arquivo chamado clouds.flv
em um objeto de vídeo.
Para reproduzir um arquivo FLV externo em um documento do Flash:

1. Crie um novo documento do Flash chamado playFLV.fla.
2. No painel Library (Biblioteca), em Window (Janela) > Library, selecione New Video
(Novo vídeo) no menu pop-up Library.
ActionScript).
desse objeto.
8. Digite o seguinte código no painel Actions:
status_txt.autoSize = "left";

// Criar um objeto NetConnection
var my_nc:NetConnection = new NetConnection();
// Criar uma conexão de fluxo local
my_nc.connect(null);
// Criar um objeto NetStream e definir uma função onStatus()
var my_ns:NetStream = new NetStream(my_nc);
my_ns.onStatus = function(infoObject:Object):Void {
status_txt.text += "status (" + this.time + " seconds)\n";
status_txt.text += "\t Level: " + infoObject.level + "\n";
status_txt.text += "\t Code: " + infoObject.code + "\n\n";
};
// Anexar o fluxo de vídeo NetStream ao objeto Video
my_video.attachVideo(my_ns);
// Definir o tempo do buffer
my_ns.setBufferTime(5);
// Iniciar a reprodução do arquivo FLV
my_ns.play("http://www.helpexamples.com/flash/video/clouds.flv");
Para obter informações sobre como pré-carregar arquivos FLV, consulte “Pré-carregando
arquivos FLV” na página 639. Para obter informações sobre como carregar dinamicamente
vídeo FLV em componentes, consulte “Creating an application with the FLVPlayback
component” na página 507. Para obter informações sobre arquivos FLV e o servidor, bem
como arquivos FLV e a reprodução desses arquivos localmente no Macintosh, consulte “Sobre
a configuração de arquivos FLV para hospedagem em um servidor” na página 652.
Criando uma faixa de vídeo

O conteúdo de vídeo em faixas e outros anúncios do Flash são geralmente usados para fins de
propaganda, como para a exibição de anúncios de televisão ou a visualização de filmes do
Flash. O exemplo a seguir mostra como criar uma instância de vídeo e adicionar um código
ActionScript a um arquivo FLA para criar uma faixa de anúncio que contém vídeo.
Para criar uma faixa de vídeo:

1. Crie um novo documento do Flash chamado vidBanner.fla.
2. Selecione Modify (Modificar) > Document (Documento).
3. Altere as dimensões do arquivo FLA; em seguida, digite 468 e 60 nas caixas de texto de
largura e altura, respectivamente.
(Novo vídeo) nas opções de Library.

ActionScript).
do vídeo.
9. Com a instância do vídeo ainda selecionada, no inspetor Properties, digite 105 e 60 nas
caixas de texto de largura e altura, respectivamente.
10. Arraste a instância do vídeo para uma posição no Stage ou use o inspetor Properties para
definir suas coordenadas x e y.
var my_nc:NetConnection = new NetConnection();
my_nc.connect(null);
var my_ns:NetStream = new NetStream(my_nc);
my_video.attachVideo(my_ns);
my_ns.setBufferTime(5);
my_ns.play("http://www.helpexamples.com/flash/video/vbanner.flv");
13. Selecione Insert (Inserir) > Timeline > Layer (Camada) para criar uma nova camada e
atribua o nome button a ela.
14. Selecione a ferramenta Rectangle (Retângulo) no painel Tools (Ferramentas).
15. Na seção Colors (Cores) do painel Tools, clique no ícone de lápis para selecionar o controle
de cor do traço.
16. Selecione No Color (Nenhuma cor), que desativa o contorno do retângulo.
17. Arraste o ponteiro diagonalmente no Stage para criar um retângulo.
O tamanho do retângulo não é importante porque você o redimensionará usando o
18. Clique na ferramenta Selection (Seleção) no painel Tools e, em seguida, clique no retângulo
no Stage para selecioná-lo.
19. Com o retângulo ainda selecionado, no inspetor Properties, digite 468 e 60 nas caixas de
texto de largura e altura, respectivamente. Em seguida, altere as coordenadas X e Y (caixas
de texto X e Y) para 0.

20.Com o retângulo selecionado no Stage, pressione F8 a fim de alterar o retângulo para um
símbolo.
21. Na caixa de diálogo Convert to Symbol (Converter em símbolo), digite invisible btn na
caixa de texto Name (Nome), selecione Button (Botão) e clique em OK.
22.Clique duas vezes no novo botão no Stage para entrar no modo de edição de símbolo.
O retângulo está no primeiro quadro Up (Para cima) do botão criado. Este é o estado Up
do botão, ou seja, o que os usuários vêem quando o botão está no Stage. Entretanto, como
o botão não deve ficar visível no Stage, é necessário mover o retângulo para o quadro Hit
(Área), que é a área sensível do botão (a região ativa em que o usuário pode clicar para
ativar as ações do botão).
23.Cliqueno quadro-chave no quadro Up e mantenha pressionado o botão do mouse
enquanto arrasta o quadro-chave para o quadro Hit.
Agora você pode clicar em toda a área da faixa, mas a aparência do botão não é exibida na
faixa.
24.Clique em Scene 1 (Cena 1) para retornar à Timeline principal.
Um retângulo azulado aparece sobre a área da faixa, representando a área sensível do botão
invisível.
25.Selecioneo botão criado, abra o inspetor Properties e digite inv_btn na caixa de texto
Instance Name (Nome da instância).
26.Selecione o Frame 1 da Timeline e digite o seguinte código no painel Actions:
inv_btn.onRelease = function(){
getURL("http://www.macromedia.com");
};
27. Faça outras modificações na faixa; por exemplo, adicione gráfico ou texto.
28.Selecione Control (Controlar) > Test Movie (Testar filme) para testar a faixa no Flash
Player.
Nesse exemplo, você criou uma faixa e a redimensionou para as dimensões padronizadas
estabelecidas, definidas pelo IAB (Interactive Advertising Bureau, Agência de propaganda
interativa). Para obter informações sobre as dimensões padrão de propaganda (e várias outras
diretrizes úteis), consulte a página de padrões e diretrizes do Interactive Advertising Bureau em
www.iab.net/standards/adunits.asp.

Apesar das diretrizes padronizadas, confirme primeiro as diretrizes aplicáveis ao serviço de
propaganda, ao cliente ou ao site no qual você está anunciando. Caso submeta sua faixa a uma
empresa de publicidade, verifique se o arquivo atende às diretrizes especificadas de taxas de
quadros, versão do Flash Player de destino, dimensões e tamanho. Além disso, considere as
regras aplicáveis aos tipos de mídia que podem ser usados, ao código de botão usado no
arquivo FLA e assim por diante.
Pré-carregando arquivos FLV

Para controlar o progresso do download de arquivos FLV, use as propriedades
NetStream.bytesLoaded e NetStream.bytesTotal. Para obter o número total de bytes e o
número atual de bytes carregados para um arquivo FLV, use as propriedades
NetStream.bytesLoaded e NetStream.bytesTotal.
O exemplo a seguir usa as propriedades bytesLoaded e bytesTotal que mostram o progresso

do carregamento do arquivo video1.flv na instância do objeto de vídeo chamada my_video.
Um campo de texto chamado loaded_txt é criado dinamicamente para mostrar informações
sobre esse processo.
Para pré-carregar um arquivo FLV:

1. Crie um novo arquivo FLA chamado preloadFLV.fla.
ActionScript).
desse objeto.
7. Com a instância do vídeo ainda selecionada, no inspetor Properties, digite 320 e 213 nas
caixas de texto de largura e altura, respectivamente.

var connection_nc:NetConnection = new NetConnection();
connection_nc.connect(null);
var stream_ns:NetStream = new NetStream(connection_nc);
my_video.attachVideo(stream_ns);
stream_ns.play("http://www.helpexamples.com/flash/video/
lights_short.flv");
this.createTextField("loaded_txt", this.getNextHighestDepth(), 10, 10,

160, 22);
var loaded_interval:Number = setInterval(checkBytesLoaded, 500,
stream_ns);
function checkBytesLoaded(my_ns:NetStream) {
var pctLoaded:Number = Math.round(my_ns.bytesLoaded / my_ns.bytesTotal
* 100);
loaded_txt.text = Math.round(my_ns.bytesLoaded / 1000) + " of " +
Math.round(my_ns.bytesTotal / 1000) + " KB loaded (" + pctLoaded +
"%)";
progressBar_mc.bar_mc._xscale = pctLoaded;
if (pctLoaded >= 100) {
clearInterval(loaded_interval);
}
}
N OT A
Se a barra de progresso for carregada instantaneamente, o vídeo terá sido

armazenado em cache no disco rígido (a partir do teste deste exemplo ou do seu
carregamento em outro procedimento). Se isso ocorrer, faça upload de um arquivo
FLV no servidor e carregue esse arquivo.
Outra maneira de pré-carregar arquivos FLV é usar o método NetStream.setBufferTime().

Esse método utiliza um único parâmetro que indica o número de segundos do fluxo de FLV a
ser armazenado no buffer antes do início da reprodução. Para obter mais informações,
consulte %{setBufferTime (NetStream.setBufferTime method)}%, %{getBytesLoaded
(MovieClip.getBytesLoaded method)}%, %{getBytesTotal
(MovieClip.getBytesTotal method)}%, %{bytesLoaded (NetStream.bytesLoaded
property)}%, %{bytesTotal (NetStream.bytesTotal property)}% e %{setInterval
function}% em ActionScript 2.0 Language Reference
Trabalhando com pontos de início

Diversos tipos de pontos de início podem ser usados com o Flash Video. Você pode usar o
ActionScript para interagir com pontos de início incorporados em um arquivo FLV (ao criar
esse arquivo) ou criados com o ActionScript.

Pontos de início de navegação Estes pontos são incorporados no pacote de metadados
FLV e no fluxo de FLV durante a codificação do arquivo FLV. Utilize-os a fim de permitir que
os usuários busquem determinada parte de um arquivo.
Pontos de início de evento Estes pontos são incorporados no pacote de metadados FLV e
no fluxo de FLV durante a codificação do arquivo FLV. Você pode criar um código para
manipular os eventos que são ativados em determinados pontos durante a reprodução do FLV.
Pontos de início do ActionScript Pontos de início externos criados com o código
ActionScript. Você pode criar um código para ativar esses pontos em relação à reprodução do
vídeo. Esses pontos são menos precisos do que os pontos de início incorporados (até um
décimo de segundo) porque são controlados separadamente pelo exibidor de vídeo.
Os pontos de início de navegação criam um quadro-chave no local do ponto de início
especificado; dessa maneira, é possível usar um código a fim de mover a reprodução do
exibidor de vídeo para esse local. Você pode definir pontos específicos de um arquivo FLV
para os quais os usuários poderão navegar. Por exemplo, o seu vídeo poderá conter vários
capítulos ou segmentos, e você poderá controlá-lo incorporando pontos de início de
navegação no arquivo de vídeo.
Se planejar criar um aplicativo no qual os usuários deverão navegar para um ponto de início,
crie e incorpore pontos de início ao codificar o arquivo em vez de usar os pontos de início do
ActionScript. Os pontos de início devem ser incorporados no arquivo FLV, pois são mais
precisos. Para obter mais informações sobre a codificação de arquivos FLV com pontos de
início, consulte “Incorporando pontos de início (somente Flash Professional)” na página 333
em Usando o Flash.
Para acessar parâmetros de ponto de início, crie um código ActionScript. Esses parâmetros
fazem parte do objeto de evento recebido com o evento cuePoint
(event.info.parameters). Para obter informações sobre o acesso ou o rastreamento de
pontos de início, consulte “Trabalhando com pontos de início” na página 640 em Usando o
Flash.
Rastreando pontos de início em um arquivo FLV

Para rastrear os pontos de início incorporados em um documento FLV, use
NetStream.onMetaData. Opere recursivamente a estrutura dos metadados retornada, para
ver as informações de pontos de início.
O código a seguir rastreia os pontos de início em um arquivo FLV:
stream_ns.onMetaData = function(metaProp:Object) {
trace("The metadata:");

traceMeta(metaProp);
// traceObject(metaProp, 0);
};
stream_ns.play("http://www.helpexamples.com/flash/video/cuepoints.flv");
function traceMeta(metaProp:Object):Void {
var p:String;
for (p in metaProp) {
switch (p) {
case "cuePoints" :
trace("cuePoints: ");
//percorre os pontos de início
var cuePointArr:Array = metaProp[p];
for (var j:Number = 0; j < cuePointArr.length; j++) {
//percorre os parâmetros atuais de ponto de início
trace("\t cuePoints[" + j + "]:");
var currentCuePoint:Object = metaProp[p][j];
var metaPropPJParams:Object = currentCuePoint.parameters;
trace("\t\t name: " + currentCuePoint.name);
trace("\t\t time: " + currentCuePoint.time);
trace("\t\t type: " + currentCuePoint.type);
if (metaPropPJParams != undefined) {
trace("\t\t parameters:");
traceObject(metaPropPJParams, 4);
}
}
break;
default:
trace(p + ": " + metaProp[p]);
break;
}
}
}
function traceObject(obj:Object, indent:Number):Void {
var indentString:String = "";
for (var j:Number = 0; j < indent; j++) {
indentString += "\t";
}
for (var i:String in obj) {
if (typeof(obj[i]) == "object") {
trace(indentString + " " + i + ": [Object]");
traceObject(obj[i], indent + 1);
} else {
trace(indentString + " " + i + ": " + obj[i]);
}
}
}
A seguinte saída é exibida:

The metadata:
canSeekToEnd: true
cuePoints:
cuePoints[0]:
name: point1
time: 0.418
type: navigation
parameters:
lights: beginning
cuePoints[1]:
name: point2
time: 7.748
type: navigation
parameters:
lights: middle
cuePoints[2]:
name: point3
time: 16.02
type: navigation
parameters:
lights: end
audiocodecid: 2
audiodelay: 0.038
audiodatarate: 96
videocodecid: 4
framerate: 15
videodatarate: 400
height: 213
width: 320
duration: 16.334
Para obter informações sobre o uso de pontos de início com o componente FLVPlayback,
consulte “Usando pontos de início incorporados com o componente FLVPlayback (somente
Flash Professional)”.
Usando pontos de início incorporados com o componente

FLVPlayback (somente Flash Professional)
Você pode exibir os pontos de início de um arquivo FLV no inspetor Properties (Propriedades)
ao usar o componente FLVPlayback. Após definir a propriedade contentPath da instância de
FLVPlayback, você pode exibir todos os pontos de início incorporados no arquivo de vídeo.
Usando a guia Parameters (Parâmetros), localize a propriedade cuePoints e clique no ícone
de lupa para ver uma lista dos pontos de início do arquivo.
N OT A
Para ver os pontos de início na guia Parameters, digite o nome do arquivo FLV na caixa
de texto contentPath, em vez de usar um código para atribuir o contentPath.

O exemplo a seguir mostra como usar informações de pontos de início com o componente
FLVPlayback.
Para usar pontos de início com o componente FLVPlayback:

1. Crie um novo documento do Flash chamado cueFlv.fla.
2. Abra o painel Components (Componentes), em Window (Janela) > Components, e arraste
uma instância dos componentes FLVPlayback e TextArea para o Stage (Palco).
3. Selecione o componente TextArea e digite my_ta na caixa de texto Instance Name (Nome
da instância) do inspetor Properties (Propriedades), em Window > Properties > Properties.
4. Com o componente TextArea ainda selecionado, digite 200 e 100 nas caixas de texto de
5. Selecione a instância de FLVPlayback no Stage e digite my_flvPb na caixa de texto Instance
Name.
no painel Actions (Ações).
var my_flvPb:mx.video.FLVPlayback;
var my_ta:mx.controls.TextArea;
my_flvPb.contentPath = "http://www.helpexamples.com/flash/video/
cuepoints.flv";
listenerObject.cuePoint = function(eventObject:Object) {
my_ta.text += "Elapsed time in seconds: " + my_flvPb.playheadTime +
"\n";
};
my_flvPb.addEventListener("cuePoint",listenerObject);
O tempo decorrido é exibido na instância de TextArea quando a reprodução passa por
cada ponto de início incorporado no documento.
Para obter mais informações sobre como trabalhar com o componente FLVPlayback, consulte
“FLVPlayback Component (Flash Professional Only)” na página 505.

Criando pontos de início com o ActionScript para uso com
componentes (somente Flash Professional)
Você pode criar pontos de início com o ActionScript e usá-los com uma instância de objeto de
vídeo ou com um dos componentes de exibição de vídeo (FLVPlayback para Flash Player 8 ou
MediaPlayback para Flash Player 7). Os exemplos a seguir mostram como é fácil usar código
ActionScript para criar pontos de início e, em seguida, usar um script para acessá-los.
NO TA
Incorpore pontos de início em um documento se pretender adicionar a funcionalidade de

navegação a um aplicativo. Para obter mais informações, consulte “Trabalhando com
pontos de início” na página 640. Para ver um exemplo de como trabalhar com pontos
de início incorporados, consulte “Usando pontos de início incorporados com o
componente FLVPlayback (somente Flash Professional)” na página 643.
Para criar e usar pontos de início com o componente FLVPlayback:

1. Crie um novo documento do Flash chamado cueFlvPb.fla.
2. Arraste uma instância do componente FLVPlayback do painel Components
(Componentes), em Window (Janela) > Components, para o Stage (Palco).
O componente está na pasta FLVPlayback - Player 8.
3. Selecione o componente e abra o inspetor Properties (Propriedades), em Window >
4. Digite my_flvPb na caixa de texto Instance Name (Nome da instância).
5. Arraste uma instância do componente TextArea do painel Components para o Stage.
6. Selecione o componente TextArea e digite my_ta na caixa de texto Instance Name.
7. Com o componente TextArea ainda selecionado, digite 200 e 100 nas caixas de texto de
var my_flvPb:mx.video.FLVPlayback;
clouds.flv";
// Criar um objeto cuePoint.

var cuePt:Object = new Object();
cuePt.time = 1;
cuePt.name = "elapsed_time";
cuePt.type = "actionscript";
// Adicionar o ponto de início AS.
my_flvPb.addASCuePoint(cuePt);
// Adicionar outro ponto de início AS.

my_flvPb.addASCuePoint(2, "elapsed_time2");

// Exibir informações de pontos de início no campo de texto.
listenerObject.cuePoint = function(eventObject) {
my_ta.text += "Elapsed time in seconds: " + my_flvPb.playheadTime +
"\n";
};
my_flvPb.addEventListener("cuePoint",listenerObject);
Os seguintes pontos de início aparecem no painel Output (Saída):
Elapsed time in seconds: 1.034
Elapsed time in seconds: 2.102
Para obter informações sobre addASCuePoint(), consulte “FLVPlayback.addASCuePoint()”

na página 552. Para obter informações sobre como trabalhar com pontos de início e o
componente FLVPlayback, consulte “Using cue points” na página 513 e “FLVPlayback
Component (Flash Professional Only)” na página 505.
O exemplo a seguir mostra como adicionar pontos de início durante a execução e rastreá-los
quando um arquivo FLV é reproduzido no componente MediaPlayback.
Para criar e usar pontos de início com o componente MediaPlayback:

1. Crie um novo documento do Flash chamado cuePointMP.fla
2. Arraste uma instância do componente MediaPlayback do painel Components
(Componentes), em Window (Janela) > Components, para o Stage (Palco).
O componente está na pasta Media - Player 6 - 7.
4. Digite my_mb na caixa de texto Instance Name (Nome da instância).
5. Selecione a guia Parameters (Parâmetros) e clique em Launch Component Inspector
(Iniciar Inspetor de componentes).
6. No Component Inspector, digite http://www.helpexamples.com/flash/video/clouds.flv
na caixa de texto URL.
7. Abra o painel Actions (Ações), em Window > Actions, e digite o seguinte código no painel
Script:
import mx.controls.MediaPlayback;
var my_mp:MediaPlayback;
my_mp.autoPlay = false;
my_mp.addEventListener("cuePoint", doCuePoint);
my_mp.addCuePoint("one", 1);
my_mp.addCuePoint("two", 2);
my_mp.addCuePoint("three", 3);

my_mp.addCuePoint("four", 4);
function doCuePoint(eventObj:Object):Void {
trace(eventObj.type + " = {cuePointName:" + eventObj.cuePointName +
" cuePointTime:" + eventObj.cuePointTime + "}");
}
Os seguintes pontos de início aparecem no painel Output (Saída):
cuePoint = {cuePointName:one cuePointTime:1}
cuePoint = {cuePointName:two cuePointTime:2}
cuePoint = {cuePointName:three cuePointTime:3}
cuePoint = {cuePointName:four cuePointTime:4}
Para obter mais informações sobre como trabalhar com o componente MediaPlayback,
consulte “Media components (Flash Professional only)” na página 831. Para obter mais
informações sobre como trabalhar com o componente FLVPlayback, consulte “FLVPlayback
Component (Flash Professional Only)” na página 505.
Adicionando a funcionalidade de busca com pontos de início

(somente Flash Professional)
Você pode incorporar pontos de início de navegação em um arquivo FLV para adicionar a
funcionalidade de busca aos seus aplicativos. O método seekToNavCuePoint() do
componente FLVPlayback localiza no arquivo FLV o ponto de início com o nome definido,
na hora ou após a hora especificada. Você pode especificar um nome como uma seqüência de
caracteres (como "part1" ou "theParty").
Você também pode usar o método seekToNextNavCuePoint(), que busca o próximo ponto
de início de navegação, com base no playheadTime atual. Você pode passar para esse método
um parâmetro, time, que indica a hora a partir da qual o próximo ponto de início de
navegação deve ser procurado. O valor padrão é o playheadTime atual.
Opcionalmente, também é possível buscar uma duração especificada do arquivo FLV, usando
o método seek().
Nos exemplos a seguir, você adicionará um botão que será usado para percorrer vários pontos
de início ou para ir até uma duração especificada em um arquivo FLV que é reproduzido no
componente FLVPlayback, e outro botão para ir até um ponto de início especificado.
Para buscar uma duração especificada:

1. Crie um novo documento do Flash chamado seekduration.fla.
(Componentes), em Window (Janela) > Components.

5. Arraste uma instância do componente Button do painel Components para o Stage (Palco).
6. Selecione o componente Button e digite my_button na caixa de texto Instance Name.
import mx.video.FLVPlayback;
var seek_button:Button;
var my_flvPb:FLVPlayback;
my_flvPb.autoPlay = false;
sheep.flv";
seek_button.label = "Seek";
seek_button.addEventListener("click", seekFlv);
function seekFlv(eventObj:Object):Void {
// buscar 2 segundos
my_flvPb.seek(2);
}
Quando você clica no botão, a reprodução do vídeo é movida para a duração especificada:
2 segundos no vídeo.
Para adicionar a funcionalidade de busca com o componente FLVPlayback:

1. Crie um novo documento do Flash chamado seek1.fla.

cuepoints.flv";
my_button.label = "Next cue point";
function clickMe(){
my_flvPb.seekToNextNavCuePoint();
}
my_button.addEventListener("click", clickMe);
O arquivo cuepoints.flv contém três pontos de início de navegação: um no início, outro
no meio e outro no fim do arquivo de vídeo. Quando você clica no botão, a instância de
FLVPlayback busca o próximo ponto de início até chegar no último ponto de início do
arquivo de vídeo.
Também é possível buscar um ponto de início especificado em um arquivo FLV usando o
método seekToCuePoint(), como mostra o exemplo a seguir.
Para buscar um ponto de início especificado:

1. Crie um novo documento do Flash chamado seek2.fla.
5. Com a instância de FLVPlayback ainda selecionada, clique na guia Parameters
(Parâmetros).
6. Digite http://www.helpexamples.com/flash/video/cuepoints.flv na caixa de texto
contentPath.
Quando o URL é digitado na caixa de texto contentPath, os pontos de início aparecem na
guia Parameters (próximo ao parâmetro cuePoint). Portanto, é possível determinar o nome
do ponto de início a ser localizado no código. Clique no ícone de lupa para exibir todos os
pontos de início do arquivo de vídeo e informações sobre cada ponto em uma tabela.

my_button.label = "Seek to point2";
function clickMe(){
my_flvPb.seekToNavCuePoint("point2");
}
my_button.addEventListener("click", clickMe);
O arquivo cuepoints.flv contém três pontos de início de navegação: um no início, outro
no meio e outro no fim do arquivo de vídeo. Quando você clica no botão, a instância de
FLVPlayback busca o ponto de início especificado (point2).
Para obter mais informações sobre pontos de início, consulte “Using cue points”
na página 513. Para obter mais informações sobre o componente FLVPlayback, consulte
“FLVPlayback Component (Flash Professional Only)” na página 505.
Trabalhando com metadados

Você pode usar o método onMetaData para exibir informações de metadados no arquivo FLV.
Os metadados incluem informações sobre o arquivo FLV, como duração, largura, altura e taxa
de quadros. As informações de metadados adicionadas ao arquivo FLV dependem do software
usado para codificar esse arquivo ou do software usado para adicionar essas informações.
N OT A
Se o arquivo de vídeo não contiver informações de metadados, você poderá usar

ferramentas para adicionar essas informações ao arquivo.
Para trabalhar com NetStream.onMetaData, é necessário ter um Flash Video que contenha
metadados. Se você codificar os arquivos FLV com o Flash 8 Video Encoder, o arquivo FLV
conterá informações de metadados (consulte o exemplo a seguir para obter uma lista de
metadados de um arquivo FLV codificado com o Flash 8 Video Encoder).
NO T A
O Flash Video Exporter 1.2 e versões posteriores (incluindo o Flash 8 Video Exporter)
adicionam os metadados aos arquivos FLV. O Sorenson Squeeze 4.1 e versões
posteriores também adicionam metadados aos arquivos de vídeo.
O exemplo a seguir usa NetStream.onMetaData para rastrear as informações de metadados

de um arquivo FLV codificado com o Flash 8 Video Encoder.
Para usar NetStream.onMetaData para exibir informações de metadados:

1. Crie um novo arquivo FLA chamado flvMetadata.fla.

ActionScript).
desse objeto.
7. Com a instância do vídeo ainda selecionada, digite 320 e 213 nas caixas de texto de largura
e altura, respectivamente.
// Criar um objeto NetConnection.
var netConn:NetConnection = new NetConnection();
// Criar uma conexão de fluxo local.
netConn.connect(null);
// Criar um objeto NetStream e definir uma função onStatus().
var nStream:NetStream = new NetStream(netConn);
// Anexar o fluxo de vídeo NetStream ao objeto Video.
my_video.attachVideo(nStream);
// Definir o tempo do buffer.
nStream.setBufferTime(30);
// Reproduzir o arquivo FLV.
nStream.play("http://www.helpexamples.com/flash/video/
lights_short.flv");
// Rastrear os metadados.
nStream.onMetaData = function(myMeta) {
for (var i in myMeta) {
trace(i + ":\t" + myMeta[i])
}
};
As seguintes informações serão exibidas no painel Output (Saída):
canSeekToEnd:true
audiocodecid:2
audiodelay:0.038
audiodatarate:96
videocodecid:4
framerate:15
videodatarate:400

height:213
width:320
duration:8.04
NO T A
Se o vídeo não incluir áudio, as informações de metadados relacionadas a áudio

(como audiodatarate) retornarão undefined porque nenhuma informação de áudio é
adicionada aos metadados durante a codificação.
O formato a seguir também pode ser usado para exibir a maioria das informações de
metadados. Por exemplo, este código mostra a duração de um arquivo FLV:
nStream.onMetaData = function(myMeta) {
trace("FLV duration: " + myMeta.duration + " sec.");
};
Esse formato não rastreia as informações de metadados cuePoint. Para obter informações
sobre o rastreamento de pontos de início, consulte “Rastreando pontos de início em um
arquivo FLV” na página 641.
Sobre a configuração de arquivos FLV para

hospedagem em um servidor
Ao trabalhar com arquivos FLV, talvez você precise configurar o servidor para usar o formato
de arquivo FLV. O MIME é uma especificação de dados padronizada que permite enviar
arquivos não-ASCII por meio de conexões com a Internet. Os navegadores da Web e os
clientes de e-mail são configurados para interpretar vários tipos MIME de modo que possam
enviar e receber vídeo, áudio, gráficos e texto formatado. Para carregar arquivos FLV de um
servidor Web, talvez seja necessário registrar o tipo MIME e a extensão do arquivo nesse
servidor; portanto, consulte a documentação do servidor. O tipo MIME dos arquivos FLV é
video/x-flv. As informações completas do tipo de arquivo FLV são as seguintes:
Tipo Mime: video/x-flv

Extensão do arquivo: .flv
Parâmetros necessários: nenhum
Parâmetros opcionais: nenhum
Considerações sobre codificação: os arquivos FLV são arquivos binários; alguns aplicativos
podem exigir a definição do subtipo aplicativo/fluxo de octeto.
Questões de segurança: nenhuma
Especificação publicada: www.macromedia.com/go/flashfileformat.

A Microsoft modificou a forma como a mídia de fluxo é tratada no servidor Web Microsoft
Internet Information Services (IIS) 6.0 em relação às versões anteriores. As versões anteriores
do IIS não exigem modificação para transmitir em fluxo o Flash Video. No IIS 6.0, o servidor
Web padrão fornecido com o Windows 2003, um tipo MIME é necessário para que o
servidor reconheça os arquivos FLV como mídia de fluxo.
Quando os arquivos SWF que transmitem em fluxo arquivos FLV externos são colocados em
um servidor Microsoft Windows 2003 e exibidos em um navegador, o arquivo SWF é
reproduzido corretamente, mas o vídeo FLV não é transmitido em fluxo. Esse problema afeta
todos os arquivos FLV colocados no servidor Windows 2003, incluindo os criados com
versões anteriores da ferramenta de criação do Flash, o Macromedia Flash Video Kit for
Dreamweaver MX 2004. Esses arquivos funcionarão corretamente se forem testados em
outros sistemas operacionais.
Para obter informações sobre a configuração do Microsoft Windows 2003 e do Microsoft IIS
Server 6.0 para transmitir em fluxo vídeo FLV, consulte www.macromedia.com/go/tn_19439.
Sobre a definição de arquivos FLV locais como

destino no Macintosh
Se você tentar reproduzir um FLV local de uma unidade não pertencente ao sistema em um
computador Macintosh usando um caminho com uma barra (/), o vídeo não será
reproduzido. As unidades não pertencentes ao sistema incluem, mas não se limitam a, CD-
ROMs, discos rígidos particionados, mídia de armazenamento removível e dispositivos de
armazenamento conectados.
N OT A
Esse problema ocorre devido a uma limitação do sistema operacional, e não a uma
limitação do Flash ou do Flash Player.
Para que um arquivo FLV de uma unidade não pertencente ao sistema seja reproduzido em
um Macintosh, faça referência a ele com um caminho absoluto usando a notação de dois-
pontos (:) em vez de usar a notação de barra (/). A lista a seguir mostra a diferença entre os
dois tipos de notação:
Notação de barra myDrive/myFolder/myFLV.flv
Notação de dois-pontos (Macintosh) myDrive:myFolder:myFLV.flv
Você também pode criar um arquivo projetor para um CD-ROM que será usado para
reprodução no Macintosh. Para obter as informações mais recentes sobre arquivos FLV e CD-
ROMs Macintosh, consulte www.macromedia.com/go/3121b301.

Sobre a criação de animações do
progresso para arquivos de mídia
O ActionScript oferece diversas formas de pré-carregar ou controlar o progresso do download
de mídia externa. Você pode criar animações ou barras de progresso para mostrar visualmente
o progresso do carregamento ou o volume de conteúdo carregado.
Para pré-carregar arquivos SWF e JPEG, use a classe MovieClipLoader, que fornece um
mecanismo de ouvinte de eventos para verificar o progresso do download. Para obter mais
informações, consulte “Pré-carregando arquivos SWF e JPEG” na página 427.
Para controlar o progresso do download de arquivos MP3, use os métodos
Sound.getBytesLoaded() e Sound.getBytesTotal(); para controlar o progresso do
download de arquivos FLV, use as propriedades NetStream.bytesLoaded e
NetStream.bytesTotal. Para obter mais informações, consulte “Pré-carregando arquivos
MP3” na página 420.
Para obter informações sobre a criação de barras de progresso para carregar arquivos de mídia,
■ “Criando uma animação do progresso para carregar arquivos SWF e de imagem”
na página 655
■ “Criando uma barra de progresso para carregar arquivos MP3 com o ActionScript”
na página 657
■ “Criando uma barra de progresso para carregar arquivos FLV com o ActionScript”
na página 659
Há um arquivo de origem de exemplo chamado tweenProgress.fla que usa animação com
script para criar uma animação da barra de progresso. Esse arquivo está localizado na pasta
Samples do seu disco rígido:

Criando uma animação do progresso para carregar
arquivos SWF e de imagem
Ao carregar arquivos SWF ou de imagem grandes em um aplicativo, você poderá criar uma
animação que mostre o progresso do carregamento. Você pode criar uma barra de progresso
que aumente de tamanho à medida que a animação é carregada. Também pode criar uma
animação que seja alterada à medida que o arquivo é carregado. Para obter informações sobre
como carregar arquivos SWF e de imagem, consulte “Carregando arquivos SWF e de imagem
externos” na página 621.
O exemplo a seguir mostra como usar a classe MovieClipLoader e a API (Application
Programming Interface, Interface de programação de aplicativos) Drawing para exibir o
progresso do carregamento de um arquivo de imagem.
Para criar uma barra de progresso para carregar arquivos de imagem ou SWF:
1. Crie um novo documento do Flash chamado loadImage.fla.
2. Selecione Modify (Modificar) > Document (Documento) e digite 700 e 500 nas caixas de
texto de largura e altura, respectivamente, para alterar as dimensões do documento.
//criar clipes para armazenar o conteúdo
this.createEmptyMovieClip("progressBar_mc", 0);
progressBar_mc.createEmptyMovieClip("bar_mc", 1);
progressBar_mc.createEmptyMovieClip("stroke_mc", 2);
//usar métodos de desenho para criar uma barra de progresso
with (progressBar_mc.stroke_mc) {
lineStyle(0, 0x000000);
moveTo(0, 0);
lineTo(100, 0);
lineTo (100, 10);
lineTo(0, 10);
lineTo(0, 0);
}
with (progressBar_mc.bar_mc) {
moveTo(0, 0);
lineTo(100, 0);
lineTo(100, 10);
lineTo(0, 10);
lineTo(0, 0);
endFill();
_xscale = 0;
}
progressBar_mc._x = 2;
progressBar_mc._y = 2;
Sobre a criação de animações do progresso para arquivos de mídia 655

// progresso do carregamento
var loadListener:Object = new Object();
mclListener.onLoadStart = function(target_mc:MovieClip) {
progressBar_mc.bar_mc._xscale = 0;
};
bytesLoaded:Number, bytesTotal:Number) {
progressBar_mc.bar_mc._xscale = Math.round(bytesLoaded/
bytesTotal*100);
};
mclListener.onLoadComplete = function(target_mc:MovieClip) {
progressBar_mc.removeMovieClip();
};
target_mc._height = 500;
target_mc._width = 700;
};
//Criar um clipe para armazenar a imagem.
this.createEmptyMovieClip("loadTarget_mc", this.getNextHighestDepth());
var image_mcl:MovieClipLoader = new MovieClipLoader();
image_mcl.addListener(mclListener);
/* Carregar a imagem no clipe.
Você pode alterar o URL a seguir para um arquivo SWF ou outro arquivo de
imagem. */
image_mcl.loadClip("http://www.helpexamples.com/flash/images/gallery1/
images/pic3.jpg", image_mc);
4. Selecione Control (Controlar) > Test Movie (Testar filme) para ver o carregamento da
imagem e a barra de progresso.
NO T A
Se você testar esse código uma segunda vez, a imagem será armazenada em cache,
e a barra de progresso será encerrada imediatamente. Para testar várias vezes, use
diferentes imagens e carregue-as a partir de uma origem externa. Uma origem local
poderá ocasionar problemas durante o teste do aplicativo porque o conteúdo é
carregado muito rápido.


Você também pode encontrar exemplos de aplicativos de galeria de fotos. Esses arquivos
mostram como usar o ActionScript para controlar clipes de filme dinamicamente ao carregar
arquivos de imagem em um arquivo SWF. Os arquivos de origem de exemplo, gallery_tree.fla
e gallery_tween.fla, podem ser encontrados na pasta Samples do seu disco rígido.
Criando uma barra de progresso para carregar

arquivos MP3 com o ActionScript
O exemplo a seguir carrega várias músicas em um arquivo SWF. Uma barra de progresso,
criada com a API Drawing, mostra o progresso do carregamento. Quando o carregamento da
música inicia e é concluído, o painel Output (Saída) exibe informações. Para obter
informações sobre como carregar arquivos MP3, consulte “Carregando um arquivo MP3”
na página 627.
Para criar uma barra de progresso para carregar arquivos MP3:

1. Crie um novo documento do Flash chamado loadSound.fla.
no painel Actions (Ações).
var pb_height:Number = 10;
var pb_width:Number = 100;
var pb:MovieClip = this.createEmptyMovieClip("progressBar_mc",
this.getNextHighestDepth());
pb.createEmptyMovieClip("bar_mc", pb.getNextHighestDepth());
pb.createEmptyMovieClip("vBar_mc", pb.getNextHighestDepth());
pb.createEmptyMovieClip("stroke_mc", pb.getNextHighestDepth());
pb.createTextField("pos_txt", pb.getNextHighestDepth(), 0, pb_height,
pb_width, 22);
pb._x = 100;
pb._y = 100;
with (pb.bar_mc) {
beginFill(0xFF0000);
moveTo(0, 0);
lineTo(pb_width, 0);
lineTo(pb_width, pb_height);
lineTo(0, pb_height);
lineTo(0, 0);
endFill();

_xscale = 0;
}
with (pb.vBar_mc) {
moveTo(0, 0);
}
with (pb.stroke_mc) {
moveTo(0, 0);
lineTo(pb_width, 0);
lineTo(pb_width, pb_height);
lineTo(0, 0);
}
var my_interval:Number;
my_sound.onLoad = function(success:Boolean) {
if (success) {
trace("sound loaded");
}
};
my_sound.onSoundComplete = function() {
clearInterval(my_interval);
trace("Cleared interval");
}
my_sound.loadSound("http://www.helpexamples.com/flash/sound/song2.mp3",
true);
my_interval = setInterval(updateProgressBar, 100, my_sound);
function updateProgressBar(the_sound:Sound):Void {
var pos:Number = Math.round(the_sound.position / the_sound.duration *
100);
pb.bar_mc._xscale = pos;
pb.vBar_mc._x = pb.bar_mc._width;
pb.pos_txt.text = pos + "%";
}
3. Selecione Control (Controlar) > Test Movie (Testar filme) para carregar o arquivo MP3 e
observe a barra de progresso.
NO T A
Se você testar esse código uma segunda vez, a imagem será armazenada em cache,
e a barra de progresso será encerrada imediatamente. Para testar várias vezes, use
diferentes imagens e carregue-as a partir de uma origem externa. Uma origem local
poderá ocasionar problemas durante o teste do aplicativo porque o conteúdo é
carregado muito rápido.

Para obter mais informações sobre o uso de som, consulte a entrada da classe Sound,
%{Sound}%, em ActionScript 2.0 Language Reference.
A pasta Samples do disco rígido também contém um arquivo de origem de exemplo,
jukebox.fla, que carrega arquivos MP3. Esse exemplo demonstra como criar um jukebox
usando tipos de dados, princípios gerais de codificação e vários componentes.
Criando uma barra de progresso para carregar

arquivos FLV com o ActionScript
Você pode criar uma barra de progresso para exibir o progresso do carregamento de um
arquivo FLV. Para obter informações sobre como carregar arquivos FLV em um arquivo SWF,
consulte “Pré-carregando arquivos FLV” na página 639. Para obter outras informações sobre
arquivos FLV e o Flash, consulte “Sobre o uso de vídeo FLV” na página 632.
O exemplo a seguir usa a API Drawing para criar uma barra de progresso. O exemplo também
usa as propriedades bytesLoaded e bytesTotal para mostrar o progresso do carregamento do
arquivo video1.flv na instância do objeto de vídeo chamada my_video. O campo de texto
loaded_txt é criado dinamicamente para mostrar informações sobre o progresso do
carregamento.
Para criar uma barra de progresso que mostra o progresso do carregamento:

1. Crie um novo arquivo FLA chamado flvProgress.fla.
ActionScript).

desse objeto.
7. Com a instância do vídeo selecionada, digite 320 e 213 nas caixas de texto de largura e
altura, respectivamente.
stream_ns.play("http://www.helpexamples.com/flash/video/
typing_short.flv");
this.createTextField("loaded_txt", this.getNextHighestDepth(), 10, 10,

160, 22);
this.createEmptyMovieClip("progressBar_mc", this.getNextHighestDepth());
progressBar_mc.createEmptyMovieClip("bar_mc",
progressBar_mc.getNextHighestDepth());
with (progressBar_mc.bar_mc) {
beginFill( 0xFF0000 );
moveTo(0, 0);
lineTo(100, 0);
lineTo(100, 10);
lineTo(0, 10);
lineTo(0, 0);
endFill();
_xscale = 0;
}
progressBar_mc.createEmptyMovieClip("stroke_mc",
progressBar_mc.getNextHighestDepth());
with (progressBar_mc.stroke_mc) {
moveTo(0, 0);
lineTo(100, 0);
lineTo(100, 10);
lineTo(0, 10);
lineTo(0, 0);
}
var loaded_interval:Number = setInterval(checkBytesLoaded, 500,

stream_ns);
function checkBytesLoaded(my_ns:NetStream) {

var pctLoaded:Number = Math.round(my_ns.bytesLoaded /
my_ns.bytesTotal * 100);
loaded_txt.text = Math.round(my_ns.bytesLoaded / 1000) + " of " +
Math.round(my_ns.bytesTotal / 1000) + " KB loaded (" + pctLoaded +
"%)";
progressBar_mc.bar_mc._xscale = pctLoaded;
if (pctLoaded>=100) {
clearInterval(loaded_interval);
}
}
O vídeo é carregado, e uma barra com animação e a alteração dos valores de texto
informam o progresso do carregamento. Se esses elementos se sobrepuserem ao vídeo,
mova o objeto de vídeo no Stage. Você pode personalizar a cor da barra de progresso
modificando beginFill e lineStyle no trecho de código anterior.
N OT A
Se a barra de progresso for carregada instantaneamente, o vídeo será armazenado

em cache no disco rígido (tanto a partir do teste deste exemplo ou do seu
carregamento em outro procedimento). Se isso ocorrer, faça upload de um arquivo
FLV no servidor e carregue esse arquivo.


CAPÍTULO 16
Trabalhando com dados

externos
16
No Macromedia Flash Basic 8 e no Macromedia Flash Professional 8, é possível usar o
ActionScript para carregar dados de origens externas em um arquivo SWF.Também é possível
enviar dados, que poderiam ser fornecidos pelo suário ou servidor, de um arquivo SWF para
um servidor de aplicativos (como o Macromedia ColdFusion ou o Macromedia JRun) ou
outro tipo de script de servidor, como PHP ou Perl. O Flash Player pode enviar e carregar
dados através do HTTP, HTTPS ou carregar de um arquivo de texto local. Você também
pode criar conexões persistentes de soquete TCP/IP para aplicativos que exijam baixa latência,
por exemplo, aplicativos de bate-papo ou serviços de cotação de ações. O recurso de carregar
arquivos do computador do usuário em um servidor e fazer download dos arquivos de um
servidor para o computador do usuário é novo no Flash Player 8.
É possível formatar os dados carregados ou enviados de um arquivo SWF como XML
(Extensible Markup Language, Linguagem de marcação extensível) ou como pares nome/
valor.
O Flash Player também pode enviar e receber dados do ambiente de host, um navegador da
Web, por exemplo, ou de outra instância do Flash Player no mesmo computador ou página da
Web.
Por padrão, um arquivo SWF pode acesasr somente os dados residentes exatamente no mesmo
domínio (por exemplo, www.macromedia.com). Para obter mais informações, consulte
“Sobre domínios, segurança entre domínios e arquivos SWF” na página 727.)
Para obter mais informações sobre como trabalhar com dados externos, consulte os seguintes
tópicos:
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
663
Enviando e carregando variáveis
Um arquivo SWF é uma janela para a captura e exibição de informações, semelhante a uma
página HTML. Contudo, os arquivos SWF podem permanecer carregados no navegador e ser
constantemente atualizados com novas informações sem a necessidade do recarregamento da
página inteira. Com as funções e os métodos do ActionScript, você pode enviar e receber
informações de arquivos de texto, arquivos XML e scripts de servidor.
Além disso, os scripts de servidor podem solicitar informações específicas a um banco de
dados e retransmiti-las para um arquivo SWF. Os scripts do servidor podem ser escritos em
diversas linguagens: as mais comuns são CFML, Perl, ASP (Microsoft Active Server Pages,
Páginas de servidor ativo da Microsoft) e PHP. Com o armazenamento e recuperação de
informações em um banco de dados, você pode criar um conteúdo dinâmico e personalizado
para o arquivo SWF. Por exemplo, você pode criar um quadro de mensagens, perfis pessoais
para usuários ou um carrinho de compras para controlar as compras de um usuário.
Várias funções e métodos do ActionScript permitem passar informações para/de um arquivo
SWF. Cada função ou método usa um protocolo para transferir as informações e requer que
elas sejam formatadas de uma determinada maneira.
■ As funções e os métodos de MovieClip que usam o protocolo HTTP ou HTTPS para
enviar informações em um formato de código URL são getURL(), loadVariables(),
loadVariablesNum(), loadMovie() e loadMovieNum().
■ Os métodos LoadVars que usam o protocolo HTTP ou HTTPS para enviar e carregar
informações em formato de código URL são load(), send() e sendAndLoad().
■ Os métodos que usam o protocolo HTTP ou HTTPS para enviar e carregar informações
como XML são XML.send(), XML.load() e XML.sendAndLoad().
■ Os métodos que criam e usam uma conexão de soquete TCP/IP para enviar e carregar
informações como XML são XMLSocket.connect() e XMLSocket.send().
■ “Verificando os dados carregados” na página 664
■ “Criando uma barra de progresso para exibir o progresso do carregamento dos dados”
na página 666
Verificando os dados carregados

Todas as funções ou métodos que carregam dados em um arquivo SWF (exceto
XMLSocket.send()) são assíncronas: os resultados da ação são retornados em um momento
indeterminado.
664 Trabalhando com dados externos

Antes de usar dados carregados em um arquivo SWF, verifique se eles foram realmente
carregados. Por exemplo, você pode carregar variáveis e manipular seus valores no mesmo
script, pois os dados a serem manipulados não existirão no arquivo até que ele seja carregado.
No script a seguir, você só poderá usar a variável lastSiteVisited quando tiver certeza de
que ela foi carregada do arquivo myData.txt. No arquivo myData.txt, haverá texto
semelhante ao seguinte exemplo:
lastSiteVisited=www.macromedia.com
Se você tiver usado o seguinte código, não poderá rastreiar os dados que estão sendo
carregados:
loadVariables("myData.txt", 0);
trace(lastSiteVisited); // undefined
Cada função ou método possui uma técnica específica que pode ser usada para verificar os
dados que foram carregados. Se usar %{loadVariables function}% ou %{loadMovie
function}%, você poderá carregar informações em um destino de clipe de filme e usar o
manipulador onData para executar um script. Se você usar %{loadVariables function}% para
carregar os dados, o manipulador onData será executado quando a última variável for
carregada. Se você usar %{loadMovie function}% para carregar os dados, o manipulador
onData será executado sempre que um fragmento do arquivo SWF for enviado ao Flash
Player.
Por exemplo, o ActionScript a seguir carrega as variáveis do arquivo myData.txt no clipe de
filme loadTarget_mc. Um manipulador onData() para a instância loadTarget_mc usa a
variável lastSiteVisited, carregada do arquivo myData.txt. As seguintes ações de
rastreamentosó são exibidas depois que todas as variáveis, incluindo lastSiteVisited, são
carregadas:
this.createEmptyMovieClip("loadTarget_mc", this.getNextHighestDepth());
this.loadTarget_mc.onData = function() {
trace("Data Loaded");
trace(this.lastSiteVisited);
};
loadVariables("myData.txt", this.loadTarget_mc);
Se você usar os métodos XML.load(), XML.sendAndLoad() e XMLSocket.connect(), deverá

definir um manipulador para processar os dados quando eles chegarem. Esse manipulador é
uma propriedade do objeto XML ou XMLSocket à qual você atribui uma função definida. Os
manipuladores são chamados automaticamente quando as informações são recebidas. Para o
objeto XML, use XML.onLoad() ou XML.onData(). Para o objeto XMLSocket,
use XMLSocket.onConnect().
Enviando e carregando variáveis 665

Para obter mais informações, consulte “Usando a classe XML” na página 684 e “Usando a
classe XMLSocket” na página 690. Para obter mais informações sober como usar o LoadVars
para enviar e carregar os dados que podem ser processados após seu recebimento, consulte
“Usando a classe LoadVars” na página 670.
Criando uma barra de progresso para exibir o

progresso do carregamento dos dados
O exercício a seguir cria dinamicamente um pré-carregador simples utilizando a API
(application programming interface, interface de programação de aplicativos) do aplicativo de
desenho e exibe o progresso de carregamento para um documento XML.
DICA
Se o carregamento do arquivo XML remoto for executado rápido demais para permitir a
visualização do efeito de pré-carregamento, tente carregar um arquivo XML maior na
Internet.
Criando uma barra de progresso com a API do aplicativo de desenho:

1. Crie um novo documento do Flash e salve-o como drawapi.fla.
principal:
var barWidth:Number = 200;
var barHeight:Number = 6;
this.createEmptyMovieClip("pBar_mc", 9999);
var bar:MovieClip = pBar_mc.createEmptyMovieClip("bar_mc", 10);
bar.beginFill(0xFF0000, 100);
bar.moveTo(0, 0);
bar.lineTo(barWidth, 0);
bar.lineTo(barWidth, barHeight);
bar.lineTo(0, barHeight);
bar.lineTo(0, 0);
bar.endFill();
bar._xscale = 0;
var stroke:MovieClip = pBar_mc.createEmptyMovieClip("stroke_mc", 20);

stroke.lineStyle(0, 0x000000);
stroke.moveTo(0, 0);
stroke.lineTo(barWidth, 0);
stroke.lineTo(barWidth, barHeight);
stroke.lineTo(0, barHeight);
stroke.lineTo(0, 0);
pBar_mc.createTextField("label_txt", 30, 0, barHeight, 100, 21);

pBar_mc.label_txt.autoSize = "left";
pBar_mc.label_txt.selectable = false;

pBar_mc._x = (Stage.width - pBar_mc._width) / 2;
pBar_mc._y = (Stage.height - pBar_mc._height) / 2;

my_xml.onLoad = function(success:Boolean) {
pBar_mc.onEnterFrame = undefined;
if (success) {
trace("XML loaded successfully");
} else {
trace("Unable to load XML");
}
};
my_xml.load("http://www.helpexamples.com/flash/xml/ds.xml");
pBar_mc.onEnterFrame = function() {
var pctLoaded:Number = Math.floor(my_xml.getBytesLoaded() /
my_xml.getBytesTotal() * 100);
if (!isNaN(pctLoaded)) {
pBar_mc.bar_mc._xscale = pctLoaded;
pBar_mc.label_txt.text = pctLoaded + "% loaded";
if (pctLoaded >= 100) {
pBar_mc.onEnterFrame = undefined;
}
}
};
O código anterior divide-se em sete seções. A primeira define a largura e a altura da barra
de progresso quando desenhada no Stage (Palco). A barra de progresso será centralizada no
Stage na próxima seção. A próxima seção de código cria dois clipes de filme, pBar_mc e
bar_mc. O clipe de filme bar_mc é aninhado dentro de pBar_mc e desenha um retângulo
vermelho no Stage. A instância de bar_mc modifica sua propriedade _xscale quando o
arquivo XML externo é carregado a partir do site da Web remoto.
Em seguida, um segundo clipe de filme é aninhado dentro do clipe de filme pBar_mc,
stroke_mc. O clipe de filme stroke_mc desenha um contorno no Stage que corresponde
às dimensões especificadas pelas variáveis barHeight e barWidth definidas na primeira
seção. A quarta seção do código cria, dentro do clipe de filme pBar_mc, um campo de
texto usado para exibir a porcentagem do arquivo XML já carregada, semelhante ao rótulo
no componente ProgressBar. Em seguida, o clipe de filme pBar_mc (que inclui as
instâncias aninhadas de bar_mc, stroke_mc e label_txt) é centralizado no Stage.
Enviando e carregando variáveis 667

A sexta seção do código define uma nova instância do objeto XML, usada para carregar
um arquivo XML externo. Um manipulador de eventos onLoad é definido e rastreia uma
mensagem para o painel Output (Saída). O manipulador de eventos onLoad também
exclui o manipulador de eventos onEnterFrame (definido na próxima seção) do clipe de
filme pBar_mc. A última seção do código define um manipulador de eventos
onEnterFrame para o clipe de filme pBar_mc. Esse manipulador de eventos monitora o
quanto do arquivo XML externo foi carregado e modifica a propriedade _xscale do clipe
de filme bar_mc. Priemiro, o manipulador de eventos onEnterFrame calcula a
porcentagem do arquivo cujo download já terminou. Contanto que a porcentagem do
arquivo carregada seja um número válido, a propriedade _xscale de bar_mc será definida
e o campo de texto em pBar_mc exibirá essa porcentagem. Se o carregamento do arquivo
tiver sido concluído (alcançando 100%), o manipulador de eventos onEnterFrame será
excluído para que o progresso do download não seja mais monitorado.
Flash.
A medida que o arquivo XML externo é carregado, o clipe de filme bar_mc aninhado é
redimensionado para exibir o progresso de download do XML. Após a conclusão do
carregamento do arquivo XML, o manipulador de eventos onEnterFrame erá excluído
para que nã o continue calculando o progresso do download. Dependendo da rapidez da
conclusão do download, você poderá visualizar a barra crescendo lentamente até que
bar_mc fique da mesma largura que o clipe de filme stroke_mc. Se o download for muito
rápido, a barra de progresso poderá ir de 0% a 100% velozmente, tornando difícil a
visualização do efeito; nesse caso, talvez seja necessário tentar o download de um arquivo
XML maior.
Usando HTTP para conectar a scripts do

servidor
As funções %{loadVariables function}%, %{loadVariablesNum function}%, %{getURL
function}%, %{loadMovie function}%, %{loadMovieNum function}% e os métodos
%{loadVariables (método MovieClip.loadVariables)}%, %{loadMovie (método
MovieClip.loadMovie)}%, e %{getURL (método MovieClip.getURL)}% podem se
comunicar com scripts de servidor usando protocolos HTTP ou HTTPS.Esses métodos e
funções enviam todas as variáveis da Timeline Linha de tempo) à qual a função está anexada.
Quando usadas como métodos do objeto MovieClip, as funções loadVariables(),
getURL() e loadMovie() enviam todas as variáveis do clipe de filme especificado. Cada
função (ou método) manipula sua resposta da seguinte maneira:

■ A função getURL() retorna todas as informações para uma janela do navegador e não para
o Flash Player.
■ O métodoloadVariables() carrega as variáveis em uma Timeline ou nível especificado
do Flash Player.
■ O método loadMovie() carrega um arquivo SWF em um nível especificado ou um clipe
de filme no Flash Player.
Ao usar a função loadVariables(), getURL() ou loadMovie(), você pode especificar
vários parâmetros:
■ URL é o arquivo onde residem as variáveis remotas.
■ Local é o nível ou o destino no arquivo SWF que recebe as variáveis. (A função getURL()
não requer esse parâmetro.)
(Para obter mais informações sobre níveis e destinos, consulte Capítulo 1, “Sobre várias
timelines (linhas de tempo) e níveis” em Usando o Flash.)
■ Variables define o método HTTP, GET (anexa as variáveis ao final do URL) ou POST
(envia as variáveis em um cabeçalho HTTP separado), pelo qual as variáveis são enviadas.
Quando esse parâmetro é omitido, o Flash Player adota como padrão GET, mas nenhuma
variável é enviada.
Por exemplo, para controlar as pontuações mais altas de um jogo, você pode armazená-las em
um servidor e usar uma função loadVariables() para carregá-las no arquivo SWF sempre
que alguém jogar o jogo. A chamada de função seria semelhante ao seguinte exemplo:
this.createEmptyMovieClip("highscore_mc", 10);
loadVariables("http://www.helpexamples.com/flash/highscore.php",
highscore_mc, "GET");
Esse exemplo carrega as variáveis do script ColdFusion chamado high_score.cfm na instância

de clipe de filme scoreClip usando o método HTTP GET.
Todas as variáveis carregadas com a função loadVariables() devem estar no formato padrão
de aplicativo MIME/x-www-form-urlencoded (um formato padrão usado pelos scripts CFM e
CGI). O arquivo especificado no parâmetro URL de loadVariables() deve gravar a variável e
os pares de valroes nesse formato para que o Flash possa lê-los. Esse arquivo pode especificar
qualquer número de avriáveis; a variável e os pares de valroes devem ser separados com um E
comercial (&), e as palavras contidas em um valor devem ser separadas por um sinal de adição
(+). Por exemplo, a frase abaixo define diversas variáveis:
highScore1=54000&playerName1=RGoulet&highScore2=53455&playerName2=
WNewton&highScore3=42885&playerName3=TJones
NO T A
Você pode precisar codificar por URL determinados caracteres, como o sinal de adição
(+) ou E comercial (&). Para obter mais informações, consulte www.macromedia.com/
go/tn_14143.
Usando HTTP para conectar a scripts do servidor 669

Para obter mais informações, consulte o seguinte tópico: “Usando a classe LoadVars”
na página 670. Além disso, consulte as entradas %{loadVariables function}%, %{getURL
function}%, %{loadMovie function}% e %{LoadVars}% em ActionScript 2.0 Language
Reference.
Usando a classe LoadVars

Se você estiver publicando no Flash Player 6 ou posterior e quiser mais flexibilidade do que a
oferecida por loadVariables(), poderá usar a classe LoadVars em vez de transferir variáveis
entre um arquivo SWF e um servidor.
A classe LoadVars foi incluída no Flash Player 6 para oferecer uma interface mais limpa e mais
orientada a objeto para a tarefa comum de trocar dados CGI com um servidor Web. As
vantagens da classe LoadVars são as seguintes:
■ Não é necessário criar clipes de filme de recipiente para armazenar dados ou agrupar clipes
de filme existentes com variáveis específicas da comunicação cliente/servidor.
■ A interface da classe é semelhante ao objeto XML, o que proporciona alguma consistência
no ActionScript. Ela usa os métodosd load(), send() e sendAndLoad() para iniciar a
comunicação com um servidor. A principal diferença entre as classes LoadVars e XML é
que os dados de LoadVars são uma propriedade do objeto LoadVars, em vez de uma árvore
DOM (Document Object Model, Modelo de objetos de documentos) XML armazenada
no objeto XML.
■ A interface da classe é mais direta, com os métodos chamados load, send, sendAndLoad,
do que a interface loadVariables mais antiga.
■ Você pode obter informações adicionais sobre a comunicação, usando os métodos
getBytesLoaded e getBytesTotal
■ Você pode obter informações de progresso sobre o download dos dados (embora não possa
acesasr os dados até que sejam totalmente descarregados).
■ A interface de retorno de chamada utiliza os métodos do ActionScript (onLoad) em vez
do método obsoleto onClipEvent (dados) necessário para loadVariables.
■ Há notificações de erro.
■ É possível adcionar cabeçalhos de solicitação HTTP personalizados.
Você precisa criar um objeto LoadVars para chamar seus métodos. Esse objeto é um recipiente
que mantém os dados carregados.

O procedimento a seguir mostra como usar ColdFusion e a classe LoadVars para enviar um e-
mail de um arquivo SWF.
NO T A
Você deve ter instalado o ColdFusion no navegador da Web para este exemplo.
Para carregar dados com o objeto LoadVars:

1. Crie um arquivo CFM no Macromedia Dreamweaver ou no seu editor de texto favorito.
Adicione o código a seguir ao arquivo:
<cfif StructKeyExists(Form, "emailTo")>
<cfmail to="#Form.emailTo#" from="#Form.emailFrom#"
subject="#Form.emailSubject#">#Form.emailBody#</cfmail>
&result=true
<cfelse>
&result=false
</cfif>
2. Salve o arquivo como email.cfm e carregue-o no seu site da Web.

3. No Flash, crie um novo documento.
4. Crie quatro campos de texto de entrada no Stage (Palco) e atribua-lhes os seguintes nomes
de instância: emailFrom_txt, emailTo_txt, emailSubject_txt e emailBody_txt.
5. Crie um campo de texto dinâmico no Stage e atribua a ele o nome de instância debug_txt.
6. Crie um símbolo de botão, arraste uma istância para o Stage (Palco) e denomine-a como
submit_btn.
7. Selecione Frame 1 (Quadro 1) na Timeline e abra o painel Actions (Ações), em Window
(Janela) > Actions, caso ainda não esteja aberto.
8. Insira o código a seguir no painel Actions (Ações):
this.submit_btn.onRelease = function() {
var emailResponse:LoadVars = new LoadVars();
emailResponse.onLoad = function(success:Boolean) {
if (sucesso) {
debug_txt.text = this.result;
} else {
debug_txt.text = "error downloading content";
}
};
var email:LoadVars = new LoadVars();
email.emailFrom = emailFrom_txt.text;
email.emailTo = emailTo_txt.text;
email.emailSubject = emailSubject_txt.text;
email.emailBody = emailBody_txt.text;

email.sendAndLoad("http://www.yoursite.com/email.cfm", emailResponse,
"POST");
};
Este código ActionScript cria uma nova instância do objeto LoadVars, copia os valores dos
campos de texto para ela e envia os dados ao servidor. O arquivo CFM envia o e-mail e
retorna uma variável (true ou false) ao arquivo SWF chamada result, que é exibida
no campo de texto debug_txt.
NO T A
Lembre-se de atlerar o URL www.yoursite.com para seu próprio domínio.
9. Salve o documento como sendEmail.fla e publique-o selecionando File (Arquivo) >

Publish (Publicar).
10. Carregue sendEmail.swf no mesmo diretóri que contém email.cfm (o arquivo ColdFusion
salvo e carregado na etapa 2).
11. Exiba e teste o arquivo SWF em um navegador.
Para obter mais informações, consulte a entrada %{LoadVars}% em ActionScript 2.0 Language
Reference.
O Flash Player 8 introduziu o manipulador de eventos onHTTPStatus para as classes
LoadVars, XML e MovieClipLoader, com o objetivo de permitir que os usuários acessem o
código de status de uma solicitação HTTP. Isso permite que os desenvolvedores determinem
por que uma determinada operação de carregamento falhou, em vez de apenas detectarem que
uma operação desse tipo já falhou.
O exemplo a seguir mostra como você pode usar o manipulador de eventos onHTTPStatus da
classe LoadVars para verificar se o download de um arquivo de texto foi realizado com êxito do
servidor e qual o código de status retornado da solicitação HTTP.
Para verificar o status HTTP com o objeto LoadVars:

1. Crie um novo documento do Flash e salve-o como loadvars.fla.
principal:
this.createTextField("params_txt", 10, 10, 10, 100, 21);
params_txt.autoSize = "left";

my_lv.onHTTPStatus = function(httpStatus:Number) {
trace("HTTP status is: " + httpStatus);
};
my_lv.onLoad = function(success:Boolean) {
if (success) {
trace("text file successfully loaded");

params_txt.text = my_lv.dayNames;
} else {
params_txt.text = "unable to load text file";
}
};
my_lv.load("http://www.helpexamples.com/flash/404.txt");
/* output:
Error opening URL "http://www.helpexamples.com/flash/404.txt"
HTTP status is: 404
*/
O código anterior cria um novo campo de texto no Stage e permite o dimensionamento

automático desse campo. Em seguida, são criados um objeto LoadVars e dois
manipuladores de eventos: onHTTPStatus e onLoad. O manipulador de eventos
onHTTPStatus é novo no Flash Player 8 e é chamado quando a operação
LoadVars.load() ou LoadVars.sendAndLoad() é concluída. O valor passado para a
função do manipulador de eventos onHTTPStatus (httpStatus no código anterios)
contém a definição do código de status HTTP para a operação de carregamento atual. Se
o arquivo SWF foi carregado com êxito no arquivo de texto, o valor de httpStatus será
definido como 200 (código de status HTTP para “OK”). Se o arquivo não existisse no
servidor, o valor de httpStatus seria definido para 404 (código de status HTTP para
“Não encontrado”). O segundo manipulador de eventos, LoadVars.onLoad(), é
chamado após a conclusão do carregamento do arquivo. Se o arquivo for carregado com
êxito, o valor do parâmetro success (sucesso) será definido como true (verdadeiro), caso
contrário, o parâmetro success será definido como false (falso). Finalmente, o arquivo
externo será carregado usando-se o método LoadVars.load().
Flash.
O Flash exibe uma mensagem de erro no painel Output (Saída) afirmando que não pode
carregar a imagem porque ela não existe no servidor. O manipulador de eventos
onHTTPStatus rastreia o código de status 404 porque não foi possível encontrar o arquivo
no servidor, e o manipulador de eventos onLoad define a propriedade do campo de texto
params_txt como “unable to load text file” (incapaz de carregar o arquivo de texto).
A T E NÇ Ã O
Se um servidor da Web não retornar um código de status para o Flash Player, o

número 0 será retornado para o manipulador de eventos onHTTPStatus.

Sobre upload e download de arquivos
A classe FileReference permite adicionar a capacidade de carregar e fazer download de
arquivos entre um cliente e um servidor. Os usuários podem carregar ou fazer download de
arquivos entre seus computadores e um servidor. Os usuários devem selecionar um arquivo a
ser carregado ou um local para download em uma caixa de diálogo (como a caixa de diálogo
Abrir do sistema operacional Windows).
Cada objeto FileReference que você cria com o ActionScript refere-se a um único arquivo no
disco rígido do usuário. O objeto tem propriedades que contêm informações sobre o tamanho
do arquivo, seu tipo, nome, data de criação e data de modificação. No Macintosh, também há
uma propriedade para o tipo de autor do arquivo.
Você pode criar uma instância da classe FileReference de duas maneiras. Você pode usar o
seguinte operador new (novo):
import flash.net.FileReference;
var myFileReference:FileReference = new FileReference();
Ou, você pode chamar o método FileReferenceList.browse(), que abre uma caixa de
diálogo no sistema do usuário para solicitar que ele selecione um arquivo para carregar e criará
um array de objetos FileReference se o usuário selecionar um ou mais arquivos com êxito.
Cada objeto FileReference representa um arquivo selecionado pelo usuário na caixa de
diálogo. Um objeto FileReference não conterá nenhum dado nas propriedades FileReference
(como name, size ou modificationDate) até que o método FileReference.browse() ou
FileReferenceList.browse() seja chamado e o usuário selecione um arquivo no seletor de
arquivos ou até que o método FileReference.download() seja usado para selecionar um
item no seletor de arquivos.
N OT A
FileReference.browse() permite que o usuário selecione um único arquivo.

FileReferenceList.browse() permite que o usuário selecione vários arquivos.
Após a realização de uma chamada bem-sucedida para o método browse(), chame

FileReference.upload() para carregar um arquivo de cada vez.

Também é possível adicionar a funcionalidade de download ao seu aplicativo Flash. O método
FileReference.download() solicita aos usuários finais um local em seus discos rígidos para
salvar o arquivo de um servidor. Esse método também inicia o download de um URL remoto.
Durante o uso do método download(), somente a propriedade FileReference.name pode
ser acessada quando o evento onSelect é disparado. As outras propriedades só poderão ser
acessadas quando o evento onComplete for disparado.
NO TA
quando uma caixa de diálogo é exibida no computador do usuário final, o local padrão
mostrado nessa caixa é a pasta utilizada mais recentemente (se por possível determinar
esse local) ou a área de trabalho (se não for possível determinar a pasta mais recente).
As APIs de FileReference e FileReferenceList não permitem que você defina o local
padrão do arquivo
Para obter informações sobre a funcionalidade e a segurança da API de FileReference, consulte

“Sobre a funcionalidade e a segurança da API de FileReference API” na página 675. Para obter
um exemplo de um aplicativo que usa a API de FileReference, consulte “Adicionando a
funcionalidade de carregamento de arquivo a um aplicativo” na página 676. Você poderá
encontrar o arquivo de origem de exemplo, FileUpload.fla, na pasta Samples (Exemplos) no
disco rígido.
■ No Windows, vá para unidade de inicialização\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\FileUpload.
■ No Macintosh, vá para HD Macintosh/Applications/Macromedia Flash 8/Samples and
Tutorials/Samples/ActionScript/FileUpload.
Para obter informações sobre cada método, propriedade e evento da API de FileReference,
consulte %{FileReference (flash.net.FileReference)}% e %{FileReferenceList
(flash.net.FileReferenceList)}% em ActionScript 2.0 Language Reference.
Sobre a funcionalidade e a segurança da API de

FileReference API
O Flash Player e a API de FileReference (consulte “Sobre upload e download de arquivos”
na página 674) oferecem suporte ao carregamento e download de arquivos de até 100 MB. A
API de FileReference não permite que o aplicativo Flash que inicia a transferência de arquivo
faça o seguinte:
■ Acesse o arquivo carregado ou cujo download foi realizado
■ Acesse o caminho do arquivo no computador do usuário
Sobre upload e download de arquivos 675

Quando um servidor requer autenticação, a única operação possivelmente bem-sucedida é a
realização do download do arquivo com o plug-in do navegador do Flash Player. O
carregamento em todos os Flash Players ou o download por meio do Flash Player
independente ou externo falhará em um servidor que exija autenticação. Use os ouvintes de
eventos de FileReference para determinar se as operações foram concluídas com êxito ou para
manipular erros.
O carregamento e o download de arquivo estão restritos ao domínio de arquivo SWF,
incluindo os domínios especificados com o uso de um arquivo de diretivas entre domínios. É
necessário colocar um arquivo de diretivas no servidor quando o arquivo SWF que inicia o
carregamento ou o download não vem do mesmo domínio que o servidor. Para obter mais
informações sobre arquivos de diretivas entre domínios e segurança, consulte “Sobre
domínios, segurança entre domínios e arquivos SWF” na página 727.
Quando as chamadas a FileReference.browse(), FileReferenceList.browse() ou
FileReference.download() estiverem em execução, a reprodução do arquivo SWF será
interrompida nas seguintes plataformas: Plug-ins de navehador do Flash Player no Mac OS X,
Flash Player externo do Macintosh e exibidor inependente Macintosh no Mac OS X 10.1 e
posterior. O arquivo SWF continua a ser executado em todos os exibidores Windows e no
-Flash Player independente do Macintosh no Mac OS X 10.2 e posterior.
A VI S O
Ao permitir que os usuários carreguem arquivos em um ervidor, você sempre deve ter o
cuidado de verificar o tipo de arquivo, antes de salvá-lo no disco rígido. Por exemplo,
você não gostaria de permitir que um usuário carregasse um script de servidor que
pudesse ser usado para excluir pastas ou arquivos nesse servidor. Se você só quiser
permitir que os usuários carreguem um arquivo de imagem, verifique se o script de
servidor que carrega os arquivos determina se o arquivo sendo carregado é uma
imagem válida.
Para obter um exemplo de um aplicativo que usa a API de FileReference, consulte

“Adicionando a funcionalidade de carregamento de arquivo a um aplicativo” na página 676.
Adicionando a funcionalidade de carregamento de

arquivo a um aplicativo
O procedimento a seguir mostra como criar um aplicativo que permite o carregamento de
arquivos de imagem em um servidor. O aplicativo permite que os usuários selecionem uma
imagem em seus discos rígidos para carregar e enviar a um servidor. A imagem carregada
aparecerá no arquivo SWF utilizado para carregar a imagem.

Depois do exemplo que cria o aplicativo Flash há um exemplo que detalha o código do
servidor. Lembre-se de que os arquivos de imagem têm tamanhos restritos: você só pode
carregar imagens com até 200K.
Para criar um aplicativo FLA usando a API de FileReference:

1. Crie um novo documento do Flash e salve-o como fileref.fla.
2. Abra o painel Components (Componentes) e arraste um componente ScrollPane para o
Stage (Palco) e dê a ele o nome de instância imagePane. (A instância ScrollPane será
dimensionada e reposicionada com o uso do ActionScript em uma etapa posterior.)
3. Arraste um componente Button (Botão) para o Stage e dê a ele o nome de instância
uploadBtn.
4. Arraste dois componentes Label (Rótulo) para o Stage e dê a eles os nomes de instância
imageLbl e statusLbl.
5. Arraste um componente ComboBox (Caixa de combinação) para o Stage e dê a ele o nome
de instância imagesCb.
6. Arraste um componente TextArea (Área de texto) para o Stage e d6e a ele o nome de
instância statusArea.
7. Crie um novo símbolo de clipe de filme no Stage e abra o símbolo para edição (clique duas
vezes na instância para abri-la no modo de edição de símbolo).
8. Crie um novo campo de texto estático dentro do clipe de filme e adicione o seguinte texto:
O arquivo do qual você tentou fazer download não está no servidor.
No aplicativo final, esse aviso poderá aparecer devido a um dos seguintes motivos, entre
outros:
■ A imagem foi excluída da fila no servidor durante o carregamento de outra imagem.
■ O servidor não copiou a imagem porque o tamanho do arquivo ultrapassou 200K.
■ O tipo de arquivo não era JPEG, GIF ou PNG válido.
N OT A
A largura do campo de texto deve ser menor do que a da instância de ScrollPane

(400 pixels); caso contrário, os usuários terão que rolar horizontalmente para
visualizar a mensagem de erro
9. Clique com o botão direito do mouse no símbolo na Library (Biblioteca) e selecione

10. Marque as caixas de seleção Export for ActionScript (Exportar para ActionScript) e Export
in First Frame (Exportar no primeiro quadro) e digite Message (Mensagem) no campo de
texto Identifier (Identificador). Clique em OK.

N OT A
Os comentários do código apresentam detalhes sobre a funcionalidade. Uma visão

geral do código será mostrada depois desse exemplo.
import flash.net.FileReference;
imagePane.setSize(400, 350);
imagePane.move(75, 25);
uploadBtn.move(75, 390);
uploadBtn.label = "Upload Image";
imageLbl.move(75, 430);
imageLbl.text = "Select Image";
statusLbl.move(210, 390);
statusLbl.text = "Status";
imagesCb.move(75, 450);
statusArea.setSize(250, 100);
statusArea.move(210, 410);
/* The listener object listens for FileReference events. */

var listener:Object = new Object();
/* When the user selects a file, the onSelect() method is called, and
passed a reference to the FileReference object. */
listener.onSelect = function(selectedFile:FileReference):Void {
/* Update the TextArea to notify the user that Flash is attempting to
upload the image. */
statusArea.text += "Attempting to upload " + selectedFile.name + "\n";
/* Upload the file to the PHP script on the server. */
selectedFile.upload("http://www.helpexamples.com/flash/file_io/
uploadFile.php");
};
/* When the file begins to upload, the onOpen() method is called, so

notify the user that the file is starting to upload. */
listener.onOpen = function(selectedFile:FileReference):Void {
statusArea.text += "Opening " + selectedFile.name + "\n";
};
/* When the file has uploaded, the onComplete() method is called. */

listener.onComplete = function(selectedFile:FileReference):Void {
/* Notify the user that Flash is starting to download the image. */
statusArea.text += "Downloading " + selectedFile.name + " to
player\n";
/* Add the image to the ComboBox component. */
imagesCb.addItem(selectedFile.name);
/* Set the selected index of the ComboBox to that of the most recently
added image. */
imagesCb.selectedIndex = imagesCb.length - 1;
/* Call the custom downloadImage() function. */

downloadImage();
};
var imageFile:FileReference = new FileReference();

imageFile.addListener(listener);
imagePane.addEventListener("complete", imageDownloaded);
imagesCb.addEventListener("change", downloadImage);
uploadBtn.addEventListener("click", uploadImage);
/* If the image does not download, the event object's total property will
equal -1. In that case, display a message to the user. */
function imageDownloaded(event:Object):Void {
if (event.total == -1) {
imagePane.contentPath = "Message";
}
}
/* When the user selects an image from the ComboBox, or when the
downloadImage() function is called directly from the
listener.onComplete() method, the downloadImage() function sets the
contentPath of the ScrollPane in order to start downloading the image
to the player. */
function downloadImage(event:Object):Void {
imagePane.contentPath = "http://www.helpexamples.com/flash/file_io/
images/" + imagesCb.value;
}
/* When the user clicks the button, Flash calls the uploadImage()
function, and it opens a file browser dialog box. */
function uploadImage(event:Object):Void {
imageFile.browse([{description: "Image Files", extension:
"*.jpg;*.gif;*.png"}]);
}
Esse código do ActionScript primeiro importa a classe FileReference e inicializa, posiciona

e redimensiona cada um dos componentes no Stage. Em seguida, um objeto ouvinte e três
manipuladores de evento são definidos: onSelect, onOpen e onComplete. O objeto
ouvinte é adicionado a um novo objeto FileReference denominado imageFile. Em
seguida, ouvintes de eventos são adicionados à instância de ScrollPane imagePane, à
instância de ComboBox imagesCb eà instância de Button uploadBtn. Cada uma das
funções do ouvinte de eventos é definida no código após essa seção de código.

A primeira função, imageDownloaded(), verifica se a quantidade total de bytes para as
imagens descarregadas é -1, e se for, define contentPath para a instância de ScrollPane
como o clipe de filme com o identificador de vinculação de Message, que você criou em
uma etapa anterior. A segunda função, downloadImage(), tenta fazer o download da
imagem recém-carregada na instância de ScrollPane. Quando o download da imagem
terminar, a função imageDownloaded() definida anteriormente será ativada e verificará se
o downloaded foi realizado com êxito. A última função, uploadImage(), abre uma caixa
de diálogo de navegador de arquivos, que filtra todas as imagens JPEG, GIF e PNG.
12. Salve as alterações no documento.
13. Selecione File (Arquivo) > Publish settings (Configurações de publicação), escolha a guia
Formats (Formatos) e verifique se as opções Flash e HTML estão selecionadas.
14. (Opcional) Na caixa de diálogo Publish Settings, selecione a guia Flash e a opção Access
Network Only (Acessar somente a rede) no menu pop-up Local Playback Security
(Segurança de reprodução local).
Se concluir essa etapa, você não encontrará restrições de segurança ao testar o documento
em um navegador local.
15. Na caixa de diálogo Publish Settings, clique em Publish (Publicar) para criar os arquivos
HTML e SWF.
Quando terminar, vá para o próximo procedimento, no qual você criará o recipiente para
o arquivo SWF.
Você poderá encontrar o arquivo de origem de exemplo, FileUpload.fla, na pasta Samples
O procedimento a seguir requer que o recurso PHP esteja instalado no servidor da Web e que
você tenha permissões de gravação nas subpastas de imagens denominadas e temporárias.
Primeiro, é necessário concluir o procedimento anterior ou usar o arquivo SWF concluído
disponível nas pastas indicadas anteriormente.
Para criar um script de servidor para o aplicativo de carregamento de imagem:

1. Crie um novo documento PHP usando um editor de texto como o Dreamweaver ou o
Bloco de Notas.
2. Adicione o código PHP a seguir ao documento. (Uma visão geral do código será mostrada
depois desse script.)

<?php
$MAXIMUM_FILESIZE = 1024 * 200; // 200KB

$MAXIMUM_FILE_COUNT = 10; // keep maximum 10 files on server
echo exif_imagetype($_FILES['Filedata']);
if ($_FILES['Filedata']['size'] <= $MAXIMUM_FILESIZE) {
move_uploaded_file($_FILES['Filedata']['tmp_name'], "./temporary/
".$_FILES['Filedata']['name']);
$type = exif_imagetype("./temporary/".$_FILES['Filedata']['name']);
if ($type == 1 || $type == 2 || $type == 3) {
rename("./temporary/".$_FILES['Filedata']['name'], "./images/
".$_FILES['Filedata']['name']);
} else {
unlink("./temporary/".$_FILES['Filedata']['name']);
}
}
$directory = opendir('./images/');
$files = array();
while ($file = readdir($directory)) {
array_push($files, array('./images/'.$file, filectime('./images/
'.$file)));
}
usort($files, sorter);
if (count($files) > $MAXIMUM_FILE_COUNT) {
$files_to_delete = array_splice($files, 0, count($files) -
$MAXIMUM_FILE_COUNT);
for ($i = 0; $i < count($files_to_delete); $i++) {
unlink($files_to_delete[$i][0]);
}
}
print_r($files);
closedir($directory);
function sorter($a, $b) {

if ($a[1] == $b[1]) {
return 0;
} else {
return ($a[1] < $b[1]) ? -1 : 1;
}
}
?>
Esse código PHP primeiro define duas variáveis constantes: $MAXIMUM_FILESIZE e

$MAXIMUM_FILE_COUNT. Essas variáveis determinam o tamanho máximo (em kilobytes) de
uma imagem sendo carregada no servidor (200KB), bem como a quantidade de arquivos
carregados recentemente que pode ser mantida na pasta de imagens (10). Se o tamanho do
arquivo de imagem sendo carregado no momento for menor que ou igual ao valor de
$MAXIMUM_FILESIZE, a imagem será movida para a pasta temporária.

Em seguida, o tipo de arquivo carregado será evrificado para garantir que a imagem seja
JPEG, GIF ou PNG. Se a imagem for de um tipo compatível, ela será copiada da pasta
temporária para a pasta de imagens. Se o arquivo carragado não pertencer a um tipo
permitido, ele será excluído do sistema de arquivos.
Em seguida, uma listagem de diretório da pasta de imagens será criada e repetida com uma
repetição while. Cada arquivo na pasta de imagens será adicionado a um array e
classificado em seguida. Se o número atual de arquivos na pasta de imagens for maior do
que o valor de $MAXIMUM_FILE_COUNT, arquivos serão excluídos até que haja apenas
$MAXIMUM_FILE_COUNT imagens. Isso evita que a pasta de imagens atinja um tamanho
impossível de gerenciar, já que ela só pode conter 10 imagens de cada vez, e cada imagem
só pode ter até 200KB (ou aproximadamente 2 MB de imagens de cada vez).
3. Salve as alterações no documento PHP.
4. Carregue os arquivos SWF, HTML e PHP no navegador da Web.
5. Visualize o documento HTML remoto em um navegador da Web e clique no botão
Upload Image (Carregar imagem) no arquivo SWF.
6. Localize um arquivo de imagem no disco rígido e selecione Open (Abrir) na caixa de
diálogo.
O arquivo SWF carrega o arquivo de imagem no documento PHP remoto e o exibe no
ScrollPane (que adiciona barras de rolagem se necessário). Para visualizar uma imagem
carregada anteriormente, selecione o nome de arquivo na instância de ComboBox no
Stage. Se o usuário tentar carregar uma imagem que não seja de um tipo permitido (JPEG,
GIF ou PNG) ou o arquivo for grande demais (mais de 200 KB), o Flash exibirá a
mensagem de erro no clipe de filme Message na Library.
Você poderá encontrar o arquivo de origem de exemplo, FileUpload.fla, na pasta Samples
Para obter mais informações sobre a segurança de arquivo local, consulte “Sobre segurança do
arquivo local e o Flash Player” na página 709.
Para obter mais informações sobre como gravar em PHP, vá para www.php.net/.

Sobre XML
Extensible Markup Language (XML) is becoming the standard for exchanging structured data
in Internet applications. É possível integrar dados no Flash com servidores que usam a
tecnologia XML para criar aplicativos sofisticados, como sistemas de bate-papo ou de
corretagem.
No XML, assim como no HTML, use marcas para especificar ou marcar um corpo de texto.
No HTML, use as marcas predefinidas para indicar como o texto deve aparecer no navegador
da Web (por exemplo, a marca< b >indica que o texto deve estar em negrito). No XML,
defina as marcas que identificam o tipo dos dados (por exemplo, >password<VerySecret</
password>). O XML separa a estrutura das informações da forma como elas são exibidas, de
modo que o mesmo documento XML possa ser usado e reutilizado em ambientes diferentes.
Toda marca XML é chamada de nó ou elemento. Cada nó possui um tipo (1, que indica um
elemento XML, ou 3, que indica um nó de texto), e os elementos também podem ter
atributos. Um nó aninhado em outro nó é denominado nó-filho. Essa estrutura de árvore
hierárquica de nós é denominada DOM XML, semelhante ao DOM JavaScript, que é a
estrutura de elementos de um navegador da Web.
No exemplo a seguir, <portfolio> é o nó pai. Ele não tem atributos e contém o nó filho
<holding>, que tem os atributos symbol, qty, price e value:
<portfolio>
<holding symbol="rich"
qty="75"
price="245.50"
value="18412.50" />
</portfolio>

■ “Usando a classe XML” na página 684
■ “Usando a classe XMLSocket” na página 690
Para obter mais informações sobre XML, consulte www.w3.org/XML.
Há vários arquivos de exemplo no disco rígido que carregam XML em um arquivo SWF em
tempo de execução. Um exemplo demonstra como criar um controlador de log da Web
carregando, analisando e manipulando dados XML. Você poderá encontrar o arquivo de
origem de exemplo, xml_blogTracker.fla, na pasta Samples (Exemplos) no disco rígido.
■ No Windows, vá para boot drive\Program Files\Macromedia\Flash 8\Samples and
Tutorials\Samples\ActionScript\XML_BlogTracker.
Tutorials/Samples/ActionScript/XML_BlogTracker.
Sobre XML 683

Um segundo exemplo demonstra como usar XML e arrays aninhados paa selecionar
seqüências de caracteres de idiomas diferentes para preencher campos de texto. Você poderá
encontrar o arquivo de origem de exemplo, xml_languagePicker.fla, na pasta Samples
8\Samples and Tutorials\Samples\ActionScript\XML_LanguagePicker.
Tutorials/Samples/ActionScript/XML_LanguagePicker.
Um terceiro exemplo demonstra como criar um menu dinâmico com dados XML. O exemplo
chama o construtor ActionScript XmlMenu() e passa dois parâmetros a ele: o caminho para o
arquivo de menu XML e uma referência para a Timeline atual. O restante da funcionalidade
reside em um arquivo de classe personalizado, XmlMenu.as.
Você poderá encontrar o arquivo de origem de exemplo, xmlmenu.fla, na pasta Samples
Tutorials/Samples/ActionScript/XML_Menu.
Usando a classe XML

Os métodos da classe ActionScript XML (por exemplo, appendChild(), removeNode() e
insertBefore()) permitem estruturar os dados XML no Flash para enviá-los a um servidor e
para manipular e interpretar os dados XML descarregados.
Os métodos da classe XML a seguir enviam e carregam dados XML em um servidor usando o
método POST HTTP:
■ O método load() faz o download do XML de um URL e coloca-o em um
objeto ActionScript XML.
■ O método send()codifica o objeto XML em um documento XML e o envia para um
URL especificado usando o método POST. Se especificado, uma janela de navegador
exibirá os dados retornados.
■ O método sendAndLoad() passa um objeto XML para um URL. Todas as informações
retornadas são colocadas em um objeto ActionScript XML.
Por exemplo, é possível criar um sistema de corretagem para a venda de títulos que armazene
todas as informações (nomes de usuários, senhas, identificações de sessões, títulos em carteira
e informações sobre transações) em um banco de dados.

O script do servidor que transfere as informações entre o Flash e o banco de dados lê e grava
os dados no formato XML. O ActionScript pode ser usado para converter as informações
obtidas no arquivo SWF (por exemplo, um nome de usuário e uma senha) em um objeto
XML e, em seguida, enviar os dados para o script de servidor como um documento XML.
Você também pode usar o ActionScript para carregar o documento XML retornado pelo
servidor em um objeto XML para ser usado no arquivo SWF.
loginReplyXML documento XML Resposta
loginXML documento XML Solicitação SQL
Banco de dados
username Jean Smith
Submit
password •••••••
Filme do Flash
O fluxo e a conversão de dados entre um filme do Flash, um script do servidor e um banco de dados
A validação da senha no sistema de corretagem requer dois scripts: uma função definida no
Quadro 1, e um script que cria e depois envia os objetos XML criados no documento.
Quando os usuários inserem informações em campos de texto no arquivo SWF com as
variáveis username e password, essas variáveis devem ser convertidas em XML antes de serem
passadas para o servidor. A primeira seção do script carrega as variáveis em um objeto XML
criado recentemente chamado loginXML. Quando o usuário clica em um botão para fazer
login, o objeto loginXML é convertido em uma seqüência de caracteres do XML e
enviado para o servidor.
O código ActionScript a seguir é colocado na Timeline e é usado para enviar dados
formatados em XML para o servidor. Para compreender esse script, leia as linhas comentadas
(indicadas pelos caracteres //):
// ignore XML white space
XML.prototype.ignoreWhite = true;
// Construct an XML object to hold the server's reply
var loginReplyXML:XML = new XML();
// this function triggers when an XML packet is received from the server.
loginReplyXML.onLoad = function(success:Boolean) {
if (success) {
// (optional) Create two text fields for status/debugging
//status_txt.text = this.firstChild.attributes.status;
//debug_txt.text = this.firstChild;
switch (this.firstChild.attributes.STATUS) {
case 'OK' :
_global.session = this.firstChild.attributes.SESSION;
Sobre XML 685

trace(_global.session);
gotoAndStop("welcome");
break;
case 'FAILURE' :
gotoAndStop("loginfailure");
break;
default:
// this should never happen
trace("Unexpected value received for STATUS.");
}
} else {
trace("an error occurred.");
}
};
// this function triggers when the login_btn is clicked
login_btn.onRelease = function() {
var loginXML:XML = new XML();
// create XML formatted data to send to the server
var loginElement:XMLNode = loginXML.createElement("login");
loginElement.attributes.username = username;
loginElement.attributes.password = password_txt.text;
loginXML.appendChild(loginElement);
// send the XML formatted data to the server
loginXML.sendAndLoad("http://www.flash-mx.com/mm/main.cfm",
loginReplyXML);
};
Você pode testar esse código usando o nome de usuário JeanSmith e a senha VerySecret. A
primeira seção do script gera o seguinte XML quando o usuário clica no botão de login:
<login username="JeanSmith" password="VerySecret" />

O servidor recebe o XML, gera uma resposta XML e envia-a de volta ao arquivo SWF. Se a
senha for aceita, o servidor responderá da seguinte maneira:
<LOGINREPLY STATUS="OK" SESSION="4D968511" />
Esse XML inclui um atributo session que contém a identificação de uma sessão exclusiva,
gerada aleatoriamente, que será usada em todas as comunicações entre o cliente e o servidor
no restante da sessão. Se a senha for rejeitada, o servidor responderá com a seguinte
mensagem:
<LOGINREPLY STATUS="FAILURE" />
O nó XML loginreply deve ser carregado em um objeto XML limpo no arquivo SWF. A
instrução a seguir cria o objeto XML loginreplyXML para receber o nó XML:
// Construct an XML object to hold the server's reply
var loginReplyXML:XML = new XML();
loginReplyXML.onLoad = function(success:Boolean) {
A segunda instrução nesse código ActionScript defime uma função anônima (inline),
chamada quando o evento onLoad é disparado.
O botão de login (instância login_btn) é usado para enviar o nome do usuário e a senha
como XML ao servidor e para carregar uma resposta XML de volta para o arquivo SWF. Você
pode usar o método sendAndLoad() para fazer isso, como mostra o seguinte exemplo:
loginXML.sendAndLoad("http://www.flash-mx.com.com/mm/main.cfm",
loginReplyXML);
Primeiro, os dados formatados em XML são criados por meio dos valores inseridos pelo
usuário no arquivo SWF, e esse objeto XML é enviado por meio do método sendAndLoad.
Semelhante aos dados de uma função loadVariables(), o elemento XML loginreply
chega de forma assíncrona (ou seja, não espera os resultados antes de ser retornado) e é
carregado no objeto loginReplyXML. Quando os dados chegam, o manipulador onLoad do
objeto loginReplyXML é chamado. Você deve definir a função loginReplyXML, chamada
quando o manipulador onLoad é disparado, de modo que possa processar o elemento
loginreply.
NO T A
Essa função sempre deve estar no quadro que contém oActionScript referente ao botão
de login.
Sobre XML 687

Se o login for bem-sucedido, o arquivo SWF passará para o rótulo de quadro welcome. Se
houver falha no login, a reprodução passará para o rótulo de quadro loginfailure. Esse
processamento usa uma condição e uma instrução case. Para obter mais informações sobre as
instruções case e break, consulte %{case statement}% e %{break statement}% em ActionScript
2.0 Language Reference. Para obter mais informações sobre condições, consulte %{if
statement}% e %{else statement}% em ActionScript 2.0 Language Reference.
NO TA
Esse design é apenas um exemplo, e a Macromedia não oferece garantia alguma quanto
ao nível de segurança proporcionado. Se você estiver implementando um sistema
seguro protegido por senha, deverá ter um bom conhecimento de segurança de rede.
Para obter mais informações, consulte Integrating XML and Flash in a Web Application
(Integrando XML e Flash em um aplicativo da Web) em www.macromedia.com/support/
flash/interactivity/xml/ e a entrada %{XML}% em ActionScript 2.0 Language Reference. Para
obter mais informações sobre a segurança de arquivo local, consulte “Sobre segurança do
Você poderá encontrar o arquivo de origem de exemplo, login.fla, na pasta Samples
(Exemplos) no disco rígido. Esse exemplo mostra como adicionar uma funcionalidade de
login simples aos sites da Web usando o ActionScript 2.0. O exemplo usa o ActionScript e
seus componentes para criar um pequeno formulário no qual você insere um nome de usuário
e uma senha, e depois clica em um botão para entrar em um site.
8\Samples and Tutorials\Samples\ActionScript\Login.
Tutorials/Samples/ActionScript/Login.
O Flash Player 8 introduziu o manipulador de eventos onHTTPStatus para as classes
LoadVars, XML e MovieClipLoader, com o objetivo de permitir que os usuários acessem o
código de status de uma solicitação HTTP. Isso permite que os desenvolvedores determinem
por que uma determinada operação de carregamento falhou, em vez de apenas detectarem que
uma operação desse tipo já falhou.
O exemplo a seguir mostra como você pode usar o manipulador de eventos onHTTPStatus da
classe XML para verificar se o download de um arquivo XML foi realizado com êxito do
servidor e qual o código de status retornado da solicitação HTTP.
Verificando os códigos de status HTTP com a classe XML:

1. Crie um novo documento do Flash e salve-o como xmlhttp.fla.
principal:

my_xml.onHTTPStatus = function(httpStatus:Number) {
trace("HTTP status is: " + httpStatus);
};
my_xml.onLoad = function(success:Boolean) {
if (success) {
trace("XML carregado com êxito");
// 0 (No error; parse was completed successfully.)
trace("o status XML é: " + my_xml.status);
} else {
trace("impossível carregar XML");
}
};
my_xml.load("http://www.helpexamples.com/crossdomain.xml");
O código anterior define um novo objeto XML com o nome de variável my_xml, define
dois manipuladores de evento (onHTTPStatus e onLoad) e carrega um arquivo XML
externo. O manipulador de eventos onLoad verifica se o arquivo XML foi carregado com
êxito e, se esse for o caso, envia uma mensagem ao painel Output, bem como rastreia a
propriedade de status do objeto XML. É importante lembrar que o ouvinte de eventos
onHTTPStatus retorna o código de status do servidor da Web, enquanto a propriedade
XML.status contém um valor numérico que indica se o objeto XML foi analisado com
êxito.
Flash.
DICA
O manipulador de eventos XML.onHTTPStatus é novo no Flash Player 8.

A VI S O
Não confunda os códigos HTTP httpStatus com a propriedade status da classe

XML. O manipulador de eventos onHTTPStatus retorna o código de status do servidor
de uma solicitação HTTP e a propriedade status define automaticamente e retorna
um valor numérico que indica se um documento XML foi analisado com êxito em um
objeto XML.
A T E NÇ Ã O
Se um servidor da Web não retornar um código de status para o Flash Player, o

número 0 será retornado para o manipulador de eventos onHTTPStatus.
Há vários arquivos de exemplo no disco rígido que carregam XML em um arquivo SWF em
tempo de execução. Um exemplo demonstra como criar um controlador de log da Web
carregando, analisando e manipulando dados XML. Você poderá encontrar o arquivo de
origem de exemplo, xml_blogTracker.fla, na pasta Samples (Exemplos) no disco rígido.
Sobre XML 689

8\Samples and Tutorials\Samples\ActionScript\XML_BlogTracker.
Tutorials/Samples/ActionScript/XML_BlogTracker.
Um segundo exemplo demonstra como usar XML e arrays aninhados paa selecionar
seqüências de caracteres de idiomas diferentes para preencher campos de texto. Você poderá
encontrar o arquivo de origem de exemplo, xml_languagePicker.fla, na pasta Samples
8\Samples and Tutorials\Samples\ActionScript\XML_LanguagePicker.
Tutorials/Samples/ActionScript/XML_LanguagePicker.
Um terceiro exemplo demonstra como criar um menu dinâmico com dados XML. O exemplo
chama o construtor ActionScript XmlMenu() e passa dois parâmetros a ele: o caminho para o
arquivo de menu XML e uma referência para a Timeline atual. O restante da funcionalidade
reside em um arquivo de classe personalizado, XmlMenu.as.
Você poderá encontrar o arquivo de origem de exemplo, xmlmenu.fla, na pasta Samples
Tutorials/Samples/ActionScript/XML_Menu.
Usando a classe XMLSocket

O ActionScript dispõe de uma classe XMLSocket interna que permite a abertura de
uma conexão contínua com um servidor. Uma conexão de soquete permite que o servidor
publique ou envie informações para o cliente assim que elas estejam disponíveis. Sem
uma conexão contínua, o servidor deve aguardar uma solicitação HTTP. Essa conexão aberta
elimina os problemas de latência e é normalmente usada para aplicativos em tempo real, como
aplicativos de bate-papo. Os dados são enviados através da conexão de soquete como
uma única seqüência de caracteres e devem estar no formato XML. Você pode usar a classe
XML para estruturar os dados.

Para criar uma conexão de soquete, é necessário criar um aplicativo do servidor para aguardar
a solicitação dessa conexão e enviar uma resposta ao arquivo SWF. É possível criar esse tipo de
aplicativo de servidor em uma linguagem de programação, como Java.
NO TA
A classe XMLSocket não pode ser encapsulada de forma automática através de

firewalls porque, diferentemente do protocolo RTMP, essa classe não tem recursos de
encapsulamento HTTP. Se você precisar usar o encapsulamento HTTP, em vez disso,
use o Flash Remoting ou Flash Communication Server (que oferece suporte a RTMP).
Você pode usar os métodos connect() e send() da classe XMLSocket para transferir XML
para/de um servidor através de uma conexão de soquete. O método connect() estabelece
uma conexão de soquete com uma porta do servidor da Web. O método send() envia um
objeto XML para o servidor especificado na conexão de soquete.
Quando você chama o método connect(), o Flash Player abre uma conexão TCP/IP com o
servidor e mantém a conexão aberta até que ocorra uma das seguintes situações:
■ O método close() da classe XMLSocket é chamado.
■ Não existe mais nenhuma referência ao objeto XMLSocket.
■ O Flash Player é encerrado.
■ A conexão é interrompida (por exemplo, o modem é desconectado).
O exemplo a seguir cria uma conexão de soquete XML e envia os dados do objeto XML
myXML. Para compreender o script, leia as linhas comentadas (indicadas pelos caracteres //):
// Create XMLSocket object
var theSocket:XMLSocket = new XMLSocket();
// Connect to a site on unused port above 1024 using connect() method.
// Enter localhost or 127.0.0.1 for local testing.
// For live server, enter your domain www.yourdomain.com
theSocket.connect("localhost", 12345);
// displays text regarding connection
theSocket.onConnect = function(myStatus) {
if (myStatus) {
conn_txt.text = "connection successful";
} else {
conn_txt.text = "no connection made";
}
};
// data to send
function sendData() {
var myXML:XML = new XML();
var mySend = myXML.createElement("thenode");
mySend.attributes.myData = "someData";
myXML.appendChild(mySend);
theSocket.send(myXML);
}
// button sends data
Sobre XML 691

sendButton.onRelease = function() {
sendData();
};
// traces data returned from socket connection
theSocket.onData = function(msg:String):Void {
trace(msg);
};
Para obter mais informações, consulte a entrada %{XMLSocket}% em ActionScript 2.0

Language Reference.
Enviando mensagens para o Flash Player

e a partir deste
Para enviar mensagens de um arquivo SWF a seu ambiente de host (por exemplo, um
navegador da Web, um filme do Macromedia Director ou o Flash Player independente), use a
função fscommand().Essa função permite estender o arquivo SWF com os recursos do host.
Por exemplo, você pode enviar uma função fscommand() para uma função JavaScript em uma
página HTML que abra uma nova janela do navegador com propriedades específicas.
Para controlar um SWF do Flash Player a partir de linguagens de script do navegador da Web,
como JavaScript, VBScript e Microsoft JScript, você pode usar os métodos do Flash Player,
funções que enviam mensagens de um ambiente de host para o SWF. Por exemplo, você pode
ter um link em uma página HTML que envie o arquivo SWF para um quadro específico.
■ “Usando a função fscommand()” na página 692
■ “Sobre o uso de JavaScript para controlar os aplicativos Flash” na página 695
■ “Sobre os métodos do Flash Player” na página 696
Usando a função fscommand()

N O TA
A API External (Externa) é uma substituta da função fscommand() no Flash 8 para

interoperação com uma página HTML ou um aplicativo de recipiente. A API External
oferece uma funcionalidade mais avançada do que a funçãofscommand() nessa situação.
Para obter mais informações, consulte “Sobre a API External” na página 696.

Use a função fscommand() para enviar uma mensagem para qualquer programa que esteja
hospedando o Flash Player, como um navegador da Web.
NO T A
O uso de fscommand() para chamar o JavaScript não funciona nos navegadores Safari
ou Internet Explorer para Macintosh.
A função fscommand() tem dois parâmetros: command e arguments. Para enviar uma
mensagem para a versão independente do Flash Player, use comandos e argumentos
predefinidos. Por exemplo, o manipulador de eventos a seguir faz com que o exibidor
independente dimensione o arquivo SWF para o tamanho de tela cheia quando o usuário
solta o botão:
my_btn.onRelease = function() {
fscommand("fullscreen", true);
};
A tabela a seguir mostra os valores que podem ser especificados para os parâmetros command e
arguments da função fscommand() a fim de controlar a aparência de arquivo SWF que esteja
sendo reproduzido no exibidor independente (incluindo projetores):
N OT A
Um projetor é um arquivo SWF salvo em um formato que pode ser executado comom
aplicativo independente — ou seja, incorporando o Flash Player com o conteúdo de um
arquivo executável.
Comando Arguments Objetivo

quit Nenhum Fecha o projetor.
fullscreen true ou false A especificação de true define o Flash Player no modo de
tela cheia. A especificação de false retorna o exibidor
para a exibição normal de menu.
allowscale true ou false O valor false define o exibidor para que ele sempre
desenhe o arquivo SWF em seu tamanho original e nunca
redimensionado. O valor true força o arquivo SWF a ser
redimensionado para a escala de 100% do exibidor.
showmenu true ou false A especificação de true ativa o conjunto completo de
itens do menu de contexto. A especificação de false torna
esmaecidos todos os itens do menu de contexto, exceto
Settings (Configurações) e About Flash Player (Sobre o
Flash Player).
exec Caminho para o Executa um aplicativo no projetor.
aplicativo
Enviando mensagens para o Flash Player e a partir deste 693

Para usar fscommand() para enviar uma mensagem para uma linguagem de script como
JavaScript em um navegador da Web, passe dois parâmetros quaisquer em command e
arguments. Esses parâmetros podem ser seqüências de caracteres ou expressões e serão usados
em uma função JavaScript que “captura”, ou manipula, a função fscommand().
Uma função fscommand() chama a função JavaScript moviename_DoFSCommand na página
HTML que incorpora o arquivo SWF, onde moviename é o nome do Flash Player designado
pelo atributo name da marca embed ou pelo atributo id da marca objeto. Se o nome do
arquivo SWF atribuído ao Flash Player for myMovie, a função JavaScript chamada será
myMovie_DoFSCommand.
Para usar fscommand() a fim de abrir uma caixa de mensagem em um arquivo

SWF na página HTML através de JavaScript:
1. Crie um novo arquivo FLA e salve-o como myMovie.fla.
2. Arraste duas instâncias do componente Button para o Stage (Palco) e atribua-lhes os nomes
window_btn e alert_btn, respectivamente, e os rótulos Open Window e Alert.
3. Insira uma nova camada na Timeline e a remomeie como Actions.
4. Selecione o Quadro 1 da camada Actions e adicione o seguinte código ActionScript no
painel Actions (Ações):
window_btn.onRelease = function() {
fscommand("popup", "http://www.macromedia.com/");
};
clear_btn.onRelease = function() {
fscommand("alert", "You clicked the button.");
};
5. Selecione File (Arquivo) > Publish Settings (Configurações de publicação) e verifique se o

Flash com FSCommand está selecionado no menu Template (Modelo) da guia HTML.
6. Selecione File > Publish (Arquivo - Publicar) para gerar os arquivos SWF e HTML.
7. Em um editor de texto ou HTML, abra o arquivo HTML gerado na etapa 6 e examine o
código. Quando você publicou o arquivo SWF usando o Flash com o modelo FSCommand
na guia HTML da caixa de diálogo Publish Settings, um código adicional foi inserido no
arquivo HTML. Os atributos NAME e ID do arquivo SWF são o nome do arquivo. Por
exemplo, para o arquivo myMovie.fla, os atributos serão definidos como myMovie.
8. No arquivo HTML, adicione o código JavaScript a seguir, onde // Place your code
here. é exibido no documento:
if (command == "alert") {
alert(args);
} else if (command == "popup") {
window.open(args, "mmwin", "width=500,height=300");
}

(Para obter mais informações sobre publicação, consulte Capítulo 17, “Publicação” em
Usando o Flash.)
Como alternativa, nos aplicativos do Microsoft Internet Explorer, é possível anexar um
manipulador de eventos na marca <SCRIPT>, como mostrado neste exemplo:
<script Language="JavaScript" event="FSCommand (command, args)"
for="theMovie">
...
</script>
9. Salve e feche o arquivo HTML.

Quando estiver reeditando os arquivos HTML fora do Flash dessa maneira, lembre-se de
que você deve desmarcar a caixa de seleção HTML em File > Publish Settings; caso
contrário, o código HTML será substituído pelo Flash quando for feita a nova publicação.
10. Em um da navegador da Web, abra o arquivo HTML para exibi-lo. Clique no botão Open
Window (Abrir janela); uma janela é aberta no site da Macromedia. Clique no botão Alert
(Alerta) para abrir uma janela de alerta.
A função fscommand() pode enviar mensagens ao Macromedia Director que são interpretadas
pelo Lingo como seqüências de caracteres, eventos ou código Lingo executável. Se a
mensagem for uma seqüência de caracteres ou um evento, você deverá criar o código Lingo
para recebê-la a partir da ação fscommand() e executar uma ação no Director. Para obter mais
informações, consulte o Director Support Center (Centro de suporte do Director em
www.macromedia.com/support/director.
No Visual Basic, Visual C++ e em outros programas que podem hospedar controles
ActiveX, fscommand() envia um evento VB com duas seqüências de caracteres que podem ser
manipuladas na linguagem de programação do ambiente. Para obter mais informações, use as
palavras-chave Flash method e faça uma pesquisa no Flash Support Center (Centro de suporte
do Flash) em www.macromedia.com/support/flash.
Sobre o uso de JavaScript para controlar os

aplicativos Flash
O Flash Player 6 (6.0.40.0) e as versões posteriores oferecem suporte aos métodos JavaScript
específicos dos aplicativos Flash, bem como o FSCommand no Netscape 6.2 e posterior. As
versões anteriores não oferecem suporte aos métodos do Flash JavaScript e ao FSCommand no
Netscape 6.2 ou versões posteriores. Para obter mais informações, consulte o artigo do
Macromedia Support Center (Centro de suporte da Macromedia), “Scripting With Flash”
(Criando scripts com o Flash) em www.macromedia.com/support/flash/publishexport/
scriptingwithflash/.
Enviando mensagens para o Flash Player e a partir deste 695

Para o Netscape 6.2 e versões posteriores, não é necessário definir o atributo swliveconnect
como true. Entretanto, a definição de swLiveConnect como true não tem efeitos adversos
no arquivo SWF. Para obter mais informações, consulte o atributo swLiveConnect em
“Parâmetros e atributos” na página 540 in Usando o Flash.
Sobre os métodos do Flash Player

Você pode usar os métodos do Flash Player para controlar um arquivo SWF no Flash Player a
partir de linguagens de script de navegador da Web, como JavaScript e VBScript. Como
ocorre em outros métodos, é possível usar os métodos do Flash Player para enviar chamadas
aos arquivos SWF do Flash a partir de um ambiente de script diferente do ActionScript. Cada
método possui um nome, e a maioria dos métodos contém parâmetros. Um parâmetro
especifica o valor com que o método opera. O cálculo executado por alguns métodos retorna
um valor que pode ser usado pelo ambiente de script.
Duas tecnologias permitem a comunicação entre o navegador e o Flash Player: LiveConnect
(Netscape Navigator 3.0 ou posterior no Windows 95/98/2000/NT ou Power Macintosh) e
ActiveX (Internet Explorer 3.0 e posterior no Windows 95/98/2000/NT/XP). Embora as
técnicas de script sejam semelhantes para todos os navegadores e linguagens, há propriedades e
eventos adicionais disponíveis para uso com os controles ActiveX.
Para obter mais informações, inclusive uma lista completa dos métodos de script do Flash
Player, use as palavras-chave Flash method para fazer uma busca no Flash Support Center
(Centro de suporte do Flash) em www.macromedia.com/support/flash.
Sobre a API External

A classe ExternalInterface também é denominada API External, um novo subsistema que
permite a você comunicar-se facilmente do ActionScript e do recipiente do Flash Player para
uma página HTML com o JavaScript ou para um aplicativo desktop com o Flash Player
incorporado.
N OT A
Essa funcionalidade substitui a antiga função fscommand() para interoperação com uma
página HTML ou um aplicativo de recipiente. A API External oferece uma funcionalidade
mais avançada do que a funçãofscommand() nessa situação. Para obter mais
informações, consulte “Sobre a API External” na página 696.
A classe ExternalInterface somente está disponível nas seguintes circunstâncias:

■ Em todas as versões com suporte do Internet Explorer para Windows (5.0 e posterior).
■ Em um recipiente ActiveX personalizado incorporado, como um aplicativo desktop que
incorpore o controle ActiveX do Flash Player.

■ Em qualquer navegador com suporte para a interface NPRuntime, que atualmente são os
seguintes:
■ Firefox 1.0 e posterior
■ Mozilla 1.7.5 e posterior
■ Netscape 8.0 e posterior
■ Safari 1.3 e posterior.
Em todas as outras situações, a propriedade ExternalInterface.available retornará false.
No ActionScript, você pode chamar uma função JavaScript na página HTML. A API External
oferece a seguinte funcionalidade aperfeiçoada, em comparação com fscommand():
■ Você pode usar qualquer função do JavaScript, não apenas aquelas que usa com
%{fscommand function}%.
■ Também é possível passar qualquer número de argumentos, com qualquer nome; você não
está limitado a passar um comando e seus argumentos.
■ É possível passar vários tipos de dados (como Boolean [Booleano], Number [Número] e
String [Seqüência de caracteres]); você não está mais limitado aos parâmetros de String.
■ Agora você pode receber o valor de uma chamada, e esse valor é retornado imediatamente
para o ActionScript (como o valor de retorno da chamada feita).
É possível chamar uma função do ActionScript do JavaScript oem uma página HTML. Para
obter mais informações, consulte %{ExternalInterface
(flash.external.ExternalInterface)}%. Para obter mais informações sobre a segurança
de arquivo local, consulte “Sobre segurança do arquivo local e o Flash Player” na página 709.
As seguintes seções contêm exemplos que usam a API External:
■ “Criando interação com a API External” na página 697
■ “Controlando Flash Video com a API External” na página 701
Criando interação com a API External

Você pode criar interação entre o navegador e um arquivo SWF incorporado em uma página
da Web. O procedimento a seguir envia texto à página HTML que contém o arquivo SWF, e
o HTML envia uma mensagem de volta ao arquivo SWF em tempo de execução.
Para criar o aplicativo Flash:

1. Crie um novo documento do Flash e salve-o como extint.fla.
2. Arraste dois componentes TextInput (Entrada de texto) para o Stage e dê a eles os nomes
de instância in_ti e out_ti.
Sobre a API External 697

3. Arraste um componente Label para o Stage, atribua a ele o nome de instância de out_lbl,
posicione-o acima da instância de TextInput out_ti e defina a propriedade de texto da
guia Parameters (Parâmetros) do inspetor Properties (Propriedades) Sending to JS:
(Enviando ao JS).
4. Arraste um componente Button para o Stage (Palco), posicione-o ao lado do rótulo
out_lbl e dê a ele um nome de instância send_button.
5. Arraste um componente Label para o Stage, atribua a ele um nome de instância de in_lbl,
posicione-o acima da instância de TextInput in_ti e defina sua propriedade de texto na
guia Parameters como Receiving from JS: (Recebendo do JS).
principal:
import flash.external.ExternalInterface;
ExternalInterface.addCallback("asFunc", this, asFunc);

function asFunc(str:String):Void {
in_ti.text = "JS > Hello " + str;
}
send_button.addEventListener("click", clickListener);
function clickListener(eventObj:Object):Void {
trace("click > " + out_ti.text);
ExternalInterface.call("jsFunc", out_ti.text);
}
O código anterior divide-se em três seções. A primeira importa a classe ExternalInterface

para que você não tenha que usar seu nome de classe totalmente qualificado. A segunda
seção do código define uma função de retorno, asFunc(), chamada do JavaScript em um
documento HTML criado em um próximo exemplo. Essa função define o texto dentro de
um componente TextInput no Stage. A terceira seção do código define uma função e a
atribui como ouvinte de eventos para quando o usuário clica na instância do componente
Button no Stage. Sempre que o usuário clica no botão, o arquivo SWF chama a função
JavaScript jsFunc() na página HTML e passa a propriedade de texto da instância de
entrada de texto out_ti.
7. Selecione File (Arquivo) > Publish Settings, escolha a guia Formats e verifique se as opções
Flash e HTML estão selecionadas.
8. Clique em Publish para criar os arquivos HTML e SWF.
o arquivo SWF.

Antes de testar o documento do Flash anterior, é necessário modificar o código HTML gerado
e adicionar mais HTML e JavaScript. O procedimentoa seguir modifica o recipiente HTML
para o arquivo SWF, de modo que os dois arquivos possam interagir quando executados em
um navegador.
Para criar o recipiente HTML do arquivo SWF:

1. Conclua o procedimento anterior.
2. Abra o arquivo extint.html que o Flash cria quando você publica o aplicativo.
Ele fica na mesma pasta que o documento do Flash.
3. Adicione o seguinte código JavaScript entre as marcas de abertura e fechamento head:

</script>
Esse código JavaScript define três métodos. O primeiro retorna uma referência ao arquivo
SWF incorporado com base em se o navegador do usuário é o Microsoft Internet Explorer
(IE) ou um Mozilla. A segunda função, makeCall(), chama o método asFunc() definida
dentro do documento do Flash no exemplo anterior. O parâmetro "extint" na chamada
de função thisMovie() refere-se à identificação do objeto e ao nome do arquivo SWF
incorporado. Se você salvou o documento do Flash com outro nome, será necessário
alterar essa seqüência de caracteres para corresponder os valores no objeto e marcas
incorporadas. A terceira função, jsFunc(), define o valor do campo de texto inField no
documento HTML. Essa função é chamada do documento do Flash quando um usuário
clica no componente Button send_button.
4. Adicione o seguinte código HTML antes da marca de fechamento</body>:
<form name="outForm" method="POST"
action="javascript:makeCall(document.outForm.outField.value);">
Sending to AS:<br />
<input type="text" name="outField" value="" /><br />
<input type="submit" value="Send" />

</form>
<form name="inForm" method="POST" action="">

Receiving from AS:<br />
<input type="text" name="inField">
</form>
Esse código HTML cria dois formulários HTML semelhantes àqueles criados no
ambiente do Flash no exercício anterior. O primeiro formulário envia o valor do campo de
texto outField à função JavaScript makeCall() definida em uma etapa anterior. O
segundo formulário é usado para exibirum valor enviado do arquivo SWF quando o
usuário clica na instância de send_button.
5. Salve o documento HTML e carregue os arquivos HTML e SWF em um navegador da
Web.
6. Visualize o arquivo HTML em um navegador da Web, insira uma seqüência de caracteres
na instância de TextInput out_ti e clique no botão Send (Enviar).
O Flash chama a função JavaScript jsFunc() e passa o conteúdo do campo de texto
out_ti, que exibe o conteúdo no campo de entrada de texto inField do formulário
HTML inForm.
7. Digite um valor no campo de texto HTML outField e clique no botão Send.
O Flash chama a função asFunc() do arquivo SWF, que exibe a seqüência de caracteres na
instância de TextInput in_ti.
Você poderá encontrar o arquivo de origem de exemplo, ExtInt.fla, na pasta Samples
8\Samples and Tutorials\Samples\ActionScript\ExternalAPI\simple example.
Tutorials/Samples/ActionScript/ExternalAPI/simple example.
Para obter um exemplo mais complexo que use a API External, consulte “Controlando Flash
Video com a API External” na página 701. Para obter mais informações sobre a segurança de
arquivo local, consulte “Sobre segurança do arquivo local e o Flash Player” na página 709.
N OT A
Evite usar outros métodos de acesso ao objeto de plug-in, como

document.getElementById("pluginName") ou document.all.pluginName, porque esses
outros métodos não funcionam de modo consistente em todos os navegadores.

Controlando Flash Video com a API External
O procedimento a seguir mostra como controlar arquivos do Flash Video (FLV) usando
controles em uma página HTML e exibe informações sobre o vídeo em um campo de texto
HTML. Esse procedimento usa a API External para obter essa funcionalidade.
Para criar um aplicativo Flash usando a API External:

1. Crie um novo documento do Flash e salve-o como video.fla.
2. Adicione um novo símbolo de vídeo à biblioteca selecionando New Video (Novo vídeo) no
menu pop-up no painel Library.
3. Arraste o símbolo de vídeo para o Stage e dê a ele o nome de instância selected_video.
4. Selecione a instância de selected_video e depois no inspetor Properties para
redimensioná-la para 320 pixels de largura por 240 pixels de altura.
5. Defina as coordenadas x e y para a posição do vídeo como 0.
6. Selecione o Stage e use o inspetor Properties para redimensionar suas dimensões para 320
por 240 pixels.
Agora, o Stage corresponde às dimensões da instância de vídeo.
principal:
import flash.external.ExternalInterface;
/* Register playVideo() and pauseResume() so that it is possible

to call them from JavaScript in the container HTML page. */
ExternalInterface.addCallback("playVideo", null, playVideo);
ExternalInterface.addCallback("pauseResume", null, pauseResume);
/* The video requires a NetConnection and NetStream object. */

var server_nc:NetConnection = new NetConnection();
server_nc.connect(null);
var video_ns:NetStream = new NetStream(server_nc);
/* Attach the NetStream object to the Video object on Stage so

that the NetStream data is displayed in the Video object. */
selected_video.attachVideo(video_ns);
/* The onStatus() method is called automatically when the status of

the NetStream object is updated (the video starts playing, for example).
When that occurs, send the value of the code property to the HTML page by
calling the JavaScript updateStatus() function via ExternalInterface. */
video_ns.onStatus = function(obj:Object):Void {
ExternalInterface.call("updateStatus", " " + obj.code);
};

function playVideo(url:String):Void {
video_ns.play(url);
}
function pauseResume():Void {
video_ns.pause();
}
A primeira parte desse código ActionScript define duas funções de retorno

ExternalInterface, playVideo() e pauseResume(). Essas funções serão chamadas do the
JavaScript no próximo procedimento. A segunda parte do código cria um novo objeto
NetConnection e NetStream, que você usa com a instância de vídeo para a reprodução
dinâmica de arquivos FLV.
O código no próximo procedimento define um manipulador de eventos onStatus para o
objeto NetStream video_ns. Sempre que o objeto NetStream altera seu status, o Flash usa
o método ExternalInterface.call() para disparar a função personalizada JavaScript,
updateStatus(). As duas últimas funções, playVideo() e pauseResume(), controlam a
reprorução da instância de vídeo no Stage. Essas duas funções são chamadas do JavaScript
escrito no procedimento a seguir.
9. Selecione File (Arquivo) > Publish Settings (Configurações de publicação), escolha a guia
Formats (Formatos) e verifique se as opções Flash e HTML estão selecionadas.
10. Clique em Publish para publicar os arquivos SWF e HTML no disco rígido.
o arquivo SWF.
Você poderá encontrar o arquivo de origem de exemplo, external.fla, na pasta Samples
8\Samples and Tutorials\Samples\ActionScript\ExternalAPI.
Tutorials/Samples/ActionScript/ExternalAPI.
No procedimento a seguir, você modificará o código HTML gerado pelo Flash no
procedimento anterior. Esse procedimento cria o JavaScript e o HTML necessários para fazer
com que os arquivos FLV sejam reproduzidos no arquivo SWF.
Para criar o recipiente para o arquivo SWF:

1. Conclua o procedimento anterior.
2. Abra o documento video.html publicado na última etapa do procedimento anterior.

3. Modifique o código existente para que corresponda ao seguinte:
N OT A
Examine os comentários do código no exemplo a seguir. Uma visão geral do código

será mostrada depois desse exemplo.
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://

www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1"
/>
<title>ExternalInterface</title>
// Use a variable to reference the embedded SWF file.
var flashVideoPlayer;
/* When the HTML page loads (through the onLoad event of the <body>
tag), it calls the initialize() function. */
function initialize() {
/* Check whether the browser is IE. If so, flashVideoPlayer is
window.videoPlayer. Otherwise, it's document.videoPlayer. The
videoPlayer is the ID assigned to the <object> and <embed> tags. */
var isIE = navigator.appName.indexOf("Microsoft") != -1;
flashVideoPlayer = (isIE) ? window['videoPlayer'] :
document['videoPlayer'];
}
/* When the user clicks the play button in the form, update the
videoStatus text area, and call the playVideo() function within the
SWF file, passing it the URL of the FLV file. */
function callFlashPlayVideo() {
var comboBox = document.forms['videoForm'].videos;
var video = comboBox.options[comboBox.selectedIndex].value;
updateStatus("____" + video + "____");
flashVideoPlayer.playVideo("http://www.helpexamples.com/flash/
video/" + video);
}
// Call the pauseResume() function within the SWF file.

function callFlashPlayPauseVideo() {
flashVideoPlayer.pauseResume();
}
/* The updateStatus() function is called from the SWF file from the
onStatus() method of the NetStream object. */
function updateStatus(message) {
document.forms['videoForm'].videoStatus.value += message + "\n";
}
</script>

</head>
<body bgcolor="#ffffff" onLoad="initialize();">
swflash.cab#version=8,0,0,0" width="320" height="240" id="videoPlayer"
align="middle">
<param name="movie" value="video.swf" />
<embed src="video.swf" quality="high" bgcolor="#ffffff" width="320"
height="240" name="videoPlayer" align="middle"
</object>
<form name="videoForm">
Select a video:<br />
<select name="videos">
<option value="lights_long.flv">lights_long.flv</option>
<option value="clouds.flv">clouds.flv</option>
<option value="typing_long.flv">typing_long.flv</option>
<option value="water.flv">water.flv</option>
</select>
<input type="button" name="selectVideo" value="play"
onClick="callFlashPlayVideo();" />
<br /><br />
Playback <input type="button" name="playPause" value="play/pause"

onClick="callFlashPlayPauseVideo();" />
<br /><br />

Video status messages <br />
<textarea name="videoStatus" cols="50" rows="10"></textarea>
</form>
</body>
</html>
Esse código HTML define quatro funções JavaScript: initialize(),

callFlashPlayVideo(), callFlashPlayPauseVideo() e updateStatus(). A função
initialize() é chamada dentro da marca body no evento onLoad. As funções
callFlashPlayVideo() e callFlashPlayPauseVideo() são chamadas quando o usu’rio
clica no botão de reprodução ou no botão de reprodução/pausa dentro de um documento
HTML e dispara as funções playVideo() e pauseResume() no arquivo SWF.

A função final, updateStatus(), é chamada pelo arquivo SWF sempre que o
manipulador de eventos onStatus do objeto NetStream video_ns é disparado. Esse
código HTML também define um formulário que tem uma caixa de combinação de
vídeos que o usuário pode escolher. Sempre que um usuário seleciona um vídeo e clica no
botão de reprodução, a função JavaScript callFlashPlayVideo() é chamada, que por
sua vez chama a função playVideo() dentro do arquivo SWF. Essa função passa o URL
do arquivo SWF para carregar na instância do vídeo. À medida que o vídeo é reproduzido
e o status do objeto NetStream é alterado, o conteúdo da área de texto HTML no Stage é
atualizado.
4. Salve as alterações no documento HTML e carregue os arquivos HTML e SWF em um site
da Web.
5. Abra o documento remoto video.html do site da Web, selecione um vídeo na caixa de
combinação e clique no botão de reprodução.
O Flash reproduz o arquivo FLV selecionado e atualiza o conteúdo da área de texto
videoStatus dentro do documento HTML.
Você poderá encontrar o arquivo de origem de exemplo, external.fla, na pasta Samples
8\Samples and Tutorials\Samples\ActionScript\ExternalAPI.
Tutorials/Samples/ActionScript/ExternalAPI.
Para obtr mais informações sobre a API External, consulte %{ExternalInterface
(flash.external.ExternalInterface)}% em ActionScript 2.0 Language Reference.
N OT A
Evite usar outros métodos de acesso ao objeto de plug-in, como

document.getElementById("pluginName") ou document.all.pluginName, porque esses
outros métodos não funcionam de modo consistente em todos os navegadores.

CAPÍTULO 17
Noções básicas de
segurança
17
No Macromedia Flash Basic 8 e no Macromedia Flash Professional 8, você pode usar o
ActionScript para carregar dados de origens externas em um arquivo SWF ou enviar dados a
um servidor. Quando carrega os dados em um arquivo SWF, você deve entender e acomodar o
modelo de segurança do Flash 8. Quando abrir um arquivo SWF no disco rígido, talvez você
precise fazer configurações especiais para testar o arquivo localmente.
Para obter informações sobre a segurança de arquivo local, consulte “Sobre segurança do
arquivo local e o Flash Player” na página 709. Para obter informações sobre as mudanças entre
o modelo de segurança do Flash Player 7 e do Flash Player 8, consulte “Sobre compatibilidade
com os modelos de segurança anteriores do Flash Player” na página 708. Para obter
informações sobre como carregar e analisar dados de um servidor, leia o Capítulo 16,
“Trabalhando com dados externos”, na página 663. Para obter informações sobre segurança,
consulte www.macromedia.com/devnet/security e www.macromedia.com/software/
flashplayer/security/.
Para obter mais informações sobre segurança no Flash 8, consulte estes tópicos:
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
707
Sobre compatibilidade com os modelos
de segurança anteriores do Flash Player
Como resultado das alterações ao recurso de segurança no Flash Player 7, o conteúdo
executado conforme p esperado no Flash Player 6 ou nas versões anteriores talvez não seja
executado da mesma forma nas versões posteriores do Flash Player. Por exemplo, no Flash
Player 6, um arquivo SWF em www.macromedia.com podia ler os dados de um servidor
localizado em data.macromedia.com. Ou seja, o Flash Player 6 permitia que um arquivo SWF
de um domínio carregasse dados de um domínio semelhante.
No Flash Player 7 e versões posteriores, se um arquivo SWF da versão 6 (ou anterior) tentar
carregar dados de um servidor em outro domínio, e esse servidor não fornecer um arquivo de
diretivas que permita leitura a partir do domínio daquele arquivo SWF, será exibida a caixa de
diálogo Macromedia Flash Player Settings (Configurações do Macromedia Flash Player). A
caixa de diálogo solicita que o usuário autorize ou negue o acesso aos dados entre domínios.
Se o usuário clicar em Allow (Autorizar), o arquivo SWF poderá acessar os dados solicitados;
se o usuário clicar em Deny (Negar), o arquivo SWF não poderá acessar os dados solicitados.
Para evitar que essa caixa de diálogo seja exibida, crie um arquivo de diretivas de segurança no
servidor que está fornecendo os dados. Para obter mais informações, consulte “Sobre a
autorização de carregamento de dados entre domínios” na página 737.
O Flash Player 7 e as versões posteriores não permitem o acesso entre domínios sem um
arquivo de diretivas de segurança.
O Flash Player 8 alterou o modo como manipula System.security.allowDomain. Um
arquivo SWF do Flash 8 que chama System.security.allowDomain sem nenhum
argumento, ou qualquer outro arquivo SWF que use o valor curinga (*), permite acesso
apenas a si mesmo. Agora, há suporte para um valor curinga (*), por exemplo:
System.security.allowDomain("*") e System.security.allowInsecureDomain("*").
Se um arquivo SWF da versão 7 ou posterior chamar System.security.allowDomain ou
System.security.allowInsecureDomain com outro argumento, sem ser o curinga (*), isso
afetará todos os arquivos SWF da versão 7 ou anterior no domínio do arquivo SWF que fez a
chamada, assim como ocorria no Flash Player 7. Entretanto, esse tipo de chamada não afeta
nenhum arquivo SWF do Flash Player 8 (ou posterior) no domínio do arquivo SWF
efetuando a chamada. Isso ajuda a minimizar a quebra de conteúdo legado no Flash Player.
Para obter mais informações, consulte “Sobre domínios, segurança entre domínios e arquivos
SWF” na página 727, %{allowDomain (security.allowDomain method)}%, e
%{allowInsecureDomain (security.allowInsecureDomain method)}%.
708 Noções básicas de segurança

O Flash Player 8 não permite que os arquivos SWF locais se comuniquem com a Internet sem
uma configuração específica no computador. Vamos supor que exista conteúdo legado
publicado antes da efetivação dessas restrições. Se esse conteúdo tentar se comunicar com a
rede ou o sistema de arquivos local, ou ambos, o Flash Player 8 interromperá a operação e você
deverá fornecer explicitamente a permissão para que o aplicativo funcione do modo correto.
Para obter mais informações, consulte “Sobre segurança do arquivo local e o Flash Player”
na página 709.
Sobre segurança do arquivo local e o

Flash Player
O Flash Player 8 aperfeiçoou o modelo de segurança, estabelecendo que os aplicativos e
arquivos SWF do Flash em um computador local não têm permissão para se comunicar com a
Internet e o sistema de arquivos local por padrão. Um arquivo SWF local é um arquivo SWF
instalado localmente no computador de um usuário, não disponibilizado de um site da Web e
que não inclui arquivos de projetor (EXE).
N OT A
As restrições analisadas nesta seção não afetam os arquivos SWF presentes na

Internet.
Quando cria um arquivo FLA, você pode indicar se um arquivo SWF tem permissão para se
comunicar com uma rede ou sistema de arquivos local. Nas versões anteriores do Flash Player,
os arquivos SWF locais podiam interagir com outros arquivos SWF e carregar dados de
qualquer posição local ou remota. No Flash Player 8, um arquivo SWF não pode estabelecer
conexões com o sistema de arquivos local e a Internet. Essa é uma alteração de segurança, para
que um arquivo SWF não possa ler arquivos no seu disco rígido e enviar o conteúdo desses
arquivos pela Internet.
Essa restrição de segurança afeta todo o conteúdo implantado localmente, quer seja conteúdo
legado (um arquivo FLA criado em uma versão anterior do Flash) ou criado no Flash 8.
Imagine que você faça a implantação de um aplicativo do Flash, usando o Flash MX 2004 ou
posterior, executado localmente e que também acessa a Internet. No Flash Player 8, esse
aplicativo agora solicita que o usuário dê permissão para comunicar-se com a Internet.
Quando você testa um arquivo no disco rígido, é necessário seguir uma série de etapas para
determinar se ele é um documento confiável local ou um documento possivelmente não
confiável. Se você criar o arquivo no ambiente de criação do Flash, por exemplo, quando você
seleciona Control (Controlar) > Test Movie (Testar filme), o arquivo será confiável porque está
em um ambiente de teste.
Sobre segurança do arquivo local e o Flash Player 709

No Flash Player 7 e anterior, os arquivos SWF locais tinham permissões pare ler de um sistema
de arquivos local e da rede (como a Internet). No Flash Player 8, os arquivos SWF locais
podem ter os seguintes níveis de permissão:
Access the local file system only (Acessar apenas o sistema de arquivos local - padrão)
Um arquivo SWF local pode ler do sistema de arquivos local e de caminhos de rede UNC
(universal naming convention, convenção de atribuição de nome universal), mas não pode se
comunicar com a Internet. Para obter mais informações sobre arquivos SWF de acesso local,
consulte “Access local files only (Acessar arquivos locais somente - padrão)” na página 718.
Access the network only (Acessar somente a rede) Um arquivo SWF local pode acessar
a rede (como a Internet), mas não o sistema de arquivos local em que está instalado. Para obter
mais informações sobre arquivos SWF somente de rede, consulte “Access network only
(Acessar somente a rede)” na página 719.
Access to the local file system and the network (Acessar o sistema de arquivos local e a
rede) Um arquivo SWF local pode ler do sistema de arquivos local em que está instalado, lr
e gravar de e para servidores e pode fazer scripts entre outros arquivos SWF na rede ou no
sistema de arquivos local. Esses arquivos são confiáveis e se comportam da mesma forma que
no Flash Player 7. Para obter mais informações sobre arquivos SWF de acesso de rede e local,
consulte “Access file system and network (Acessar o sistema de arquivos e a rede)”
na página 719.
Para obter mais informações sobre a segurança de arquivo local no Flash 8 em relação à
ferramenta de criação, consulte estas seções:
■ “Noções básicas sobre as sandboxes de segurança local” na página 711
■ “Sobre as configurações de segurança do Flash Player” na página 712
■ “Sobre a segurança de arquivo local e os arquivos de projetores” na página 714
■ “Sobre a resolução de problemas de arquivos SWF legados” na página 715
■ “Corrigindo o conteúdo legado implantado em computadores locais” na página 716
■ “Publicando arquivos para implantação local” na página 717
Para obter informações sobre a segurança de arquivo local para os usuários, consulte “Sobre as
configurações de segurança do Flash Player” na página 712. Para obter mais informações sobre
segurança, consulte www.macromedia.com/devnet/security/ e www.macromedia.com/
software/flashplayer/security/.

Noções básicas sobre as sandboxes de segurança
local
Há várias sandboxes se segurança diferentes no Flash Player. Cada uma delas determina o
modo como um arquivo SWF pode interagir com o sistema de arquivos local, a rede ou
ambos ao mesmo tempo. Restringir o modo como um arquivo pode interagir com o sistema
de arquivos local ou a rede ajuda a manter o computador e seus arquivos seguros. Entender as
sandboxes de segurança ajuda a desenvolver e a testar aplicativos Flash no computador, sem
encontrar erros inesperados.
Local-with-file-system (Local com sistema de arquivos)

Por questões de segurança, o Flash Player 8 coloca todos os arquivos SWF locais, inclusive os
legados, na sandbox local com sistema de arquivos, por padrão (a menos que alguma outra
configuração seja feita). Para alguns arquivos SWF legados (de versões anteriores ao Flash
Player 8), as operações podem ser afetadas pela imposição de restrições ao seu acesso (sem
acesso externo à rede), mas isso proporciona o padrão mais seguro para a proteção dos
usuários.
A partir dessa sandbox, os arquivos SWF podem ler de arquivos no sistema local ou caminhos
UNC (usando o método XML.load(), por exemplo), mas não podem se comunicar com a
rede de nenhuma forma. Isso assegura ao usuário que não haverá vazamento dos dados locais
para a rede ou qualquer outro tipo de compartilhamento inadequado.
Local-with-networking (Local com a rede)

Quando os arquivos SWF locais são atribuídos à sandbox local com a rede, eles perdem o
acesso ao sistema de arquivos local. Entretanto, esses arquivos são autorizados a acessar à rede.
Todavia, um arquivo SWF local com a rede ainda não tem autorização para ler nenhum dado
derivado da rede, a menos que sejam definidas permissões para essa ação. Portanto, um
arquivo SWF local com a rede não em acesso local, embora tenha a capacidade de transmitir
dados pela rede e possa ler dados dos sites na rede que designam permissões de acesso
específicas.
Local-trusted (Local confiável)

Os arquivos SWF atribuídos à sandbox local confiável podem interagir com qualquer outro
arquivo SWF e carregar dados de qualquer lugar (remota ou localmente).

Sobre as configurações de segurança do Flash
Player
A Macromedia desenvolveu o Flash Player para fornecer configurações de segurança que não
requerem que você permita ou negue explicitamente o acesso na maioria das situações. De vez
em quando, você poderá encontrar conteúdo legado do Flash criado com regras de segurança
mais antigas para o Flash Player 7 ou as versões anteriores. Nesses casos, o Flash Player permite
que você defina o conteúdo para funcionar da maneira pretendida pelo desenvolvedor,
utilizando as regras de segurança mais antigas; também é possível optar por impor as novas
regras mas rigorosas. A última opção garante que você só exiba ou reproduza conteúdo que
atenda aos padrões mais atuais de segurança, mas, às vezes, pode impedir que o conteúdo mais
antigo do Flash funcione corretamente.
Todos os usuários que exibem arquivos SWF (inclusive aqueles que não desenvolvem para
Flash) podem definir permissões globalmente por meio do painel Global Security Settings
(Configurações de segurança globais) no Settings Manager (Gerenciado de configurações) do
Flash Player (mostrado na figura a seguir).
Quando o conteúdo mais antigo é executado em uma versão mais nova do exibidor, e o Flash
Player precisa que você decida se deseja impor regras mais novas ou não, uma das caixas de
diálogo pop-up a seguir poderá ser exibida. Essas caixas de diálogo solicitam permissão antes
de permitir que o conteúdo antigo do Flash se comunique com outros locais na Internet:
■ Poderá ser exibida uma caixa de diálogo avisando que o conteúdo do Flash utilizado está
tentando usar regras de segurança mais antiga para acessar as informações de um site fora
de seu próprio domínio e que essas informações poderão ser compartilhadas entre os dois
sites. O Flash Player pergunta se você deseja permitir ou negar esse acesso.

Além de responder à caixa de diálogo, você pode usar o painel Global Security Settings
para especificar se o Flash Player sempre deverá pedir permissão, por meio dessa caixa,
antes de permitir o acesso; sempre negar o acesso, sem perguntar primeiro; ou sempre
permitir o acesso a outros sites ou domínios sem pedir permissão.
■ (Flash Player 8 somente) Poderá ser exibida uma caixa de diálogo avisando que um
arquivo SWF está tentando se comunicar com a Internet. O Flash Player 8 não permite
que o conteúdo local do Flash s comunique com a Internet, por padrão.
Clique em Settings (Configurações) para acessar o painel Global Security Settings, no qual
é possível especificar que certos aplicativos do Flash no computador possam se comunicar
com a Internet.
Para alterar as configurações de segurança ou saber mais sobre suas opções, use o painel Global
Security Settings. Use esse painel para redefinir as configurações de privacidade no
Macromedia Flash Player:
■ Se você selecionar Always Deny (Sempre negar) e confirmar essa seleção, o acesso não será
negado para nenhum site da Web que tentar usar a câmera ou o microfone. Você não verá
a pergunta se um site da Web pode usar sua câmera o microfone novamente. Essa ação
aplica-se aos sites da Web que você já visitou ou não.
■ Se você selecionar Always Ask (Sempre perguntar) e confirmar essa seleção, qualquer site da
Web que tentar usar a câmera ou o microfone deverá pedir permissão. Essa ação aplica-se
aos sites da Web que você já visitou ou não.

Se você tiver selecionado Remember (Lembrar) no painel Privacy Settings (Configurações de
privacidade), conforme mostrado na figura a seguir, para permitir ou negar permanentemente
o acesso a um ou mais sites da Web, a seleção de Always Ask ou Always Deny terá o efeito de
desmarcar a opção Remember para todos esses sites. Em outras palavras, a seleção feita aqui
substitui qualquer escolha feita anteriormente no painel Privacy Settings, mostrado na figura a
seguir.
Depois que você selecionar Always Ask ou Always Deny (ou em vez de fazê-lo), especifique as
configurações de privacidade para sites da Web individuais já visitados. Por exemplo, você
pode selecionar Always Deny aqui e depois usar o painel Website Privacy Settings
(Configurações de privacidade de site da Web) e selecionar Always Allow para sites individuais
que conhece e nos quais confia.
Para o conteúdo implantado localmente e os dados locais, os usuários têm outra opção: eles
podem especificar quais arquivos SWF podem acessar a Internet utilizando o painel Global
Security Settings (Configurações de segurança globais). Para obter mais informações sobre
como especificar configurações no painel Global Security Settings, consulte “Especificando
arquivos confiáveis usando o Settings Manager” na página 721. Para obter mais informações
sobre o painel Global Security Settings, consulte www.macromedia.com/support/
documentation/en/flashplayer/help/settings_manager04a.html.
N OT A
As seleções que os usuários fizerem no painel Global Security Settings substituirão as

decisões tomadas na caixa de diálogo de segurança pop-up.
Sobre a segurança de arquivo local e os arquivos de

projetores
Os arquivos de projetores e os arquivos SWF neles contidos ou carregados no projetor em
tempo de execução não são afetados pelas restrições de segurança de arquivo local, porque o
usuário final precisa utilizar o executável para usar o arquivo SWF. Não há alterações nos
arquivos de segurança e de projetores no Flash Player 8; ele apresenta o mesmo nível de acesso
e segurança que as versões anteriores do Flash Player.

Lembre-se de que os usuários freqüentemente são cautelosos em relação à execução de
arquivos de projetores. Um arquivo de projetor é um aplicativo executável EXE ou Macintosh
e os usuários devem ter cuidado ao executar esses arquivos em seus computadores. Se você
distribuir um aplicativo usando arquivos de projetores, é possível que alguns usuários não o
instalem.
Além disso, um arquivo de projetor incorpora uma versão específica do Flash Player dentro do
projetor, que pode ser mais antiga do que a versão mais recente do Flash Player disponível para
download no site da Macromedia na Web. O Flash Player incorporado no arquivo de projetor
pode ser uma versão legada do projetor criado com uma versão anterior do Flash ou uma
edição do Flash Player lançada após a versão atual da ferramenta de criação do Flash. Por isso,
distribua os aplicativos usando arquivos SWF sempre que possível.
Sobre a resolução de problemas de arquivos SWF

legados
Alguns arquivos FLA e SWF legados (criados com o Flash MX 2004 e versões anteriores)
talvez não funcionem quando testados ou implantados localmente (em um disco rígido)
devido às alterações de segurança no Flash 8. Isso poderá ocorrer quando um arquivo SWF
tentar acessar sites da Web fora de seu domínio e, nesse caso, será necessário implementar um
arquivo de diretivas entre domínios.
Talvez você tenha arquivos FLA ou SWF criados no Flash MX 2004 ou versões anteriores que
foram distribuídos aos usuários que não utilizam a ferramenta de criação do Flash 8, mas
atualizaram para o Flash Player 8. Caso o conteúdo testado localmente ou legado implantado
(um arquivo SWF antigo no disco rígido de um usuário) seja quebrado por tentar se
comunicar com a Internet quando executado no Flash Player 8, você dependerá dos usuários
para confiarem explicitamente no seu conteúdo para que ele seja executado de modo correto
(clicando em um botão de uma caixa de diálogo).
Para saber como corrigir conteúdo legado para reprodução em um computador local, consulte
“Corrigindo o conteúdo legado implantado em computadores locais” na página 716.

Corrigindo o conteúdo legado implantado em
computadores locais
Se você tiver publicado arquivos SWF para o Flash Player 7 ou versões anteriores implantadas
nos computadores locais e se comunicar com a Internet, os usuários deverão permitir
explicitamente a comunicação com a Internet. Os usuários podem impedir quebra de
conteúdo adicionando a localização do arquivo SWF em seus computadores locais à sandbox
confiável no Settings Manager (Gerenciador de configurações).
Para corrigir os arquivos SWF para a reprodução local, use uma destas
opções:
Redeploy (Implantar novamente) Executa o Local Content Updater (Atualizador de
conteúdo local). O Local Content Updater reconfigura o arquivo SWF para torná-lo
compatível com o modelo de segurança do Flash Player 8. Reconfigure o arquivo SWF local
para que ele possa acessar somente a rede ou o sistema de arquivos local. Para obter mais
informações e fazer download do Local Content Updater, consulte www.macromedia.com/
support/flashplayer/downloads.html.
Republish and redeploy (Publicar e implantar novamente) Publica o arquivo novamente
com o Flash Basic 8 ou o Flash Professional 8. A ferramenta de criação requer que você
especifique na caixa de diálogo Publish Settings se um arquivo SWF local pode acessar a rede
ou o sistema de arquivos local — mas não ambos. Se especificar que um arquivo SWF local
pode acessar a rede, você também deverá ativar permissões para esse arquivo SWF (e todos os
arquivos SWF locais) nos arquivos SWF, HTML, de dados e/ou servidor que ele acessar. Para
obter mais informações, consulte “Publicando arquivos para implantação local”
na página 717.
Deploy new content (Implantar novo conteúdo) Usa um arquivo de configuração (.cfg) na
pasta #Security/FlashPlayerTrust. Você pode usar esse arquivo para definir permissões de rede
e acesso local. Para obter mais informações, consulte “Criando arquivos de configuração para
o desenvolvimento em Flash” na página 723.
N OT A
Todas essas opções requerem que você publique ou implante o arquivo SWF
novamente.

Publicando arquivos para implantação local
Você pode enviar os arquivos FLA ou SWF do Flash 8 a um usuário para testar ou aprovar a
necessidade de acesso à Internet do aplicativo. Se o documento for reproduzido em um
sistema local, mas acessar arquivos na Internet (por exemplo, carregando XML ou enviando
variáveis), talvez o usuário precise de um arquivo de configuração para que o conteúdo
funcione corretamente ou talvez seja necessário configurar o arquivo FLA para que o arquivo
SWF publicado possa acessar a rede. Como alternativa, você pode definir um arquivo de
configuração dentro do diretório FlashPlayerTrust. Para obter mais informações sobre como
definir arquivos de configuração, consulte “Criando arquivos de configuração para o
desenvolvimento em Flash” na página 723.
Use o Flash Basic 8 ou o Flash Professional 8 para criar conteúdo para implantação local que
funcione com a segurança de arquivo local do Flash Player 8. Nas configurações de publicação
do Flash 8, especifique se o conteúdo local pode acessar a rede ou o sistema de arquivos local,
mas não ambos.
Você pode definir níveis de permissão para um arquivo FLA na caixa de diálogo Publish
Settings. Esses níveis de permissão afetam a reprodução local do arquivo FLA, quando
executado localmente em um disco rígido.
N OT A
Se você especificar o acesso de rede para um arquivo local, também será necessário
ativar as permissões nos arquivos SWF, HTML, de dados e de servidor acessados pelo
arquivo SWF local.
Network SWF files (Arquivos SWF de rede) Os arquivos SWF transferidos de uma rede
(como um servidor on-line) são colocados em uma sandbox separada que corresponde aos
domínios de origem de site da Web exclusivos deles. Os arquivos SWF locais que especificam
o acesso à rede são colocados na sandbox local-with-networking (local com a rede). Por padrão,
esses arquivos podem ler dados somente do mesmo site no qual se originaram. A
correspondência de domínio exato aplica-se a esses arquivos. Os arquivos SWF de rede
poderão acessar dados de outros domínios se tiverem as permissões corretas. Para obter mais
informações sobre arquivos SWF de rede, consulte “Access network only (Acessar somente a
rede)” na página 719.
Local SWF files (Arquivos SWF locais) Os arquivos SWF que operam com sistemas de
arquivos locais ou caminhos de rede UNC são colocados em uma das três sandboxes no Flash
Player 8. Por padrão, os arquivos SWF locais são colocados na sandbox local-with-file-system
(local com sistema de arquivos). Os arquivos SWF locais registrados como confiáveis (com o
uso de um arquivo de configuração) são colocados na sandbox local-trusted (local confiável).
Para obter informações sobre essas sandboxes, consulte “Access local files only (Acessar
arquivos locais somente - padrão)” na página 718.

Para obter mais informações sobre a sandbox de segurança, consulte “Noções básicas sobre as
sandboxes de segurança local” na página 711.
Os dois primeiros níveis de permissão são definidos no ambiente de criação do Flash, e o
terceiro é definido com o uso do painel Global Security Settings ou do arquivo
FlashAuthor.cfg. O exemplo a seguir mostra quais opções estão disponíveis quando você
publica um arquivo para teste no disco rígido local.
Para publicar um documento com um nível de permissão especificado:

1. Abra o arquivo FLA para o qual você deseja especificar um nível de permissão.
2. Selecione File (arquivo) > Publish Settings (Configurações de publicação) > Flash.
3. Encontre a caixa de diálogo Local Playback Security (Segurança de reprodução local) e
selecione uma destas opções no menu pop-up:
■ Access local files only (Acessar arquivos locais somente - consulte “Access local files
only (Acessar arquivos locais somente - padrão)”)
■ Access network only (Acessar somente a rede - consulte “Access network only (Acessar
somente a rede)”)
4. Clique em OK para continuar criando o arquivo FLA ou em Publish para criar o arquivo
SWF.
Para obter mais informações sobre os níveis de permissões que você pode especificar para seus
aplicativos, consulte “Access local files only (Acessar arquivos locais somente - padrão)”
na página 718, “Access network only (Acessar somente a rede)” na página 719 e “Access file
system and network (Acessar o sistema de arquivos e a rede)” na página 719.
Access local files only (Acessar arquivos locais somente -

padrão)
Para definir esse nível de permissão, selecione Publish Settings > Flash e depois escolha Access
Local Files Only no menu pop-up Local Playback Security. Esse nível de permissão permite
que um arquivo SWF local acesse apenas o sistema de arquivos local em que o SWF está sendo
executado. O arquivo SWF pode ler de arquivos conhecidos no disco local, sem nenhuma
restrição. No entanto, as seguintes restrições se aplicam aos aplicativos acessando a rede:
■ O arquivo SWF não pode acessar a rede de nenhuma forma. O arquivo SWF não pode
criar scripts entre arquivos SWF de rede ou ter seu script transferido entre arquivos SWF
de rede.

■ O arquivo SWF não pode se comunicar com arquivo SWF locais que tenham permissão
para acessar somente a rede e também não pode se comunicar com páginas HTML. No
entanto, a comunicação é permitida em alguns casos, por exemplo, se o HTML for
confiável e se allowScriptAccess for definido como always ou se allowScriptAccess
não for definido e o arquivo SWF pertencer ao Flash Player 7 ou versões anteriores.
Access network only (Acessar somente a rede)

Para definir esse nível de permissão, selecione Publish Settings > Flash e depois escolha Access
Network Only no menu pop-up Local Playback Security. Os arquivos SWF com acesso de
rede poderão ler de um servidor se ele contiver um arquivo de diretivas entre domínios com
<allow-access-from-domain= “*”>. Os arquivos SWF locais com acesso de rede podem
criar script entre outros arquivos SWF, se esses outros arquivos, que estão sendo acessados,
contiverem System.security.allowDomain(“*”). Os arquivos SWF de rede poderão criar
scripts entre um arquivo SWF local com acesso de rede se esse arquivo SWF local contiver
allowDomain(“*”). O arquivo SWF nunca poderá ler de arquivos locais. Em alguns casos, o
tipo de arquivo SWF afeta o acesso. Para obter informações, consulte %{allowDomain
(método security.allowDomain)}% em ActionScript 2.0 Language Reference.
O valor curinga (*) indica que todos os domínios, inclusive os hosts locais, têm permissão de
acesso. Esteja certo de que você deseja fornecer esse amplo nível de acesso, antes de usar o
argumento curinga.
Sem nenhuma dessas permissões, os arquivos SWF locais com acesso de rede somente podem
se comunicar com outros arquivos SWF locais que tenham acesso de rede, e podem enviar
dados aos servidores (usando XML.send(), por exemplo). Em alguns casos, o acesso somente
será permitido se o arquivo HTML for confiável.
Access file system and network (Acessar o sistema de

arquivos e a rede)
Este é o nível de permissão mais alto. Um arquivo SWF que tenha essas permissões é um
arquivo SWF confiável local. Os arquivos SWF confiáveis locais podem ler de outros arquivos
SWF locais, interagir com qualquer servidor e escrever ActionScript para outros arquivos
SWF ou HTML que não tenham proibido explicitamente a permissão de arquivo (por
exemplo, com allowScriptAccess="none"). O usuário ou o desenvolvedor do Flash pode
conceder esse nível de permissão das seguintes formas:
■ Usando o painel Global Security Settings no Settings Manager.
■ Usando um arquivo de configuração global.

Um arquivo de configuração pode ser instalado com o arquivo SWF, criado por um
desenvolvedor do Flash ou adicionado por um administrador (para todos os usuários ou o
usuário atual) ou qualquer desenvolvedor do Flash (para o usuário atual).
Para obter mais informações sobre arquivos de configuração e o painel Global Security
Settings, consulte “Sobre as configurações de segurança do Flash Player” na página 712 e
“Especificando arquivos confiáveis usando o Settings Manager” na página 721 e “Criando
arquivos de configuração para o desenvolvimento em Flash” na página 723.
Testando o conteúdo localmente com as restrições

de segurança de arquivo local do Flash 8
Como desenvolvedor do Flash, com freqüência você testará os aplicativos do Flash localmente,
portanto, poderá visualizar um prompt de caixa de diálogo quando um aplicativo local do
Flash tentar se comunicar com a Internet. Essa caixa de diálogo poderá ser exibida quando
você testar um arquivo SWF no Flash Player, se esse arquivo não tiver acesso de rede. Para
obter mais informações sobre como publicar arquivos SWF com níveis de permissão
especificados, consulte “Publicando arquivos para implantação local” na página 717. A
publicação de um arquivo SWF com uma dessas opções indica que você pode se comunicar
com a rede ou o sistema de arquivos local.
Às vezes, pode ser que você precise se comunicar com o sistema de arquivos local e a rede ao
testar um documento. Como o novo modelo de segurança pode interromper seu fluxo de
trabalho durante a criação de aplicativos do Flash, você poderá usar o painel Global Security
Settings no Settings Manager do Flash Player para especificar quais aplicativos do Flash no
computador sempre poderão se comunicar com a Internet e o sistema de arquivos local. Ou
você poderá modificar o arquivo de configuração para especificar diretórios confiáveis no
disco rígido.
Para obter mais informações, consulte as seguintes seções:
■ “Especificando arquivos confiáveis usando o Settings Manager” na página 721
■ “Criando arquivos de configuração para o desenvolvimento em Flash” na página 723

Especificando arquivos confiáveis usando o Settings Manager
É possível especificar que o conteúdo do Flash no seu computador sempre poderá usar as
regras de segurança antigas adicionando o local desse conteúdo ao painel Global Security
Settings no Flash Player Settings Manager (Gerenciador de configurações do Flash Player).
Depois que você adicionar um local no computador ao painel Security (Segurança), o
conteúdo nesse local será confiável. O Flash Player não pedirá permissão e sempre autorizará o
uso das regras de segurança antigas, mesmo que a opção Always Deny esteja selecionada no
painel Security. A lista Always Trust Files in These Locations (Sempre confiar nos arquivos
desses locais) substitui as opções no painel Settings (Configurações). Ou seja, se você optar
por sempre negar ao conteúdo local e da Web o direito de usar as regras de segurança antigas,
os arquivos locais na lista de itens confiáveis sempre serão autorizados a utilizá-las.
Essa lista na parte inferior do painel aplica-se especialmente ao conteúdo do Flash
descarregado para o seu computador, não ao conteúdo que você usa ao visitar um site.
O exemplo a seguir mostra como especificar que um arquivo SWF local possa se comunicar
com a Internet. Quando você testar um arquivo em um navegador localmente, em File
(Arquivo) > Publish Preview (Visualizar publicação) > HTML, talvez seja exibida uma caixa
de diálogo de segurança. Se você clicar em Settings, o painel Global Security Settings do
Settings Manager será exibido.
.
Para especificar que um arquivo SWF possa se comunicar com a Internet e o

sistema de arquivos local:
1. No painel Global Security Settings, clique no menu pop-up e selecione Add Location
(Adicionar local).

A caixa Add Location será aberta.
Se você acessou o Settings Manager clicando no botão Settings em uma caixa de diálogo, a
caixa Add Location conterá um caminho semelhante a
C:\nome_do_diretório\nome_do_arquivo.swf ou /Users/nome_do_diretório/
nome_do_arquivo.swf; esse caminho informa qual arquivo tentou se comunicar com a
Internet e foi interrompido pela segurança do Flash Player. Se o caminho apresentar o
conteúdo que deverá ter permissão para se comunicar com a Internet, copie e cole-o na
caixa Trust This Location (Confiar nesse local). Ou clique em um dos botões Browse
(Procurar) e encontre o conteúdo.
Você pode adicionar um arquivo individual ou um diretório completo. Caso adicione um
diretório completo, todos os arquivos e subdiretórios nele contidos serão considerados
confiáveis. Uma parte do conteúdo do Flash consiste em vários arquivos relacionados e
talvez seja necessário confiar no diretório completo em que esses arquivos se encontram.
Em geral, não confie em diretórios de nível superior.
2. Clique em Confirm (Confirmar).
O local será adicionado ao painel Security Settings (Configurações de segurança). Os
locais na lista sempre terão permissão para usar as regras de segurança antigas, mesmo que
as opções Always Deny ou Always Ask na parte superior do painel Security estejam
selecionadas.
Após a adição de locais confiáveis, você poderá reiniciar o conteúdo local do Flash
atualizando o navegador ou reiniciando o exibidor.
Se você clicar em Always Allow, essa opção só aplicará essa configuração ao conteúdo legado
sempre permitido (Flash Player 7 e versões anteriores). A configuração nem “sempre autoriza”
o conteúdo do Flash Player 8. É recomendável especificar os aplicativos e diretórios do Flash
no computador que poderão se comunicar com a Internet e o sistema de arquivos local.

Criando arquivos de configuração para o desenvolvimento em
Flash
A ferramenta de criação do Flash 8 define um sinalizador no disco rígido para identificá-lo
como desenvolvedor e direcioná-lo a uma versão específica para desenvolvedores do painel
Global Security Settings, em vez desse mesmo painel para usuários. O sinalizador fica no
arquivo FlashAuthor.cfg no disco rígido, que é instalado automaticamente junto com as
ferramentas de criação do Flash Basic 8 e do Flash Professional 8.
O arquivo FlashAuthor.cfg fica nos seguintes diretórios aproximados:
Windows disco de inicialização\Documents and Settings\<Usuário>\Application
Data\Macromedia\Flash Player\#Security
Macintosh /Users/<Usuário>/Library/Preferences/Macromedia/Flash Player/#Security/
Por padrão, esse arquivo é definido para LocalSecurityPrompt=Author, o que significa que s
avisos exibidos no computador tratam você como desenvolvedor do Flash, e não como usuário
sem a ferramenta de criação instalada.
Você poderá testar os arquivos locais como usuário final e visualizar as caixas de diálogo d
aviso que um usuário final encontraria. Para fazer isso, abra FlashAuthor.cfg em um editor de
texto e altere LocalSecurityPrompt no arquivo FlashAuthor.cfg para corresponder ao seguinte:
LocalSecurityPrompt=User
Talvez você queira fornecer um arquivo FlashAuthor.cfg, com LocalSecurityPrompt
definido como Author (Autor) para outros desenvolvedores no processo de design ou
desenvolvimento ou para os usuários que testam os aplicativos Flash no disco rígido e não têm
a ferramenta de criação do Flash 8 instalada. Isso ajuda a simular a experiência do usuário final
com o conteúdo implantado localmente.
N OT A
Se o arquivo FlashAuthor.cfg for excluído, ele será recriado quando você iniciar a
ferramenta de criação do Flash 8.
No diretório #Security no disco rígido, você poderá criar um diretório FlashPlayerTrust no

qual armazenar arquivos de configuração exclusivos. Dentro desses arquivos, especifique os
diretórios ou aplicativos nos quais confia no disco rígido. Esse diretório não requer acesso
administrativo, portanto, os usuários sem permissões administrativas podem definir
permissões para arquivos SWF e aplicativos de teste.

Se você não especificar um diretório, talvez o conteúdo não funcione conforme pretendido.
Os arquivos de configuração dentro de um diretório FlashPlayerTrust contêm caminhos de
diretório. O arquivo pode conter uma lista de vários diretórios e você pode anexar novos
caminhos a ele. O Flash Player espera encontrar um caminho por linha nos arquivos de
configuração. Qualquer linha iniciada com # (sem nenhum espaço antes desse sinal) será
tratada como comentário.
Para criar um arquivo de configuração para confiar em um diretório:

1. Encontre a pasta #Security no disco rígido.
2. Crie uma pasta chamada FlashPlayerTrust dentro da pasta #Security.
3. Crie um novo arquivo no diretório FlashPlayerTrust usando um editor de textos e salve-o
como myTrustFiles.cfg.
Você pode usar qualquer nome exclusivo para o arquivo de configuração.
4. Encontre o diretório no qual você testa os aplicativos do Flash.
5. Digite ou cole cada caminho de diretório (qualquer caminho de diretório no disco rígido)
em uma nova linha do arquivo. É possível colar vários caminhos de diretório em linhas
separadas. Quando terminar, o arquivo ficará parecido com o seguinte exemplo:
C:\Documents and Settings\<seu_nome>\My Documents\files\
C:\Documents and Settings\<seu_nome>\My Documents\testapps\
6. Salve as alterações em myTrustFiles.cfg.

7. Teste um documento que acesse arquivos locais e de rede a partir do diretório ao qual você
adicionou o arquivo.
Os aplicativos do Flash salvos nesse diretório agora podem acessar arquivos locais e a rede.
É possível salvar vários caminhos de diretório em cada arquivo de configuração e vários
arquivos *.cfg no diretório FlashPlayerTrust.
Se você criar aplicativos que são instalados no disco rígido de um usuário final, talvez seja
necessário criar um arquivo de configuração no FlashPlayerTrust para especificar um diretório
confiável para o aplicativo. Crie os arquivos de configuração dentro do diretório
FlashPlayerTrust que especifica o local do aplicativo confiável. Consulte o procedimento
anterior para obter informações sobre esse diretório e criar arquivos de configuração.
NO T A
Um instalador é executado por um usuário com permissão administrativa em um

computador.

Desenvolva um esquema de atribuição de nomes exclusivo para evitar conflitos com outros
aplicativos que possam instalar arquivos nesse diretório. Por exemplo, talvez você queira usar o
nome exclusivo da sua empresa e software no nome do arquivo para evitar conflitos.
D IC A
Se não quiser usar arquivos de configuração, publique os aplicativos do Flash em um

servidor de teste separado, e vez de fornecer aos clientes ou outros desenvolvedores
arquivos SWF para execução em seus discos rígidos locais.
Para obter mais informações sobre arquivos de configuração, consulte www.macromedia.com/

go/flashauthorcfg. Também é possível criar um arquivo de configuração exclusivo para confiar
em um ou mais diretórios. Para obter informações detalhadas sobre segurança, consulte
www.macromedia.com/devnet/security/e www.macromedia.com/software/flashplayer/
security/.
Sobre a propriedade sandboxType

A propriedade System.security.sandboxType do Flash Player 8 retorna o tipo de sandbox
de segurança na qual o arquivo SWF fazendo a chamada está operando.
A propriedade sandboxType apresenta um destes quatro valores:
remote O arquivo SWF é armazenado na Internet e opera de acordo com regras de sandbox
baseada em domínio.
localTrusted O arquivo SWF é um arquivo local no qual o usuário confiou, utilizando o
Global Security Settings Manager ou um arquivo de configuração do FlashPlayerTrust. O
arquivo SWF pode ler de fontes de dados locais e se comunicar com a rede (como a Internet).
localWithFile O arquivo SWF é um arquivo local no qual o usuário não confiou, e que não
foi publicado com uma designação de rede. O arquivo SWF pode ler de fontes de dados
locais, mas não pode se comunicar com a rede (como a Internet).
localWithNetwork O arquivo SWF é um arquivo local no qual o usuário não confiou, e
que foi publicado com a opção Access Network Only selecionada na caixa de diálogo Publish
Settings (guia Flash). O arquivo SWF pode se comunicar com a rede, mas não pode ler de
fontes de dados locais.

Você pode marcar a propriedade sandboxType de qualquer arquivo SWF, embora um valor
seja retornado somente nos arquivos publicados para o Flash Player 8. Isso significa que
quando publica para o Flash Player 7 ou anterior, você não sabe se há suporte para a
propriedade sandboxType em tempo de execução. Se não houver suporte para a propriedade
em tempo de execução, o valor será undefined (indefinido), o que ocorrerá quando a versão
do Flash Player (indicada pela propriedade System.capabilities.version) for anterior à 8.
Se o valor for undefined, você poderá determinar o tipo de sandbox verificando se o URL do
arquivo SWF é um arquivo local ou não. Se o arquivo SWF for local, o Flash Player
classificará o SWF como localTrusted (que é como todo o conteúdo local foi tratado antes
do Flash Player 8); caso contrário, o Flash Player classificará o arquivo SWF como remote.
Sobre as restrições do tipo local-with-file-system

Um arquivo do tipo local-with-file-system não foi registrado com o arquivo de configuração
dentro do diretório FlashPlayerTrust, do painel Global Security Settings no Settings Manager
ou não recebeu permissão de acesso de rede na caixa de diálogo Publish Settings no ambiente
de criação do Flash.
N OT A
Para obter informações sobre sandboxes de segurança, consulte “Noções básicas

sobre as sandboxes de segurança local” na página 711.
Esses arquivos incluem conteúdo legado executado no Flash Player 8. Se estiver

desenvolvendo conteúdo no Flash 8 ou se tiver conteúdo que se enquadre em uma das
categorias a seguir, você (ou seus usuários) deverá registrar o arquivo como confiável. Para
obter informações sobre como registrar um arquivo como confiável, consulte “Especificando
arquivos confiáveis usando o Settings Manager” na página 721. Para obter informações sobre
como conceder permissões para a reprodução de arquivo local usando arquivos de
configuração, consulte “Criando arquivos de configuração para o desenvolvimento em Flash”
na página 723.
Os arquivos SWF do tipo local-with-file-system apresentam as seguintes restrições:
■ Não podem acessar a rede, o que inclui o seguinte:
■ Carregar outros arquivos SWF da rede (exceto utilizando caminhos UNC não
pertencentes à Internet)
■ Enviar solicitações HTTP
■ Criar conexões usando XMLSocket, Flash Remoting ou NetConnection
■ Chamar getURL() exceto se você usar getURL("file:...") ou
getURL("mailto:...")

■ Podem interagir com outros arquivos local-with-file-system, mas apresentam restrições
relativas ao seguinte:
■ Script entre arquivos (como o acesso do ActionScript aos objetos em outros arquivos
SWF).
■ Chamar System.security.allowDomain
■ Usar LocalConnection como remetente ou ouvinte e independentemente dos
manipulares LocalConnection.allowDomain.
NO TA
Os arquivos SWF do tipo local-with-file-system podem interagir com outros

arquivos SWF local-with-file-system não pertencentes à rede. No entanto, não
podem interagir com arquivos SWF do tipo local-with-network.
Os arquivos SWF local-with-file-system têm acesso de leitura aos arquivos conhecidos no

sistema de arquivos local. Por exemplo, você pode usar XML.load() em um arquivo SWF
local-with-file-system desde que carregue de outro sistema de arquivos local e não da
Internet.
■ Os arquivos SWF local-with-file-system não podem se comunicar com páginas HTML, o
que inclui o seguinte:
■ Scripts de entrada (como a API ExternalInterface, o ActiveX, o LiveConnect e o
XPConnect)
■ Scripts de saída (como chamadas personalizadas a fscommand e
getURL("javascript:..."))
N OT A
Se a página HTML for confiável, ela representará uma exceção a isso.
Sobre domínios, segurança entre

domínios e arquivos SWF
Por padrão, o Flash Player 7 e outras versões impedem que um arquivo SWF seja
disponibilizado de um domínio por meio de leitura de dados, objetos ou variáveis de arquivos
SWF disponibilizadas de domínios diferentes. Além disso, o conteúdo que é carregado através
de protocolos não protegidos (não-HTTPS) não pode ler conteúdos protegidos (HTTPS),
mesmo que os dois estejam exatamente no mesmo domínio. Por exemplo, um arquivo SWF
localizado em http://www.macromedia.com/main.swf não pode carregar dados de https://
www.macromedia.com/data.txt sem permissão explícita; nem um arquivo SWF
disponibilizado em um domínio pode carregar dados (utilizando loadVars(), por exemplo)
de outro domínio.
Sobre domínios, segurança entre domínios e arquivos SWF 727

Endereços IP numéricos idênticos são compatíveis. Contudo, um nome de domínio não é
compatível com um endereço IP, mesmo que o nome do domínio corresponda ao mesmo
endereço IP.
A tabela a seguir mostra exemplos de domínios compatíveis:
www.macromedia.com www.macromedia.com
data.macromedia.com data.macromedia.com
65.57.83.12 65.57.83.12
A tabela a seguir mostra exemplos de domínios incompatíveis:
www.macromedia.com data.macromedia.com
macromedia.com www.macromedia.com
www.macromedia.com macromedia.com
65.57.83.12 www.macromedia.com (mesmo que esse domínio

corresponda a 65.57.83.12 )
www.macromedia.com 65.57.83.12 (mesmo que www.macromedia.com corresponda

a esse endereço IP)
O Flash Player 8 não permite que os arquivos SWF locais se comuniquem com a Internet sem
uma configuração apropriada. Para obter informações sobre como definir um arquivo de
configuração para testar o conteúdo localmente, consulte “Criando arquivos de configuração
para o desenvolvimento em Flash” na página 723.
Para obter mais informações sobre segurança, consulte www.macromedia.com/devnet/
security/ e www.macromedia.com/software/flashplayer/security/.
■ “Regras relativas a nomes de domínio para configurações e dados locais” na página 728
■ “Acesso entre domínios e a subdomínios entre arquivos SWF” na página 729
■ “Sobre a autorização de carregamento de dados entre domínios” na página 737
Regras relativas a nomes de domínio para

configurações e dados locais
No Flash Player 6, as regras de correspondência de domínio superior são usadas, por padrão,
ao acessar configurações locais (tais como permissões de acesso a uma câmera ou microfone)
ou dados com persistência local (objetos compartilhados). Ou seja, as configurações e dados
para arquivos SWF hospedados em here.xyz.com, there.xyz.com e xyz.com são
compartilhados e armazenados em xyz.com.

No Flash Player 7, as regras de correspondência de domínio exato são usadas por padrão. Ou
seja, as configurações e dados de um arquivo hospedado em aqui.xyz.com são armazenados
em here.xyz.com, as configurações e dados de um arquivo hospedado em there.xyz.com são
armazenados em there.xyz.com e assim sucessivamente. System.exactSettings permite que
você especifique as regras que deverão ser utilizadas. Esta propriedade é suportada por
arquivos publicados para Flash Player 6 ou versões posteriores. Para arquivos publicados para
Flash Player 6, o valor padrão é false, significando que as regras de correspondência de
domínio superior estão sendo usadas. Para arquivos publicados para Flash Player 7 ou 8, o
valor padrão é true, significando que as regras de correspondência de domínio exato estão
sendo usadas. Se você estiver usando configurações ou dados locais persistentes e quiser
publicar um arquivo SWF do Flash Player 6 para Flash Player 7 ou 8, poderá ser necessário
definir este valor como false no arquivo portado. Para obter mais informações, consulte
%{exactSettings (System.exactSettings property)}% em ActionScript 2.0 Language
Reference.
Acesso entre domínios e a subdomínios entre

arquivos SWF
Ao desenvolver uma série de arquivos SWF que se comunicam entre si on-line — por
exemplo, ao usar loadMovie(), MovieClip.loadMovie(), MovieClipLoader.LoadClip()
ou objetos Local Connection — você poderá hospedar os arquivos SWF em domínios ou
subdomínios diferentes ou de um mesmo domínio superior.
Nos arquivos publicados para Flash Player 5 e versões anteriores, não havia restrições em
relação ao acesso entre domínios e a subdomínios.
Nos arquivos publicados para Flash Player 6, você podia utilizar o manipulador
LocalConnection.allowDomain ou o método System.security.allowDomain() para
especificar o acesso entre domínios (por exemplo, para permitir que um arquivo em
someSite.com pudesse ser acessado por um arquivo em someOtherSite.com), e não era
necessário nenhum comando para autorizar acesso ao subdomínio (por exemplo, um arquivo
em www.someSite.com podia ser acessado por um arquivo em store.someSite.com).

Arquivos publicados para Flash Player 7 implementam acesso entre arquivos SWF de forma
diferente das versões anteriores, de duas maneiras. Primeiro, o Flash Player 7 implementa as
regras de correspondência de domínio exato, em vez das regras de correspondência de
domínio superior. Portanto, o arquivo que está sendo acessado (mesmo se publicado para uma
versão anterior ao Flash Player 7) deve autorizar explicitamente o acesso entre domínios ou a
um subdomínio. Este assunto é analisado nesta seção. Segundo, um arquivo hospedado em
um site que usa um protocolo seguro (HTTPS) deve autorizar explicitamente o acesso de um
arquivo hospedado em um site que usa um protocolo inseguro (HTTP ou FTP). Este assunto
é discutido na próxima seção (consulte “Acesso de protocolo HTTP para HTTPS entre
arquivos SWF” na página 741).
Geralmente você chama System.security.allowDomain nos seus aplicativos. Entretanto,
quando o destinatário de LocalConnection é um arquivo SWF HTTPS e o remetente não é,
allowInsecureDomain é chamado.
A questão a seguir afeta apenas os arquivos SWF publicados para o Flash Player 7. Quando o
destinatário é HTTPS, e o remetente é um arquivo SWF local, allowDomain() é chamado,
mesmo que allowInsecureDomain() deva ser chamado. No entanto, no Flash Player 8,
quando um destinatário HTTPS LocalConnection é Flash Player 8, e o remetente é um
arquivo local, allowInsecureDomain() é chamado.
Os arquivos executados no Flash Player 8 estão sujeitos a alterações em relação ao modo como
são executados no Flash Player 7. Chamar System.security.allowDomain permite
operações entre scripts somente quando o arquivo SWF sendo acessado é aquele que chamou
System.security.allowDomain. Em outras palavras, um arquivo SWF que chama
System.security.allowDomain agora permite acesso apenas a si mesmo. Nas versões
anteriores, chamar System.security.allowDomain permitia operações entre scripts nas
quais o arquivo SWF sendo acessado podia ser qualquer arquivo SWF no mesmo domínio que
o que chamasse System.security.allowDomain. Isso abria todo o domínio do arquivo SWF
fazendo a chamada.
Foi adicionado suporte para o valor curinga (*) para System.security.allowDomain("*")
e System.security.allowInsecureDomain("*"). O valor de caractere curinga (*) permite
operações entre scripts nas quais o arquivo de acesso é qualquer um e pode ser carregado de
qualquer local (como uma permissão global). As permissões curinga podem ser úteis, mas
devem seguir as novas regras de segurança de arquivo local no Flash Player 8. Especificamente,
os arquivos locais não vêm de um domínio, portanto, é necessário utilizar o valor curinga.
Entretanto, tenha cuidado ao usar o valor curinga porque qualquer domínio tem acesso ao
arquivo. Para obter mais informações, consulte %{allowInsecureDomain (método
security.allowInsecureDomain)}%.

Talvez você se depare com uma situação em que carrega um arquivo SWF filho de um
domínio diferente daquele que o chamou. Talvez você queira permitir que esse arquivo crie
script para o SWF pai, mas não conhece o domínio final do qual o arquivo SWF filho virá.
Essa situação pode acontecer, por exemplo, quando você usa redirecionamentos de
balanceamento de carga ou servidores de terceiros. Nessa situação, você pode usar a
propriedade MovieClip._url como argumento para esse método. Por exemplo, se carregar
um arquivo SWF em my_mc, você poderá chamar
System.security.allowDomain(my_mc._url). Se você fizer isso, será necessário esperar até
que o arquivo SWF em my_mc comece a ser carregado, porque a propriedade _url ainda não
tem esse valor correto final. Para determinar quando o carregamento de um arquivo SWF
filho foi iniciado, use MovieClipLoader.onLoadStart.
A situação oposta também pode ocorrer; ou seja, você pode criar um arquivo SWF filho que
queira permitir que seu pai crie script para ele, mas não sabe qual será o domínio de seu
arquivo SWF pai (trata-se de um arquivo SWF que pode ser carregado por vários domínios).
Nessa situação, chame System.security.allowDomain(_parent._url) do arquivo SWF
filho. Não é necessário esperar o carregamento do arquivo SWF pai, porque ele é carregado
antes do filho.
N OT A
Se o arquivo SWF da Internet sendo acessado for carregado de um URL HTTPS, o

arquivo SWF devera chamar System.security.allowInsecureDomain("*").

A tabela a seguir resume as regras de correspondência de domínio nas versões diferentes do
Flash Player:
Arquivos Acesso entre domínios entre Acesso de subdomínio

publicados para o arquivos SWF entre arquivos SWF
Flash Player (allowDomain() é necessário)
5 ou anterior Sem restrições Sem restrições
6 Correspondência de domínio Sem restrições

superior: allowDomain() é
necessário para domínios
superiores que não correspondem.
7 e posterior Correspondência de domínio exato Correspondência de domínio

Permissão explícita para arquivos exato
hospedados HTTPS acessarem Permissão explícita para
arquivos hospedados HTTP ou arquivos hospedados HTTPS
FTP acessarem arquivos
hospedados HTTP ou FTP
N OT A
Você precisará de System.security.allowInsecureDomain no Flash Player 7 e posterior

se estiver executando acesso HTTP-para-HTTPS, mesmo que tenha correspondência
de domínio exato.
As versões que controlam o comportamento do Flash Player são versões de arquivos SWF (a
versão especificada do Flash Player de um arquivo SWF), não a versão do próprio Flash Player.
Por exemplo, quando o Flash Player 8 estiver reproduzindo um arquivo SWF publicado para a
versão 7, o Flash Player aplicará um comportamento consistente com a versão 7. Essa prática
garante que as atualizações do exibidor não alterem o comportamento de
System.security.allowDomain() nos arquivos SWF implantados.
Como o Flash Player 7 e as versões posteriores implementam regras de correspondência exata

de domínio, em vez das regras de correspondência de domínio superior, poderá ser necessário
modificar os scripts que já existam se você desejar acessá-los a partir de arquivos publicados
para Flash Player 7 ou 8. Você também pode publicar para Flash Player 6 os arquivos
modificados. Se tiver utilizado alguma instrução LocalConnection.allowDomain() ou
System.security.allowDomain() em seus arquivos e definido permissão para sites de
domínios superiores, você precisará alterar seus parâmetros para especificar domínios exatos.
O exemplo a seguir mostra as alterações que você talvez precise fazer se tiver código do Flash
Player 6:
// Flash Player 6 commands in a SWF file at www.anyOldSite.com
// to allow access by SWF files that are hosted at www.someSite.com
// or at store.someSite.com
System.security.allowDomain("someSite.com");

my_lc.allowDomain = function(sendingDomain) {
return(sendingDomain=="someSite.com");
}
// Corresponding commands to allow access by SWF files
// that are published for Flash Player 7 or later
System.security.allowDomain("www.someSite.com", "store.someSite.com");
return(sendingDomain=="www.someSite.com" ||
sendingDomain=="store.someSite.com");
}
Poderá ser necessário adicionar instruções como estas em seus arquivos, se você ainda não as
estiver utilizando. Por exemplo, se o seu arquivo SWF estiver hospedado em
www.someSite.com e você desejar autorizar o acesso por um arquivo SWF publicado para
Flash Player 7 que está em store.someSite.com, inclua instruções como as a seguir no arquivo
em www.someSite.com (você ainda poderá publicar para Flash Player 6 o arquivo em
www.someSite.com):
System.security.allowDomain("store.someSite.com");
return(sendingDomain=="store.someSite.com");
}
Além disso, considere que se um aplicativo Flash Player 6 em execução no Flash Player 7
tentar acessar dados fora de seu domínio exato, o Flash Player 7 e as regras de correspondência
de domínio exato serão impostos e o usuário deverá permitir ou negar o acesso.
Em resumo, poderá ser necessário modificar os seus arquivos para adicionar ou alterar
instruções allowDomain se você publicar arquivos para Flash Player 7 que atendam às
seguintes condições:
■ Você implementou scripts entre arquivos SWF (consulte “Permitindo o acesso a dados
entre arquivos SWF de domínios diferentes” na página 734).
■ O arquivo SWF chamado (de qualquer versão) não está hospedado em site com protocolo
seguro (HTTPS), ou os arquivos SWF chamado e de chamada estão ambos hospedados
em sites HTTPS. Se somente o arquivo SWF chamado estiver em HTTPS, consulte
“Acesso de protocolo HTTP para HTTPS entre arquivos SWF” na página 741.
■ Os arquivos SWF não estão no mesmo domínio (por exemplo, um arquivo está em
www.domain.com e o outro em store.domain.com).
Você deve realizar as seguintes alterações:
■ Se o arquivo SWF chamado estiver publicado para Flash Player 7 ou posterior, inclua
System.security.allowDomain ou LocalConnection.allowDomain nesse arquivo
SWF, usando a correspondência de nome de domínio exato.

■ Se o arquivo SWF chamado estiver publicado para Flash Player 6, modifique-o para
adicionar ou alterar uma instrução System.security.allowDomain ou
LocalConnection.allowDomain, usando a correspondência de nome de domínio exato,
conforme mostrado nos exemplos de código desta seção. Você pode publicar o arquivo
modificado tanto para Flash Player 6 quanto para 7.
■ Se o arquivo SWF chamado estiver publicado para Flash Player 5 ou versões anteriores,
porte o arquivo chamado para Flash Player 6 ou 7 e adicione uma instrução
System.security.allowDomain, usando a correspondência de nome de domínio exato,
conforme mostrado nos exemplos de código desta seção. Objetos LocalConnection não
são suportados no Flash Player 5 e versões anteriores.
Para obter informações sobre sandboxes de segurança local, consulte “Sobre segurança do
Permitindo o acesso a dados entre arquivos SWF de

domínios diferentes
Para que dois arquivos SWF acessem dados um do outro (variáveis e objetos), os dois arquivos
devem se originar do mesmo domínio. Por padrão, no Flash Player 7 e versões posteriores, os
dois domínios devem ser exatamente iguais para que os dois arquivos possam compartilhar os
dados. Entretanto, um arquivo SWF pode conceder acesso a arquivos SWF de domínios
específicos, chamando LocalConnection.allowDomain ou
System.security.allowDomain().
System.security.allowDomain() permite que arquivos SWF e HTML no domínio

especificado acessem objetos e variáveis no arquivo SWF que contém a chamada à
allowDomain().
Se dois arquivos SWF forem disponibilizados do mesmo domínio — por exemplo, http://
mysite.com/movieA.swf and http://mysite.com/movieB.swf — então movieA.swf poderá
examinar e modificar variáveis, objetos, propriedades, métodos etc. em movieB.swf, e movieB
poderá fazer o mesmo para movieA. Isso se chama script entre filmes ou operação entre scripts.
Se dois arquivos SWF forem disponibilizados de domínios diferentes — por exemplo, http://
mysite.com/movieA.swf and http://othersite.com/movieB.swf — então, por padrão, o Flash
Player não permitirá que movieA.swf crie script para movieB.swf, e nem o contrário. Se você
chamar System.security.allowDomain("mysite.com"), movieB.swf dará a movieA.swf
permissão para criar script para movieB.swf. Um arquivo SWF dá aos arquivos SWF de outros
domínios permissão para a criação de script por meio da chamada para
System.security.allowDomain(). Isso se chama criação de script entre domínios.

Para obter mais informações sobre System.security.allowDomain(), operações entre
scripts e script entre domínios, consulte %{allowDomain (security.allowDomain method)}%
Por exemplo, suponha que o arquivo main.swf esteja disponível a partir de
www.macromedia.com. Em seguida, esse arquivo SWF carrega outro arquivo SWF (data.swf )
de data.macromedia.com em uma instância de clipe de filme criada dinamicamente com
createEmptyMovieClip().
// In macromedia.swf
this.createEmptyMovieClip("target_mc", this.getNextHighestDepth());
target_mc.loadMovie("http://data.macromedia.com/data.swf");
Suponha que data.swf defina um método chamado getData() em sua Timeline principal.
Por padrão, main.swf não pode chamar o método getData() definido em data.swf após o
carregamento desse arquivo porque os dois arquivos SWF não residem no mesmo domínio.
Por exemplo, ocorrerá uma falha na chamada de método a seguir em main.swf, caso data.swf
tenha sido carregado.
// In macromedia.swf, after data.swf has loaded:
target_mc.getData(); // This method call will fail
Entretanto, data.swf pode conceder acesso a arquivos SWF disponibilizados de

www.macromedia.com usando o manipulador LocalConnection.allowDomain ou o
método System.security.allowDomain(), dependendo do tipo de acesso desejado. O
código a seguir, incluído em data.swf, permite que um arquivo SWF disponibilizado a partir
de www.macromedia.com acesse suas variáveis e métodos:
// Within data.swf
System.security.allowDomain("www.macromedia.com");
var my_lc:LocalConnection = new LocalConnection();
my_lc.allowDomain = function(sendingDomain:String):Boolean {
return (sendingDomain == "www.macromedia.com");
};
function getData():Void {
var timestamp:Date = new Date();
output_txt.text += "data.swf:" + timestamp.toString() + "\n\n";
}
output_txt.text = "**INIT**:\n\n";
Agora, a função getData no arquivo SWF carregado pode ser chamada pelo arquivo
macromedia.swf. Observe que allowDomain permite a qualquer arquivo SWF do domínio
autorizado acessar qualquer arquivo SWF do domínio que permite o acesso, a menos que o
arquivo SWF que esteja sendo acessado esteja hospedado em um site que usa um protocolo
seguro (HTTPS).

Para obter mais informações sobre correspondências de nomes de domínios, consulte “Acesso
entre domínios e a subdomínios entre arquivos SWF” na página 729.
Arquivos de diretivas de servidor para

autorizar o acesso a dados
Um documento do Flash pode carregar dados de uma origem externa usando uma das
seguintes chamadas de carregamento de dados: XML.load(), XML.sendAndLoad(),
LoadVars.load(), LoadVars.sendAndLoad(), loadVariables(), loadVariablesNum(),
MovieClip.loadVariables(), XMLSocket.connect(), e Macromedia Flash Remoting
(NetServices.createGatewayConnection). Além disso, um arquivo SWF pode importar
RSLs (Runtime Shared Libraries, Bibliotecas compartilhadas em tempo de execução) ou
recursos definidos em outro arquivo SWF durante a execução. Por padrão, os dados ou a RSL
devem residir no mesmo domínio que o arquivo SWF que estiver carregando dados ou mídia
externos.
Para disponibilizar dados e recursos de bibliotecas compartilhadas em tempo de execução para
arquivos SWF em diferentes domínios, você deve usar um arquivo de diretivas entre domínios.
Um arquivo de diretivas entre domínios é um arquivo XML que fornece um modo ao servidor
para indicar que seus dados e documentos estão disponíveis aos arquivos SWF atendidos por
determinados domínios ou por todos os domínios. Todos os arquivos SWF disponíveis a
partir de um domínio especificado no arquivo de diretivas do servidor terão permissão para
acessar dados, recursos ou RSLs desse servidor.
Se você estiver carregando dados externos, deverá criar arquivos de diretivas mesmo se não
planejar portar nenhum dos arquivos para Flash Player 7. Se estiver utilizando RSLs, deverá
criar arquivos de diretivas se o arquivo de chamada ou o arquivo chamado estiver publicado
para Flash Player 7.
■ “Sobre a autorização de carregamento de dados entre domínios” na página 737
■ “Sobre locais de arquivo de diretivas personalizadas” na página 738
■ “Sobre arquivos de diretivas XMLSocket” na página 740

Sobre a autorização de carregamento de dados entre
domínios
Quando um documento do Flash tenta acessar os dados de outro domínio, o Flash Player
tenta automaticamente carregar um arquivo de diretivas daquele domínio. Se o domínio do
documento do Flash que está tentando acessar os dados estiver incluído no arquivo de
diretivas, os dados ficarão automaticamente acessíveis.
Os arquivos de diretivas devem ser denominados crossdomain.xml e podem residir no
diretório raiz ou em outro diretório no servidor que esteja disponibilizando os dados com
ActionScript adicional (consulte “Sobre locais de arquivo de diretivas personalizadas”
na página 738). Os arquivos de diretivas funcionam somente nos servidores que se
comunicam através de HTTP, HTTPS ou FTP. O arquivo de diretivas é específico da porta e
do protocolo do servidor onde ele reside.
Por exemplo, um arquivo de diretivas localizado em https://www.macromedia.com:8080/
crossdomain.xml se aplicará somente às chamadas de carregamento de dados feitas a
www.macromedia.com através do HTTPS na porta 8080.
Uma exceção a essa regra é o uso de um objeto XMLSocket para conectar a um servidor de
soquete em outro domínio. Nesse caso, um servidor HTTP executado na porta 80 do mesmo
domínio que o servidor de soquete deve fornecer o arquivo de diretivas para a chamada do
método.
Um arquivo de diretivas XML contém uma única marca <cross-domain-policy>, a qual,
por sua vez, contém nenhuma ou mais marcas <allow-access-from>. Cada marca <allow-
access-from> contém um atributo, domain, que especifica um endereço IP exato, um
domínio exato ou um domínio curinga (qualquer domínio). Os domínios curingas são
indicados por um asterisco (*), que corresponde a todos os domínios e todos os endereços IP,
ou por um asterisco seguido de um sufixo, que corresponde apenas aos domínios terminados
com o sufixo especificado. Os sufixos devem ser iniciados com um ponto. Entretanto os
domínios curingas com sufixos podem corresponder a domínios compostos somente pelo
sufixo, sem o ponto inicial. Por exemplo, foo.com é considerado como parte de *.foo.com. Os
curingas não são permitidos nas especificações de domínios IP.
Se você especificar um endereço IP, será concedido acesso somente a arquivos SWF carregados
a partir daquele endereço IP através da sintaxe IP (por exemplo, http://65.57.83.12/
flashmovie.swf ), e não para os carregados utilizando a sintaxe de nome de domínio. O Flash
Player não executa a resolução de DNS.
O exemplo a seguir mostra um arquivo de diretivas que permite acesso aos documentos do
Flash provenientes de foo.com, friendOfFoo.com, *.foo.com e 105.216.0.40, a partir de um
documento do Flash em foo.com:
Arquivos de diretivas de servidor para autorizar o acesso a dados 737

<?xml version="1.0" ?>

<cross-domain-policy>
<allow-access-from domain="www.friendOfFoo.com" />
<allow-access-from domain="*.foo.com" />
<allow-access-from domain="105.216.0.40" />
Também é possível permitir o acesso aos documentos originados de qualquer domínio,

conforme mostrado no exemplo a seguir:
<?xml version="1.0" ?>

<allow-access-from domain="*" />
Cada marca <allow-access-from> também tem o atributo opcional secure . O padrão do

atributo secure é true. Você poderá definir o atributo como false se o arquivo de diretivas
estiver em um servidor HTTPS e se quiser que os arquivos SWF em um servidor HTTP
carreguem dados do servidor HTTPS.
A definição do atributo secure como false pode comprometer a segurança oferecida por
HTTPS.
Se o arquivo SWF que você está descarregando vier de um servidor HTTPS, mas o arquivo
SWF carregando-o estiver em um servidor HTTP, será necessário adicionar o atributo
secure="false" à marca <allow-access-from>, conforme mostrado no código a seguir:
<allow-access-from domain="www.foo.com" secure="false" />
Um arquivo de diretivas que não contenha marcas <allow-access-from> tem o mesmo

efeito de não haver uma diretiva no servidor.
Sobre locais de arquivo de diretivas personalizadas

O Flash Player 7 (7.0.19.0) oferece suporte a um método denominado
System.security.loadPolicyFile. Esse método permite especificar um local
personalizado em um servidor no qual um arquivo de diretiva entre domínios possa ser
encontrado, portanto, ele não precisa estar no diretório raiz. O Flash Player 7 (7.0.14.0)
somente procurava arquivos de diretivas no local raiz de um servidor, mas podia ser
inconveniente para um administrador de site colocar esse arquivo no diretório raiz. Para obter
mais informações sobre o método loadPolicyFile e as conexões XMLSocket, consulte
“Sobre arquivos de diretivas XMLSocket” na página 740 e %{loadPolicyFile
(security.loadPolicyFile method)}% em ActionScript 2.0 Language Reference.

Se você usar o método loadPolicyFile, um administrador de site poderá colocar o arquivo
de diretiva em qualquer diretório, desde que os arquivos SWF que precisam usar esse arquivo
chamem loadPolicyFile para informar ao Flash Player onde ele está localizado. No entanto,
os arquivos de diretivas não colocados no diretório raiz têm um escopo limitado. O arquivo de
diretivas permite acesso somente aos locais em seu próprio nível ou abaixo dele na hierarquia
do servidor.
O método loadPolicyFile está disponível somente no Flash Player 7 (7.0.19.0) ou
posterior. Os autores de arquivos SWF que usarem o método loadPolicyFile deverão seguir
um destes procedimentos:
■ Exigir o Flash Player 7 (7.0.19.0) ou posterior.
■ Verificar se o site de onde os dados vêm tem um arquivo de diretivas no local padrão (o
diretório raiz) e em um local não padrão. As versões anteriores do Flash Player usam o
local padrão.
Caso contrário, os autores deverão criar arquivos SWF para que a falha de uma operação de
carregamento entre domínios seja implementada.
A T E NÇ Ã O
Se os arquivos do SWF dependerem de loadPolicyFile, os visitantes com o Flash

Player 6 ou anterior ou Flash Player 7 (7.0.19.0) ou posterior não terão problemas. No
entanto, os visitantes com o Flash Player 7 (7.0.14.0) não terão suporte para
loadPolicyFile.
Se você quiser usar um arquivo de diretivas em um local personalizado no servidor, chame

System.security.loadPolicyFile antes de fazer qualquer solicitação que dependa do
arquivo de diretivas, como o seguinte:
System.security.loadPolicyFile("http://www.foo.com/folder1/folder2/
crossdomain.xml");
my_xml.load("http://www.foo.com/folder1/folder2/myData.xml");
É possível carregar vários arquivos de diretivas com escopos sobrepostos usando-se

loadPolicyFile. Para todas as solicitações, o Flash Player tentará consultar todos os arquivos
cujo escopo inclua seu local. Se um arquivo de diretivas não conceder acesso entre domínios,
outro arquivo não será impedido de conceder acesso aos dados. Se todas as tentativas de acesso
falharem, o Flash Player procurará no local padrão do arquivo crossdomain.xml (no diretório
raiz). A solicitação falhará se nenhum arquivo de diretivas for encontrado no local padrão.
Arquivos de diretivas de servidor para autorizar o acesso a dados 739

Sobre arquivos de diretivas XMLSocket
Para uma tentativa de conexão XMLSocket, o Flash Player 7 (7.0.14.0) procurava
crossdomain.xml em um servidor HTTP na porta 80 no subdomínio em que essa tentativa
era feita. O Flash Player 7 (7.0.14.0) e todas as versões anteriores restringiam o acesso de
conexões XMLSocket às portas 1024 e superiores. No entanto, no Flash Player 7 (7.0.19.0) e
posteriores, o ActionScript pode informar ao Flash Player sobre um local não padrão para um
arquivo de diretivas usando System.security.loadPolicyFile. Qualquer local
personalizado para arquivos de diretivas XMLSocket ainda deverá estar em um servidor de
soquete XML.
No exemplo a seguir, o Flash Player recupera um arquivo de diretivas de um URL
especificado:
System.security.loadPolicyFile("http://www.foo.com/folder/policy.xml");
As permissões concedidas pelo arquivo de diretivas no local aplicam-se a todo o conteúdo no

mesmo nível ou abaixo dele na hierarquia do servidor. Portanto, se tentar carregar os seguintes
dados, você descobrirá que somente pode carregar dados de certos locais:
myLoadVars.load("http://foo.com/sub/dir/vars.txt"); // allowed
myLoadVars.load("http://foo.com/sub/dir/deep/vars2.txt"); // allowed
myLoadVars.load("http://foo.com/elsewhere/vars3.txt"); // not allowed
Para contornar isso, você poderá carregar mais de um arquivo de diretivas em um único
arquivo SWF usando loadPolicyFile. O Flash Player sempre espera a conclusão do
download de qualquer arquivo de diretiva antes de negar uma solicitação que requeira um
arquivo desse tipo. O Flash Player consultará o local padrão de crossdomain.xml se nenhuma
outra diretiva for autorizada no arquivo SWF.
A sintaxe especial permite a recuperação dos arquivos de diretiva diretamente de um servidor
XMLSocket:
System.security.loadPolicyFile("xmlsocket://foo.com:414");
Nesse exemplo, o Flash Player tenta recuperar um arquivo de diretivas do host e da porta
especificados. Qualquer porta poderá ser usada se o arquivo de diretivas não estiver no
diretório padrão (raiz); caso contrário, a porta só poderá ser a 1024 ou superior (assim como
ocorre com os exibidores anteriores). Quando uma conexão é estabelecida com a porta
especificada, o Flash Player envia <policy-file-request />, terminada por um byte nulo.
O servidor de soquete XML pode ser configurado para disponibilizar arquivos de diretivas das
seguintes formas:
■ Disponibilizar arquivos de diretivas e conexões normais de soquete pela mesma porta. O
servidor deverá aguardar <policy-file-request /> antes de transmitir um arquivo de
diretivas.

■ Disponibilizar arquivos de diretivas em uma porta separada das conexões normais, caso em
que poderá enviar um arquivo de diretivas tão logo uma conexão seja estabelecida na porta
de arquivo de diretivas dedicada.
O servidor deverá enviar um byte nulo para terminar um arquivo de diretivas antes de fechar a
conexão. Se o servidor não fechar a conexão, o Flash Player fará isso ao receber o byte nulo de
término.
Um arquivo de diretivas disponibilizado por um soquete XML tem a mesma sintaxe que outro
arquivo de diretivas, mas também deve especificar as portas às quais o acesso é concedido. As
portas autorizadas são especificadas em um atributo to-ports na marca <allow-access-
from>. Se o arquivo de diretivas for inferior à porta 1024, ele poderá conceder acesso a
qualquer porta; quando um arquivo de diretivas vem da porta 1024 ou superior, ele somente
pode conceder acesso a outras portas acima de 1024. Números de porta exclusivos, intervalos
de portas e curingas são permitidos. O seguinte código é um exemplo de um arquivo de
diretivas XMLSocket:
<allow-access-from domain="*" to-ports="507" />
<allow-access-from domain="*.foo.com" to-ports="507,516" />
<allow-access-from domain="*.bar.com" to-ports="516-523" />
<allow-access-from domain="www.foo.com" to-ports="507,516-523" />
<allow-access-from domain="www.bar.com" to-ports="*" />
Coo a capacidade de se conectar a portas inferiores a 1024 está disponível no Flash Player 7
(7.0.19.0) e posterior, um arquivo de diretivas carregado com loadPolicyFile sempre deverá
autorizar esse procedimento, mesmo quando um arquivo SWF estiver se conectando a seu
próprio subdomínio.
Acesso de protocolo HTTP para HTTPS

entre arquivos SWF
É necessário usar um manipulador ou método allowDomain para permitir que um arquivo
SWF em um domínio seja acessado por um arquivo SWF em outro domínio. Entretanto, se o
arquivo SWF que está sendo acessado estiver hospedado em um site que usa protocolo seguro
(HTTPS), o manipulador ou método allowDomain não permitirá acesso a partir de um
arquivo SWF hospedado em um site que usa um protocolo inseguro. Para permitir esse acesso,
você deverá usar as instruções LocalConnection.allowInsecure Domain() ou
System.security.allowInsecureDomain(). Consulte “Permitindo o acesso de protocolo
HTTP para HTTPS entre arquivos SWF” na página 742 para obter mais informações.
Acesso de protocolo HTTP para HTTPS entre arquivos SWF 741

Permitindo o acesso de protocolo HTTP para HTTPS
entre arquivos SWF
Além das regras de correspondência de domínio exato, você deve autorizar explicitamente o
acesso de arquivos hospedados em sites que utilizem um protocolo inseguro a arquivos
hospedados em sites que utilizem um protocolo seguro (HTTPS). Se o arquivo chamado
estiver publicado para Flash Player 6, 7 ou 8, você deverá implementar uma das instruções
allowDomain (consulte “Acesso entre domínios e a subdomínios entre arquivos SWF”
na página 729) ou utilizar as novas instruções LocalConnection.allowInsecure Domain
ou System.security.allowInsecureDomain().
Por exemplo, se o arquivo SWF em https://www.someSite.com/data.swf tiver de permitir o
acesso através de um arquivo SWF em http://www.someSite.com, o código a seguir
adicionado a data.swf permitirá tal acesso:
// No data.swf
System.security.allowInsecureDomain("www.someSite.com");
my_lc.allowInsecureDomain = function(sendingDomain:String):Boolean {
return (sendingDomain == "www.someSite.com");
};
AVISO
A implementação de uma instrução allowInsecureDomain() compromete a segurança

oferecida pelo protocolo HTTPS. Você deverá efetuar estas alterações somente se não
puder reorganizar o seu site de forma que todos os arquivos SWF sejam
disponibilizados através de protocolos HTTPS.
O código a seguir mostra um exemplo das alterações que você provavelmente terá de fazer:
// Commands in a Flash Player 6 SWF file at https://www.someSite.com
// to allow access by Flash Player 7 SWF files that are hosted
// at http://www.someSite.com or at http://www.someOtherSite.com
System.security.allowDomain("someOtherSite.com");
return(sendingDomain=="someOtherSite.com");
}
// Corresponding commands in a Flash Player 7 SWF file
// to allow access by Flash Player 7 SWF files that are hosted
// at http://www.someSite.com or at http://www.someOtherSite.com
System.security.allowInsecureDomain("www.someSite.com",
"www.someOtherSite.com");
my_lc.allowInsecureDomain = function(sendingDomain) {
return(sendingDomain=="www.someSite.com" ||
sendingDomain=="www.someOtherSite.com");
}

Poderá ser necessário adicionar instruções como estas em seus arquivos, se você ainda não as
estiver utilizando. Poderá ser necessária uma modificação mesmo se ambos os arquivos
estiverem no mesmo domínio (por exemplo, um arquivo em http://www.domain.com está
chamando um arquivo em https://www.domain.com).
Em resumo, poderá ser necessário modificar os seus arquivos para incluir ou alterar instruções
se você publicar arquivos para Flash Player 7 ou posterior que atendam às seguintes condições:
■ Você implementou scripts entre arquivos SWF (usando loadMovie(),
MovieClip.loadMovie(), MovieClipLoader.LoadClip() ou objetos Local
Connection).
■ O arquivo de chamada não está hospedado em um servidor com protocolo HTTPS e o
arquivo chamado está em HTTPS.
Você deve realizar as seguintes alterações:
■ Se o arquivo chamado estiver publicado para Flash Player 7, inclua
System.security.allowInsecureDomain ou
LocalConnection.allowInsecureDomain no arquivo chamado, usando
correspondência de nome de domínio exato, conforme mostrado nos exemplos de código
desta seção.
■ Se o arquivo chamado estiver publicado para Flash Player 6 ou versões anteriores e os
arquivos chamado e de chamada estiverem no mesmo domínio (por exemplo, um arquivo
em http://www.domain.com chama um arquivo em https://www.domain.com), nenhuma
modificação será necessária.
■ Se o arquivo chamado estiver publicado para Flash Player 6, os arquivos não estiverem no
mesmo domínio e você não desejar portar o arquivo chamado para Flash Player 7,
modifique o arquivo chamado adicionando ou alterando uma instrução
System.security.allowDomain ou LocalConnection.allowDomain, usando
correspondência de nome de domínio exato, conforme mostrado nos exemplos de código
desta seção.
■ Se o arquivo chamado estiver publicado para Flash Player 6 e você desejar portá-lo para
Flash Player 7, deverá incluir System.security.allowInsecureDomain ou
LocalConnection.allowInsecureDomain nesse arquivo, usando correspondência de
domínio exato, conforme mostrado nos exemplos de código desta seção.
Acesso de protocolo HTTP para HTTPS entre arquivos SWF 743

■ Se o arquivo chamado estiver publicado para Flash Player 5 ou versões anteriores e os
arquivos não estiverem no mesmo domínio, você poderá optar por uma destas duas ações.
Você poderá portar o arquivo chamado para Flash Player 6 e adicionar ou alterar uma
instrução System.security.allowDomain, usando correspondência de nome de
domínio exato, conforme mostrado nos exemplos de código desta seção, ou portar o
arquivo chamado para Flash Player 7 e incluir uma instrução
System.security.allowInsecureDomain nesse arquivo, usando correspondência de
nome de domínio exato, conforme mostrado nos exemplos de código desta seção.

CAPÍTULO 18
Depurando aplicativos 18
O Macromedia Flash Basic 8 e o Macromedia Flash Professional 8 oferecem várias
ferramentas para testar o ActionScript nos arquivos SWF. O Debugger (Depurador) permite
que você encontre erros em um arquivo SWF durante sua execução no Flash Debug Player
(consulte “Depurando scripts” na página 745). O Flash também fornece as seguintes
ferramentas de depuração adicionais:
■ O painel Output (Saída), que exibe mensagens de erro, inclusive alguns erros de tempo de
execução, e listas de variáveis e objetos (consulte “Usando o painel Output”
na página 759)
■ A instrução trace, que envia observações de programação e valores de expressão para o
painel Output (consulte “Usando a instrução trace” na página 764)
■ As instruções throw e try..catch..finally que permitem testar e responder aos erros
em tempo de execução de dentro do script.
Esta seção descreve como depurar os scripts e os aplicativos Flash utilizando o Debugger e
como usar o painel Output. Para obter mais informações, consulte os seguintes tópicos:
Depurando scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .745
Usando o painel Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .759
Depurando scripts
O Debugger no Flash 8 ajuda a encontrar erros no arquivo SWF durante sua execução no
Flash Player. Você deve exibir seu arquivo SWF em uma versão especial do Flash Player
chamada Flash Debug Player. Ao instalar a ferramenta de criação, o Flash Debug Player é
instalado automaticamente. Assim, se você instalar o Flash e navegar por um site com
conteúdo Flash ou usar a opção Test Movie (Testar filme), estará usando o Flash Debug
Player. Também é possível executar o instalador no seguinte diretório no Windows ou no
Macintosh: diretório de instalação do Flash\Players\Debug\ ou inicie o Flash Debug Player
independente do mesmo diretório.
745
Quando usar o comando Control (Controle) > Test Movie para testar os arquivo SWF que
implementam controles de teclado (tabulação, atalhos de teclado criados usando
Key.addListener() e assim por diante), selecione Control > Disable Keyboard Shortcuts
(Desativar atalhos de teclado). A seleção desta opção evita que o ambiente de criação “retenha”
pressionamentos de teclas e permite passá-los diretamente para o exibidor. Por exemplo, no
ambiente de criação, Control+U abre a caixa de diálogo Preferences (Preferências). Se o seu
script associar Control+U a uma ação que sublinha o texto na tela, ao usar o comando Test
Movie, o pressionamento de Control+U abrirá a caixa de diálogo Preferences (Preferências)
em vez de executar a ação que sublinha o texto. Para permitir que o comando Control+U seja
passado para o exibidor, você deve selecionar Control > Disable Keyboard Shortcuts.
A T E NÇ Ã O
Quando você usar um aplicativo em outro idioma em um sistema em inglês, o comando

Test Movie falhará se alguma parte do caminho SWF tiver caracteres que não possam
ser representados com o esquema de codificação MBCS. Por exemplo, caminhos em
japonês em um sistema em inglês não funcionam. Todas as áreas do aplicativo que
usarem o exibidor externo estarão sujeitas a esta limitação.
O Debugger mostra uma lista hierárquica de clipes de filme carregados atualmente no Flash
Player. Com o Debugger, você pode exibir e modificar valores de variáveis e propriedades
durante a reprodução do arquivo SWF, e pode usar pontos de interrupção para interromper
sua execução e percorrer o código do ActionScript linha por linha.
Use o Debugger no modo de teste com arquivos locais ou para testar arquivos em um servidor
Web em local remoto. O Debugger permite definir pontos de interrupção no ActionScript
para interromper o Flash Player e executar a depuração direta do código durante a sua
execução. Depois, você pode voltar para os scripts e editá-los para que produzam os resultados
corretos.
Uma vez ativada, a barra de status do Debugger exibe o URL ou o caminho local do arquivo,
informa se o arquivo está sendo executado no modo de teste ou a partir de um local remoto, e
mostra uma lista de exibição dinâmica do clipe de filme. Quando os clipes de filme são
adicionados ou removidos do arquivo, a lista de exibição reflete as alterações imediatamente. É
possível redimensionar a lista de exibição movendo o divisor horizontal.
Para ativar o Debugger no modo de teste:

■ Selecione Control (Controle) > Debug Movie (Depurar filme).
746 Depurando aplicativos

Esse comando exporta o arquivo SWF com as informações de depuração (o arquivo
SWD) e permite a depuração do arquivo SWF. Ele abre o Debugger e o arquivo SWF no
modo de teste.
NO T A
Se necessário, você poderá redimensionar as várias regiões do painel Debugger.

Quando o ponteiro muda entre cada região, você pode arrastar para redimensionar
as listas de exibição e observação, e a exibição do código.
Barra de status Lista de observação

Lista de exibição Visualização de código

■ “Depurando um arquivo SWF a partir de um local remoto”
■ “Exibindo e modificando variáveis” na página 750
■ “Usando a lista de observação” na página 752
■ “Exibindo propriedades do clipe de filme e alterando propriedades editáveis”
na página 753
■ “Definindo e removendo pontos de interrupção” na página 755
■ “Sobre como trabalhar nas linhas de código” na página 757
Depurando scripts 747

Depurando um arquivo SWF a partir de um local
remoto
É possível depurar um arquivo SWF remoto usando as versões independentes, ActiveX ou
plug-in do Flash Player. Para encontrar essas versões do Flash Player, procure no seguinte
diretório no Windows ou no Macintosh: diretório de instalação do Flash\Players\Debug\.
Durante a exportação de um arquivo SWF, é possível ativar a depuração e criar uma senha
para depuração. Se você não ativar a depuração, o Debugger não será ativado.
Para garantir que somente usuários confiáveis possam executar arquivos SWF no Flash Debug
Player, publique-os com uma senha para depuração. Assim como no JavaScript ou no HTML,
os usuários podem exibir variáveis de cliente no ActionScript. Para armazenar variáveis de
maneira segura, você deve enviá-las a um aplicativo no servidor, em vez de armazená-las no
arquivo. Entretanto, como desenvolvedor do Flash, você pode ter outros segredos comerciais,
como estruturas de clipes de filmes, que não deseja revelar. Use a senha para depuração a fim
de proteger o seu trabalho.
Para ativar a depuração remota de um arquivo SWF:

2. Na guia Flash da caixa de diálogo Publish Settings, selecione Debugging permitted
(Depuração permitida).
3. Para definir uma senha, digite-a na caixa Password (Senha).

Depois de definida a senha, ninguém poderá fazer download de informações para o
Debugger sem ela. No entanto, se o campo Password for deixado em branco, a senha não
será solicitada.
4. Feche a caixa de diálogo Publish Settings e selecione um dos seguintes comandos:
■ Control > Debug Movie
■ File > Export (Exportar) > Export Movie (Exportar filme)
■ File > Publish (Publicar)

O Flash cria um arquivo de depuração, com a extensão .swd e salva-o no mesmo diretório
que o arquivo SWF. O arquivo SWD é usado para depurar o ActionScript e contém
informações que lhe permitem usar pontos de interrupção e depurar o código
diretamente.
5. Coloque o arquivo SWD no mesmo diretório do arquivo SWF no servidor.
Mesmo que o arquivo SWD não esteja no mesmo diretório do arquivo SWF, você poderá
executar uma depuração remota. No entanto, o Debugger não tem informações de pontos
de interrupção e não permitirá a depuração direta do código.
6. No Flash, selecione Window (Janela) > Debugger.
7. No Debugger, selecione Enable Remote Debugging (Ativar a depuração remota) no menu
pop-up no canto superior direito do painel.
Para ativar o Debugger a partir de um local remoto:

1. Abra o aplicativo de criação Flash.
2. Em um navegador ou na versão existente do exibidor independente, abra o arquivo SWF
publicado a partir do local remoto.
A caixa de diálogo Remote Debug (Depuração remota) é exibida.

NO TA
Se essa caixa de diálogo não for exibida, significa que o Flash não pôde encontrar o
arquivo SWD. Nesse caso, clique com o botão direito do mouse (Windows), ou
mantenha pressionada a tecla Control e clique (Macintosh), no arquivo SWF para
exibir o menu de contexto. Selecione Debugger nesse menu.
3. Na caixa de diálogo Remote Debug (Depuração remota), selecione Localhost (Host local)
ou Other Machine (Outra máquina):
■ Selecione Localhost se o Debug Player e o aplicativo de criação Flash estiverem no
mesmo computador.
■ Selecione Other Machine (Outra máquina) se o Debug Player e o aplicativo de criação
Flash não estiverem no mesmo computador. Digite o endereço IP do computador em
que o aplicativo de criação Flash está sendo executado.
4. Quando a conexão for estabelecida, a senha será solicitada.
Digite a senha para depuração se já houver uma definida.
A lista de exibição do arquivo SWF aparece no Debugger. Se o arquivo SWF não for
reproduzido, o Debugger poderá ser interrompido, portanto, clique em Continue para
iniciá-lo.
Exibindo e modificando variáveis

A guia Variables no Debugger mostra os nomes e os valores de todas as variáveis globais e de
linha de tempo no arquivo SWF selecionadas na lista de exibição. Se você alterar o valor de
uma variável na guia Variables, poderá ver a alteração refletida no arquivo SWF durante sua
execução. Por exemplo, para testar a detecção de colisão em um jogo, você pode inserir o valor
da variável para posicionar uma bola no local correto próximo a uma parede.

No Debugger, a guia Locals (Locais) mostra os nomes e os valores das variáveis locais
disponíveis, na linha do ActionScript em que o arquivo SWF esteja parado atualmente, em
um ponto de interrupção ou em qualquer outro local dentro de uma função definida pelo
usuário.
Para exibir uma variável:

1. Selecione o clipe de filme que contém a variável na lista de exibição.
Para exibir variáveis globais, selecione o clipe _global na lista de exibição.
NO TA

Quando o ponteiro muda entre cada região, você pode arrastar para redimensionar
as listas de exibição e observação, e a exibição do código.
2. Clique na guia Variables (Variáveis).

A lista de exibição é atualizada automaticamente enquanto o arquivo SWF é reproduzido. Se
um clipe de filme for removido do arquivo SWF em um quadro específico, esse clipe será
removido da lista de exibição do Debugger juntamente com sua variável e o nome de variável.
No entanto, se você marcar uma variável para a lista de observação (consulte “Usando a lista
de observação” na página 752), ela será removida da guia Variables (Variáveis), mas ainda
poderá ser exibida nessa lista.
Para modificar o valor de uma variável:

■ Clique duas vezes no valor e insira um novo.

O valor não pode ser uma expressão. Por exemplo, use "Hello", 3523 ou "http://
www.macromedia.com", mas não use x + 2 ou eval("name:" +i). O valor pode ser uma
seqüência de caracteres (qualquer valor entre aspas [""]), um número ou um valor booleano
(true (verdadeiro) ou false (falso)).
N OT A
Para escrever o valor de uma expressão para o painel Output no modo de teste, use a
instrução trace. Consulte “Usando a instrução trace” na página 764.
Usando a lista de observação

Para monitorar um conjunto de variáveis críticas de forma organizada, você pode marcá-las
para serem exibidas na lista de observação. Essa lista mostra o caminho absoluto para a variável
e o valor. Também é possível inserir um novo valor de variável na lista de observação da
mesma maneira que na guia Variables. Agora, a lista de observação mostra apenas as variáveis e
as propriedades que você pode acessar usando um caminho de destino absoluto, como
_global ou _root.
Se uma variável local for inserida na lista de observação, seu valor aparecerá apenas quando o
Flash Player for parado em uma linha do ActionScript com o escopo dessa variável. Todas as
demais variáveis aparecerão durante a reprodução do arquivo SWF. Se o Debugger não
encontrar o valor da variável, ele será listado como Undefined (Indefinido).
NO T A

Quando o ponteiro muda entre cada região, você pode arrastar para redimensionar as
listas de exibição e observação, e a exibição do código.
A lista de observação mostra apenas as variáveis e não as propriedades ou funções.
Variáveis marcadas para a lista de observação e variáveis na lista de observação

Para adicionar variáveis à lista de observação, escolha uma desta opções:
■ Na guia Variables ou Locals, clique com o botão direito do mouse (Windows) ou,
pressionando Control, clique (Macintosh) em uma variável selecionada e escolha Watch
(Observação) no menu de contexto. É exibido um ponto azul próximo à variável.
■ Na guia Watch (Observação), clique no botão direito do mouse (Windows), ou mantenha
pressionada a tecla Control e clique (Macintosh) e selecione Add (Adicionar) no menu de
contexto. Clique duas vezes na coluna de nome e insira o caminho de destino para o nome
da variável no campo.
Para remover variáveis da lista de observação:

■ Na guia Watch ou Variables (Variáveis), clique com o botão direito do mouse (Windows)
ou mantenha pressionada a tecla Control (Macintosh) e clique e selecione Remove no
menu de contexto.
Exibindo propriedades do clipe de filme e alterando

propriedades editáveis
No Debugger, a guia Properties (Propriedades) mostra todos os valores de propriedades de
qualquer clipe de filme no Stage (Palco). É possível alterar um valor e ver o efeito no arquivo
SWF durante sua reprodução. Algumas propriedades de clipe de filme são somente de
leitura e não podem ser alteradas.
N OT A

Quando o ponteiro muda entre cada região, você pode arrastar para redimensionar as
listas de exibição e observação, e a exibição do código.
Para exibir as propriedades de um clipe de filme no Debugger:

1. Selecione um clipe de filme na lista de exibição.

2. No Debugger, clique na guia Properties.
Para modificar o valor de uma propriedade:

■ Clique duas vezes no valor e insira um novo.
O valor não pode ser uma expressão. Por exemplo, insira 50 ou "clearwater", mas não x +
50. O valor pode ser uma seqüência de caracteres (qualquer valor entre aspas [""]), um
número ou um valor booleano (true (verdadeiro) ou false (falso)). Não é possível digitar
valores de objeto ou de array (por exemplo, {id: "rogue"} ou [1, 2, 3]) no Debugger.
NO TA
Para escrever o valor de uma expressão para o painel Output no modo de teste, use
a instrução trace. Consulte “Usando a instrução trace” na página 764.

Definindo e removendo pontos de interrupção
Um ponto de interrupção permite interromper um aplicativo Flash em execução no Flash
Debug Player em uma linha específica do ActionScript. Use os pontos de interrupção para
testar os possíveis itens problemáticos do código. Por exemplo, se você tiver escrito um
conjunto de instruções if..else if e não conseguir determinar qual delas está em execução,
poderá adicionar um ponto de interrupção antes das instruções e examinar cada uma delas no
Debugger.
Você pode definir os pontos de interrupção no painel Actions, na janela Script ou no
Debugger. Os pontos de interrupção definidos no painel Actions são salvos com o arquivo
FLA. Os pontos de interrupção definidos no Debugger e na janela Script não são salvos no
arquivo FLA e são válidos somente para a sessão atual de depuração.
A T E NÇ Ã O
Se definir pontos de interrupção no painel Actions ou na janela Script e pressionar o

botão Auto Format (Formatação automática), você poderá observar que alguns desses
pontos não estão mais no local correto. Pode ser que o ActionScript tenha sido movido
para outra linha quando o código foi formatado, porque, às vezes, as linhas em branco
são removidas. Talvez seja necessário verificar e modificar os pontos de interrupção
depois que você clicar em Auto Format ou formatar automaticamente os scripts antes
de selecionar pontos de interrupção.
Para definir ou remover um ponto de interrupção no painel Actions ou na

janela Script durante uma sessão de depuração, siga um destes
procedimentos:
■ Clique na margem esquerda. Um ponto vermelho indica um ponto de interrupção.
■ Clique no botão Debug options (Opções de depuração) acima do painel Script.
■ Clique com o botão direito do mouse (Windows) ou mantenha a tecla Control
pressionada e clique (Macintosh) para exibir o menu de contexto e selecione Set
Breakpoint (Definir ponto de interrupção), Remove Breakpoint (Remover ponto de
interrupção) ou Remove Breakpoints in this File (Remover pontos de interrupção neste
arquivo).
NO T A
Na janela Script, também é possível selecionar Remove Breakpoints in all AS Files

(Remover pontos de interrupção em todos os arquivos AS).
■ Pressione Control+Shift+B (Windows) ou Command+Shift+B (Macintosh).

N O TA
Em algumas versões anteriores do Flash, um clique na margem esquerda do painel

Script selecionava a linha de código; agora essa ação adiciona ou remove um ponto
de interrupção. Para selecionar uma linha de código, clique com o botão do mouse e
pressione Control (Windows) ou clique e pressione Command (Macintosh).

Para definir e remover pontos de interrupção no Debugger, siga um destes
procedimentos:
■ Clique na margem esquerda. Um ponto vermelho indica um ponto de interrupção.
■ Clique no botão Toggle Breakpoint (Alternar o ponto de interrupção) ou Remove All
Breakpoints acima da visualização do código.
■ Clique com o botão direito do mouse (Windows) ou mantenha a tecla Control
pressionada e clique (Macintosh) para exibir o menu de contexto e selecione Set
Breakpoint, Remove Breakpoint ou Remove Breakpoints in the File.
■ Pressione Control+Shift+B (Windows) ou Command+Shift+B (Macintosh).
Depois que o Flash Player parar no ponto de interrupção, será possível executar uma
depuração total, parcial ou circular daquela linha de código. (Consulte “Sobre como trabalhar
nas linhas de código” na página 757.)
Você pode definir pontos de interrupção na janela Script e visualizá-los no depurador, se o
depurador apresentar o mesmo caminho para o arquivo do ActionScript que aquele que estava
aberto na janela Script. Da mesma forma, é possível definir pontos de interrupção no
depurador durante uma sessão de depuração e visualizá-los no arquivo do ActionScript se você
abri-lo na janela Script.
NO TA
Não defina pontos de interrupção em comentários ou linhas em branco; se forem

definidos em comentários ou linhas vazias, os pontos de interrupção serão ignorados.
Sobre o arquivo XML de pontos de interrupção

Quando você trabalha com pontos de interrupção em um arquivo de script externo na janela
Script, o arquivo AsBreakpoints.xml permite o armazenamento de informações de ponto de
interrupção. O arquivo AsBreakpoints.xml é gravado no diretório Local Settings
(Configurações locais), nos seguintes locais:
Windows:
Disco rígido\Documents and Settings\User\Local Settings\Application
Data\Macromedia\Flash 8\language\Configuration\Debugger\
Macintosh:
HD do Macintosh/Users/User/Library/Application Support/Macromedia Flash 8/
Configuration/Debugger/
Um exemplo de AsBreakpoints.xml é mostrado a seguir:
<?xml version="1.0"?>
<flash_breakpoints version="1.0">
<file name="c:\tmp\myscript.as">
<breakpoint line="10"></breakpoint>

</file>
<file name="c:\tmp\myotherscript.as">
</file>
</flash_breakpoints>
O arquivo XML consiste nas seguintes marcas:

flash_breakpoints Esse nó tem um atributo, denominado version, que indica a versão do
arquivo XML. A versão do Flash 8 é 1.0.
file Um nó filho de flash_breakpoints. Esse nó tem um atributo, denominado name, que
indica o nome do arquivo que contém pontos de interrupção.
breakpoint Um nó filho de file. Esse nó tem um atributo, denominado line, que indica o
número da linha em que o ponto de interrupção existe.
O arquivo AsBreakpoints.xml é lido quando você inicia o Flash e gerado novamente quando o
Flash é encerrado. AsBreakpoints.xml é usado para controlar os pontos de interrupção entre as
sessões de desenvolvimento do Flash. Uma estrutura de dados interna mantém os pontos de
interrupção enquanto você os define e remove ao desenvolver no Flash.
Sobre como trabalhar nas linhas de código

Quando uma sessão de depuração é iniciada, o Flash Player é interrompido para que você
possa alternar pontos de interrupção. Se definir pontos de interrupção no painel Actions
(Ações), você poderá clicar no botão Continue (Continuar) para reproduzir o arquivo SWF
até atingir um ponto de interrupção. Se você não definir pontos de interrupção no painel
Actions, use o menu de salto no Debugger para selecionar qualquer script no arquivo SWF.
Quando selecionar o script. você poderá adicionar pontos de interrupção a ele.
Após a adição de pontos de interrupção, clique em Continue para iniciar o arquivo SWF. O
Debugger parará quando alcançar o ponto de interrupção. Por exemplo, no código a seguir,
suponha que o ponto de interrupção esteja definido dentro de um botão na linha
myFunction():
on(press){
myFunction();
}

Quando você clica no botão, o ponto de interrupção é alcançado e o Flash Player é
interrompido. Desse modo, é possível entrar no código e levar o Debugger até a primeira linha
da função myFunction(), independentemente do local em que ela esteja definida no
documento. Também é possível percorrer a função ou sair dela.
À medida que você percorre as linhas de código, os valores de variáveis e propriedades são
alterados na lista de observação e nas guias Variables (Variáveis), Locals (Locais) e Properties
(Propriedades). A seta amarela do lado esquerdo da visualização de código do Debugger indica
a linha em que o Debugger parou. Use os botões a seguir localizados na parte superior da
visualização de código:
Continue (Continuar)
Stop Debugging (Parar a depuração)
Toggle Breakpoint (Alternar o ponto de interrupção)
Remove All Breakpoints (Remover todos os pontos de interrupção)
Step Out (Depuração circular)

Step In (Depuração total)
Step Over (Depuração parcial)
Step In (Depuração total) avança o Debugger (indicado pela seta amarela) dentro de uma
função. O botão Step In funciona somente com funções definidas pelo usuário.
No exemplo a seguir, se você colocar um ponto de interrupção na linha 7 e clicar em Step In,
o Debugger avançará para a linha 2, e, com um clique posterior em Step In, ele avançará para
a linha 3. Para avançar o Debugger uma linha de código, clique em Step In para linhas que
não têm funções definidas pelo usuário. Por exemplo, se você parar na linha 2 e selecionar
Step In, o Debugger avançará para a linha 3, conforme mostrado no seguinte exemplo:
1 function myFunction() {
2 x = 0;
3 y = 0;
4 }
5
6 mover = 1;
7 myFunction();
8 mover = 0;
NO TA
Os números neste trecho de código indicam números de linha. Eles não fazem parte do
código.

Step Out (Depuração circular) avança o Debugger até sair de uma função. Esse botão só
funcionará se você estiver parado no momento em uma função definida pelo usuário. Ele
move a seta amarela para a linha posterior àquela em que a função foi chamada. No exemplo
anterior, se você colocar um ponto de interrupção na linha 3 e clicar em Step Out, o
Debugger avançará para a linha 8. Clicar em Step Out em uma linha fora de uma função
definida pelo usuário é o mesmo que clicar em Continue. Por exemplo, se você parar na linha
6 e clicar em Step Out, o exibidor continuará executando o script até encontrar um ponto de
interrupção.
Step Over (Depuração parcial) avança o Debugger sobre uma linha de código. Esse botão
move a seta amarela para a próxima linha no script. No exemplo anterior, se tivesse parado na
linha 7 e clicado em Step Over, você avançaria diretamente para a linha 8 sem parar em
myFunction(), embora o código de myFunction() ainda seja executado.
Continue (Continuar) sai da linha em que o exibidor está parado e continua a reprodução até
alcançar um ponto de interrupção.
Stop Debugging (Parar a depuração) desativa o Debugger, mas continua a reproduzir o
arquivo SWF no Flash Player.
Usando o painel Output

No modo de teste, o painel Output (Saída) mostra informações para ajudá-lo a solucionar
problemas do arquivo SWF. Algumas informações, como erros de sintaxe, são exibidas
automaticamente. Você pode mostrar outras informações usando os comandos List Objects
(Listar objetos) e List Variables (Listar variáveis). (Consulte “Listando os objetos de um
arquivo SWF” na página 761 e “Listando as variáveis de um arquivo SWF” na página 762.)
Se você usar a instrução trace em seus scripts, poderá enviar informações específicas para o
painel Output enquanto o arquivo SWF é executado. Essas informações podem incluir
observações sobre o status do arquivo SWF ou o valor de uma expressão. (Consulte “Usando a
instrução trace” na página 764.)
Para mostrar o painel Output, siga um destes procedimentos:

■ Selecione Window (Janela) > Output (Saída).
■ Pressione F2.
Usando o painel Output 759

Para trabalhar com o conteúdo do painel Output, clique no menu pop-up no canto superior
direito para visualizar suas opções.
A tabela a seguir lista as opções disponíveis no menu pop-up do painel Output:
Item de menu O que faz

Word wrap (Quebra Alterna automaticamente a quebra automática de linha, para que o
automática de linha) usuário não tenha que utilizar a barra de rolagem horizontal para
visualizar toda a linha de caracteres. Se selecionada, quebra as
linhas; caso contrário, não haverá quebra de linhas.
Copy (Copiar) Copia todo o conteúdo do painel Output na Área de transferência

do computador. Para copiar uma parte selecionada da saída,
escolha a área que você deseja copiar e selecione Copy.
Clear (Limpar) Limpa toda a saída presente no painel Output no momento.
Find (Localizar) Abre uma caixa de diálogo que você pode usar para encontrar uma
palavra-chave ou frase no conteúdo do painel Output.
Find Again (Localizar Tenta localizar a próxima instância de uma palavra-chave ou frase
novamente) no conteúdo do painel Output.
Save to File (Salvar em Salva o conteúdo atual do painel Output em um arquivo de texto
arquivo) externo.
Print (Imprimir) Mostra a caixa de diálogo Print, que permite imprimir o conteúdo
atual do painel Output em uma impressora instalada ou em
programas instalados, como o Flash Paper ou o Acrobat.
Filter level (Nível de Permite selecionar dois níveis possíveis de saída: None (Nenhum)
filtro) ou Verbose (Extenso). Selecione None para eliminar a saída
enviada ao navegador.

Item de menu O que faz
Maximize Panel Maximiza o painel Output quando acoplado.
(Maximizar painel)
Close Panel (Fechar Fecha o painel Output e limpa o conteúdo do painel.
painel)
Para obter mais informações sobre como o painel Output, consulte os seguintes tópicos:
■ “Listando os objetos de um arquivo SWF” na página 761
■ “Listando as variáveis de um arquivo SWF” na página 762
■ “Sobre como exibir as propriedades do campo de texto para depuração” na página 763
■ “Usando a instrução trace” na página 764
■ “Atualizando o Flash Player para teste” na página 765
Listando os objetos de um arquivo SWF

No modo de teste, o comando List Objects (Listar Objetos) mostra o nível, o quadro, o tipo
de objeto (forma, clipe de filme ou botão), caminhos de destino e nomes de instâncias de
clipes de filme, botões e campos de texto em uma lista hierárquica. Essa opção é especialmente
útil para localizar o caminho de destino e o nome de instância corretos. Ao contrário do
Debugger, a lista não é atualizada automaticamente enquanto o arquivo SWF é reproduzido.
Selecione o comando List Objects sempre que desejar enviar as informações para o painel
Output (Saída).
A TE N ÇÃ O
Selecione o comando List Objects para limpar as informações exibidas atualmente no

painel Output. Se você não quiser perder informações no painel Output, selecione Save
to File no menu pop-up Options desse painel ou copie e cole essas informações em
outro local antes de selecionar o comando List Objects.
O comando List Objects não lista todos os objetos de dados do ActionScript. Nesse contexto,
um objeto é considerado como uma forma ou símbolo no Stage.

Para exibir uma lista de objetos em um arquivo SWF:
1. Se o arquivo SWF não estiver em execução no modo de teste, selecione Control (Controlar)
> Test Movie (Testar filme).
2. Selecione Debug > List Objects.
Uma lista de todos os objetos do Stage é exibida no painel Output, como mostrado
neste exemplo:
Level #0: Frame=1 Label="Scene_1"
Button: Target="_level0.myButton"
Shape:
Movie Clip: Frame=1 Target="_level0.myMovieClip"
Shape:
Edit Text: Target="_level0.myTextField" Text="This is sample text."
Listando as variáveis de um arquivo SWF

No modo de teste, o comando List Variables (Listar variáveis) mostra uma lista de todas as
variáveis atualmente no arquivo SWF. Essa lista é especialmente útil para localizar o nome da
variável e seu caminho de destino corretos. Ao contrário do Debugger, a lista não é atualizada
automaticamente enquanto o arquivo SWF é reproduzido. Selecione o comando List
Variables sempre que desejar enviar as informações para o painel Output (Saída).
O comando List Variables também mostra as variáveis globais declaradas com o identificador
_global. As variáveis globais são exibidas na parte superior da saída de List Variables em uma
seção intitulada Global Variables (Variáveis globais), e cada variável possui o prefixo _global.
Além disso, o comando List Variables mostra as propriedades getter/setter (apanhadoras/
definidoras), isto é, aquelas criadas com o método Object.addProperty(), e inicia os
métodos get ou set. Uma propriedade getter/setter é exibida juntamente com qualquer outra
propriedade do objeto a que pertence. Para facilitar a distinção entre essas propriedades e
outras variáveis, o valor de uma propriedade getter/setter é iniciado com a seqüência de
caracteres [getter/setter]. O valor exibido para uma propriedade getter/setter é
determinado mediante a avaliação da função get da propriedade.
ATENÇÃO
Selecione o comando List Variables para limpar as informações exibidas atualmente no

painel Output. Se você não quiser perder informações no painel Output, selecione Save
to File no menu pop-up Options desse painel ou copie e cole essas informações em
outro local antes de selecionar o comando List Variables.

Para exibir uma lista de variáveis em um arquivo SWF:
1. Se o arquivo SWF não estiver em execução no modo de teste, selecione Control (Controlar)
> Test Movie (Testar filme).
2. Selecione Debug (Depurar) > List Variables.
Uma lista de todas as variáveis atualmente no arquivo SWF é exibida no painel Output,
como mostrado neste exemplo:
Global Variables:
Variable _global.mycolor = "lime_green"
Level #0:
Variable _level0.$version = "WIN 7,0,19,0"
Variable _level0.myArray = [object #1, class 'Array'] [
0:"socks",
1:"gophers",
2:"mr.claw"
]
Movie Clip: Target="_level0.my_mc"
Sobre como exibir as propriedades do campo de

texto para depuração
Para obter informações depuradas sobre os objetos TextField, você pode usar o comando
Debug (Depurar)> List Variables (Listar variáveis) no modo de teste. O painel Output usa as
seguintes convenções para mostrar objetos TextField:
■ Se uma propriedade não for encontrada no objeto, ela não será exibida.
■ Não mais de quatro propriedades são exibidas em uma linha.
■ Uma propriedade com um valor de seqüência de caracteres é exibida em uma linha
separada.
■ Se houver alguma outra propriedade definida para o objeto após as propriedades
internas serem processadas, elas serão adicionadas à exibição usando-se as regras no
segundo e terceiro pontos dessa lista.
■ As propriedades de cor são exibidas como números hexadecimais (0x00FF00).
■ As propriedades são exibidas na seguinte ordem: variable, text, htmlText, html,
textWidth, textHeight, maxChars, borderColor, backgroundColor, textColor,
border, background, wordWrap, password, multiline, selectable, scroll, hscroll,
maxscroll, maxhscroll, bottomScroll, type, embedFonts, restrict, length,
tabIndex, autoSize.

O comando List Objects (Listar objetos) no menu Debug (durante o modo de teste) lista os
objetos TextField. Se um nome de instância for especificado para um campo de texto, o painel
Output mostrará o caminho de destino completo, incluindo o nome de instância, da seguinte
forma:
Target = "target path"
Para obter mais informações sobre os comandos List Variables (Listar variáveis) e List Objects
(Listar objetos), consulte “Usando o painel Output” na página 759.
Usando a instrução trace

Ao usar a instrução trace em um script, você pode enviar informações para o painel Output.
Por exemplo, ao testar um arquivo SWF ou uma cena, você pode enviar observações de
programação específicas para o painel ou fazer com que resultados específicos sejam exibidos
quando for pressionado um botão ou quando um quadro for reproduzido. A instrução trace
é semelhante à instrução JavaScript alert.
Quando a instrução trace é usada em um script, você pode usar expressões como parâmetros.
O valor de uma expressão é exibido no painel Output no modo de teste, conforme mostrado
pelo trecho de código e pela imagem do painel Output a seguir.
Para usar a instrução trace em um script:

código ao painel Actions (Ações):
trace(target_mc+" loaded in "+getTimer()+" ms");
};
mclListener.onLoadError = function(target_mc:MovieClip,
errorCode:String, httpStatus:Number) {
trace(">> error downloading image into "+target_mc);
trace(">>\t errorCode="+errorCode+", httpStatus="+httpStatus);
};
img_mcl.loadClip("http://www.helpexamples.com/flash/images/404.jpg",
img_mc);

O painel Output (Saída) exibirá a seguinte mensagem:
Atualizando o Flash Player para teste

Você pode fazer download da versão mais recente do Flash Player do Macromedia Support
Center em www.macromedia.com/support/flash e usá-la para testar seus arquivos SWF.

CAPÍTULO 19
Melhores práticas e convenções de

codificação para ActionScript 2.0 19
Os designers e desenvolvedores do Macromedia Flash devem escrever códigos e estruturar
aplicativos de uma forma intuitiva benéfica para eles próprios e também para as outras pessoas
que estão trabalhando no mesmo projeto. Isso é especialmente importante em arquivos FLA
com muitos recursos ou longos arquivos de códigos. Quando você segue as melhores práticas e
convenções de codificação, todos na equipe de design e desenvolvimento podem entender a
estrutura de arquivos e o código do ActionScript, e podem trabalhar com mais eficiência. Este
documento ajuda a formalizar o processo de desenvolvimento e codificação do Flash.
Como é comum mais de um designer ou desenvolvedor trabalhar em um único projeto Flash,
as equipes se beneficiam quando todos seguem um conjunto padrão de diretrizes para utilizar
Flash, organizar arquivos FLA e escrever o código ActionScript 2.0. As seções deste capítulo
descrevem as melhores práticas para escrever o código ActionScript; e algumas seções de
Usando o Flash abordam as melhores práticas para a utilização da ferramenta de criação Flash.
As diretrizes a seguir apresentam as vantagens da consistência para que as pessoas aprendam a
usar Flash e escrever o código ActionScript. Adote as melhores práticas em todas as ocasiões,
quer você seja designer ou desenvolvedor, ou esteja trabalhando sozinho ou em equipe.
■ Quando você trabalhar em documentos do Flash ou ActionScript
A adoção de práticas consistentes e eficientes ajuda a acelerar o fluxo de trabalho. Com
convenções de codificação estabelecidas, a tarefa de desenvolvimento se torna mais rápida
e fica mais fácil compreender e lembrar como o documento foi estruturado, caso você
queira editá-lo posteriormente. Além disso, o código costuma ter mais mobilidade no
framework de um projeto de maior porte, além de ser reutilizado mais facilmente.
■ Quando você compartilhar arquivos FLA ou AS
Outras pessoas editando o documento poderão localizar e entender rapidamente o
ActionScript, modificar o código consistentemente e encontrar e editar recursos.
■ Quando você trabalhar em aplicativos
767
Vários autores poderão trabalhar em um aplicativo com menos conflitos e mais eficiência.
Se melhores práticas e convenções de codificação forem seguidas, os administradores de
projetos ou sites poderão gerenciar e estruturar projetos ou aplicativos complexos com
menor quantidade de conflitos ou redundâncias.
■ Quando você estiver estudando ou ensinando o Flash e o ActionScript
Aprender a criar aplicativos usando as melhores práticas e seguindo convenções de
codificação reduz a necessidade de reaprender determinadas metodologias. Se os alunos
que estão aprendendo Flash exercitarem maneiras melhores e consistentes de estruturar o
código, poderão aprender a linguagem com mais rapidez e menos frustração.
Técnicas consistentes e as diretrizes a seguir ajudam pessoas que estejam aprendendo Flash ou
que estejam trabalhando efetivamente em ambientes de equipe. Quando você trabalha
sozinho, métodos consistentes o ajudam a lembrar como estruturou seu documento,
especialmente se não tiver usado o arquivo FLA recentemente.
Essas são apenas algumas razões pelas quais você deve aprender e seguir as melhores práticas.
Você está prestes a descobrir muito mais quando ler essas melhores práticas e desenvolver seus
próprios bons hábitos. Considere os tópicos a seguir como uma diretriz para a utilização do
Flash; você pode optar por seguir algumas ou todas as recomendações. Você também pode
modificá-las para que se ajustem ao seu modo de trabalho. Muitas das diretrizes neste capítulo
o ajudam a desenvolver uma maneira consistente de trabalhar com Flash e a criar o código
ActionScript.
Este capítulo aborda os seguintes tópicos sobre as convenções de codificação e as melhores
práticas:
Convenções de atribuição de nome . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .769
Usando de comentários no código. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 779
Convenções de codificação do ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 782
Otimização do ActionScript e do Flash Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 798
Formatando a sintaxe do ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .799
768 Melhores práticas e convenções de codificação para ActionScript 2.0

Convenções de atribuição de nome
Geralmente, você gasta 80% de seu tempo de desenvolvimento com depuração, solução de
problemas e manutenção geral, especialmente em projetos maiores. Mesmo quando você
trabalha em projetos pequenos, gasta um tempo significativo analisando e corrigindo o
código. A legibilidade do seu código é importante para seu benefício e o benefício dos
membros de sua equipe. Ao seguir as convenções de atribuição de nome, você melhora a
legibilidade, ao mesmo tempo aumentando o fluxo de trabalho e permitindo a localização e
correção de erros no código. Todos os programadores seguem uma maneira padronizada de
escrever código, o que aprimora o projeto de muitas maneiras.
A utilização de convenções de atribuição de nome para nomes de variáveis pode ser útil nas
seguintes importantes funções:
■ Elas tornam o código legível de modo que seja possível identificar imediatamente o tipo de
dados de uma variável. Isso pode ajudar aos alunos que estejam aprendendo a criar
códigos, bem como a desenvolvedores que não estejam familiarizados com o seu código.
■ Elas podem ser pesquisadas e substituídas quando necessário.
■ Elas ajudam a reduzir conflitos com palavras reservadas e construções de linguagem.
■ Elas podem ajudá-lo a distinguir entre as variáveis de escopos diferentes (variáveis locais,
propriedades de classe, parâmetros etc.).
As seções a seguir contêm diretrizes de atribuição de nomes para a criação de código do
ActionScript, como arquivos de atribuição de nome, variáveis, constantes, componentes etc. A
seção “Formatando a sintaxe do ActionScript” na página 799 analisa as convenções de
atribuição de nome específicas do ActionScript e comuns em outras linguagens de
programação. A seção “Convenções de codificação do ActionScript” na página 782 aborda as
codificações de atribuição de nome específicas para a criação de ActionScript e
desenvolvimento com o Flash 8.
NO T A
As versões 7 e 8 do Flash Player seguem a especificação de linguagem ECMAScript

(ECMA-262) edição3. É útil ver essa especificação para obter informações sobre o
funcionamento da linguagem. (Consulte www.ecma-international.org/publications/
standards/Ecma-262.htm.)
Esta seção contém os seguintes tópicos:

■ “Diretrizes gerais de atribuição de nome” na página 770
■ “Como evitar palavras reservadas ou construções de linguagem” na página 771
■ “Atribuição de nome a variáveis” na página 772
■ “Atribuindo nomes a constantes” na página 775
■ “Atribuindo nomes a variáveis booleanas” na página 775
Convenções de atribuição de nome 769

■ “Atribuindo nomes a funções e métodos” na página 775
■ “Nomeando classes e objetos” na página 776
■ “Atribuindo nomes a pacotes” na página 777
■ “Atribuindo nomes a interfaces” na página 778
■ “Atribuição de nomes a componentes personalizados” na página 778
Diretrizes gerais de atribuição de nome

Esta seção analisa as diretrizes de atribuição de nome usadas para escrever o código
ActionScript. As convenções de atribuição de nome são importantes para escrever o código
lógico. O principal objetivo consiste em melhorar a legibilidade do código ActionScript 2.0.
Lembre-se de que todas as variáveis devem ser nomes exclusivos. Os nomes fazem distinção
entre maiúsculas e minúsculas no Flash Player 7 e nas versões posteriores. Não use o mesmo
nome com maiúsculas e minúsculas diferentes, pois isso pode confundir os programadores ao
lerem seu código, bem como causar problemas em versões anteriores do Flash que não forçam
essa distinção. Lembre-se destas diretrizes ao atribuir nomes a itens, como variáveis, arquivos e
classes no Flash:
■ Limite o uso de abreviações.
Use abreviações consistentemente. Uma abreviação deve representar claramente apenas
um item. Por exemplo, a abreviação “sec” pode representar “section” e “second.”
■ Faça a concatenação de palavras para criar nomes.
Use combinações de maiúsculas e minúsculas ao concatenar palavras para fazer distinção
entre palavras, para fins de legibilidade. Por exemplo, selecione myPelican em vez
demypelican (meu pelicano)
■ Denomine um arquivo de modo a descrever o processo ou o item, como addUser
(adicionar usuário).
■ Não use nomes que não sejam descritivos para métodos ou variáveis.
Por exemplo, se recuperar uma parte dos dados correspondente ao nome de usuário do
visitante, você poderá usar o método getUserName(), em vez do método menos
descritivo getData(). Esse exemplo expressa o que está acontecendo, e não como você
realiza a ação.
■ Mantenha o tamanho de todos os nomes o menor possível.
Lembre-se de usar nomes descritivos.
As seções a seguir oferecem mais detalhes sobre a atribuição de nomes a itens, como variáveis,
classes, pacotes e constantes no seu código.

Como evitar palavras reservadas ou construções de
linguagem
Ao atribuir nomes a instâncias e variáveis, evite usar palavras reservadas, pois elas podem
causar erros no código. As palavras reservadas incluempalavras-chave na linguagem
ActionScript.
Além disso, não use nenhuma palavra nas linguagens ActionScript 2.0 (chamada de construção
de linguagem) para o nome de uma instância ou variável. As construções ActionScript
abrangem nomes de classes, nomes de classes de componentes, nomes de métodos e
propriedades e nomes de interfaces.
A VI S O
Nunca use maiúsculas e minúsculas diferentes para evitar conflito com palavras
reservadas. Por exemplo, a atribuição de nome a uma instância da classe TextField
textfield (que não entra em conflito com TextField porque o Flash faz distinção entre
maiúsculas e minúsculas) é uma prática de codificação inadequada.
A tabela a seguir lista as palavras reservadas no ActionScript 2.0 que causam erros nos scripts
quando usadas como nomes de variáveis:
add and break case

catch class continue default
delete do dynamic else
eq extends false finally
for função ge get
gt if ifFrameLoaded implements
import in instanceof interface

intrinsic le it ne
new not Null on
onClipEvent or private public
return set static super
switch tellTarget this throw
try typeof var void

while with

As palavras a seguir são reservadas para uso futuro no Flash, com base na especificação de
linguagem preliminar ECMAScript (ECMA-262) Edition 4. Evite usar essas palavras, pois
elas podem ser utilizadas em futuras versões do Flash.
as abstract Boolean bytes
char const debugger double
enum export final float
goto is long namespace
native package protected short
synchronized throws transient use
volatile
Atribuição de nome a variáveis

Os nomes de variáveis podem conter somente letras, números e cifrão ($). Não comece nomes
de variáveis com números. As variáveis devem ser exclusivas e fazem distinção entre maiúsculas
e minúsculas no Flash Player 7 e posterior. Por exemplo, evite os seguintes nomes de variáveis:
my/warthog = true; // includes a slash
my warthogs = true; // includes a space
my.warthogs = true; // includes a dot
5warthogs = 55; // begins with a number
Sempre que possível, use uma atribuição estrita de tipos de dados em suas variáveis, pois isso o
ajudará da seguinte maneira:
■ Adiciona a funcionalidade de conclusão de código, o que agiliza a codificação.
■ Gera erros no painel Output (Saída), para que não ocorra uma falha silenciosa durante a
compilação do arquivo SWF. Esses erros ajudam a localizar e corrigir problemas nos
aplicativos.
Para adicionar um tipo de dados às variáveis, você deve defini-las usando a palavra-chave var.
No exemplo a seguir, ao criar um objeto LoadVars, você usaria a atribuição estrita de tipo de
dados:
var paramsLv:LoadVars = new LoadVars();

A atribuição estrita de tipo de dados possibilita a conclusão do código e garante que o valor de
paramsLv contenha um objeto LoadVars. Isso também garante que esse objeto não seja usado
para armazenar dados numéricos ou de seqüências de caracteres. Como a atribuição estrita
utiliza a palavra-chave var, você não pode adicioná-la a variáveis ou propriedades globais em
um objeto ou array. Para obter mais informações sobre variáveis, consulte “Sobre a atribuição
de tipos de dados e a atribuição estrita de tipos de dados” na página 85.
NO TA
A atribuição estrita de tipo de dados não torna mais lento um arquivo SWF. A verificação
de tipo ocorre durante a compilação (quando o arquivo SWF é criado), e não em tempo
de execução.
Use as seguintes diretrizes ao atribuir nomes a variáveis no código:

■ Todas as variáveis devem ter nomes exclusivos.
■ Não use o mesmo nome de variável com maiúsculas/minúsculas diferentes.
Por exemplo, não use firstname (nome) e firstName (Nome) como variáveis diferentes
no aplicativo. Embora os nomes façam distinção entre maiúsculas e minúsculas no Flash
Player 7 e posterior, o uso do mesmo nome de variável com maiúsculas e minúsculas
diferentes pode confundir os programadores que lêem o seu código, além de causar
problemas em versões anteriores do Flash que não forçam a distinção entre maiúsculas e
minúsculas.
■ Não use palavras que façam parte da linguagem ActionScript 1.0 ou 2.0 como nomes de
variáveis.
Em particular, nunca use palavras-chave como nomes de instância, porque elas causam
erros no código. Para evitar conflitos e possibilitar o funcionamento do seu código, não
utilize a distinção entre maiúsculas e minúsculas.
■ Não use variáveis que façam parte de construções de programação comuns.
Não use construções de linguagem se você souber da existência delas em outras linguagens
de programação, mesmo que o Flash não inclua essas construções ou não ofereça suporte a
elas. Por exemplo, não use as seguintes palavras-chave como variáveis:
textfield = "myTextField";
switch = true;
new = "funk";
■ Sempre adicione anotações de tipo de dados ao código.

Também conhecido como “uso de tipos de dados estritos com variáveis” ou “atribuição
rigorosa a variáveis”, o processo de adição de tipos de dados às variáveis é importante para:
■ Gerar erros em tempo de compilação para que o aplicativo não falhe em silêncio.
■ Disparar a conclusão do código.
■ Ajudar os usuários a entenderem o código.

Para obter informações sobre como adicionar anotações de tipo, consulte “Sobre a
atribuição de tipos de dados e a atribuição estrita de tipos de dados” na página 85.
■ Não use o tipo Object (Objeto) demais.
As anotações de tipo de dados devem ser precisas para melhorar o desempenho. Use um
tipo Object somente quando não houver uma alternativa razoável.
■ Mantenha o tamanho das variáveis o menor possível, ao mesmo tempo em que mantém
sua clareza.
Verifique se os nomes das variáveis são descritivos, mas não exagere e use nomes muito
longos e complexos.
■ Somente use nomes de variável de caractere único para otimização em loops.
Como opção, você pode usar nomes de variáveis de caractere único para variáveis
temporárias em loops (como i, j, k, m e n). Use esses nomes de variável de caractere único
somente para índices curtos de loop ou quando a velocidade e otimização do desempenho
são essenciais. O seguinte exemplo mostra esse uso:
var fontArr:Array = TextField.getFontList();
fontArr.sort();
var i:Number;
for (i = 0; i<fontArr.length; i++) {
trace(fontArr[i]);
}
■ Inicie as variáveis com uma letra minúscula.

Os nomes com iniciais maiúsculas são reservados para classes, interfaces etc.
■ Use uma combinação de maiúsculas e minúsculas para palavras concatenadas.
Por exemplo, use myFont (minhaFonte), em vez de myfont (minhafonte).
■ Não use acrônimos e abreviações.
Exceção a essa regra: se os acrônimos ou abreviações representarem o padrão para uso de
um termo (como HTML ou CFM). Para acrônimos comumente usados, use maiúsculas/
minúsculas como em newHtmlParser em vez de newHTMLParser para melhorar a
legibilidade.
■ Use pares complementares ao criar um conjunto relacionado de nomes de variáveis.
Por exemplo, você pode usar pares complementares para indicar a pontuação mínima e
máxima de um jogo, da seguinte forma:
var minScoreNum:Number = 10; // minimum score
var maxScoreNum:Number = 500; // maximum score

Atribuindo nomes a constantes
É possível usar constantes em situações em que você precisa fazer referência a uma propriedade
cujo valor nunca é alterado. Isso ajuda a encontrar erros de digitação no código que talvez não
sejam encontrados se literais foram usados. Também permite alterar o valor em um único
local.
As variáveis devem ser letras minúsculas ou maiúsculas/minúsculas; contudo, você siga estas
diretrizes para atribuir nomes a constantes estáticas (variáveis que não são alteradas):
■ As constantes devem estar em maiúsculas.
■ As palavras separadas devem conter sublinhados.
Você pode ver essas diretrizes funcionando nos seguinte trecho de código ActionScript:
var BASE_URL:String = "http://www.macromedia.com"; // constant
var MAX_WIDTH:Number = 10; // constant
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.
Atribuindo nomes a variáveis booleanas

Inicie as variáveis booleanas com a palavra “is” (porque um valor booleano “é” ou “não é” em
virtude de sua natureza). Portanto, você pode usar o seguinte para uma situação em que um
bebê seja uma menina ou não (que é um valor booleano):
isGirl
Ou, para uma variável indicando se um usuário fez login (ou não), você pode usar o seguinte:
isLoggedIn
Atribuindo nomes a funções e métodos

Use as diretrizes a seguir ao atribuir nomes a funções e métodos no código. Para obter mais
informações sobre como escrever funções e métodos, consulte o Capítulo 6, “Funções e
métodos.”.
■ Use nomes descritivos.
■ Use uma combinação de maiúsculas e minúsculas para palavras concatenadas.
Um bom exemplo seria singLoud().
■ Inicie os nomes de funções e métodos com uma letra minúscula.
■ Descreva o valor que está sendo retornado no nome da função.
Por exemplo, se estiver retornando o nome de uma música, você deverá atribuir à função o
nome getCurrentSong().

■ Estabeleça um padrão de atribuição de nome para relacionar funções semelhantes.
O ActionScript 2.0 não permite a 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.
■ Atribua nomes a métodos como verbos.
Você pode concatenar o nome, mas ele deve conter um verbo. Como os verbos executa um
operação em um objeto, use-os para a maioria dos métodos.
Estes são exemplos de nomes de métodos:
sing();
boogie();
singLoud();
danceFast();
Nomeando classes e objetos

Ao criar um novo arquivo de classes, use as diretrizes a seguir ao atribuir um nome à classe e ao
arquivo ActionScript. Para a formatação correta, consulte os seguintes exemplos de nomes de
classes:
class Widget;
class PlasticWidget;
class StreamingVideo;
Pode haver variáveis de membro públicas e privadas em uma classe. A classe pode conter
variáveis que os usuários não devem definir nem acessar diretamente. Torne essas variáveis
privadas e somente permita que os usuários acessem os valores usando os métodos getter/
setter.
As seguintes diretrizes se aplicam à atribuição de nomes a classes:
■ O nome de uma classe deve iniciar com uma letra maiúscula.
■ Escreva os nomes de classes em maiúsculas e minúsculas quando forem palavras compostas
ou concatenadas.
Comece com uma letra maiúscula para uma palavra composta ou concatenada. Um bom
exemplo seria NewMember.
■ Em geral, os nomes de classes são substantivos ou substantivos qualificados.
O qualificador descreve o substantivo ou a frase. Por exemplo, em vez de “member”, você
pode qualificar o substantivo usando NewMember or OldMember.
■ Nomes claros são mais importantes que nomes curtos.
■ Não use acrônimos e abreviações.

Exceção a essa regra: se os acrônimos ou abreviações representarem o padrão para uso de
um termo (como HTML ou CFM). Para acrônimos comumente usados, você deve usar
maiúsculas/minúsculas como NewHtmlParser em vez de NewHTMLParser para melhorar a
legibilidade.
■ Use nomes significativos e simples que descrevam o conteúdo da classe.
Para evitar imprecisões ou confusões, use nomes genéricos.
■ Às vezes, o nome de uma classe é uma palavra composta.
O qualificador pode descrever o substantivo ou a frase. Por exemplo, em vez de “member”,
você pode qualificar o substantivo usando NewMember or OldMember.
■ Não pluralize as palavras usadas no nome da classe (como Witches ou BaldPirates).
Na maioria dos casos, é melhor deixar as palavras como substantivos qualificados. O
qualificador descreve o substantivo ou a frase. Por exemplo, em vez de “cat” ou
“buckaneer”, você pode qualificar o substantivo como BlackCat ou OldBuckaneer.
■ Não use um nome de classe nas propriedades dessa classe, porque isso causa
redundância.
Por exemplo, não faz sentido ter Cat.catWhiskers. Em vez disso, Cat.whiskers é bem
melhor.
■ Não use substantivos que também possam ser interpretados como verbos.
Por exemplo, Running ou Gardening. O uso desses substantivos pode provocar confusão
com métodos, estados ou outras atividades de aplicativos.
■ Use nomes de classes exclusivos para cada classe em um único aplicativo.
■ Não atribua nomes a classes que entrem em conflito com os nomes das classes internas no
Flash.
■ Tente comunicar o relacionamento que uma classe tem dentro de uma hierarquia.
Isso ajuda a exibir o relacionamento de uma classe dentro de um aplicativo. Por exemplo,
você pode ter a interface Widget e sua implementação pode ser PlasticWidget,
SteelWidget e SmallWidget.
Para obter mais informações sobre interfaces, consulte Capítulo 9, “Interfaces.”.
Atribuindo nomes a pacotes

Em nomes de pacotes, é comum usar a convenção de atribuição de nome “domínio reverso”.
Exemplos de nomes de domínio reverso incluem com.macromedia para macromedia.com e
org.yourdomain para yourdomain.org.
Use as seguintes diretrizes ao atribuir nomes a pacotes:

■ Coloque todo o prefixo do nome do pacote em letras minúsculas.

Por exemplo, com, mx ou org.
■ Coloque classes relacionadas (classes com funcionalidade relacionada) no mesmo pacote.
■ Comece os nomes de pacotes com um prefixo consistente.
Por exemplo, você pode usar com.macromedia.projectName para manter a consistência.
Outro exemplo seria com.macromedia.docs.learnAS2.Users para o manual Learning
ActionScript 2.0 Reference.
■ Use um nome de pacote claro e auto-explicativo.
É importante explicar as responsabilidades do pacote. Por exemplo, você pode ter um
pacote com o nome Pentagons, que seja responsável pelo uso da API de desenho Flash
para desenhar vários tipos de pentágonos nos exemplos da documentação; seu nome seria
com.macromedia.docs.as2.Pentagons.
■ Use maiúsculas/minúsculas para nomes de pacotes compostos ou concatenados.
packageName é um exemplo de nome de pacote composto ou concatenado. Lembre-se de
usar somente minúsculas para o prefixo (com, org etc.).
■ Não use sublinhados nem caracteres de cifrão.
Atribuindo nomes a interfaces

Iniciar o nome de uma interface com um “I” maiúsculo ajuda a diferenciá-la de uma classe. O
seguinte nome de interface, IEmployeeRecords, usa uma letra maiúscula inicial e palavras
concatenadas com maiúsculas/minúsculas da seguinte maneira:
interface IEmployeeRecords{}
As seguintes convenções também se aplicam:

■ Os nomes de interfaces apresentam a primeira letra maiúscula.
O mesmo ocorre com os nomes de classes.
■ Em geral, os nomes de interfaces são adjetivos.
Printable é um bom exemplo.
Para obter mais informações sobre interfaces, consulte Capítulo 9, “Interfaces.”.
Atribuição de nomes a componentes personalizados

Os nomes de componente têm uma primeira letra maiúscula e as palavras concatenadas são
escritas com maiúsculas/minúsculas. Por exemplo, o seguinte conjunto de componentes de
interface de usuário padrão usa palavras concatenadas e maiúsculas/minúsculas:
■ CheckBox (Caixa de seleção)
■ ComboBox (Caixa de combinação)

■ DataGrid (Grade de dados)
■ DateChooser (Selecionador de data)
■ DateField (Campo de data)
■ MenuBar (Barra de menus)
■ NumericStepper (Mostrador numérico)
■ ProgressBar (Barra de andamento)
■ RadioButton (Botão de opção)
■ ScrollPane (Painel de rolagem)
■ TextArea (Área de texto)
■ TextInput (Entrada de texto)
Os componentes de não usam palavras concatenadas começam com letra maiúscula.
Se você desenvolver componentes personalizados, use uma convenção de atribuição de nome
para evitar incompatibilidades de nomes em componentes Macromedia. Os nomes dos
componentes devem ser diferentes do conjunto padrão incluído no Flash. Se você adotar sua
própria convenção consistente de atribuição de nome, evitará conflitos de nomes.
Lembre-se de que as convenções de atribuição de nome desta seção são diretrizes. É mais
importante usar um esquema de atribuição de nome que funcione bem e você deve usá-lo de
maneira consistente.
Usando de comentários no código

Esta seção descreve como usar comentários no código. Os comentários documentam as
decisões tomadas em relação ao código, respondendo às perguntas como e por quê. Por
exemplo, você pode descrever uma solução alternativa em comentários. Outro desenvolvedor
poderia conseguir encontrar o código relacionado para atualização ou correção. Por fim, o
problema poderia ser solucionado em uma versão futura do Flash ou Flash Player e, portanto,
a solução alternativa não seria mais necessária.
Para obter mais informações sobre como escrever comentários no código ActionScript,
■ “Criando comentários adequados” na página 780
■ “Adição de comentários a classes” na página 781
Usando de comentários no código 779

Criando comentários adequados
O uso de comentários de forma consistente no ActionScript 2.0 permite descrever áreas de
código complexas ou interações importantes que, de outro modo, não estão claras. Os
comentários devem explicar claramente a intenção do código e não apenas traduzi-lo. Se
houver algo que não for muito óbvio no código, adicione comentários a ele.
Se você usar a ferramenta Auto Format (Formatação automática) no código, perceberá que os
comentários finais (consulte “Comentários finais” na página 142) passarão para a linha
seguinte. Você pode adicionar esses comentários após formatar o código ou deve modificar o
novo posicionamento do comentário após usar a ferramenta Auto Format.
Para obter informações sobre como usar comentários em classes, consulte “Adição de
comentários a classes” na página 781.
Use as seguintes diretrizes ao adicionar comentários ao código:
■ Use blocos de comentários (/* e */) para comentários com várias linhas e uma única linha
( // ) para comentários pequenos.
Também é possível usar um comentário final na mesma linha que o código ActionScript,
caso necessário.
■ Não use comentários para traduzir o código ActionScript.
Não é necessário comentar os elementos óbvios no código ActionScript.
■ Comente os elementos que não forem óbvios no código.
Em particular, adicione comentários quando o assunto não for descrito nos parágrafos
próximos.
■ Não use comentários desordenados.
Uma linha de comentários desordenados freqüentemente contém sinais de igualdade (=)
ou asteriscos (*). Em vez disso, use espaços em branco para separar os comentários do
código ActionScript.
N OT A
Se você usar a ferramenta Auto Format para formatar o ActionScript, removerá o

espaço em branco. Lembre-se de adicioná-lo de volta ou usar linhas de comentário
únicas (//) para manter o espaçamento. Essas linhas podem ser removidas
facilmente após a formatação do código.
■ Remova os comentários desnecessários do código, antes de implantar o projeto.

Se você achar que há comentários demais no código ActionScript, analise a possibilidade
de reescrever uma parte dele. Se você sentir que deve incluir muitos comentários sobre o
funcionamento do código ActionScript, normalmente será um sinal de que o código foi
mal-escrito.
NO TA
O uso de comentários no código ActionScript é mais importante quando este tem

fins didáticos. Por exemplo, adicione comentários ao código se você estiver criando
aplicativos de exemplo destinados a ensinar o Flash, ou se estiver criando tutoriais
sobre o código ActionScript.
Adição de comentários a classes

Os dois tipos de comentários em um arquivo de classe ou interface típico são comentários de
documentação e comentários de implementação.
NO TA
Os comentários de documentação e implementação não são representados

formalmente na linguagem ActionScript. No entanto, em geral são usados pelos
desenvolvedores ao escreverem arquivos de classe e interface.
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 comentários de documentação são
delimitados por /** e */, e os comentários de implementação são delimitados por /* e */.
Use os comentários de documentação para descrever interfaces, classes, métodos e
construções. 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 para
documentar que não se ajustem aos comentários de documentação, use comentários de
implementação (no formato de bloco de comentários ou em comentários de linha única).
As classes devem iniciar com um comentário padrão, no seguinte formato:
/**
Classe de usuário
versão 1.2
3/21/2004
*/
Após os comentários de documentação, declare a classe. Os comentários de implementação

deve seguir diretamente a declaração.
N O TA
Não inclua comentários que não se relacionem diretamente à classe que está sendo lida.
Por exemplo, não inclua comentários que descrevam o pacote correspondente.
Usando de comentários no código 781

Use comentários em bloco, de linha única ou finais no corpo da classe para fazer comentários
sobre o código ActionScript. Para obter mais informações sobre como usar comentários em
arquivos de classes, consulte “Adição de comentários a classes” na página 781.
Convenções de codificação do
ActionScript
Um dos aspectos mais importantes sobre programação é a consistência, seja ela relacionada aos
esquema de atribuição de nome de variáveis (abordado em “Convenções de atribuição de
nome” na página 769), à formatação de código (abordada em “Formatando a sintaxe do
ActionScript” na página 799) ou ao padrões de codificação e ao posicionamento do código
your ActionScript 2.0, que é abordado nesta seção. Se o código for organizado e obedecer a
padrões, será possível simplificar significativamente a depuração e a manutenção do mesmo.
Para obter mais informações sobre convenções de codificação, consulte os seguintes tópicos:
■ “Manutenção do código ActionScript em um único local” na página 782
■ “Anexando código a objetos” na página 783
■ “Manipulação do escopo” na página 784
■ “Estruturando um arquivo de classes” na página 788
■ “Sobre o uso de funções” na página 795
Manutenção do código ActionScript em um único

local
Sempre que possível, você deve colocar o código ActionScript 2.0 em um único local, como
em um ou mais arquivos externos do ActionScript ou no Quadro 1 da Timeline (quando
colocado na Timeline, o código é conhecido como script de quadro).
Se você colocar o código ActionScript em um script de quadro, coloque-o no primeiro ou
segundo quadro da Timeline, em uma camada chamada Actions, que é a primeira ou segunda
camada da Timeline. Às vezes, você pode criar duas camadas (uma prática aceitável) para o
ActionScript a fim de separar as funções. Alguns aplicativos Flash nem sempre colocam todo o
código em um único lugar (em especial, quando você usa telas ou comportamentos).
Apesar dessas raras exceções, normalmente é possível colocar todo o código no mesmo local.
Veja a seguir as vantagens de colocar o ActionScript em um único local:
■ O código pode ser encontrado facilmente em um arquivo de origem potencialmente
complexo.

■ A depuração do código é fácil.
Uma das partes mais difíceis da depuração de um arquivo FLA é a localização de todo o
código. Depois de localizar todo o código, você deve descobrir como ele interage com outras
partes do código juntamente como o arquivo FLA. Se você colocar o código em um único
quadro, a depuração será mais fácil porque será centralizada, e esses problemas ocorrem com
menos freqüência. Para obter informações sobre com anexar código a objetos (e descentralizar
o código), consulte “Anexando código a objetos” na página 783. Para obter informações sobre
comportamentos e código descentralizado, consulte Capítulo 3, “Melhores práticas para usar
comportamentos” em Usando o Flash.
Anexando código a objetos

Você deve evitar a anexação do código ActionScript a objetos (como instâncias de botões e de
clipes de filme) em um arquivo FLA, mesmo em aplicativos simples e de protótipo. A
anexação de código a um objeto significa selecionar uma instância de clipe de filme,
componente ou botão, abrir o editor do ActionScript (painel Actions (Ações) ou janela Script)
e adicionar o código ActionScript usando as funções manipuladoras on() ou onClipEvent().
Essa prática é desaconselhável pelas seguintes razões:
■ O código ActionScript anexado a objetos são difíceis de localizar, ao passo que os arquivos
FLA são difíceis de editar.
■ O código ActionScript anexado a objetos é difícil de depurar.
■ O código ActionScript escrito na Timeline ou em classes é mais elegante e mais fácil de
criar.
■ O código ActionScript anexado a objetos piora o estilo de codificação.
■ O código ActionScript anexado a objetos força alunos e leitores a aprender sintaxes
adicionais, bem como vários estilos de codificação que geralmente são inadequados e
limitados.
■ Em geral, os usuários têm que reaprender a escrever funções e assim por diante, em uma
Timeline posteriormente.
Convenções de codificação do ActionScript 783

Alguns usuários de Flash falam que é mais fácil aprender o ActionScript anexando o código a
um objeto. Outros dizem que pode ser mais fácil adicionar um código simples ou ensinar o
ActionScript ou escrever sobre ele dessa maneira. No entanto, o contraste entre os dois estilos
de codificação (código colocado em objetos e scripts de quadro) pode ser confuso para os
desenvolvedores aprendendo o ActionScript e deve ser evitado. Além disso, os usuários que
sabem escrever código anexado aos objetos com freqüência têm que reaprender a colocar o
código equivalente como script de quadro posteriormente. É por isso que a consistência em
todo o processo de aprendizado, por exemplo, aprendendo-se a escrever scripts de quadros,
tem suas vantagens.
O processo para anexação do código ActionScript a um botão chamado myBtn seria
semelhante ao mostrado a seguir. Evite este método:
on (release) {
// Do something.
}
No entanto, a colocação do código ActionScript equivalente em uma Timeline seria

semelhante ao seguinte:
// good code
myBtn.onRelease = function() {
// Do something.
};
Para obter mais informações sobre a sintaxe do ActionScript, consulte “Formatando a sintaxe
do ActionScript” na página 799
N OT A
Às vezes, o uso de comportamentos e telas envolve a anexação de códigos a objetos e,

portanto, diversas práticas se aplicam quando esses recursos são usados. Para obter
mais informações, consulte Capítulo 3, “Melhores práticas para usar comportamentos”
em Usando o Flash.
Manipulação do escopo
O escopo é a área em que a variável é conhecida e pode ser usada em um arquivo SWF, como
na Timeline, globalmente em todo um aplicativo ou localmente em uma função. Em geral, é
possível referenciar o escopo de mais de uma forma quando você escreve código. O uso correto
do escopo significa que você pode criar o código ActionScript de forma móvel e reutilizável, e
não é necessário correr o risco de dividir os aplicativos durante a criação de novos módulos.

É importante compreender a diferença entre os escopos raiz e global. O escopo raiz é exclusivo
para cada arquivo SWF carregado. O escopo global aplica-se a todos os escopos e Timelines
dos arquivos SWF. Use o endereçamento relativo em vez de referência a Timelines raiz, pois o
endereçamento relativo torna o código reutitlizável e móvel. Para obter mais informações
sobre como manipular o escopo em seus aplicativos, consulte estas seções:
“Sobre variáveis e escopo” na página 101
“Sobre escopo e referência” na página 130
“Noções básicas sobre classes e escopo” na página 299.
Evitando o uso de destinos absolutos (_root)

Há várias maneiras de direcionar instâncias que permitem evitar o uso de _root; esses
métodos serão abordados posteriormente nesta seção. Evite usar _root no ActionScript 2.0,
pois os arquivos SWF carregados em outros arquivos SWF podem não funcionar
corretamente. O identificador _root direciona o arquivo SWF de base que está sendo
carregado, e não o arquivo SWF que usa o endereçamento relativo em vez de _root. Esse
problema limita a portabilidade do código nos arquivos SWF carregados em outros arquivo,
em especialmente, em componentes e clipes de filme. Você pode ajudar a solucionar o
problema usando _lockroot, mas somente use _lockroot quando necessário (por exemplo,
ao carregar um arquivo SWF sem ter acesso ao arquivo FLA). Para obter informações sobre
como usar _lockroot, consulte “Usando _lockroot” na página 786.
Use a palavra-chave this, this._parent, ou _parent em vez de _root, dependendo de onde
esteja localizado o código ActionScript 2.0. Este exemplo mostra o endereçamento relativo:
myClip.onRelease = function() {
trace(this._parent.myButton._x);
};
É necessário definir o escopo de todas as variáveis, exceto as que forem parâmetros de função e
variáveis locais. Sempre que possível, defina o escopo das variáveis em relação a seu caminho
atual, usando o endereçamento relativo, como a propriedade this. Para obter mais
informações sobre como usar a propriedade this, consulte %{this property}% em

Usando _lockroot
Você pode usar _lockroot para direcionar o conteúdo como uma maneira de solucionar os
problemas de escopo eventualmente associados ao uso inadequado de _root. Embora isso
resolva muitos problemas com aplicativos, considere _lockroot como uma solução
alternativa para os problemas causados pelo uso de _root. Se você tiver problemas para
carregar o conteúdo em um arquivo SWF ou em uma instância de componente, tente aplicar
_lockroot a um clipe de filme que carregue o conteúdo. Por exemplo, se você tiver um clipe
de filme chamado myClip que carregue conteúdo, e ele parar de funcionar após ser carregado,
tente usar o seguinte código, que é colocado em uma Timeline:
Uso da palavra-chave this

Sempre que possível, use a palavra-chave this como prefixo em vez de omiti-la, mesmo que
seu código funcione sem ela. Use a palavra-chave this para saber quando um método ou uma
propriedade pertence a uma classe específica. Por exemplo, para uma função em uma
Timeline, escreva o código ActionScript 2.0 usando o seguinte formato:
circleClip.onPress = function() {
this.startDrag();
};
circleClip.onRelease = function() {
this.stopDrag();
};
Para uma classe, escreva o código usando o seguinte formato:

class User {
private var username:String;
private var password:String;
function User(username:String, password:String) {
this.username = username;
this.password = password;
}
public function get username():String {
return this.username;
}
public function set username(username:String):Void {
this.username = username;
}
}
Se você adicionar a palavra-chave this nessas situações, o código ActionScript 2.0 será muito
mais fácil de ler e compreender.

Sobre o escopo em classes
Ao transportar o código para as classes do ActionScript 2.0, classes, talvez você precise alterar
a maneira como usa a palavra-chave this. Por exemplo, se houver um método de classe que
use 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 refere-se à classe do objeto LoadVars. Nessa situação,
talvez seja necessário criar um ponteiro para a classe atual, como mostra o seguinte exemplo:
class Product {
private var m_products_xml:XML;
// Constructor
// targetXmlStr contains the path to an XML file
function Product(targetXmlStr:String) {
/* Create a local reference to the current class.
Even if you are within the XML's onLoad event handler, you
can reference the current class instead of only the XML packet. */
var thisObj:Product = this;
// Create a local variable, which is used to load the XML file.
if (success) {
/* If the XML successfully loads and parses,
set the class's m_products_xml variable to the parsed
XML document and call the init function. */
thisObj.m_products_xml = this;
thisObj.init();
} else {
/* There was an error loading the XML file. */
}
};
// Begin loading the XML document
prodXml.load(targetXmlStr);
}
public function init():Void {
// Display the XML packet
trace(this.m_products_xml);
}
}
Como você está tentando fazer referência à variável membro privada em um manipulador
onLoad, a palavra-chave this realmente se refere à instância prodXml e não à classe Product
esperada. Por isso, você deve criar um ponteiro para o arquivo de classes local para que possa
fazer referência direta à classe do manipulador onLoad.
Para obter mais informações sobre classes, consulte “Noções básicas sobre classes e escopo”
na página 299. Para obter mais informações sobre escopo, consulte “Manipulação do escopo”
na página 784.

Estruturando um arquivo de classes
Crie classes em arquivos ActionScript 2.0 separados, que são importados para um arquivo
SWF quando ele é compilado.
Crie classes em arquivos ActionScript 2.0 separados, que são importados para um arquivo
SWF quando um aplicativo é compilado. Para criar um arquivo de classes, escreva o código
com determinada metodologia e ordenamento. Essa metodologia é abordada nas próximas
seções.
As convenções indicadas a seguir, usadas para a estruturação de um arquivo de classes,
mostram como você pode ordenar partes de uma classe para aumentar a eficiência e melhorar
a legibilidade de seu código.
Para estruturar um arquivo de classe, use os seguintes elementos:

1. Adicione comentários de documentação que incluam uma descrição geral do código, além
de informações sobre o autor e a versão.
2. Adicione suas instruções de importação (se aplicável).
3. Escreva uma declaração de classe ou declaração de interface, da seguinte maneira:
UserClass{...}
4. Inclua os comentários necessários sobre a implementação de classe ou interface.
Nesse comentário, adicione informações pertinentes à toda classe ou interface.
5. Adicione todas as variáveis estáticas.
Escreva as variáveis de classe pública primeiro, seguidas de variáveis de classe privada.
6. Adicione variáveis de instância.
Escreva primeiro as variáveis membro públicas, seguidas das variáveis membro privadas.
7. Adicione a instrução construtora, como a do exemplo abaixo:
public function UserClass(username:String, password:String) {...}
8. Escreva os métodos.
Agrupe-os por funcionalidade, e não por acessibilidade ou escopo. A organização dos
métodos dessa maneira ajuda a melhorar a legibilidade e clareza do código.
9. Escreva os métodos getter/setter no arquivo de classe.
Diretrizes para a criação de uma classe

Lembre-se das seguintes diretrizes ao criar um arquivo de classe:
■ Coloque apenas uma declaração em cada linha
■ Não coloque várias declarações em uma única linha.

Por exemplo, formate as declarações conforme mostrado a seguir:
var prodSkuNum:Number; // Product SKU (identifying) number
var prodQuantityNum:Number; // Quantity of product
Esse exemplo mostra uma forma melhor do que colocar as duas declarações na mesma
linha. Coloque essas declarações no início de um bloco de código.
■ Inicialize as variáveis locais ao declará-las.
As propriedades de uma classe somente deverão ser inicializadas na declaração se o
inicializador for uma constante de tempo de compilação.
■ Declare as variáveis antes de utilizá-las.
Isso inclui os loops.
■ 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:
var counterNum:Number = 0;
for (var counterNum:Number = 0; counterNum<=4; counterNum++) {
// statements;
}
}
Esse código declara a mesma variável dentro de um bloco interno, e essa é a prática que
você deve evitar.
■ Não atribua muitas variáveis a um único valor em uma instrução.
Siga essa convenção porque, caso contrário, o código será difícil de ler, como mostra o
código ActionScript a seguir:
playBtn.onRelease = playBtn.onRollOut = playsound;
ou
class User {
private var m_username:String, m_password:String;
}
■ Somente torne públicos um método ou propriedade se isso for necessário por algum
motivo. Caso contrário, deixe seus métodos e propriedades privados.
■ Não utilize em excesso as funções getter/setter no arquivo de classe.
As funções getter/setter são excelentes para várias finalidades (consulte “Sobre os métodos
getter e setter” na página 270), no entanto, seu uso excessivo pode indicar que você
poderia melhorar a arquitetura ou a organização do aplicativo.

■ 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/setter.
Usando este prefixo em arquivos de classe

Use a palavra-chave this como prefixo nas suas classes para métodos e variáveis membro.
Embora isso não seja necessário, é mais fácil saber se uma propriedade ou um método
pertence a uma classe quando ele tem um prefixo; sem ele, não há como 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 feitas por você. A qualificação de
referência torna o código legível. Dependendo do ambiente de codificação que você está
usando, os prefixos também podem ativar a referência e a conclusão do código. O código a
seguir demonstra o prefixo de uma propriedade estática com um nome de classe:
class Widget {
}
}
N OT A
Você não precisa adicionar esses prefixos, e alguns desenvolvedores acham que isso é
desnecessário. A Macromedia recomenda adicionar a palavra-chave this como prefixo,
pois ela pode melhorar a legibilidade e ajudar a escrever um código limpo, fornecendo
contexto.
Sobre a inicialização
Para os valores iniciais de variáveis, atribua um valor padrão ou permita o valor undefined,
como mostra o seguinte exemplo de classe. 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. Esta classe define os valores iniciais de m_username
e m_password como strings vazias:
class User {
private var m_username:String = "";
private var m_password:String = "";
function User(username:String, password:String) {

this.m_username = username;
this.m_password = password;
}
}
Exclua variáveis ou torne-as null quando não precisar mais delas. A definição de variáveis
como null ainda pode aumentar o desempenho. Esse processo é normalmente chamado
coleta de lixo. A exclusão de variáveis ajuda a otimizar o uso da memória durante o tempo de
execução, pois recursos desnecessários são removidos do arquivo SWF. É melhor excluir
variáveis do que defini-las como null. Para obter mais informações sobre variáveis, consulte
“Otimizando o código” na página 798.
NO TA
O Flash Player 8 aperfeiçoou a coleta de lixo no Flash Player.
Para obter informações sobre a atribuição de nomes a variáveis, consulte “Atribuição de nome
a variáveis” na página 772. Para obter mais informações sobre como excluir objetos, consulte
%{delete statement}% em ActionScript 2.0 Language Reference.
O uso de classes é uma das maneiras mais fáceis de inicializar o código usando o ActionScript
2.0. Você pode encapsular toda a inicialização de uma instância na função construtora da
classe ou abstraí-la para um método separado, que chamaria explicitamente após a criação da
variável, como mostra o seguinte código:
class Product {
function Product() {
if (success) {
trace("loaded");
} else {
}
};
prodXml.load("products.xml");
}
}
O código a seguir poderia ser a primeira chamada de função no aplicativo, e o único criado
para a inicialização. O Quadro 1 de um arquivo FLA que está carregando o XML pode usar
um código semelhante ao seguinte ActionScript:
if (init == undefined) {
if (success) {

trace("loaded");
} else {
}
};
prodXml.load("products.xml");
init = true;
}
Usar instruções trace

Use as instruções trace nos documentos para ajudá-lo a depurar o código durante a criação
do arquivo FLA. Por exemplo, usando a instrução trace e o loop for, você pode ver os
valores das variáveis no painel Output (Saída), como seqüências de caracteres, arrays e
objetos, como mostra o seguinte exemplo:
var dayArr:Array = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
var numOfDays:Number = dayArr.length;
for (var i = 0; i<numOfDays; i++) {
trace(i+": "+dayArr[i]);
}
Isto exibe as seguintes informações no painel Output:

0: sun
1: mon
2: tue
3: wed
4: thu
5: fri
6: sat
O uso de uma instrução trace é uma maneira eficiente de depurar o ActionScript 2.0.
Você pode remover as instruções trace ao publicar um arquivo SWF, o que significa uma
pequeno aumento no desempenho da reprodução. Antes de publicar um arquivo SWF, abra
Publish Settings (Configurações de publicação) e selecione Omit Trace Actions (Omitir ações
Trace) na guia Flash. Para obter mais informações sobre como usar trace, consulte %{trace
function}% em ActionScript 2.0 Language Reference.
A ferramenta Debugger também é útil para a depuração do código ActionScript. Para obter
mais informações, consulte Capítulo 18, “Depurando aplicativos.”.
Sobre o prefixo super

Se você fizer referência a um método na classe pai, adicione o prefixo super ao método, de
modo que outros desenvolvedores saibam de onde o método é chamado. O seguinte trecho do
ActionScript 2.0 demonstra o ouso do escopo adequado por meio do prefixo super:

No exemplo a seguir, é possível criar duas classes. Use a palavra-chave super na classe Socks
para chamar funções na classe pai (Clothes). Embora as classes Socks e Clothes tenham um
método denominado getColor(), o uso de super permite referenciar especificamente os
métodos e as propriedades da classe de base. Crie um novo arquivo AS denominado
Clothes.as e insira o seguinte código:
class Clothes {
private var color:String;
function Clothes(paramColor) {
this.color = paramColor;
trace("[Clothes] I am the constructor");
}
function getColor():String {
trace("[Clothes] I am getColor");
return this.color;
}
function setColor(paramColor:String):Void {
trace("[Clothes] I am setColor");
}
}
Crie uma nova classe chamada Socks que estenda a classe Clothes, conforme mostrado no
seguinte exemplo:
class Socks extends Clothes {
private var color:String;
function Socks(paramColor:String) {
trace("[Socks] I am the constructor");
}
function getColor():String {
trace("[Socks] I am getColor");
return super.getColor();
}
function setColor(paramColor:String):Void {
trace("[Socks] I am setColor");
}
}
Em seguida, crie um novo arquivo AS ou FLA e insira o seguinte ActionScript no documento:

import Socks;
var mySock:Socks = new Socks("maroon");
trace(" -> "+mySock.getColor());
mySock.setColor("Orange");
trace(" -> "+mySock.getColor());

O seguinte resultado é exibido no painel Output:
[Clothes] I am the constructor
[Socks] I am the constructor
[Socks] I am getColor
[Clothes] I am getColor
-> maroon
[Socks] I am setColor
[Clothes] I am getColor
-> Orange
Se você esqueceu de colocar a palavra-chave super no método getColor() da classe Socks, o

método getColor() poderá se chamar repetidamente, o que causará a falha do script to
devido a problemas de recorrência infinita. O painel Output exibirá o seguinte erro se você
não usar a palavra-chave super:
...
256 levels of recursion were exceeded in one action list.
This is probably an infinite loop.
Further execution of actions has been disabled in this SWF file.
Evitar a instrução with

O uso da instrução with é um dos conceitos mais confusos a serem compreendidos pelas
pessoas que estão aprendendo o ActionScript 2.0. Considere o seguinte código que usa a
instrução with:
this.attachMovie("circleClip", "circle1Clip", 1);
with (circle1Clip) {
_x = 20;
_y = Math.round(Math.random()*20);
_alpha = 15;
createTextField("labelTxt", 100, 0, 20, 100, 22);
labelTxt.text = "Circle 1";
someVariable = true;
}
Neste código, você anexa uma instância de clipe de filme da biblioteca e modifica suas
propriedades usando a instrução with. Quando não especifica o escopo de uma variável, você
nem sempre sabe onde está definindo as propriedades; portanto, seu código pode fica confuso.
No código anterior, você poderia esperar que someVariable fosse definido no clipe de filme
circle1Clip, mas na verdade, foi definido na Timeline principal do arquivo SWF.

Será mais fácil acompanhar o que está acontecendo no seu código se você especificar
explicitamente o escopo das variáveis, em vez de utilizar a instrução with. O exemplo a seguir
mostra um melhor exemplo do ActionScript, embora um pouco mais longo, que especifica o
escopo da variável.
this.attachMovie("circleClip", "circle1Clip", 1);
circle1Clip._x = 20;
circle1Clip._y = Math.round(Math.random()*20);
circle1Clip._alpha = 15;
circle1Clip.createTextField("labelTxt", 100, 0, 20, 100, 22);
circle1Clip.labelTxt.text = "Circle 1";
circle1Clip.someVariable = true;
Uma exceção a essa regra é que quando está trabalhando com uma API de desenho para
desenhar formas, você pode ter várias chamadas semelhantes para os mesmos métodos (como
lineTo ou curveTo) em virtude da funcionalidade da API do desenho. Por exemplo, ao
desenhar um retângulo simples, você precisa de quatro chamadas separadas para o método
lineTo, como mostra o seguinte código:
this.createEmptyMovieClip("rectangleClip", 1);
with (rectangleClip) {
lineStyle(2, 0x000000, 100);
moveTo(0, 0);
lineTo(300, 0);
lineTo(300, 200);
lineTo(0, 200);
lineTo(0, 0);
endFill();
}
Se você tiver escrito o método lineTo ou curveTo com um nome de instância totalmente
qualificado, o código se tornará desordenado rapidamente, dificultando a leitura e depuração.
Sobre o uso de funções

Reutilize blocos de código sempre que possível. Uma maneira de reutilizar o código consiste
em chamar uma função várias vezes, em vez de criar um código diferente a cada momento. As
funções podem ser trechos genéricos de código; portanto, você pode usar os mesmos blocos de
código para fins um pouco diferente em um arquivo SWF. A reutilização do código permite
criar aplicativos eficientes e minimizar o código AtionScript 2.0 a ser escrito, o que reduz o
tempo de desenvolvimento. Você pode criar funções em uma Timeline, em um arquivo de
classe ou escrever ActionScript que resida em um componente baseado em código e reutilizá-
lo de diversas formas.

Se você estiver usando o ActionScript 2.0, evite escrever funções em uma Timeline. Ao usar o
ActionScript 2.0, coloque as funções em arquivos de classes sempre que possível, como
mostra o seguinte 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);
}
}
Use esta sintaxe para criar funções:

function myCircle(radius:Number):Number {
//...
}
Evite usar a seguinte sintaxe, que é difícil de ler:

myCircle = function(radius:Number):Number {
//...
}
O exemplo a seguir coloca as funções em um arquivo de classes. Essa é a melhor prática

quando você opta por usar o ActionScript 2.0, pois ela aumenta a capacidade de reutilização
do código. 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.
class mx.site.Utils {
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);
}
static function arrayMin(numArr:Array):Number {
if (numArr.length == 0) {
return Number.NaN;
}
numArr.sort(Array.NUMERIC | Array.DESCENDING);
var min:Number = Number(numArr.pop());
return min;
}

static function arrayMax(numArr:Array):Number {
if (numArr.length == 0) {
return undefined;
}
numArr.sort(Array.NUMERIC);
var max:Number = Number(numArr.pop());
return max;
}
}
Você pode usar essas funções adicionando o seguinte código ActionScript ao arquivo FLA:
import mx.site.Utils;
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]);
trace("month: "+randomMonth);
trace("min: "+min);
trace("max: "+max);
Sobre como interromper a repetição do código

O manipulador de eventos onEnterFrame é útil porque o Flash pode usá-lo para repetir o
código na taxa de quadros de um arquivo SWF. Contudo, limite o máximo possível a
repetição usada em um arquivo do Flash de modo que o desempenho não seja prejudicado.
Por exemplo, se houver um código que seja repetido sempre que a reprodução entra em um
quadro, o processador ficará sobrecarregado. Esse comportamento poderá causar problemas de
desempenho em computadores que executam o arquivo SWF. Se você usar o manipulador de
eventos onEnterFrame para qualquer tido de animação ou repetição nos arquivos SWF, exclua
o manipulador onEnterFrame quando terminar de usá-lo. No código ActionScript 2.0 a
seguir, interrompa a repetição excluindo o manipulador de eventos onEnterFrame:
circleClip.onEnterFrame = function() {
circleClip._alpha -= 5;
if (circleClip._alpha<=0) {
circleClip.unloadMovie();
delete this.onEnterFrame;
trace("deleted onEnterFrame");
}
};
Da mesma forma, limite o uso de setInterval e lembre-se de limpar o intervalo quando

terminar de usá-lo a fim de reduzir os requisitos de processador do arquivo SWF.

Otimização do ActionScript e do Flash
Player
Se você compilar um arquivo SWF que contenha o ActionScript 2.0 com as 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 em
relação ao código, somente com o Flash Player. Portanto, se você compilar o arquivo SWF
com a opção Publish Settings (Configurações de publicação) definidas para o Flash Player 7
ou 8 e o ActionScript 1.0, a distinção entre maiúsculas e minúsculas será imposta pelo Flash.
As anotações de tipos de dados (tipos de dados estritos) são impostas em tempo de compilação
para o Flash Player 7 e 8 quando há configurações de publicação definidas para o ActionScript
2.0.
O ActionScript 2.0 compila para o código de bytes ActionScript 1.0 quando você publica seus
aplicativos, portanto, é possível ter como objetivo o Flash Player 6, 7 ou 8 ao trabalhar com o
ActionScript 2.0.
Para obter mais informações sobre como otimizar os aplicativos, consulte “Otimizando o
código”.
Otimizando o código
Lembre-se das seguintes diretrizes ao otimizar o código:
■ Evite chamar uma função várias vezes de dentro de um loop.
É melhor incluir o conteúdo de uma pequena função dentro do loop.
■ Use funções nativas quando possível.
Elas são mais rápidas do que as funções definidas pelo usuário.
■ Não use o tipo Object (Objeto) demais.
As anotações de tipo de dados devem ser precisas, porque isso melhora o desempenho. Use
o tipo Object somente quando não houver uma alternativa razoável.
■ Evite usar a função eval() ou o operador de acesso de array.
Com freqüência, é preferível e mais eficiente definir a referência local uma vez.
■ Atribua Array.length a uma variável antes de um loop.
Atribua Array.length a uma variável antes de um loop para usar como sua condição, em
vez de usar myArr.length. Por exemplo:
var arrayLen:Number = fontArr.length;
for (var i:Number = 0; i < arrayLen; i++) {

trace(fontArr[i]);
}
em vez de:
for (var i:Number = 0; i < fontArr.length; i++) {
trace(fontArr[i]);
}
■ Enfatizar a otimização de loops e qualquer ação repetida.

O Flash Player envia vários loops de processamento (como aqueles que usam a função
setInterval()).
■ Adicione a palavra-chave var ao declarar uma variável
■ Não use variáveis de classe nem variáveis globais quando variáveis locais forem suficientes
Formatando a sintaxe do ActionScript

A formatação do código ActionScript 2.0 de uma maneira padronizada é essencial para
escrever upm código que possa ser mantido, além de ser mais fácil para que outros
desenvolvedores possam entendê-lo e modificá-lo. Por exemplo, seria extremamente difícil
seguir a lógica de um arquivo FLA que não tenha recuo nem comentários, bem como
convenções de atribuição de nome e formatação inconsistentes. Recuando blocos de código
(como loops e instruções if ), você facilita a leitura e depuração do código.
Para obter mais informações sobre como formatar o código, consulte os seguintes tópicos:
■ “Diretrizes gerais de formatação” na página 800
■ “Escrevendo instruções condicionais” na página 802
■ “Escrevendo instruções compostas” na página 804
■ “Escrevendo uma instrução for” na página 804
■ “Escrevendo instruções while e do..while” na página 805
■ “Escrevendo instruções return” na página 805
■ “Escrevendo instruções switch” na página 805
■ “Escrevendo instruções try..catch e try..catch..finally” na página 806
■ “Sobre como usar a sintaxe do ouvinte” na página 806
Formatando a sintaxe do ActionScript 799

Diretrizes gerais de formatação
Quando usa espaços, quebras de linha e recuos de tabulação para adicionar um espaço em
branco ao código, você aumenta a legibilidade do código. Os espaços em branco melhoram a
legibilidade porque ajudam a mostrar a hierarquia do código. Facilitar o entendimento do
ActionScript 2.0 tornando-o mais legível é importante para todos os alunos e para os usuários
experientes trabalhando em projetos complexos. A legibilidade é importante durante a
depuração do código ActionScript, pois é muito mais fácil identificar erros quando o código
está formatado e espaçado corretamente.
Você pode formatar ou escrever uma parte do código ActionScript 2.0 de várias maneiras.
Você encontrará diferenças na maneira como a sintaxe é formatada em várias linhas do editor
do ActionScript (o painel Actions ou a janela Script), bem como onde você coloca chaves ({})
ou parênteses [()]).
Além disso, recomenda os seguintes pontos de formatação para ajudá-lo a melhorar a
legibilidade do código ActionScript.
■ Coloque uma linha em branco entre os parágrafos (módulos) do ActionScript.
Os parágrafos do código ActionScript são grupos de código relacionado logicamente. A
inclusão de uma linha em branco entre eles ajuda os usuários a ler o código ActionScript e
a entender sua lógica.
■ Use recuos consistentes no código para ajudar a mostrar a hierarquia da estrutura do
código.
Use o mesmo estilo de recuo em todo o código ActionScript e alinhe as chaves ({})
adequadamente. Chaves alinhadas melhoram a legibilidade do código. Se a sintaxe do
ActionScript estiver correta, o Flash recuará automaticamente o código de forma correta
quando você pressionar Enter (Windows) ou Return (Macintosh). Você também pode
clicar no botão Auto Format (Formatação automática) no editor do ActionScript (o painel
Actions ou a janela Script) para recuar o código ActionScript se a sintaxe estiver correta.
■ Use quebras de linha para facilitar a leitura de instruções complexas.
Você pode formatar algumas instruções, como as condicionais, de várias maneiras. Às
vezes, a formatação das instruções em várias linhas, em vez de em uma única, facilita a
leitura do código.
■ Inclua um espaço após uma palavra-chave seguida por parênteses [()].
O código ActionScript a seguir mostra um exemplo disso:
do {
// something
} while (condition);
■ Não coloque um espaço entre o nome de um método e os parênteses.

function checkLogin():Boolean {
// statements;
}
checkLogin();
ou
printSize("size is " + foo + "\n");
■ Coloque um espaço depois das vírgulas em uma lista de argumentos.

O uso de espaços depois de vírgulas facilita a distinção entre as chamadas de métodos e as
palavras-chave, como mostra o exemplo a seguir:
function addItems(item1:Number, item2:Number):Number {
return (item1 + item2);
}
var sum:Number = addItems(1, 3);
■ Use espaços para separar todos os operadores e seus operandos.

O uso de espaços facilita a distinção entre as chamadas de métodos e as palavras-chave,
como mostra o exemplo a seguir:
//good
var sum:Number = 7 + 3;
//bad
var sum:Number=7+3;
Uma exceção a essa diretriz e o operador ponto (.).

■ Não coloque espaços entre operadores unários e seus operandos.
Por exemplo, incremento (++) e decremento (--), conforme mostrado no exemplo a seguir:
while (d++ = s++)
-2, -1, 0
■ Não coloque espaços após um parêntese de abertura e antes de um parêntese de
fechamento.
// bad
( "size is " + foo + "\n" );
//good
("size is " + foo + "\n");
■ Coloque cada instrução em uma linha separada para aumentar a legibilidade do código
ActionScript.
theNum++; // Correct
theOtherNum++; // Correct
aNum++; anOtherNum++; // Incorrect

■ Não incorpore atribuições.
Às vezes, as instruções incorporadas são usadas para melhorar o desempenho em um
arquivo SWF em tempo de execução, mas o código fica muito mais difícil de ler e depurar.
O seguinte código ActionScript mostra um exemplo disso (mas lembre-se de evitar a
atribuição de nome de caractere único no código real):
var myNum:Number = (a = b + c) + d;
■ Atribua variáveis como instruções separadas.

O seguinte código ActionScript mostra um exemplo disso (mas lembre-se de evitar a
atribuição de nome de caractere único no código real):
var a:Number = b + c;
var myNum:Number = a + d;
■ Quebre uma linha antes de um operador.

■ Quebre uma linha após uma vírgula.
■ Alinhe a segunda linha com o início da expressão na linha de código anterior.
N OT A
Você pode controlar as configurações de recuo e recuo automático selecionando

Edit (Editar) > Preferences (Preferências) no Windows ou Flash > Preferences no
Macintosh, e selecionando a guia ActionScript.
Escrevendo instruções condicionais

Use as seguintes diretrizes ao escrever instruções condicionais:
■ Coloque as condições em linhas separadas nas instruções if, else..if e if..else.
■ Use chaves ({}) para instruções if.
■ Formate as chaves como mostram os seguintes exemplos:
// if statement
if (condition) {
// statements
}
// if..else statement
if (condition) {
// statements
} else {
// statements
}
// else..if statement
if (condition) {
// statements
} else if (condition) {
// statements

} else {
// statements
}
Ao escrever instruções complexas, você deve usar parênteses [()] para agrupar as condições. Se
parênteses não forem usados, você (ou outras pessoas que estejam usando o código
ActionScript 2.0) poderá encontrar erros de precedência de operador.
Por exemplo, o código a seguir não usa parênteses ao redor das condições:
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)) {}
Você pode escrever uma instrução condicional que retorne um valor booleano de duas
maneiras. O segundo exemplo é preferível:
if (cartArr.length>0) {
return true;
} else {
return false;
}
Compare este exemplo com o anterior:

// better
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.
O exemplo a seguir verifica se a variável y é maior que zero, e retorna o resultado x/y ou o
valor 0.
return ((y > 0) ? x/y : 0);
O exemplo a seguir mostra outra maneira de escrever esse código. Este exemplo é preferível:
if (y>0) {
return x/y;
} else {
return 0;
}
A sintaxe if reduzida do primeiro exemplo é mostrada como o operador condicional (?:). Ele
permite converter instruções if..else simples em uma única linha de código. Nesse caso, a
sintaxe abreviada reduz a legibilidade.
Se você precisa usar operações condicionais, coloque a condição inicial (antes do ponto de
interrogação [?]) entre parênteses para melhorar a legibilidade do código. Você pode ver um
exemplo disso no trecho de código anterior.

Escrevendo instruções compostas
As instruções compostas contêm uma lista de instruções entre chaves ({}). Essas instruções são
recuadas a partir da instrução composta. O código ActionScript a seguir mostra um exemplo
disso:
if (a == b) {
// This code is indented.
trace("a == b");
}
Delimite cada instrução entre chaves quando ela fizer parte de uma estrutura de controle
(if..else ou for), mesmo que ela contenha somente uma instrução. O exemplo a seguir
mostra o código escrito incorretamente:
// bad
if (numUsers == 0)
Embora esse código seja validado, ele é escrito de forma incorreta, pois não tem chaves
delimitando as instruções. Nesse caso, se você adicionar outra instrução após trace, o código
será executado, quer a variável numUsers seja igual a 0 ou não:
// bad
var numUsers:Number = 5;
if (numUsers == 0)
trace("I will execute");
A execução do código, apesar da variável numUsers pode levar a resultados inesperados. Por
isso, adicione chaves, como mostra o seguinte exemplo:
var numUsers:Number = 0;
if (numUsers == 0) {
trace("no users found");
}
Ao escrever uma condição, não adicione o redundante ==true ao código, da seguinte maneira:
if (something == true) {
// statements
}
Se comparado com false, você pode usar if (something==false) ou if(!something).
Escrevendo uma instrução for

Você pode escrever a instrução for usando o seguinte formato:
for (init; condition; update) {
// statements
}

A estrutura a seguir demonstra a instrução for:
var i:Number;
for (var i = 0; i<4; i++) {
myClip.duplicateMovieClip("newClip" + i + "Clip", i + 10, {_x:i*100,
_y:0});
}
Lembre-se de incluir um espaço após cada expressão em uma instrução for.
Escrevendo instruções while e do..while

Você pode escrever instruções while usando o seguinte formato:
while (condition) {
// statements
}
Você pode escrever instruções do-while usando o seguinte formato:

do {
// statements
} while (condition);
Escrevendo instruções return

Não use parênteses [()]com instruções return que contenham valores. A única vez que você
deve usar parênteses com instruções return é quando elas tornam o valor mais óbvio, como
mostra a terceira linha do seguinte trecho de código do ActionScript:
return;
return myCar.paintColor;
// parentheses used to make the return value obvious
return ((paintColor)? paintColor: defaultColor);
Escrevendo instruções switch

■ Todas as instruções switch incluem case padrão.
O case padrão é o último em uma instrução switch. O case padrão contém uma
instrução break que impede um erro de fall-through se outro case for adicionado.
■ Se o case não tiver uma instrução break, o case falhará (consulte case A no exemplo de
código a seguir).
A instrução deverá incluir um comentário no lugar da instrução break, como você poderá
ver no exemplo a seguir após case A. Neste exemplo, se a condição corresponder ao case
A, os cases A e B serão executados.

Você pode escrever instruções switch usando o seguinte formato:
switch (condition) {
case A :
// statements
// falls through
case B :
// statements
break;
case Z :
// statements
break;
default :
// statements
break;
}
Escrevendo instruções try..catch e try..catch..finally

Escreva instruções try..catch e try..catch..finally usando os seguintes formatos:
var myErr:Error;
// try..catch
try {
// statements
} catch (myErr) {
// statements
}
// try..catch..finally
try {
// statements
} catch (myErr) {
// statements
} finally {
// statements
}
Sobre como usar a sintaxe do ouvinte

Há várias maneiras de escrever ouvintes para eventos no Flash 8. Algumas técnicas comuns são
mostradas nos seguintes exemplos de código. O primeiro exemplo mostra uma sintaxe do
ouvinte adequadamente formatada, que usa um componente Loader para carregar o conteúdo
em um arquivo SWF. O evento progress inicia quando o conteúdo é carregado, e o evento
complete indica quando o carregamento termina.
var boxLdr:mx.controls.Loader;
var ldrListener:Object = new Object();
ldrListener.progress = function(evt:Object) {

trace("loader loading:" + Math.round(evt.target.percentLoaded) + "%");
};
ldrListener.complete = function(evt:Object) {
trace("loader complete:" + evt.target._name);
};
boxLdr.addEventListener("progress", ldrListener);
boxLdr.addEventListener("complete", ldrListener);
boxLdr.load("http://www.helpexamples.com/flash/images/image1.jpg");
Uma pequena variação no primeiro exemplo desta seção consiste em usar o método
handleEvent, mas essa técnica é um pouco mais complicada. A Macromedia não recomenda
essa técnica porque você deve usar uma série de instruções if..else ou uma instrução
switch para detectar qual evento será capturado.
var boxLdr:mx.controls.Loader;
var ldrListener:Object = new Object();
ldrListener.handleEvent = function(evt:Object) {
switch (evt.type) {
case "progress" :
trace("loader loading:" + Math.round(evt.target.percentLoaded) + "%");
break;
case "complete" :
trace("loader complete:" + evt.target._name);
break;
}
};
boxLdr.addEventListener("progress", ldrListener);
boxLdr.addEventListener("complete", ldrListener);
boxLdr.load("http://www.helpexamples.com/flash/images/image1.jpg");

APÊNDICE A
Mensagens de erro A
O Macromedia Flash Basic 8 e o Macromedia Flash Professional 8 fornecem relatórios
avançados de erros durante a compilação quando você publica no ActionScript 2.0 (padrão).
A tabela a seguir contém uma lista das mensagens de erro que podem ser geradas pelo
compilador do Flash:
Número do Texto da mensagem

erro
1093 Era esperado um nome de classe.
1094 É esperado um nome de classe base após a palavra-chave ‘extends’.

1095 Um atributo de membro foi usado de modo incorreto.
1096 Não é possível repetir o nome de membro mais de uma vez.
1097 Todas as funções de membros devem ter nomes.

1099 Essa instrução não é permitida na definição de classe.
1100 Já foi definida uma classe ou interface com esse nome.
1101 Tipos incompatíveis.
1102 Não existe uma classe com o nome ‘<NomeDaClasse>’.
1103 Não existe uma propriedade com o nome ‘<nomeDaPropriedade>’.
1104 Tentativa de uma chamada de função em uma não-função.
1105 Tipos incompatíveis em uma instrução de atribuição: encontrado [lhs-type]

onde [rhs-type] é requerido.
1106 O membro é privado e não pode ser acessado.
1107 Não são permitidas declarações de variáveis em interfaces.
1108 Não são permitidas declarações de eventos em interfaces.
1109 Não são permitidas declarações getter/setter (apanhadoras/definidoras) em

interfaces.
1110 Não são permitidos membros privados em interfaces.
809
erro
1111 Não são permitidos corpos de funções em interfaces.
1112 Uma classe não pode estender a si mesma.
1113 Uma interface não pode estender a si mesma.
1114 Não há interfaces definidas com esse nome.
1115 Uma classe não pode estender uma interface.
1116 Uma interface não pode estender uma classe.
1117 É esperado um nome de interface após a palavra-chave ‘implements’.

1118 Uma classe não pode implementar outra classe, somente interfaces.
1119 A classe deve implementar o método ‘nomeDoMétodo’ a partir da interface

‘nomeDaInterface’.
1120 A implementação de um método de interface deve ser um método e não uma

propriedade.
1121 Uma classe não pode estender a mesma interface mais de uma vez.
1122 A implementação do método de interface não corresponde à sua definição.
1123 Esta construção só está disponível no ActionScript 1.0.
1124 Esta construção só está disponível no ActionScript 2.0.
1125 Não são permitidos membros estáticos em interfaces.
1126 A expressão retornada deve corresponder ao tipo de retorno da função.

1127 Esta função requer uma instrução return.
1128 Atributo usado fora da classe.
1129 Uma função com tipo de retorno Void não pode retornar um valor.
1130 A cláusula ‘extends’ deve vir antes da cláusula ‘implements’.
1131 É esperado um identificador de tipo após ‘:’.
1132 As interfaces devem usar a palavra-chave ‘extends’, e não ‘implements’.
1133 Uma classe não pode estender mais do que uma classe.
1134 Uma interface não pode estender mais do que uma interface.
1135 Não existe um método com o nome ‘<nomeDoMétodo>’.
1136 Esta instrução não é permitida na definição de uma interface.
1137 Uma função set exige exatamente um parâmetro.
1138 Uma função get não exige parâmetros.
810 Mensagens de erro

erro
1139 Só é possível definir classes em scripts externos de classes do
ActionScript 2.0.
1140 Os scripts de classes do ActionScript 2.0 só podem definir construções de

classes ou de interfaces.
1141 O nome desta classe, ‘<A.B.C>’, está em conflito com o nome de outra classe
que estava carregada, ‘<A.B>’.
(Esse erro ocorre quando o compilador do ActionScript 2.0 não consegue
compilar uma classe porque o nome completo de uma classe existente é
parte do nome da classe em conflito. Por exemplo, a compilação da classe
mx.com.util gerará o erro 1141 se a classe mx.com for uma classe compilada.)
1142 A classe ou interface ‘<Nome da Classe ou Interface>’ não pôde ser

carregada.
1143 As interfaces só podem ser definidas em scripts externos de classes do

ActionScript 2.0.
1144 Não é possível acessar variáveis de instância em funções estáticas.
1145 Não é possível aninhar definições de classes e interfaces.
1146 A propriedade em questão não tem o atributo estatic.
1147 Esta chamada para super não corresponde ao superconstrutor.
1148 Somente o atributo public é permitido para métodos de interface.
1149 Não é possível usar a palavra-chave como uma diretiva.

1150 Você deve exportar o filme como Flash 7 para usar esta ação.
1151 Você deve exportar o filme como Flash 7 para usar esta expressão.
1152 Esta cláusula de exceção está colocada de modo incorreto.

1153 Uma classe deve ter somente um construtor.
1154 Um construtor não pode retornar um valor.
1155 Um construtor não pode especificar um tipo de retorno.
1156 Uma variável não pode ser do tipo Void.
1157 Um parâmetro de função não pode ser do tipo Void.
1158 Só é possível acessar membros estáticos diretamente através de classes.
1159 Várias interfaces implementadas contêm o mesmo método com tipos

diferentes.
1160 Já existe uma classe ou interface definida com esse nome.
811
erro
1161 Não é possível excluir classes, interfaces e tipos internos.
1162 Não existem classes com esse nome.
1163 A palavra-chave ‘<palavra-chave>’ é reservada para o ActionScript 2.0 e não

pode ser usada aqui.
1164 A definição do atributo personalizado não foi concluída.
1165 Só é possível definir uma classe ou interface por arquivo .as do

ActionScript 2.0.
1166 A classe em compilação, ‘<A.b>’, não coincide com a classe que foi importada,
‘<A.B>’.
(Esse erro ocorre quando um nome de classe utiliza maiúsculas e minúsculas
diferentes daquelas utilizadas em uma classe importada. Por exemplo, a
compilação da classe mx.com.util gerará o erro 1166 se a instrução import
mx.Com aparecer no arquivo util.as.)
1167 Insira o nome da classe.
1168 O nome da classe informado contém um erro de sintaxe.
1169 O nome da interface informado contém um erro de sintaxe.

1170 O nome da classe base informado contém um erro de sintaxe.
1171 O nome da interface base informado contém um erro de sintaxe.
1172 Insira o nome da interface.
1173 Insira o nome da classe ou da interface.
1174 O nome da classe ou interface informado contém um erro de sintaxe.
1175 ‘variável’ não é acessível a partir desse escopo.

1176 Foram encontradas diversas ocorrências do atributo ‘get/set/private/public/
static’.
1177 Um atributo de classe foi usado de modo incorreto.
1178 Não é possível usar funções e variáveis de instância para inicializar variáveis
estáticas.
1179 Foram descobertas circularidades durante a execução entre as seguintes

classes: <lista de classes definidas pelo usuário>.
Esse erro durante a execução indica que suas classes personalizadas fazem
referências entre si de forma errada.
1180 O Flash Player identificado no momento não oferece suporte à depuração.

erro
1181 O Flash Player identificado no momento não oferece suporte ao evento
releaseOutside.

dragOver.

dragOut.
1184 O Flash Player identificado no momento não oferece suporte a ações de

arrastar.
1185 O Flash Player identificado no momento não oferece suporte à ação

loadMovie.
1186 O Flash Player identificado no momento não oferece suporte à ação getURL.
1187 O Flash Player designado no momento não oferece suporte à ação

FSCommand.
1188 Não são permitidas instruções de importação nas definições de classe ou

interface.
1189 Não é possível importar a classe ‘<A.B>’ porque o nome da folha já está
resolvido para a classe que está sendo definida, ‘<C.B>’.
(Por exemplo, a compilação da classe util gerará o erro 1189 se a instrução
import mx.util aparecer no arquivo util.as.)
1190 Não é possível importar a classe ‘<A.B>’ porque o nome da folha já está
resolvido para uma classe previamente importada ‘<C.B>’.
(Por exemplo, a compilação de import jv.util gerará o erro 1190 se a
instrução import mx.util também aparecer no arquivo AS.)
1191 Só é possível inicializar as variáveis de instância de uma classe para

expressões de constantes durante a compilação.
1192 Funções de membros de classes não podem ter o mesmo nome de uma
função construtora de superclasse.
1193 O nome desta classe, ‘<NomeDaClasse>’, está em conflito com o nome de

outra classe que foi carregada.
1194 O superconstrutor deve ser chamado primeiro no corpo do construtor.
1195 O identificador ‘<nomeDaClasse>’ não será resolvido para o objeto interno

‘<NomeDaClasse>’ durante a execução.
1196 A classe ‘<A.B.NomeDaClasse>’ precisar ser definida em um arquivo cujo

caminho relativo seja <‘A.B>’.
813
erro
1197 O caractere curinga ‘*’ foi usado de modo incorreto no nome da classe
‘<NomeDaClasse>’.
1198 O uso de maiúsculas/minúsculas é diferente na função de membro

‘<nomedaclasse>’ em relação ao nome da classe que está sendo definida,
‘<NomeDaClasse>’; a função não será tratada como o construtor de
classe durante a execução.
1199 O único tipo permitido para um iterador de repetição for-in é String.
1200 Uma função definidora não pode retornar um valor.
1201 Os únicos atributos permitidos para funções construtoras são public e

private.
1202 O arquivo 'toplevel.as', necessário para fazer a verificação de tipo no

ActionScript 2.0, não foi encontrado. Certifique-se de que o diretório
'$(LocalData)/Classes' está listado no caminho de classe global das
preferências do ActionScript.
1203 A ramificação entre <spanStart> e <spanEnd>> ultrapassa o intervalo de 32K.
1204 Não foi encontrada nenhuma classe nem pacote com o nome '<nomePacote>'
no pacote '<NomePacote>'.
1205 O Flash Player identificado no momento não oferece suporte à ação
FSCommand2.
1206 A função de membro '<nomeFunção>' tem mais de 32K.
1207 A função anônima da linha <númeroLinha> ultrapassa o intervalo de 32K.
1208 O código da linha <númeroLinha> ultrapassa o intervalo de 32K.
1210 O nome de pacote '<NomePacote>' não pode ser usado como nome de um
método.
1211 O nome de pacote '<NomePacote>' também não pode ser usado como nome
de uma propriedade.
1212 O arquivo ASO da classe '<NomeDaClasse>' não pôde ser criado. Certifique-
se de que o nome da classe totalmente qualificado seja suficientemente curto
para que o nome do arquivo ASO, '<NomeDaClasse.aso>', tenha menos de
255 caracteres.
1213 Esse tipo de aspas não é permitido no ActionScript. Altere-o para aspas
duplas (retas) padrão.

APÊNDICE B
Operadores Flash 4
obsoletos
B
A tabela a seguir lista os operadores somente do Flash 4 que ficaram obsoletos no ActionScript
2.0. Não use esses operadores a menos que você esteja publicando no Flash Player 4 e anterior.
Operador Description (Descrição) Associatividade

not NOT lógico Direita para
esquerda
and AND lógico Esquerda para
direita
or OR lógico (Flash 4) Esquerda para
direita
add Concatenação de seqüência de caracteres (antes Esquerda para
&) direita
instanceof Instância de Esquerda para
direita
lt Menor que (versão de seqüência de caracteres) Esquerda para
direita
le Menor que ou igual a (versão de seqüência de Esquerda para
caracteres) direita
gt Maior que (versão de seqüência de caracteres) Esquerda para
direita
ge Maior que ou igual a (versão de seqüência de Esquerda para
caracteres) direita
eq Igual (versão de seqüência de caracteres) Esquerda para
direita
ne Diferente (versão de seqüência de caracteres) Esquerda para
direita
815
816 Operadores Flash 4 obsoletos
APÊNDICE C
Teclas do teclado e valores

de códigos de teclas
C
As tabelas a seguir listam todas as teclas de um teclado padrão e os valores de códigos de teclas
correspondentes e os valores de códigos de teclas ASCII usados para identificar as teclas no
ActionScript.
■ “Letras de A a Z e números padrão de 0 a 9” na página 818
■ “Teclas do teclado numérico” na página 820
■ “Teclas de função” na página 821
■ “Outras teclas” na página 822
É possível utilizar constantes de teclas para interceptar o comportamento interno dos
pressionamentos de teclas. Para obter mais informações sobre o manipulador on(), consulte
%{on handler}% em ActionScript 2.0 Language Reference. Para capturar valores de códigos de
teclas e valores de códigos de teclas ASCII utilizando um arquivo SWF e pressionamentos de
teclas, você pode usar o seguinte código do ActionScript:
trace("DOWN -> Code: " + Key.getCode() + "\tACSII: " + Key.getAscii() +
"\tKey: " + chr(Key.getAscii()));
};
Para obter mais informações sobre a classe Key, consulte %{Key}% em ActionScript 2.0
Language Reference. Para interceptar teclas ao testar um arquivo SWF no ambiente de criação
(Control [Controlar]> Test Movie [Testar filme]), certifique-se de selecionar Control >
Disable Keyboard Shortcuts (Desativar atalhos do teclado).
817
Letras de A a Z e números padrão de 0 a 9
A tabela a seguir lista as teclas de um teclado padrão, com as letras de A a Z e os números de
0 a 9, e os valores de códigos de teclas correspondentes usados para identificar as teclas
no ActionScript:
Tecla alfabética ou Código da tecla Código da tecla ASCII

numérica
A 65 65
B 66 66
C 67 67
D 68 68
E 69 69
F 70 70
G 71 71
H 72 72
I 73 73
J 74 74
K 75 75
L 76 76
M 77 77
N 78 78
O 79 79
P 80 80
Q 81 81
R 82 82
S 83 83
T 84 84
U 85 85
V 86 86
W 87 87
X 88 88
Y 89 89
818 Teclas do teclado e valores de códigos de teclas

numérica
Z 90 90
0 48 48
1 49 49
2 50 50
3 51 51
4 52 52
5 53 53
6 54 54
7 55 55
8 56 56
9 57 57
a 65 97
b 66 98
c 67 99
d 68 100
e 69 101
f 70 102
g 71 103
h 72 104
i 73 105
j 74 106
k 75 107
l 76 108
m 77 109
n 78 110
o 79 111
p 80 112
q 81 113
r 82 114
819
numérica
s 83 115
t 84 116
u 85 117
v 86 118
w 87 119
x 88 120
y 89 121
z 90 122
Teclas do teclado numérico

A tabela a seguir lista as teclas de um teclado numérico e os valores de códigos de teclas
correspondentes usados para identificar as teclas no ActionScript:
Tecla do teclado Código da tecla Código da tecla ASCII

numérico
0 do teclado numérico 96 48

Multiplicar 106 42
Somar 107 43
Enter 13 13
Subtrair 109 45

Tecla do teclado Código da tecla Código da tecla ASCII
numérico
Decimal 110 46
Dividir 111 47
Teclas de função
A tabela a seguir lista as teclas de função em um teclado padrão e os valores de códigos de
teclas correspondentes usados para identificar as teclas no ActionScript:
Tecla de função Código da tecla Código da tecla ASCII

F1 112 0
F2 113 0
F3 114 0
F4 115 0
F5 116 0
F6 117 0
F7 118 0
F8 119 0
F9 120 0
F10 Esta tecla é reservada pelo Esta tecla é reservada pelo

sistema e não pode ser usada sistema e não pode ser usada no
no ActionScript. ActionScript.
F11 122 0
F12 123 0
F13 124 0
F14 125 0
F15 126 0
821
Outras teclas
A tabela a seguir lista as teclas de um teclado padrão que não são letras, números, teclas do
teclado numérico nem teclas de função, e os valores de códigos de teclas correspondentes
usados para identificar as teclas no ActionScript:
Tecla Código da tecla Código da tecla ASCII

Backspace 8 8
Tab 9 9
Enter 13 13
Shift 16 0
Control 17 0
Caps Lock 20 0
Esc 27 27
Barra de espaços 32 32
Page Up 33 0
Page Down 34 0
End 35 0
Home 36 0
Seta para Esquerda 37 0
Seta para Cima 38 0
Seta para Direita 39 0
Seta para Baixo 40 0
Insert 45 0
Delete 46 127
Num Lock 144 0
ScrLk 145 0
Pause/Break 19 0
;: 186 59
=+ 187 61
-_ 189 45
/? 191 47
`~ 192 96

Tecla Código da tecla Código da tecla ASCII
[{ 219 91
\| 220 92
]} 221 93
"' 222 39
, 188 44
. 190 46
/ 191 47
Para obter valores de códigos de teclas e valores ASCII adicionais, use o ActionScript no início
deste apêndice e pressione a tecla desejada para obter o código da tecla.
823
APÊNDICE D
Criando scripts para versões

anteriores do Flash Player
D
O ActionScript sofreu modificações consideráveis a cada versão das ferramentas de criação do
Macromedia Flash e do Flash Player. Ao criar conteúdo para o Macromedia Flash Player 8,
você aproveitará todo o potencial do ActionScript. Você ainda poderá usar o Flash 8 para criar
conteúdo para versões anteriores do Flash Player, mas não poderá usar todos os elementos do
ActionScript.
Este capítulo fornece diretrizes para ajudá-lo a criar scripts sintaticamente corretos para a
versão do Flash Player desejada.
NO TA
Consulte as pesquisas relativas à penetração da versão do Flash Player no site da

Macromedia na Web, em www.macromedia.com/software/player_census/flashplayer/.
Sobre a especificação de versões

anteriores do Flash Player
Durante a criação de scripts, use as informações de Availability (Disponibilidade) de cada
elemento em ActionScript 2.0 Language Reference (Referência da linguagem ActionScript 2.0)
para determinar se o elemento que você deseja usar é suportado pela versão do Flash Player
especificada. Para determinar quais elementos você pode usar, exiba a caixa de ferramentas
Actions (Ações); os elementos não suportados na versão especificada serão exibidos em
amarelo.
Se estiver criando conteúdo para o Flash Player 6, 7 ou 8, use o ActionScript 2.0, que contém
diversos recursos importantes não disponíveis no ActionScript 1.0, como o aprimoramento de
erros do compilador e recursos mais robustos de programação orientada a objeto.
Para especificar a versão do exibidor e do ActionScript a ser usada na publicação de um
documento, selecione File (Arquivo) > Publish Settings (Configurações de publicação) e
escolha as opções na guia Flash. Consulte a próxima seção se precisar trabalhar com o Flash
Player 4.
825
Usando o Flash 8 para criar conteúdo
para o Flash Player 4
Para usar o Flash 8 na criação de conteúdo para o Flash Player 4, especifique Flash Player 4 na
guia Flash da caixa de diálogo Publish Settings (File > Publish Settings).
O ActionScript do Flash Player 4 possui apenas um tipo de dados primitivo básico que é
usado para a manipulação de números e de seqüências de caracteres. Ao criar um aplicativo
para o Flash Player 4, utilize os operadores obsoletos de seqüência de caracteres localizados na
categoria Deprecated (Obsoletos) > Operators (Operadores) da caixa de ferramentas
do ActionScript.
É possível usar os seguintes recursos do Flash 8 nas publicações para Flash Player 4:
■ O operador de acesso de objetos e arrays ([])
■ O operador ponto (.)
■ Operadores lógicos, operadores de atribuição e operadores de pré-incremento e pós-
incremento/decremento.
■ O operador de módulo (%) e todos os métodos e propriedades da classe Math.
Os elementos de linguagem a seguir não têm suporte nativo do Flash Player 4. O Flash 8 os
exporta como aproximações de séries, criando resultados menos precisos numericamente.
Além disso, devido à inclusão de aproximações de séries no arquivo SWF, esses elementos de
linguagem precisam de mais espaço nos arquivos SWF do Flash Player 4 do que nos arquivos
SWF do Flash Player 5 ou versões posteriores.
■ As ações for, while, do while, break e continue
■ As ações print() e printAsBitmap()
■ A ação switch
Para obter informações adicionais, consulte “Sobre a especificação de versões anteriores do
Flash Player” na página 825.
Usando o Flash 8 para abrir arquivos do Flash 4

O ActionScript do Flash 4 tinha apenas um tipo de dados verdadeiro: seqüência de caracteres.
Ele usava diferentes tipos de operadores em expressões para indicar se o valor devia ser tratado
como uma seqüência de caracteres ou um número. Nas versões subseqüentes do Flash, é
possível usar um conjunto de operadores em todos os tipos de dados.
Quando você usa o Flash 5 ou posterior para abrir um arquivo criado no Flash 4, o Flash
converte automaticamente as expressões do ActionScript para torná-las compatíveis com a
nova sintaxe. O Flash faz as seguintes conversões de operadores e tipos de dados:
826 Criando scripts para versões anteriores do Flash Player

■ O operador = no Flash 4 era usado para igualdade numérica. No Flash 5 e versões
posteriores, == é o operador de igualdade e = é o operador de atribuição. Os operadores =
em arquivos do Flash 4 são convertidos automaticamente em ==.
■ O Flash executa automaticamente as conversões de tipo para garantir o comportamento
esperado dos operadores. Devido à introdução de vários tipos de dados, os seguintes
operadores têm novos significados:
+, ==, !=, <>, <, >, >=, <=
No ActionScript do Flash 4, esses operadores eram sempre operadores numéricos. No
Flash 5 e versões posteriores, eles se comportam de maneira diferente, dependendo dos
tipos de dados dos operandos. Para evitar diferenças semânticas em arquivos importados, a
função Number() é inserida delimitando todos os operandos desses operadores. (Os
números constantes já são óbvios, portanto, eles não são incluídos em Number().) Para
obter mais informações sobre esses operadores, consulte a tabela de operadores em “Sobre
associatividade e precedência de operadores” na página 188 e “Operadores Flash 4
obsoletos” na página 815.
■ No Flash 4, a seqüência de escape \n gerava um caractere de retorno de carro (ASCII 13).
No Flash 5 e versões posteriores, para seguir o padrão ECMA-262, \n gera um caractere
de alimentação de linha (ASCII 10). Uma seqüência \n nos arquivos FLA do Flash 4 é
convertida automaticamente em \r.
■ O operador & no Flash 4 era usado para adição de seqüências de caracteres. No Flash 5 e
versões posteriores, & é o operador AND bit a bit. O operador de adição de seqüências de
caracteres chama-se agora add. Todos os operadores & nos arquivos do Flash 4 são
automaticamente convertidos em operadores add.
■ Muitas funções no Flash 4 não exigiam parênteses, por exemplo, Get Timer , Set
Variable, Stop e Play. Para criar uma sintaxe consistente, a função getTimer e todas as
ações agora exigem parênteses [()]. Esses parênteses são adicionados automaticamente
durante a conversão.
■ No Flash 5 e versões posteriores, quando a função getProperty é executada em um clipe
de filme não existente, ela retorna o valor undefined, em vez de 0. A instrução undefined
== 0 é false no ActionScript após o Flash 4 (no Flash 4, undefined == 1). No Flash 5 e
versões posteriores, solucione esse problema ao converter arquivos do Flash 4, inserindo
funções Number() nas comparações de igualdade. No exemplo a seguir, Number() força a
conversão de undefined em 0 para que a comparação tenha êxito:
Usando o Flash 8 para criar conteúdo para o Flash Player 4 827

getProperty("clip", _width) == 0
Number(getProperty("clip", _width)) == Number(0)
N OT A
Se alguma palavra-chave do Flash 5 ou posterior tiver sido usada como nome de

variável no ActionScript do Flash 4, a sintaxe retornará um erro quando for
compilada no Flash 8. Para solucionar esse problema, renomeie as variáveis em
todos os locais. Para obter mais informações, consulte “Sobre palavras reservadas”
na página 147 e “Sobre a atribuição de nomes a variáveis” na página 96.
Usando a 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. Nesse tipo de sintaxe, barras são usadas no lugar de pontos; além
disso, as variáveis devem ser precedidas de dois-pontos, como mostra o exemplo a seguir:
myMovieClip/childMovieClip:myVariable
Para escrever o mesmo caminho de destino em sintaxe de ponto, que é suportada pelo Flash
Player 5 e versões posteriores, use esta sintaxe:
myMovieClip.childMovieClip.myVariable
A sintaxe de barra era mais utilizada com a ação tellTarget, cujo uso também não é mais
recomendado. A ação with agora é mais usada por ser mais compatível com a sintaxe de
ponto. Para obter mais informações, consulte %{função tellTarget}% e %{instrução
with}% em ActionScript 2.0 Language Reference.
828 Criando scripts para versões anteriores do Flash Player

APÊNDICE E
Programação orientada a
objeto com o ActionScript 1.0
E
As informações deste apêndice vêm da documentação do Macromedia Flash MX e explicam
como usar o modelo de objetos do ActionScript 1.0 para criar scripts. Elas foram incluídas
aqui pelos seguintes motivos:
■ Se você deseja criar scripts orientados a objeto com suporte para Flash Player 5, use
o ActionScript 1.0.
■ Se você já usa o ActionScript 1.0 para criar scripts orientados a objeto e não está pronto
para migrar para o ActionScript 2.0, use este apêndice para localizar ou verificar as
informações necessárias durante a criação de scripts.
Se você nunca usou o ActionScript para criar scripts orientados a objeto e não precisa ter
como alvo o Flash Player 5, não use as informações deste apêndice, pois a criação de scripts
orientados a objeto com o ActionScript 1.0 está obsoleta. Em vez disso, para obter
informações sobre como usar o ActionScript 2.0, consulte Capítulo 7, “Classes”, na
página 239.
Este capítulo contém as seguintes seções:
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
N OT A
Alguns exemplos deste apêndice usam o método Object.registerClass(). Esse método

só é suportado no Flash Player 6 e versões posteriores; não use esse método se estiver
utilizando o Flash Player 5.
829
Sobre o ActionScript 1.0
N OT A
Vários usuários do Flash podem obter grandes benefícios utilizando o ActionScript 2.0,
especialmente com aplicativos complexos. Para obter informações sobre como usar o
ActionScript 2.0, consulte Capítulo 7, “Classes”, na página 239.
ActionScript é uma linguagem de programação orientada a objeto. A programação orientada a

objeto usa objetos, ou estruturas de dados, para agrupar as propriedades e os métodos que
controlam o comportamento ou a aparência do objeto. Os objetos permitem organizar e
reutilizar o código. Depois de definir um objeto, é possível fazer referência a ele pelo nome,
sem precisar redefini-lo a cada utilização.
Uma classe é uma categoria genérica de objetos. A classe define uma série de objetos que têm
propriedades comuns e podem ser controlados da mesma maneira. As propriedades são
atributos que definem um objeto, como tamanho, posição, cor, transparência etc. As
propriedades são definidas para uma classe e os valores das propriedades são definidos para os
diferentes objetos da classe. Os métodos são funções que podem definir ou recuperar as
propriedades de um objeto. Por exemplo, você pode definir um método para calcular o
tamanho de um objeto. Assim como as propriedades, os métodos são definidos para uma
classe de objetos e, em seguida, chamados para os diferentes objetos da classe.
O ActionScript possui diversas classes internas, incluindo as classes MovieClip e Sound, entre
outras. Também é possível criar classes personalizadas para definir categorias de objetos para
os aplicativos.
Os objetos no ActionScript podem ser meros recipientes de dados ou podem ser representados
graficamente no Stage (Palco) como clipes de filmes, botões ou campos de texto. Todos os
clipes de filmes são instâncias da classe interna MovieClip, e todos os botões são instâncias da
classe interna Button. Cada instância de clipe de filme contém todas as propriedades (por
exemplo, _height, _rotation, _totalframes) e todos os métodos (por exemplo,
gotoAndPlay(), loadMovie(), startDrag()) da classe MovieClip.
Para definir uma classe, crie uma função especial denominada função construtora. (Classes
internas têm funções construtoras internas.) Por exemplo, se você quiser informações sobre
um ciclista no aplicativo, poderá criar uma função construtora, Biker(), com as propriedades
time e distance e o método getSpeed(), que informa a velocidade do ciclista:
function Biker(t, d) {
this.time = t;
this.distance = d;
this.getSpeed = function() {return this.time / this.distance;};
}
830 Programação orientada a objeto com o ActionScript 1.0

Neste exemplo, é criada uma função que requer duas informações ou parâmetros: t e d.
Quando a função for chamada para criar novas instâncias do objeto, passe para ela os
parâmetros. O código a seguir cria instâncias do objeto Biker chamadas emma e hamish e
apresenta a velocidade da instância emma, utilizando o método getSpeed() do ActionScript
anterior:
emma = new Biker(30, 5);
hamish = new Biker(40, 5);
trace(emma.getSpeed()); // traces 6
Em scripts orientados a objeto, as classes podem receber propriedades e métodos umas

das outras de acordo com uma ordem específica. Esse processo é chamado de herança. A
herança pode ser usada para estender ou redefinir as propriedades e os métodos de uma classe.
Uma classe que herda propriedades e métodos de outra classe é chamada de subclasse. Uma
classe que passa propriedades e métodos para outra classe é chamada de superclasse. Uma classe
pode ser uma subclasse e uma superclasse ao mesmo tempo.
Um objeto é um tipo de dados complexo que pode conter ou não propriedades e métodos.
Cada propriedade, como uma variável, possui um nome e um valor. As propriedades são
anexadas ao objeto e contêm valores que podem ser alterados e recuperados. Esses valores
podem ser um dos seguintes tipos de dados: String, Number, Boolean, Object, MovieClip ou
indefinido. As propriedades a seguir são de vários tipos de dados:
customer.name = "Jane Doe";
customer.age = 30;
customer.member = true;
customer.account.currentRecord = 609;
customer.mcInstanceName._visible = true;
A propriedade de um objeto também pode ser um objeto. Na linha 4 do exemplo anterior,

account é uma propriedade do objeto customer, e currentRecord é uma propriedade do
objeto account. O tipo de dados da propriedade currentRecord é Number.
Criando um objeto personalizado no

ActionScript 1.0
NO T A
Criando um objeto personalizado no ActionScript 1.0 831

Para criar um objeto personalizado, defina uma função construtora. Uma função construtora
recebe sempre o mesmo nome do tipo de objeto que cria. Você pode usar a palavra-chave this
dentro do corpo da função construtora para fazer referência ao objeto que a construtora cria;
quando uma função construtora for chamada, o Flash passará this para a função como um
parâmetro oculto. Por exemplo, o código a seguir é uma função construtora que cria um
círculo com a propriedade radius:
function Circle(radius) {
this.radius = radius;
}
Depois de definir a função construtora, crie uma instância do objeto. Use o operador new
antes do nome da função construtora e atribua um nome de variável à nova instância. Por
exemplo, o código a seguir usa o operador new para criar um objeto Circle com um raio de 5 e
atribui-lo à variável myCircle:
myCircle = new Circle(5);
NO TA
Um objeto tem o mesmo escopo da variável à qual ele é atribuído.
Atribuindo métodos a um objeto

personalizado no ActionScript 1.0
N OT A
É possível definir os métodos de um objeto dentro da função construtora do objeto.

Entretanto, esta técnica não é recomendada porque define o método sempre que a função
construtora é utilizada. O exemplo a seguir cria os métodos getArea() e getDiameter(): e
apresenta a área e o diâmetro da instância construída myCircle com um raio definido como
55:
this.getArea = function(){
return Math.PI * this.radius * this.radius;
};
this.getDiameter = function() {
return 2 * this.radius;
};
}
var myCircle = new Circle(55);

trace(myCircle.getArea());
trace(myCircle.getDiameter());
Toda função construtora tem uma propriedade prototype, criada automaticamente quando a
função é definida. A propriedade prototype indica os valores de propriedade padrão para
objetos criados com essa função. Cada nova instância de um objeto tem uma propriedade
__proto__ que faz referência à propriedade prototype da função construtora que a criou.
Portanto, se você atribuir métodos à propriedade prototype de um objeto, eles ficarão
disponíveis para qualquer instância recém-criada desse objeto. É recomendável atribuir um
método à propriedade prototype da função construtora porque ela existe em um local e serve
de referência para novas instâncias do objeto (ou classe). Você pode usar as propriedades
prototype e __proto__ para estender objetos para que o código possa ser reutilizado de uma
forma orientada a objeto. Para obter mais informações, consulte “Criando herança no
ActionScript 1.0” na página 836.
O procedimento a seguir mostra como atribuir um método getArea() a um objeto Circle
personalizado.
Para atribuir um método a um objeto personalizado:

1. Defina a função construtora Circle():
}
2. Defina o método getArea() do objeto Circle. O método getArea() calculará a área do

círculo. No exemplo a seguir, você pode usar um literal de função para definir o método
getArea() e atribuir a propriedade getArea ao objeto protótipo do círculo:
Circle.prototype.getArea = function () {
return Math.PI * this.radius * this.radius;
};
3. O exemplo a seguir cria uma instância do objeto Circle:

var myCircle = new Circle(4);
4. Chame o método getArea() do novo objeto myCircle utilizando o seguinte código:

var myCircleArea = myCircle.getArea();
trace(myCircleArea); // traces 50.265...
O ActionScript procura o método getArea() no objeto myCircle. Como o objeto não

possui um método getArea(), é feita uma pesquisa em seu objeto protótipo
Circle.prototype para encontrar getArea(). O ActionScript o localiza e chama, e
apresenta myCircleArea.
Atribuindo métodos a um objeto personalizado no ActionScript 1.0 833

Definindo métodos manipuladores de
eventos no ActionScript 1.0
NO T A
Você pode criar uma classe do ActionScript para clipes de filme e definir os métodos
manipuladores de eventos no objeto protótipo dessa nova classe. Definir os métodos no
protótipo objeto faz todas as instâncias desse símbolo responderem da mesma forma a esses
eventos.
Você também pode adicionar métodos manipuladores de eventos onClipEvent() ou on() a
uma instância individual para fornecer instruções exclusivas que são executadas apenas
quando o evento da instância ocorre. Os métodos onClipEvent() e on() não substituem o
método manipulador de evento. Os dois eventos fazem com que seus scripts sejam executados.
No entanto, se definir os métodos manipuladores de eventos no objeto protótipo e também
definir um método manipulador de evento para uma instância específica, a definição da
instância substituirá a definição do protótipo.
Para definir um método manipulador de evento no objeto protótipo de um

objeto:
1. Crie um símbolo de clipe de filme e defina o identificador de vinculação como theID,
selecionando o símbolo no painel Library (Biblioteca) e selecionando Linkage (Vinculação)
no menu pop-up Library.
2. No painel Actions (Ações) (Window [Janelas]> Actions), use a instrução function para
definir uma nova classe, como mostra o seguinte exemplo:
// define uma classe
function myClipClass() {}
Essa nova classe é atribuída a todas as instâncias de clipe de filme adicionadas ao aplicativo
pela linha de tempo ou pelos métodos attachMovie() ou duplicateMovieClip(). Para
que esses clipes de filme tenham acesso aos métodos e propriedades do objeto MovieClip
interno, faça com que a nova classe herde tudo da classe MovieClip.
3. Insira códigos como no seguinte exemplo:
// herda da classe MovieClip
myClipClass.prototype = new MovieClip();
Agora a classe myClipClass herdará todas as propriedades e métodos da classe MovieClip.

4. Insira um código, como este do exemplo, para definir métodos manipuladores de eventos
para a nova classe:

// define métodos manipuladores de eventos para classe myClipClass
myClipClass.prototype.onLoad = function() {trace("movie clip loaded");}
myClipClass.prototype.onEnterFrame = function() {trace("movie clip
entered frame");}
5. Selecione Window > Library (Biblioteca) para abrir o painel Library se ele ainda não estiver
aberto.
6. Selecione os símbolos que deseja associar à nova classe e escolha Linkage (Vinculação) no
menu pop-up Library.
7. Na caixa de diálogo Linkage Properties (Propriedades de vinculação), selecione Export for
ActionScript (Exportar para ActionScript).
8. Insira um identificador de vinculação na caixa Identifier (Identificador).
O identificador de vinculação deve ser o mesmo para todos os símbolos que deseja associar
à nova classe. No exemplo do myClipClass, o identificador é theID.
9. Insira o código no painel Actions (Ações), como no seguinte exemplo:
// registra classe
Object.registerClass("theID", myClipClass);
this.attachMovie("theID","myName",1);
Esta etapa registra o símbolo cujo identificador de vinculação é theID com a classe
myClipClass . Todas as instâncias de myClipClass possuem métodos manipuladores de
eventos que se comportam como foram definidos na etapa 4. Eles também se comportam
como todas as instâncias da classe MovieClip, já que a nova classe foi definida para herdar
tudo da classe MovieClip na etapa 3.
O código completo é mostrado no seguinte exemplo:
function myClipClass(){}
myClipClass.prototype = new MovieClip();

myClipClass.prototype.onLoad = function(){
trace("movie clip loaded");
}
myClipClass.prototype.onPress = function(){
trace("pressed");
}
myClipClass.prototype.onEnterFrame = function(){
trace("movie clip entered frame");
}
myClipClass.prototype.myfunction = function(){
trace("myfunction called");
}
Definindo métodos manipuladores de eventos no ActionScript 1.0 835

Object.registerClass("myclipID",myClipClass);
this.attachMovie("myclipID","clipName",3);
Criando herança no ActionScript 1.0

NO TA
Herança é uma forma de organizar, estender e reutilizar a funcionalidade. Subclasses herdam

métodos e propriedades de superclasses e adicionam seus próprios métodos e propriedades
especializados. Tomando como exemplo o mundo real, Bike seria uma superclasse e
MountainBike e Tricycle seriam subclasses da superclasse. Ambas as subclasses contêm, ou
herdam, os métodos e propriedades da superclasse (por exemplo, wheels). Cada subclasse
também tem seus próprios métodos e propriedades que estendem a superclasse (por exemplo,
a subclasse MountainBike teria uma propriedade gears). Você pode usar os elementos
prototype e __proto__ para criar herança no ActionScript.
Todas as funções construtoras têm uma propriedade prototype que é criada

automaticamente quando a função é definida. A propriedade prototype indica os valores de
propriedade padrão para objetos criados com essa função. Você pode usar a propriedade
prototype para atribuir propriedades e métodos a uma classe. Para obter mais informações,
consulte “Atribuindo métodos a um objeto personalizado no ActionScript 1.0” na página 832.
Todas as instâncias de uma classe possuem uma propriedade __proto__ que informa de que
objeto recebem herança. Quando uma função construtora é usada para criar um objeto, a
propriedade __proto__ é definida para fazer referência à propriedade prototype de sua
função construtora.
A herança prossegue de acordo com uma hierarquia limitada. Quando você chama o método
ou a propriedade de um objeto, o ActionScript verifica se esse elemento existe no objeto. Se
ele não existir, o ActionScript procurará na propriedade __proto__ pela informação
(myObject.__proto__). Se a propriedade não for uma propriedade do objeto__proto__ do
objeto, o ActionScript examinará myObject.__proto__.__proto__ e assim por diante.
O exemplo a seguir define a função construtora Bike():
function Bike(length, color) {
this.length = length;
this.color = color;
this.pos = 0;
}
O código a seguir adiciona o método roll() à classe Bike.

Bike.prototype.roll = function() {return this.pos += 20;};

Em seguida, é possível rastrear a posição da classe Bike com o seguinte código:
var myBike = new Bike(55, "blue");
trace(myBike.roll()); // traces 20.
trace(myBike.roll()); // traces 40.
Em vez de adicionar roll() à classe MountainBike e à classe Tricycle, crie a classe

MountainBike com Bike como superclasse, como mostra o seguinte exemplo:
MountainBike.prototype = new Bike();
Agora é possível chamar o método roll() de MountainBike, como no exemplo a seguir:

var myKona = new MountainBike(20, "teal");
trace(myKona.roll()); // traces 20
Os clipes de filme não herdam uns dos outros. Para criar herança com clipes de filme, use
Object.registerClass() para atribuir a clipes de filme uma classe diferente de MovieClip.
Adicionando propriedades getter/setter a

objetos no ActionScript 1.0
N OT A
É possível criar propriedades getter/setter (apanhadoras/definidoras) para um objeto usando o

método Object.addProperty().
Uma função getter não possui nenhum parâmetro. Seu valor de retorno pode ser de qualquer
tipo. Seu tipo pode ser alterado entre as chamadas. O valor de retorno é tratado como o valor
atual da propriedade.
Uma função definidora utiliza um parâmetro, que é o novo valor da propriedade. Por
exemplo, se a propriedade x for atribuída pela instrução x = 1, a função definidora receberá o
parâmetro 1 do tipo Number. O valor de retorno da função definidora é ignorado.
Quando o Flash lê uma propriedade getter/setter, chama a função getter e o valor de retorno
da função torna-se um valor de prop. Quando o Flash grava uma propriedade getter/setter, ele
chama a função setter e passa a ela o novo valor como um parâmetro. Se já houver uma
propriedade com o mesmo nome, a nova propriedade a substituirá.
Adicionando propriedades getter/setter a objetos no ActionScript 1.0 837

É possível adicionar propriedades getter/setter aos objetos protótipo. Se você adicionar uma
propriedade getter/setter a um objeto protótipo, todas as instâncias de objeto que herdam o
objeto protótipo também herdarão essa propriedade. Você pode adicionar uma propriedade
getter/setter em um único local, o objeto protótipo, e fazer com que ela seja propagada para
todas as instâncias de uma classe (semelhante à adição de métodos a objetos protótipo). Se
uma função getter/setter for chamada para uma propriedade getter/setter em um objeto
protótipo herdado, a referência passada a essa função é o objeto referenciado originalmente e
não o objeto protótipo.
O comando Debug (Depurar) > List Variables (Listar variáveis) em modo de teste suporta as
propriedades getter/setter adicionadas aos objetos usando Object.addProperty(). As
propriedades adicionadas a um objeto desse modo aparecem com outras propriedades do
objeto no painel Output (Saída). As propriedades getter/setter são identificadas no painel
Output com o prefixo [getter/setter]. Para obter mais informações sobre o comando List
Variables, consulte “Usando o painel Output” na página 759.
Usando as propriedades do objeto

Function no ActionScript 1.0
N OT A
Você pode especificar o objeto ao qual a função é aplicada e os valores dos parâmetros passados
para a função usando os métodos call() e apply() do objeto Function. Toda função em
ActionScript é representada por um objeto Function para que todas as funções ofereçam
suporte a call() e apply(). Quando você cria uma classe personalizada usando uma função
construtora ou quando define métodos para uma classe personalizada usando uma função,
pode chamar call() e apply() para a função.
Chamando uma função usando o método

Function.call() no ActionScript 1.0
N O TA
O método Function.call() chama a função representada por um objeto Function.

Em quase todos os casos, o operador de chamada de função (()) pode ser usado no lugar do
método call(). O operador de chamada de função cria um código conciso e de fácil leitura.
O método call() é útil principalmente quando o parâmetro this da chamada de função
precisa ser explicitamente controlado. Normalmente, se uma função é chamada como um
método de um objeto, no corpo da função, this é definido como myObject, conforme
indicado no exemplo a seguir:
myObject.myMethod(1, 2, 3);
Em algumas situações, é possível que você queira que this aponte para algum outro lugar,
como no caso, por exemplo, de ser necessário chamar uma função como um método de um
objeto, mas ela não estiver realmente armazenada como um método desse objeto, como
indicado a seguir:
myObject.myMethod.call(myOtherObject, 1, 2, 3);
Você pode passar o valor null para o parâmetro esteObjeto para chamar uma função como
uma função regular e não como um método de um objeto. Por exemplo, as seguintes
chamadas de função são equivalentes:
Math.sin(Math.PI / 4)
Math.sin.call(null, Math.PI / 4)
Para chamar uma função usando o método Function.call():

■ Use a seguinte sintaxe:
myFunction.call(thisObject, parameter1, ..., parameterN)
O método requer os seguintes parâmetros:

■ O parâmetro thisObject especifica o valor de this no corpo da função.
■ Os parâmetros parameter1..., parameterN especificam os parâmetros a serem
passados para myFunction. Você pode especificar zero ou mais parâmetros.
Especificando o objeto ao qual uma função é

aplicada usando Function.apply() no ActionScript 1.0
N O TA
O método Function.apply() especifica o valor de this para ser usado em qualquer função
chamada pelo ActionScript. Esse método também especifica os parâmetros a serem passados a
qualquer função chamada.
Usando as propriedades do objeto Function no ActionScript 1.0 839

Os parâmetros são especificados como um objeto Array. Em geral, isso é útil quando o
número de parâmetros a serem passados só é conhecido quando o script é realmente
executado.
Para obter mais informações, consulte %{apply (Function.apply method)}% em
Para especificar o objeto ao qual uma função é aplicada usando

Function.apply():
■ Use a seguinte sintaxe:
myFunction.apply(thisObject, argumentsObject)
O método requer os seguintes parâmetros:

■ O parâmetro thisObject especifica o objeto ao qual myFunction é aplicada.
■ O parâmetro argumentsObject define qualquer array cujos elementos são passados
para myFunction como parâmetros.

APÊNDICE F
Terminologia F
Como em todas as linguagens de script, o ActionScript usa sua própria terminologia. O
Macromedia Flash também utiliza uma terminologia exclusiva. A lista apresentada a seguir
fornece uma introdução aos termos importantes do ActionScript e aos termos do Flash
referentes à programação com o ActionScript e que são exclusivos para trabalhar no ambiente
de criação do Flash.
Editor do ActionScript é o editor de código no painel Actions e na janela Script O editor do
ActionScript é formado por vários recursos, como a formatação automática, mostrando
caracteres ocultos e codificando com cores partes dos scripts. (Consulte também: janela Script,
painel Actions).
Painel Actions (Ações) é um painel no ambiente de criação do Flash, onde você escreve o
código do ActionScript.
Função anônima é uma função sem nome que faz referência a si própria; você faz referência à
função anônima ao criá-la. Para obter informações e um exemplo, consulte “Criando funções
anônimas e de retorno de chamada” na página 220.
Serrilhado refere-se ao texto serrilhado que não utiliza variações de cor para suavizar as bordas
dentadas, ao contrário do texto sem serrilhado (consulte também Sem serrilhado).
Sem serrilhado refere-se aos caracteres sem serrilhado quando é preciso 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) no Flash torna o texto mais legível ao alinhar os contornos
do texto nas fronteiras dos pixels e é eficiente para renderizar fontes menores com nitidez.
Arrays são objetos cujas propriedades são identificadas por números que representam suas
posições na estrutura. Basicamente, um array é uma lista de itens.
Ambiente de criação é a área de trabalho do Flash, incluindo todos os elementos da interface
de usuário. Você cria arquivos FLA ou arquivos de script (na janela Script) usando o ambiente
de criação.
841
Gráficos de bitmap(ou gráficos de varredura) geralmente são imagens foto-realísticas ou
gráficos com um grande volume de detalhes. Cada pixel (ou bit) da imagem contém dados, e
juntos esses bits formam a imagem propriamente dita. Os bitmaps podem ser salvos nos
formatos de arquivo JPEG, BMP ou GIF. Um outro tipo de gráfico, diferente do bitmap, é o
vetorial.
Booleano é um valor true (verdadeiro) ou false (falso).
Armazenamento em cache refere-se a informações reutilizadas no aplicativo ou armazenadas
no computador de modo que possam ser reutilizadas. Por exemplo, se você fizer o download
de uma imagem da Internet, ela será armazenada em cache, de modo que seja possível exibi-la
novamente sem fazer o download dos dados da imagem.
Funções de retorno de chamada são funções anônimas associadas a um determinado
evento. 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()). Para obter mais informações e exemplos, consulte “Criando funções
anônimas e de retorno de chamada” na página 220.
Caracteres são letras, numerais e pontuação combinados para formar seqüências de
caracteres. Às vezes são chamados glifos.
Classes são tipos de dados que podem ser criados para definir um novo tipo de objeto. Para
definir uma classe, use a palavra-chave class em um arquivo de script externo, e não em um
script escrito no painel Actions (Ações).
Caminho de classe refere-se à lista de pastas na qual o Flash pesquisa definições de classe ou
de interface. Quando você cria um arquivo de classe, precisa salvar o arquivo em um dos
diretórios especificados no caminho de classe ou em um subdiretório dentro dele. Os
caminhos de classe existem no nível global, do aplicativo e do documento.
Constantes são elementos que não se alteram. Por exemplo, a constante Key.TAB sempre tem
o mesmo significado: ela indica a tecla Tab em um teclado. Constantes são úteis para
comparar valores.
Funções construtoras (ou construtores) são funções utilizadas para definir (inicializar) 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 abaixo define
uma classe Circle (Círculo) e implementa uma função construtora:
842 Terminologia
// arquivo Circle.as
class Circle {
private var circumference:Number;
// construtor
function Circle(radius:Number){
this.circumference = 2 * Math.PI * radius;
}
}
O termo construtor também é 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 interna e à classe Circle (Círculo) personalizada:
var my_array:Array = new Array();
var my_circle:Circle = new Circle(9);
Tipos de dados descrevem que tipos de informações um elemento do ActionScript ou

variável pode conter. Os tipos de dados internos do ActionScript são String (Seqüência de
caracteres), Number (Número), Boolean (Booleano), Object (Objeto), MovieClip (Clipe de
filme), Function (Função), null (nulo) e undefined (indefinido). “Sobre tipos de dados”
na página 76Para obter mais informações, consulte .
Fontes de dispositivo são fontes especiais no Flash que não são incorporadas em um arquivo
SWF do Flash. Em vez disso, o Flash Player usa a fonte disponível no computador local mais
semelhante à fonte do 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
incorporados. 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 e Arial), _serif (semelhante à Times Roman) e
_typewriter (semelhante à Courier).
Sintaxe de ponto refere-se ao uso de um operador ponto (.) (sintaxe de ponto) para acessar
propriedades ou métodos que pertencem a um objeto ou instância no Stage (Palco) que utilize
o ActionScript. O operador ponto também é utilizado para identificar o caminho de destino
para 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.
Eventos ocorrem durante a reprodução de um arquivo SWF. Por exemplo, são gerados
eventos diferentes quando um clipe de filme é carregado, quando a reprodução entra em um
quadro, quando o usuário clica em um botão ou clipe de filme, ou quando digita no teclado.
843
Manipuladores de eventos são eventos especiais gerados quando o usuário clica com o
mouse ou quando os dados terminam de ser carregados. Existem dois tipos de manipuladores
de eventos do ActionScript: métodos manipuladores de eventos e ouvintes de eventos.
(Existem também dois manipuladores de eventos, %{on handler}% e %{onClipEvent
handler}%, que você pode atribuir diretamente a botões e clipes de filme.) Na caixa de
ferramentas Actions, cada objeto do ActionScript com métodos manipuladores de eventos ou
ouvintes de eventos tem uma subcategoria chamada Events (Eventos) ou Listeners (Ouvintes).
Alguns comandos podem ser usados como manipuladores de eventos e como ouvintes de
eventos e são incluídos nas duas subcategorias. Para obter mais informações sobre
gerenciamento de eventos, consulte “Manipulando eventos” na página 347.
Expressões são combinações legais de símbolos do ActionScript que representam um valor.
Uma expressão consiste em operadores e operandos. Por exemplo, na expressão x + 2, x e 2
são operandos e + é um operador.
Recipiente do Flash Player refere-se ao sistema que contém o aplicativo do Flash, como o
aplicativo desktop ou navegador. É possível adicionar o ActionScript e o JavaScript para
facilitar a comunicação entre o recipiente do Flash Player e o arquivo do SWF.
FlashType refere-se à tecnologia avançada de renderização de fontes do Flash 8. Por exemplo,
Alias Text for Readability (Texto serrilhado para legibilidade) utiliza a tecnologia de
renderização FlashType, o mesmo não ocorrendo com Alias Text for Animation (Texto
serrilhado para animação). Para obter informações, consulte“Sobre a renderização de fontes e
texto sem serrilhado” na página 430.
Scrips de quadros são blocos de código adicionados a um quadro em uma linha de tempo.
Funções são blocos de código reutilizáveis que podem receber parâmetros e retornar um
valor. “Sobre funções e métodos” na página 213Para obter mais informações, consulte .
Literais de função são funções sem nome declaradas 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.
IDE refere-se a um "ambiente de desenvolvimento integrado", que é um aplicativo no qual um
desenvolvedor pode codificar, testar e depurar aplicativos em um ambiente interativo. A
ferramenta de criação do Flash é algumas vezes chamada IDE.
Identificadores são nomes usados para indicar uma variável, uma propriedade, um objeto,
uma função ou um método. O primeiro caractere deve ser uma letra, um sublinhado (_) ou
um cifrão ($). Cada caractere seguinte deve ser uma letra, um número, um sublinhado ou um
cifrão. Por exemplo, firstName é o nome de uma variável.
844 Terminologia
Instâncias são objetos que contêm todas as propriedades e métodos de determinada classe.
Por exemplo, todos os 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.
Nomes de instâncias são nomes exclusivos que permitem fazer referência a instâncias que
você criou ou instâncias de clipes de filme e de botões no Stage (Palco). Por exemplo, no
código a seguir, "names" e “studentName” são nomes de instâncias de dois objetos, um array e
uma seqüência de caracteres:
var names:Array = new Array();
var studentName:String = new String();
Use o inspetor Properties (Propriedades) para atribuir nome a instâncias no Stage (Palco). Por
exemplo, um símbolo principal na biblioteca pode ser chamado de counter, e as duas
instâncias desse símbolo no arquivo SWF podem ter os nomes de
instânciasscorePlayer1_mc e scorePlayer2_mc. O código a seguir define uma variável
chamada score dentro de cada instância de clipe de filme por meio de nomes de instâncias:
this.scorePlayer1_mc.score = 0;
this.scorePlayer2_mc.score = 0;
Você pode usar atribuição estrita de tipos de dados ao criar instâncias para que referências de
código apareçam à medida que você digita o código.
Palavras-chave são palavras reservadas que têm significado especial. Por exemplo, var é uma
palavra-chave usada para declarar variáveis locais. Não é possível usar uma palavra-chave como
um identificador. Por exemplo, var não é um nome de variável legal. Para obter uma lista de
palavras-chave, consulte “Sobre palavras-chave” na página 146 e “Sobre palavras reservadas”
na página 147.
Literais representam valores que possuem um tipo específico, como literais numéricos ou
literais de seqüências de caracteres. Os literais não são armazenados em uma variável. Um
literal é um valor que aparece diretamente no código e é um valor constante (inalterável)
dentro dos documentos do Flash. Consulte também literal de função e literal de seqüência de
caracteres.
Métodos são funções associadas a uma classe. Por exemplo, sortOn() é um método interno
associado à classe Array. Você também pode criar funções que funcionem como métodos, para
objetos com base em classes internas ou objetos com base nas classes criadas por você. Por
exemplo, no código abaixo, clear() torna-se um método de um objeto controller já
definido:
function reset(){
this.x_pos = 0;
this.y_pos = 0;
}
845
controller.clear = reset;
controller.clear();
Os exemplos a seguir mostram como criar os métodos de uma classe:

// ActionScript 1.0 - exemplo
A = new Object();
A.prototype.myMethod = function() {
trace("myMethod");
}
// ActionScript 2.0 - exemplo

class B {
trace("myMethod");
}
}
Função com nome é um tipo de função criada geralmente no código do ActionScript para
executar todos os tipos de ações. Para obter informações e um exemplo, consulte “Criando
funções com nome” na página 219.
Código de objeto é a linguagem ActionScript anexada a instâncias. Para adicionar código de
objeto, selecione uma instância no Stage (Palco) e depois crie o código no painel Actions
(Ações). Não é recomendável anexar código a objetos no Stage. Para obter informações sobre
as melhores práticas, consulte “Melhores práticas e convenções de codificação para
ActionScript 2.0” na página 767.
Objetos são coleções de propriedades e métodos; cada objeto tem seu próprio nome e é uma
instância de uma classe específica. Objetos internos são predefinidos na linguagem
ActionScript. Por exemplo, a classe interna Date fornece informações sobre o relógio do
sistema.
Operadores são termos que calculam um novo valor de um ou mais valores. Por exemplo, o
operador de adição (+) soma dois ou mais valores para produzir um novo valor. Os valores
manipulados pelos operadores são denominados operandos.
Parâmetros (também denominados argumentos) são espaços reservados que permitem passar
valores para funções. Por exemplo, a função welcome() a seguir usa os dois valores que recebe
nos parâmetros firstName e hobby:
function welcome(firstName:String, hobby:String):String {
var welcomeText:String = "Hello, " + firstName + ". I see you enjoy " +
hobby +".";
return welcomeText;
}
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 (consulte “Sobre pacotes” na página 242).
846 Terminologia
Scripts presos permitem prender vários scripts de vários objetos e trabalhar simultaneamente
com eles no painel Actions (Ações). Esse recurso funciona melhor com o navegador Script.
Imagens JPEG progressivas são gradualmente construídas e exibidas durante o download a
partir de um servidor. Uma imagem JPEG normal é exibida linha por linha enquanto é feito o
download a partir de um servidor.
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.
Sinais de pontuação são caracteres especiais que ajudam a formar o código do ActionScript.
Há vários sinais de pontuação de linguagem no Flash. Os tipos mais comuns de sinais de
pontuação são ponto-e-vírgula (;), dois-pontos (:), parênteses [()] e chaves ({}). Cada um
desses sinais de pontuação tem um significado especial na linguagem do Flash e ajuda a definir
tipos de dados, concluir instruções ou estruturar o ActionScript.
Script Assist é um novo modo assistido no painel Actions (Ações). O Script Assist facilita a
criação de scripts sem necessidade de conhecimento detalhado de ActionScript. Ele ajuda a
criar scripts por meio da seleção de itens da caixa de ferramentas Actions no painel Actions e
fornece uma interface com campos de texto, botões de opção e caixas de seleção para as
variáveis corretas e outros elementos de linguagem de script. Esse recurso é semelhante ao
modo normal de edições anteriores da ferramenta de criação do Flash.
Painel Script é um painel do painel Actions (Ações) ou da janela Script, e é o local onde é
digitado o código do ActionScript.
Janela Script é um ambiente de edição de códigos onde é possível criar e modificar scripts
externos, como arquivos Flash JavaScript ou ActionScript. Por exemplo, selecione File
(Arquivo) > New (Novo) e selecione ActionScript File (Arquivo do ActionScript) para usar a
janela Script para criar um arquivo de classe.
Instruções são elementos de linguagem que executam ou especificam uma ação. Por exemplo,
a instrução return retorna um resultado como um valor da função na qual é executada. A
instrução if avalia uma condição para determinar a próxima ação que deve ser executada. A
instrução switch cria uma estrutura ramificada para as instruções do ActionScript.
String é um tipo de dados. Consulte “Sobre seqüências de caracteres e a classe String”
na página 477 para obter mais informações.
Literal de seqüência de caracteres é uma seqüência de caracteres delimitados por aspas
retas. Os próprios caracteres são um valor de dados, e não uma referência aos dados. Um literal
de seqüência de caracteres não é um objeto String (Seqüência de caracteres). Para obter mais
informações, consulte “Sobre seqüências de caracteres e a classe String” na página 477.
847
Superfície é um clipe de filme, cujo sinalizador de cache de bitmap está ativo. Para obter
informações sobre cache de bitmap, consulte “Armazenando um clipe de filme em cache”
na página 393.
Sintaxe refere-se à gramática e à ortografia da linguagem de programação utilizada. O
compilador não compreende sintaxe incorreta; portanto, você verá erros ou avisos exibidos no
painel Output (Saída) ao tentar testar o documento no ambiente de teste. Assim, a sintaxe é
uma coleção de regras e diretrizes que ajudam a formar uma linguagem ActionScript correta.
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. Você pode dar um nome a uma instância de clipe de
filme no inspetor Properties (Propriedades) do clipe de filme. (A linha de tempo principal
sempre tem o nome _root.) Você pode usar um caminho de destino para direcionar uma ação
em um clipe de filme, ou para obter ou definir o valor de uma variável ou propriedade. Por
exemplo, a seguinte instrução é o caminho de destino da propriedade volume do objeto
chamado stereoControl:
stereoControl.volume
Texto equivale a 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.
Campos de texto são elementos visuais do Stage (Palco) que permitem exibir o texto para um
usuário e que podem ser criados usando a ferramenta Text (Texto) ou usando o código do
ActionScript. 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 formatado como HTML.
Formatação de texto pode ser aplicada 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.
Funções de alto nível são aquelas que não pertencem a nenhuma classe (algumas vezes
chamadas de funções predefinidas ou internas), o que significa que podem ser chamadas sem
um construtor. Exemplos de funções “internas” da linguagem ActionScript de alto nível são
trace() e setInterval();.
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.
848 Terminologia
Variáveis são identificadores que contêm valores de qualquer tipo de dados. É possível criar,
alterar e atualizar variáveis. Os valores que elas armazenam podem ser recuperados para uso
em scripts. No exemplo a seguir, os identificadores no lado esquerdo do sinal de igual
são variáveis:
var x:Number = 5;
var name:String = "Lolo";
var c_color:Color = new Color(mcinstanceName);
Para obter mais informações sobre variáveis, consulte “Sobre variáveis” na página 91.
Gráficos vetoriais descrevem as imagens através de linhas e curvas, denominadas vetores, que
também incluem propriedades de cor e posição. Cada vetor utiliza cálculos matemáticos, em
vez de bits, para descrever a forma, o que permite seu dimensionamento sem deterioração da
qualidade. Um outro tipo de gráfico é o bitmap, representado por pontos ou pixels.
849
850 Terminologia
Índice
Símbolos ActionScript 2.0

mensagens de erro do compilador 809
\" 487 ActiveX, controles 696
\’ 487 ADFs 433, 436
\b 487 ambiente de criação 841
\f 487 anexando sons 601
\n 487 animação
\r 487 brilho 553
\t 487 com filtro de brilho 526
\unnnn 487 criando uma barra de progresso 654
\xnn 487 filtros 559
_lockroot, usando 786 taxa de quadros 499, 521
_root, escopo 130 animação com script
API de desenho 581
aplicando panorâmica a imagens 506
A classes Tween e TransitionManager 509
ações assíncronas 664 criando uma barra de progresso 654
ações, padrões de codificação 782 e classe Tween 559
Actions (Ações), painel e filtro de embaçamento 559
Actions (Ações), caixa de ferramentas 37 e filtros 559
codificação em 39 interpolação de brilho 504
definida 841 movendo imagens 506
menu pop-up 42 movendo objetos 505
Navegador Script 37 sobre 498
Script, painel 38 animação, símbolos e 80
sobre 36, 37 animações
ActionScript contínuas 522
comparando versões 73 executadas continuamente 523
configurações de publicação 66 antiAliasType, propriedade 433, 437, 440
criando pontos de início com 645 API de desenho
editando preferências 44 desenhando círculos 572
Flash Player 798 desenhando curvas 569
formatação 53 desenhando formas específicas 567, 570
sobre 71, 72 desenhando linhas, curvas e formas 568
ActionScript 2,0 desenhando retângulos 570
atribuindo a classe ActionScript 2.0 a clipes de filme desenhando retângulos arredondados 571
399 desenhando triângulos 569, 572
851
e estilos de linha 574 arquivos, carregando 674
linhas e preenchimentos 606 arrastando clipes de filme 377
preenchimentos de gradiente complexos 573 array associativo, sobre 181
sobre 567 array indexado 173, 178
API do aplicativo de desenho arrays
barra de progresso 666 adicionando e removendo elementos 177
usando 666 analogia 172
API External array associativo 182
sobre 696 array associativo usando o construtor Array 184
usando 697 array associativo usando Object 183
aplicativos da Web, conexão contínua 690 associativos 181
argumentos atribuindo valores a 95
Consulte parâmetros criando 95
definição 846 e classe Object 185
em funções com nome 220 e método sortOn() 235
armazenamento de bitmap em cache elementos de 172
armazenando um clipe de filme em cache 393 exemplos de 172, 174
ativando 389 indexado 178
definida 390 iterando uma matriz 180
e máscaras de canal alfa 398 matriz 179
opaqueBackground, propriedade 390 modificando 172, 175
quando evitar 393 para criar objeto 115
quando usar 392 passar por referência 100
scrollRect 390 referência e localização de tamanho 176
sobre 389 sintaxe abreviada 172
superfícies 389 sobre 172
vantagens e desvantagens 391 usando 173
arquitetura baseada em componentes, definida 369 usando a sintaxe abreviada para criar 95
arquivo de classe ASCII, definição 477
diretrizes para organização 788 ASCII, valores 596
estruturando 788 outras teclas 822
arquivos ASO 298 teclas de função 821
excluindo 299 teclas do teclado 818
usando 298 teclas do teclado numérico 820
arquivos de classe externa aspas, em seqüências de caracteres 84
usando os caminhos de classe para localizar 255 associatividade de operadores 188
arquivos de configuração 69 associatividade e precedência de operadores 188
arquivos de diretivas atenuação
definida 736 com código 518
devem receber o nome crossdomain.xml 737 definindo 510
Consulte também segurança sobre 516
arquivos de exemplo, sobre 15 ativar a depuração remota 749
arquivos do Flash 4, abrindo com o Flash 8 826 atribuição de nome, convenções 769
arquivos FLV atribuição estrita de tipos de dados 91
Consulte tambémvídeo atribuição forte de tipos de dados 86, 91
arquivos SWF carregados atribuindo nomes a classes e objetos, melhores práticas
identificando 129 776
removendo 373 atribuindo nomes a interfaces, melhores práticas 778
arquivos XML, atualizando para instalação do Flash 8 atribuindo nomes a pacotes, melhores práticas 777
10
852 Índice
B campo de distância de exemplo de forma adaptável
(ADF) 433
balanço (som), controlando 603 campos de distância de exemplo de forma adaptável
barra de progresso 436
criando com código 654 campos de texto
e API de desenho 666 alterando dimensões 413
para o carregamento de dados 666 alterando posição 412
bitmap aplicando cascading style sheets 452
gráficos 842 carregando texto 415
texto 432 carregando variáveis em 415
BitmapData, classe controlando mídia incorporada 473
aplicando filtros a 532 criando dinamicamente durante a execução 408,
com filtro de mapa de deslocamento 563 410
efeito de ruído 562 definição 848
sobre 561 definindo a espessura 427
usando 562 dynamic 405
Boolean e texto HTML 454
tipo de dados 79 especificando dimensões de imagem 473
booleano evitando conflitos de nome de variável 410
valores 842 exibindo propriedades para depuração 763
Bounce, classe de atenuação 516 fazendo o texto fluir em torno de imagens
incorporadas 461, 465
formatação 444
C formatando com cascading style sheets 447
cache de bitmap HTML, formatação 408
e filtros 530 incorporando arquivos SWF ou de imagem 470
sobre 508 incorporando clipes de filme em 471
cache, definição 842 incorporando imagens clicáveis em 474
cacheAsBitmap, propriedade 390 manipulando 411
caixa de ferramentas Actions (Ações), itens em amarelo nomes de instâncias 409
na 54 nomes de instâncias e de variáveis comparados 409
caixa de mensagem, exibindo 694 preenchendo com texto externo 417
caminho de classe propriedades padrão 446
definida 255 sobre 405
excluir diretório de 257 Consulte tambémTextField, classe; TextFormat,
global 257 classe; e TextField.StyleSheet, classe
modificando 68 capturando pressionamentos de teclas 596
nível de documento 257 caractere de alimentação de formulário 487
pesquisar ordem de 258 caractere de aspas duplas 487
sobre 68, 74 caractere de aspas duplas, em seqüências de caracteres
caminho de destino 486
definição 848 caractere de aspas simples 487
e instâncias aninhadas 127 caractere de aspas simples, em seqüências de caracteres
e referenciando uma instância 126 486
e sintaxe de ponto 125 caractere de barra invertida 487
inserindo 65, 131 caractere de escape 487
usando 225 caractere de nova linha (newline) 487
usando o botão 131 caractere de tabulação 487
caminhos relativos 130 caracteres
adicionando e removendo incorporados 420
Índice 853
definição 842 atribuindo a clipes de filme 399
caracteres especiais 84 atribuindo a uma instância no Flash 295
caracteres incorporados atribuindo um escopo 787
adicionando e removendo 420 caminhos de classe 255
usando com campos de texto 421 chamada de métodos de objetos internos 314
carregamento classes flash.display 308
exibindo arquivos XML 419 classes flash.external 309
mídia externa 620 classes flash.filters 309
carregando dados classes flash.geom 310
do servidor 110 classes flash.net 311
variáveis 111 classes flash.text 311
cascading style sheets classes mx.lang 311
aplicando a campos de texto 452 classes System e TextField 312
aplicando classes de estilo 454 como plantas arquitetônicas 243
atribuindo estilos a marcas HTML internas 454 como tipos de dados 240
carregamento 450 comparadas a interfaces 332
combinando estilos 453 compilador resolvendo referências 258
definindo estilos no ActionScript 451 compilando e exportando 296
e a classe TextField.StyleSheet 449 controlando o acesso de membros 288
exemplo com marcas HTML 455 criando dinâmicas 274
exemplo com marcas XML 458 criando e empacotando 281
formatando texto com 447 criando métodos e propriedades 285
propriedades suportadas 448 criando personalizadas 249
usando para definir novas marcas 458 criando um arquivo de classes 259
chamando métodos 80 criando um exemplo personalizado 278
Character Embedding (Incorporação de caracteres), criando uma instância de 294
caixa de diálogo criando uma nova instância de classe interna 313
usando 425 criando uma subclasse 322
chaves, verificando pares correspondentes 59 definida 313
classe BitmapData documentação 290
usando 631 e arquivos ASO 298
classe ExternalInterface e escopo 277, 299
sobre 696 e funções construtoras 283
usando 697 e herança 319
classe FileReference e polimorfismo 327
criando um aplicativo 676 e variáveis de instância 288
e método download() 675 em comparação com pacotes 243
e segurança 675 encapsulamento 276
sobre 674 excluindo classes internas 315
Classe LoadVars exemplo de herança 322
usando 670 importando 254
verificando o status HTTP 672 importando e empacotando 292
Classe NetStream inicializando propriedades durante a execução 401
e manipulador onMetaData 650 instanciamento 240
classe NetStream internas e de nível superior 302
usando o manipulador onMetaData 650 melhores práticas para criação 279
classe XML, métodos 684 membros de classe 265
classes membros estáticos de classes internas 315
acessando propriedades internas 313 métodos e propriedades 260
atribuição de nome a arquivos de classe 280 métodos getter/setter 270
854 Índice
nível superior 304 _root, propriedade 374
organizando em pacotes 242 efeitos de fade com código 500
pré-carregando 316 excluindo 381
propriedades de 262 executando repetição em filhos 164
propriedades e métodos estáticos 264 filho, definido 369
propriedades e métodos privados 263 funções 371
propriedades e métodos públicos, privados e gerenciando profundidade 385
estáticos 262 incorporando em campos de texto 470
resolvendo referências de classe 258 inicializando propriedades durante a execução 401
sobre internas 241 iniciando e parando 591
substituindo métodos e propriedades 324 listando objetos 761
superclasse 321 listando variáveis 762
trabalhando com internas 312 métodos e funções comparadas 370
trabalhando com personalizadas 252 métodos, listados 371
usando classes personalizadas no Flash 291 métodos, usando para desenhar formas 567
usando métodos getter/setter 271 nome de instância definida 369
vantagem de usar 241 pai, definido 369
Consulte também classes internas propriedade filtros 550
classes dinâmicas 274 propriedades 376
clipes de filme propriedades, inicializando durante a execução 401
adicionando parâmetros 383 removendo 381
ajustando cor 599 tipo de dados 80
alterando cor e brilho 502 usando como máscaras 397
alterando propriedades durante a reprodução 376 Consulte também SWF, arquivos
alterando propriedades no Debugger 753 clipes de filme aninhados definidos 369
anexando a símbolo no Stage (Palco) 381 clipes de filme pai 369
anexando manipuladores on() e onClipEvent() 356 clone(), método
aninhados definidos 369 sobre 560
aplicar filtro de brilho 526 usando 561
arrastando 377 codificação de caracteres 477
ativando com teclado 598 codificando texto 61
atribuindo estados de botão a 361 código
atribuindo uma classe personalizada a 295 etapas, copiando e colando 13
background 396 exibindo números de linha 55, 56
carregando arquivos MP3 em 626 formatação 53, 54
carregando arquivos SWF e JPEG em 621 percorrendo as linhas 757
chamando métodos 371 quebra automática de linha 55, 56
chamando vários métodos 372 selecionando uma linha 755
compartilhando 381 código de objeto, definição 846
controlando 370 códigos de teclas ASCII
criadas dinamicamente, referenciando 128 obtendo 596
criando durante a execução 378 outras teclas 822
criando subclasses 399 teclado numérico 820
criando uma instância vazia 379 teclas alfabéticas e numéricas 818
detectando colisões 604 teclas de função 821
determinando profundidade de 387 coleta de lixo 791
determinando próxima profundidade disponível colisões, detectando 604
386 entre clipes de filme 605
duplicando 381 entre um clipe de filme e um ponto no Stage (Palco)
e instrução with 372 604
Índice 855
com instrução 794 sobre 143
comentários usando 144
dentro de classes 142 contadores, repetindo ação com 162, 163
desordenados 139 contornos de fontes 436
e sinalização da sintaxe por cores 140 controles do teclado
em arquivos de classe 290 e Test Movie 746
escrevendo em arquivos de classe 781 para ativar clipes de filmes 598
finais 142 convenções de atribuição de nome 769
linha única 140 Booleanas 775
melhores práticas 780 classes e objetos 776
sobre 139 funções e métodos 775
várias linhas 140 interfaces 778
comparação, operadores 200 pacotes 242, 777
compartilhando fontes variáveis 51, 772
sobre 429 convenções de codificação
componente FLVPlayback ActionScript 782
buscar ponto de início 648, 649 componentes 778
buscar uma duração especificada 647 convenções tipográficas 13
criando pontos de início para trabalhar com 645 convertendo objetos 116
e o método seek() 647 convertendo tipos de dados 76
e pontos de início 644 cores
usando pontos de início com 645 na caixa de ferramentas Actions (Ações) 54
componentes de texto 405 valores, definindo 599
componentes, convenções de codificação 778 criando objetos 313
comportamento da transição Zoom 511 criando seqüências de caracteres 486
comportamentos CSM
sobre 65 sobre 433
transição Zoom 511 sobre parâmetros 433
comunicando com o Flash Player 692 CSS. Consulte cascading style sheets
concatenando seqüências de caracteres 84 cursores, criando personalizados 594
condições CustomFormatter, classe
escrita 151 sobre 613
condições, sobre 151 usando 613
conexões de soquete
script de exemplo 691
sobre 690 D
configurações de publicação dados
ActionScript 66 definição 75
escolhendo a versão do Flash Player 74 e variáveis 75
modificando 67 organizando em objetos 114
modificando o caminho de classe 68 sobre 75
Conjunto de caracteres universais (UCS - Universal dados carregados, verificando 665
Character Set) 478 dados externos 663, 707
conjuntos de caracteres acesso entre SWFs de domínios diferentes 734, 738
criando conjunto personalizado 426 e mensagens 692
conjuntos de caracteres personalizados, criando 425, e objeto LoadVars 670
426 e objeto XMLSocket 690
constantes e scripts de servidor 668
definição 842 e XML 683
melhores práticas 775
856 Índice
enviando e carregando 664 documentação, recursos adicionais 17
recursos de segurança 727 DOM (Document Object Model, Modelo de objetos
verificando o carregamento 664 de documentos) XML 683
data drawingAPI
barra de carregamento e progresso 666 com classes Tween e TransitionManager 581
vinculando com componentes 607 duplicando clipes de filme 381
de rolagem
e cache de bitmap 508
Debug Player 745 E
Debugger edição do ActionScript
ativar a depuração remota 749 exibindo caracteres ocultos 57
botões no 758 ferramenta Find (Localizar) 58
definindo pontos de interrupção 755 importando e exportando scripts 60
Flash Debug Player 745 números de linha 55
guia Properties 753 prender scripts 63
Lista de observação 752 quebra automática de linha 55
selecionando no menu de contexto 750 realce de sintaxe 54
usando 745 referências de código 51
variáveis 750 teclas de atalho de Escape 56
Delegate, classe verificar sintaxe 59
sobre 366 editor de método de entrada
usando 366 sobre 482
depurando 745 usando 482
com instrução trace 764 Editor do ActionScript 841
de um local remoto 748 efeito de ruído 562
Debug Player 745 efeitos
listando objetos 761 aplicando panorâmica a uma imagem 506
listando variáveis 762 brilho 552
mensagens de erro do compilador 809 brilho e cor 502
propriedades de campo de texto 763 efeitos de fade 500
usando o painel Output 759 escala de cinza 503
desempenho interpolação de brilho 504
cache de bitmap 508 modos de mistura 565
e filtros 533 ruído 562
e taxa de quadros 499 efeitos de fade em objetos 500
desenhando efeitos. Consulte filtros
com código 567 elementos, de um array 172
detectando colisões 604 eliminação de serrilhado personalizada
dicas de ferramenta. Consulte referências de código definição 432
dimensionamento em 9 trechos encapsulamento
ativando 585 sobre 248
noções básicas 583 usando 276
propriedade scale9Grid 585 endereços IP
sobre 583 arquivos de diretivas 737
usando 585 segurança 728
distinção entre maiúsculas e minúsculas enviando informações
e versão do Flash Player 123 em formato XML 664
sobre 122 formato de código URL 664
do..while, loops 170 para arquivos remotos 664
documentação PDF, onde encontrar 15
Índice 857
via TCP/IP 664 expressões condicionais 160
equilíbrio da pontuação, verificando 59 Extensible Markup Language. Consulte XML
erro de falta de memória 533
Escape, teclas de atalho de 56
escopo F
em classes 787 filho
melhores práticas 784 clipes de filme, definidos 369
sobre 130 nó 683
this, palavra-chave 365 filtro de brilho
escrevendo o ActionScript animar 526
com instrução 794 sobre 542
prefixo super 792 usando 542
trace 792 filtro de brilho gradiente
escrevendo sintaxe e instruções sobre 543
ouvinte 806 usando 543
return 805 filtro de chanfro
switch 805 sobre 545
especificação ECMA-262 121 usando 545
estilos filtro de chanfro gradiente
linha 574 aplicando 551
traço e acabamento 574 aplicando a um clipe de filme 551
estilos de acabamento array de cores 548
definindo 575 array de proporções 548
sobre 574 distribuição de cores 548
estilos de acabamento, definindo 574 e preenchimento 547
estilos de linha e preenchimento do clipe de filme 550
alfa 577 e propriedade strength 547
capsStyle e jointStyle 578 e propriedades blurX e blurY 547
cor 577 e propriedades knockout e type 547
dimensionando 578 e realce 550
e API de desenho 574 sobre 547
espessura 576 usando 549
estilos de traço e acabamento 574 valor de proporção e ângulo 550
miterLimit 581 filtro de convolução
parâmetros 576 sobre 554
pixelHinting 577 sobre a aplicação 554
sobre 574 usando 555
estilos de traço 574 filtro de embaçamento
estilos, traço e acabamento 574 animado com a classe Tween 559
evento do usuário 347 sobre 536
eventos usando e animando 536
definição 843 filtro de mapa de deslocamento
definidos 347 aplicando a uma imagem 563
e clipes de filme 399 com classe BitmapData 563
transmitindo 360 sobre 556
exibidores antigos, especificando 825 usando 556
exportando scripts e codificação de idioma 61 filtro de matriz de cores
expressões sobre 552
definição 844 usando 503, 552
manipulando valores em 185
858 Índice
filtro de sombreamento recursos novos e alterados do editor do ActionScript
animando 540 28
aplicando a uma imagem transparente 541 Flash Player, recipiente
e método clone() 560 definição 844
sobre 538 Flash Video
usando 538 Consulte vídeo
filtros FlashType
ajustando propriedades 558 sobre 430
alterando o nível de brilho 553 suporte ao Flash Player 430
animando 559 FlashVars
aplicando a instâncias 532 sobre 415
array 558 usando para exibir texto 416
definindo 526 FlashVars, propriedade
e ActionScript 534 sobre 415
e desempenho 533 FLV, arquivos
e erro de falta de memória 533 carregando arquivos externos durante a execução
e manipulação de erros 533 635
e transparência 534 configurando o servidor para FLV 652
e uso da memória 533 criando uma barra de progresso 659
filtro de brilho 526 criando uma faixa FLV 636
girando e inclinando 531 e Macintosh 653
girando, inclinando e dimensionando 532 metadados 650
manipulando com código 557 navegando com código 647
modificando propriedades 530 pontos de início 640, 641
noções básicas sobre pacotes 528 pré-carregando 639
obtendo e definindo 530 pré-carregando vídeo externo 639
ruído 562 trabalhando com pontos de início 643
Flash 8, recursos novos e alterados do ActionScript 19 vídeo externo 633
Flash Player folhas de estilos. Consulte cascading style sheets
classes, sobre 303 fontes
comunicando com 692 adicionando e removendo 420
configurações de publicação 74 compartilhando 429
dimensionando arquivo SWF para 693 definição 420
e ActionScript 798 sobre 420
exibição normal de menu 693 valores-limite 436
exibindo em tela cheia 693 fontes de dispositivo
exibindo ou esmaecendo o menu de contexto 693 definição 432, 843
métodos 696 mascarando 398
obtendo a versão mais recente 765 fontes incorporadas
padrões de codificação 798 incorporando um símbolo de fonte 423
versão de depuração 746 usando com a classe TextField 427
Flash Player 4 for, loops 166
criando conteúdo para 826 exemplo 180
Flash Player 7 for..in, loops 167
novo modelo de segurança 729, 736, 742 formatação de texto
portando scripts existentes 708 definição 848
Flash Player 8 sobre 439
elementos de linguagem novos e alterados 22 formatadores personalizados
elementos de linguagem obsoletos 28 sobre 612
usando 612
Índice 859
formatando código 53, 54 sintaxe de função com nome 214
formatando texto sobre 213
usando 440 tipos de 215
formato de código URL, enviando informações 664 usando no Flash 227
formato MIME, padrão 669 usando uma função com nome 219
fscommand(), função usando variáveis em 230
comandos e argumentos 693 funções com nome 220
comunicando com o Director 695 funções com nomes
usando 692 definição 846
função funções construtoras
bloco de função 219 criando 223
função anônima definição 842
criando 220 exemplo 830
definida 841 funções de conversão e tipos de dados 76
usando 222 funções de nível superior
função loadMovie() 665 definição 848
função loadVariables() 665 funções de retorno de chamada
funções criando 221
aninhadas 234 definição 842
assíncronos 664 funções definidas pelo usuário
atribuindo nome 226 criando 225
bloco de função 220 definição 848
chamando funções de nível superior 218 funções internas 217
como caixa preta 214 funções personalizadas 213
comparando com nome e anônimas 228
constructor 830
construtoras 223 G
conversão 76 getAscii(), método 596
criando e chamando 227 getURL(), método 592
criando funções anônimas 220 global, variáveis 102
criando funções com nome 219 glyphRange, nó, sobre 425
definição 844 gráficos vetoriais 849
definindo 224
definindo globais e de timeline 224
em comparação com métodos 236 H
em um arquivo de classe 229 herança
especificando e chamando funções definidas pelo e programação orientada a objeto (OOP) 247
usuário 225 e subclasses 320
exemplo 846 exemplo 322
formato padrão para funções com nome 219 sobre 319
internas e de nível superior 217 hitTest(), método 604
literal de função 222 HTML
melhores práticas 795 atribuindo estilos a marcas internas 454
nível superior 216 campo de texto 408
para controlar clipes de filme 371 exemplo de uso com estilos 455
passando parâmetros para 231 marcas entre aspas 462
personalizadas 213 marcas suportadas 462
retornando valores de 233 usando a marca <img> para fazer o texto fluir 461,
retorno de chamada 221 465, 470
reutilizando 227
860 Índice
usando cascading style sheets para definir marcas e programação orientada a objeto (OOP) 246
458 referenciando 126
usando em campos de texto 461 instrução return 805
HTTP, protocolo instrução try..catch..finally, escrevendo 158, 806
com métodos do ActionScript 664 instruções
comunicando com scripts de servidor 668 compostas 150
HTTPS, protocolo 664 compostos 804
condicionais 152
condicional 802
I definição 120, 847
ícones diretrizes para escrever 149
acima do painel Script 40 for 804
no Debugger 758 if 152
IDE (Integrated Development Environment, Ambiente if..else 153
de desenvolvimento integrado), definição 844 if..else if 154
identificadores definidos 844 importando 245
idiomas, usando vários em scripts 61 instruções trace 764
igualdade, operadores 200 sobre 149
imagem em escala de cinza 503 switch 156
imagem JPEG progressiva, definição 847 try..catch..finally 158, 806
imagens while e do while 805
aplicando modos de mistura 565 with 794
carregando em clipes de filme 375 instruções compostas 150
Consulte também mídia externa escrevendo 804
incorporando em campos de texto 470 instruções condicionais
IME (Input Method Editor, Editor de método de escrevendo 802
entrada) instruções for, escrevendo 804
sobre 482 instruções if..else if, escrevendo 154
usando 482 instruções if..else, escrevendo 153
import instruções switch
sobre a instrução 528 convenções 805
usando caractere curinga 529 usando 156
várias classes de um pacote 528 instruções trace, escrevendo o ActionScript 792
importando interatividade em arquivos SWF
arquivos de classe 254 criando 589
scripts e codificação de idioma 61 técnicas para 593
indo para um URL 592 interfaces
informações, transferindo entre arquivos SWF 664 atribuindo nome 334
inicialização, escrevendo o ActionScript 790 criando 335
inicializando propriedades de clipe de filme 401 criando como tipo de dados 337
instanciamento definindo e implementando 334
de objetos 313 e programação orientada a objeto (OOP) 247
definida 240 exemplo 340
instâncias 500 exemplo de interface complexa 342
aninhadas, referenciando 127 noções básicas de herança e 339
aplicando filtros a 532 sobre 331
definição 845 interpolações
definida 313 adicionando com comportamentos 511
dinâmicas, referenciando 128 adicionando com o ActionScript 513
interrompendo (percorrendo) código 757
Índice 861
interrompendo clipes de filme 591 usando 162
while 169
J
janela Script M
codificação em 39 Macromedia Director, comunicando com 695
opções de menu 42 manipulação de erros e filtros 533
sobre 36, 38 manipuladores. Consulte manipuladores de eventos
JavaScript manipulando números 82
e ActionScript 121 marcas de ID3 630
e Netscape 695 máscaras 397
enviando mensagens para 694 e fontes de dispositivo 398
instrução alert 764 e máscaras de canal alfa 398
padrão internacional 121 escrevendo scripts para criar 581
JPEG, arquivos traços ignorados 397, 567
carregando em clipes de filme 375, 621 máscaras de canal alfa 398
incorporando em campos de texto 470 matrizes
sobre 178
usando um loop for 180
L matrizes, sobre 178
layout de texto 439 MediaPlayback, componente
liberando scripts no painel Actions (Ações) 64 usando pontos de início com 646
linhas 574 melhores práticas
Linkage Properties (Propriedades de vinculação), caixa atribuindo nome a variáveis 772
de diálogo 381, 399 Booleanas, atribuindo nomes 775
List Objects (Listar Objetos), comando 761 classes e objetos, atribuindo nomes 776
List Variables (Listar Variáveis), comando 762 comentários 780
literais de função comentários em classes 781
definição 844 convenções de codificação 769
literais, definição 845 escopo 784
literal de array 178 funções 795
literal de função funções e métodos, atribuindo nomes 775
redefinindo 223 interfaces, atribuindo nomes 778
sobre 222 nomes a constantes, atribuindo 775
literal de objeto 184 pacotes, atribuindo nomes 777
literal de seqüência de caracteres 847 membros (métodos e propriedades)
LiveDocs, sobre 16 públicos, privados e estáticos 262
LoadVars, classe membros de classe 246, 315
carregando variáveis de arquivo de texto 418 sobre 246
usando para exibir texto 417 membros estáticos 315
Locale, classe membros estáticos. Consulte membros de classe
sobre 480 mensagens de erro 809
usando 480 metadados
loops sobre 650
aninhados 171 usando 650
criando e terminando 165 métodos
do..while 170 assíncronos 664
for 166 atribuindo nome 237
for..in 167 de objetos, chamando 314
862 Índice
definição 845 sobre 564
definida 235 modos de mistura.Consulte modos de mistura
e arrays 235 modulação de traço contínua 433
em comparação com funções 236 mouse, ponteiro do. Consulte cursores
para controlar clipes de filme 371 MovieClip, classe
private 263 ajustando a propriedade filters 558
públicos 262 e propriedade scale9Grid 585
sobre 213, 235 métodos de desenho 567
static 264 propriedade blendMode 564
tipos de 215 propriedade filters 530
métodos de desenho moviename_DoFSCommand, função 694
Consulte também API de desenho MP3, arquivos
métodos getter carregamento 626, 627
sobre 270 carregando em clipes de filme 626
usando 271 criando uma barra de progresso 657
métodos manipuladores de eventos lendo marcas de ID3 630
anexação a objetos 359 marcas de ID3 630
anexando a botões ou clipes de filme 355 pré-carregando 628, 639
atribuindo funções a 350
definição 844
definidos 347 N
definidos por classes do ActionScript 348 navegação
e manipuladores on() e onClipEvent() 355 controlando 589
escopo 362 indo para quadro ou cena 591
no ActionScript 2.0 365 Navegador Script 37
verificando dados XML 665 Netscape, métodos JavaScript suportados 695
métodos setter níveis
sobre 270 carregando 373
usando 271 níveis, identificando a profundidade 129
mídia externa 619 nome totalmente qualificado
carregando arquivos MP3 657 definindo 528
carregando arquivos SWF e de imagem 655 usando 528
carregando arquivos SWF e JPEG 621 nomes de domínio e segurança 728
carregando imagens e arquivos SWF 621 nomes de instância
componente ProgressBar 624 e caminhos de destino 125
criando animações da barra de progresso 654 nomes de instâncias
e a timeline raiz 625 comparados com nomes de variáveis 409
motivos para usar 619 definição 845
MP3, arquivos 626 definida 369
pré-carregando 639, 654 nós 683
reproduzindo arquivos FLV 633 null, tipo de dados 81
sobre o carregamento 620 números de linha em código, exibindo 55, 56
modelo de evento números, manipulando com métodos 82
para manipuladores on() e onClipEvent() 355
para métodos manipuladores de eventos 349
para ouvintes de eventos 351 O
modo Script Assist objeto LoadVars, criando 670
sobre 62 objeto transmissor 351
modos de mistura objeto XMLSocket
aplicando 565
Índice 863
loadPolicyFile 740 obsoletos 815
métodos 691 operandos 186
usando 690 pós-fixados 196
verificando dados 665 precedência e associatividade 188
objetos relacionais 200
acessando propriedades 313 relacionais e de igualdade 200
chamando métodos 314 sobre 185
criando 95, 114, 313 unários 197
criando no Flash 114 usando com seqüências de caracteres 192
definição 846 usando no Flash 210
efeito fade-out 500 operadores de acesso de array, verificando pares
executando repetição em filhos de 164 correspondentes 59
organizando dados em arrays 115 operadores Flash 4 obsoletos 815
padrões de codificação 783 operadores relacionais 200
tipo de dados 83 operandos 186
objetos ouvintes 351 ordem de execução (operador)
cancelando o registro 352 associatividade de operadores 188
obtendo a posição do ponteiro do mouse 595 precedência de operadores 188
obtendo informações de arquivos remotos 664 ordem de operação 567
on() e onClipEvent(), manipuladores 355 organização de scripts
anexando a clipes de filme 356 anexação a objetos 783
escopo 362 convenções de codificação 782
onEnterFrame, e taxa de quadros 499 organizando scripts
opaqueBackground, propriedade ActionScript 1.0 e ActionScript 2.0 73
definida 390 origens externas, conectando o Flash com 663, 707
usando 396 Output (Saída), painel 759
opção Pin Script (Prender script) no painel Actions conteúdo, copiando 760
(Ações) 64 e instrução trace 764
opções de renderização de texto 432 exibindo 760
opções de sinalização da sintaxe por cores, definindo no List Objects (Listar Objetos), comando 761
painel Actions (Ações) 55 List Variables (Listar Variáveis), comando 762
operador condicional 160 opções 760
operadores ouvintes de eventos 351
aditivos 198 classes que podem transmitir 351
associatividade 188 escopo 362
combinando com valores 185
comparação 193
condicionais 160, 200, 210 P
de atribuição 187, 204 pacotes
de atribuição, usando 204 atribuindo nome 242
de igualdade 200 definição 846
de ponto e acesso de array 194 em comparação com classes 243
definição 846 importando 245
deslocamento bit a bit 207 sobre 242
expressões matemáticas 185 trabalhando com 244, 528
lógicos 205, 206 padrão de design Singleton 267
lógicos bit a bit 208 padrões de design
manipulando valores 187 encapsulamento 276
multiplicativos 197 Singleton 267
numéricos 198
864 Índice
palavra-chave extends 321 prendendo scripts
sintaxe 321 definição 847
sobre 321 na Timeline 63
palavra-chave interface 333 prendendo um script 64
palavras reservadas pressionamentos de teclas, capturando 596
Consulte também palavras-chave profundidade
lista 147 definida 385
nomes de classe interna 148 determinando instância em 387
outras recomendações 149 determinando para clipes de filme 387
palavras reservadas futuras 148 determinando próxima disponível 386
sobre 147 gerenciando 385
palavras-chave programação orientada a objeto 246
_root 131 Programação orientada a objeto (OOP)
definição 845 criando classes personalizadas 249
extends 321 design 276
interface 333 e encapsulamento 248
lista 147 e herança 247
sobre 143 e interfaces 247
this 130 e objetos 246
usando 146 e polimorfismo 249
parâmetros 219, 846 instâncias e membros de classe 246
parênteses, verificando pares correspondentes 59 sobre 240, 246
percorrendo as linhas de código 757 Programação orientada a objeto. Consulte Programação
polimorfismo orientada a objeto (OOP)
sobre 249 projetores, executando aplicativos em 693
usando 327 Properties, guia do Debugger 753
ponteiro. Consulte cursores propriedade FlashVars
ponto de registro e imagens carregadas 375 usando 109
pontos de início propriedades
criando 645 de clipes de filme 376
exibindo 643 de objetos, acessando 313
navegação, evento e ActionScript 641 definição 847
rastreando 641 inicializando durante a execução 401
trabalhando com 643 private 263
usando 640 public 262
pontos de interrupção static 264
definindo no Debugger 755 propriedades de objetos
e arquivos externos 755 atribuindo valores a 313
sobre 755
XML, arquivo 756
pontos de interrupção, definindo e removendo Q
na janela Script 755 quebra automática de linha em código, ativando 55,
no painel Actions (Ações) 755 56
pontos finais 611
posição do mouse, obtendo 595
práticas recomendadas R
ActionScript 1 e ActionScript 2.0 73 propriedade _root e clipes de filme carregados 374
preferência Default Encoding 61 recuo no código, ativando 54
prefixo super 792 recursos adicionais 14
prefixos, super 792
Índice 865
recursos on-line 17 prendendo no lugar 63
referência scripts de quadro 33
e escopo 130 sobre eventos 32
referenciando testando 745
conteúdo carregado 128 scripts de quadro
referências de código 47 sobre 33
ativando 47, 51, 53 scripts de quadros
especificando configurações para 48 definição 844
exibindo manualmente 50 scripts do servidor
sobre 47 criando 680
usando 48 formato XML 685
removendo linguagens 664
arquivos SWF carregados 373 scrollRect, propriedade 390
clipes de filme 381 segurança
renderização de fontes acesso a dados entre domínios 734
métodos 431 compatibilidade do Flash Player 708
opções 432 e arquivos de diretivas 736
sobre 430 e portando scripts para o Flash Player 7 729, 736,
repetindo ações, usando loops 162 742
repetindo instruções 162, 163 entre domínios 727
reproduzindo clipes de filme 591 loadPolicyFile 738, 740
RGBA (RGB com alfa) 552 sem serrilhado
rolagem definição 841
texto 475 para animação e legibilidade 432
senhas e depuração remota 748
seqüências de caracteres 84
S analisando 488
scale-9 comparando 488
sobre 583 comparando com outros tipos de dados 490
scale-9. Consulte dimensionamento em 9 trechos convertendo e concatenando 491
Script Assist, modo convertendo maiúsculas/minúsculas 492
definição 847 criando 486
Script, janela criando um array de subseqüências de caracteres
definição 847 493
sobre o arquivo XML de pontos de interrupção 756 definição 478, 847
Script, painel determinando o comprimento 488
botões acima 40 encontrando a posição do caractere 495
definição 847 encontrando a subseqüência de caracteres 494
scripts examinando caracteres 489
atalhos de teclado para scripts presos 64 forçando comparações de tipos 491
corrigindo problemas de exibição de texto 61 repetindo em 489
criando para manipular eventos 35 retornando subseqüências de caracteres 494
depurando 745 sobre 477
eventos de clipe 33 usando 486
eventos de teclado 33 seqüências de caracteres. Consulte seqüências de
importando e exportando 61 caracteres
onde criar 31 seqüências de escape 84
organizando códigos 34 serrilhado, definição 841
portando para o Flash Player 7 708 Servidor Web IIS 6.0 653
servidores, abrindo conexão contínua 690
866 Índice
setInterval carregando e descarregando 373
e taxa de quadros 499 carregando em clipes de filme 621
usando 501 controlando no Flash Player 696
setRGB, método 599 criando controles de som 601
símbolos de fonte, incorporando 423 escalando para o Flash Player 693
sintaxe incorporando em campos de texto 470
de barra 131 indo para quadro ou cena 591
distinção entre maiúsculas e minúsculas 123, 124 inserindo em página da Web 592
verificando 59 mantendo o tamanho original 693
sintaxe de barra transferindo informações entre 664
não suportada no ActionScript 2.0 131 Consulte também clipes de filme
sobre 131
usando 828
sintaxe de ponto (notação de ponto) 125 T
sintaxe do ouvinte 806 tabelas de fontes
sintaxe pós-dois-pontos, definição 87 criando 437
sistema definindo 436
evento, definido 347 valores-limite 436
requisitos, para o ActionScript 2.0 9 taxa de quadros
sites com a classe Tween 521
depurando 748 e onEnterFrame 499
remotos, comunicando com 664 escolhendo 499
remotos, conexão contínua 690 sobre 499
solucionando problemas. Consulte depurando TCP/IP, conexão
sons com objeto XMLSocket 691
anexando à Timeline 601 enviando informações 664
Consulte também mídia externa tecla Tab e Test Movie 746
controlando 601 teclado
controle de balanço 603 atalhos para scripts presos 64
Stage (Palco), anexando símbolos a 381 valores de códigos de teclas ASCII 818
String, classe teclado numérico, valores de códigos de teclas ASCII
concat(), método 493 820
e métodos substr() and substring() 494 teclas de função, valores de códigos de teclas ASCII
length, propriedade 488, 491 821
método charAt() 489 tempo de compilação, definido 13
método toString() 491 tempo de execução, definido 13
sobre 477, 485 terminologia, ActionScript 841
split(), método 493 Test Movie
toLowerCase() e toUpperCase(), métodos 492 e controles do teclado 746
Strings (Seqüências de caracteres), painel 479 e Unicode 746
subclasses testando. Consulte depurando
criando 321 TextField, classe
criando para clipes de filme 399 criando texto de rolagem 475
exemplo 322 usando 406
subclasses, sobre 320 TextField, métodos, usando 427
superclasse 321 TextField.StyleSheet, classe 447
superfícies criando estilos de texto 451
cache de bitmap 848 e cascading style sheets 449
definida 389 e propriedade TextField.styleSheet 447, 452
SWF, arquivos
Índice 867
TextFormat, classe definição 76, 843
sobre 439 determinando o tipo 90
usando 444 e valores 245
texto MovieClip 80
atribuindo a campo de texto durante a execução null 81
407 Number 82
carregando e exibindo 416, 417, 419 Object 83
codificando 61 primitivos 77
definição 848 String 84
rolagem 475 undefined 85
terminologia 403 void 85
usando a marca <img> para fazer o texto fluir em traços
torno das imagens 465 definindo estilos 574
Consulte também campos de texto definindo parâmetros 576
texto de entrada 405 transferindo variáveis entre filme e servidor 670
texto dinâmico 405 transições
texto estático 405 adicionando com comportamentos 511
texto sem serrilhado adicionando com o ActionScript 513
criando tabela 437 definindo 512
definição, propriedade 440 Transition, classe
definindo a propriedade antiAliasType 433 animando o nível de brilho 553
espessura 440 TransitionManager, classe
limitações 431 com a classe Tween 524
modificando definição e espessura 440 com API de desenho 581
sobre 430 e atenuação 510
suporte 431 sobre 509
suporte ao Flash Player 430 usando 513
usando 433 transparência, e máscaras 398
valor avançado 433 Tween, classe
valor normal 433 animando filtros de embaçamento 559
this, palavra-chave 130, 617 animando o nível de brilho 553
como prefixo 790 com a classe TransitionManager 524
e escopo 130 com API de desenho 581
em classes 277 definindo a duração de quadros 520
escopo 277 e atenuação 510
usando 786 efeitos de fade em objetos com 519
tipo de dados complexo (valor de dados) 77 importando 518
tipo de dados MovieClip, definição 80 manipulador de eventos onMotionFinished 523
tipo de dados primitivo (valor de dados) 77 método continueTo() 522, 524
tipo de dados Void 85 método yoyo() 523, 524
tipo MIME 652 para ativar a animação concluída 521
tipos de ajustes à grade, usando 442 propriedade _alpha 524
tipos de dados sobre 509, 517
anotações 91 usando 513, 518
atribuindo 87
atribuindo automaticamente 85
básicos 76 U
Boolean 79 UCS (Universal Character Set, Conjunto de caracteres
complexos 77 universais), definição 478
convertendo 76
868 Índice
undefined, tipo de dados 85 valores padrão 93
Unicode variáveis de URL, sobre 106
código de caracteres 477 variáveis globais 102
definição 478 variável de timeline, sobre 103
e o comando Test Movie 746 variável local, sobre 104
suporte 61 vários idiomas, usando em scripts 61
UTF-16, padrão de codificação 478 verificação de tipo
UTF-8 (Unicode) 61, 478 definição 89
dinâmica 90
exemplo 89
V verificando
valores dados carregados 665
e tipos de dados 245 sintaxe e pontuação 59
manipulando em expressões 185 vídeo
Variables (Variáveis), guia do Debugger 750 adicionando a funcionalidade de busca 647
variáveis buscar ponto de início 648, 649
alterando o valor 94 buscar uma duração especificada 647
atribuindo nome 51 configurando o servidor para FLV 652
atribuindo valores 93 criando arquivos FLV 633
carregando 106, 110 criando um objeto de vídeo 634
carregando do arquivo de texto externo 418 criando uma barra de progresso para carregar FLV
carregando em campos de texto 415 659
codificadas em URL 106 criando uma faixa 636
comparando indefinidas e definidas 98 e Macintosh 653
convertendo em XML 685 metadados 650
declarando 93 navegando em um arquivo FLV 647
definição 91, 849 pontos de início 640
definindo através de um caminho 129 pré-carregando 639
diretrizes e regras de atribuição de nome 96 rastreando pontos de início 641
e escopo 101 reproduzindo arquivos FLV durante a execução 635
e guia Debugger Variables (Variáveis do depurador) sobre 632
750 sobre arquivos FLV externos 633
e lista de observação do Debugger 752 trabalhando com pontos de início 643
e operadores 96 usando o manipulador onMetaData 650
enviando para URL 592 Vídeo FLV. Consulte vídeo
evitando conflitos de nome 410 vídeo, alternativa para importação 633
instância 288 View Options (Opções de exibição), menu pop-up 55,
locais 104 56, 57
modificando no Debugger 751 vinculação
passando de HTML 416 convenções de codificação 778
passando por referência 100 identificador 381, 399
passando valores de uma seqüência de caracteres de vinculação de dados durante a execução
URL 106 com CheckBox 611
timeline 103 criando uma vinculação bidirecional 610
transferindo entre clipe de filme e servidor 670 sobre 607
usando 99 vinculação de dados, com o ActionScript 607
usando em um aplicativo 97 vinculações
usando em um projeto 111 criando com o ActionScript 608
usando FlashVars para passar 109 criando uma vinculação bidirecional 610
criando uma vinculação unidirecional 608
Índice 869
vinculando clipes de filme 381
vinculando componentes com o ActionScript 615
volume, criando controle deslizante 602
W
Watch (Observação), guia do Debugger 752
while, loops 169
X
XLIFF, arquivos 480
XML 683
carregando e exibindo texto 419
conversão de variáveis de exemplo 684
DOM 683
em scripts do servidor 685
enviando informações com métodos XML 664
enviando informações via soquete TCP/IP 664
exemplo de uso com estilos 458
hierarquia 683
XML Localization Interchange File Format (XLIFF)
480
870 Índice

Biblia Flash 8 Learning Action Script 2

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Biblia Flash 8 Learning Action Script 2

Enviado por

Direitos autorais:

Formatos disponíveis

Aprendendo ActionScript 2.

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

Capítulo 1: Novidades do ActionScript no Flash 8 . . . . . . . . . . . . 19

Capítulo 2: Escrevendo e editando o ActionScript 2.0 . . . . . . . . 31

Capítulo 3: Sobre o ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . 71

Capítulo 5: Fundamentos da sintaxe e da linguagem . . . . . . . . 119

Capítulo 6: Funções e métodos . . . . . . . . . . . . . . . . . . . . . . . . . . 213

Capítulo 7: Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239

Capítulo 8: Herança . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319

Capítulo 10: Manipulando eventos . . . . . . . . . . . . . . . . . . . . . . . 347

Capítulo 11: Trabalhando com clipes de filme . . . . . . . . . . . . . . 369

Capítulo 12: Trabalhando com texto e seqüências

Capítulo 13: Animação, filtros e desenhos . . . . . . . . . . . . . . . . . 497

Capítulo 14: Criando interação com o ActionScript . . . . . . . . . 589

Capítulo 15: Trabalhando com imagens, som e vídeo . . . . . . . . 619

Capítulo 17: Noções básicas de segurança . . . . . . . . . . . . . . . . 707

Capítulo 18: Depurando aplicativos . . . . . . . . . . . . . . . . . . . . . . 745

Capítulo 19: Melhores práticas e convenções de codificação

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

Apêndice D: Criando scripts para versões anteriores do Flash

Apêndice F: Terminologia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 841

O Macromedia Flash Basic 8 e o Macromedia Flash Professional 8 são as ferramentas de

Atualizando arquivos XML para Flash

Termos usados neste documento

Copiar e colar código

Onde encontrar arquivos PDF ou documentação

Onde encontrar documentação sobre outros

Novidades do ActionScript 2.0 e do

20 Novidades do ActionScript no Flash 8

Novidades do ActionScript 2.0 e do Flash 8 21

Acréscimos à linguagem ActionScript

22 Novidades do ActionScript no Flash 8

No Flash 8 foi adicionado suporte oficial para a classe AsBroadcaster.

Novidades do ActionScript 2.0 e do Flash 8 23

24 Novidades do ActionScript no Flash 8

Novidades do ActionScript 2.0 e do Flash 8 25

26 Novidades do ActionScript no Flash 8

Novidades do ActionScript 2.0 e do Flash 8 27

Alterações de edição do ActionScript

28 Novidades do ActionScript no Flash 8

Alterações no modelo de segurança para

Nesta descrição, um arquivo SWF local é um arquivo SWF instalado localmente no

Alterações no modelo de segurança para arquivos SWF instalados localmente 29

30 Novidades do ActionScript no Flash 8

Sobre o ActionScript e eventos

32 Escrevendo e editando o ActionScript 2.0

Ao interromper arquivo SWF em um quadro-chave específico, você precisará executar uma

Sobre o ActionScript e eventos 33

34 Escrevendo e editando o ActionScript 2.0

O código do ActionScript em arquivos externos é compilado em um arquivo SWF

Sobre a criação de scripts para manipular eventos

Organizando o código ActionScript 35

Para exibir o painel Actions, siga um destes procedimentos:

Para exibir a janela Script, siga um destes procedimentos:

36 Escrevendo e editando o ActionScript 2.0

Sobre o painel Actions 37

Sobre a janela Script

38 Escrevendo e editando o ActionScript 2.0

Para exibir a janela Script:

Sobre a codificação no painel Actions e