MACROMEDIA FLASH 8-FORMATION ACTIONSCRIPT 2.0 DANS FLASH Manuel utilisateur

Formation à ActionScript 2.0 dans Flash
Marques de commerce
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 et WebHelp sont des marques de commerce ou des marques déposées de Macromedia, Inc. qui peuvent
être déposées aux Etats-Unis et/ou dans d’autres juridictions ou pays. Les autres noms de produits, logos, graphiques, mises en
page, titres, mots ou expressions mentionnés dans cette publication peuvent être des marques de commerce, des marques de
service ou des noms de marque appartenant à Macromedia, Inc. ou à d’autres entités et peuvent être déposés dans certaines
juridictions ou pays.
Autres marques mentionnées
Ce guide contient des liens vers des sites Web qui ne sont pas sous le contrôle de Macromedia, qui n’est donc aucunement
responsable de leur contenu. L’accès à ces sites se fait sous votre seule responsabilité. Macromedia mentionne ces liens pour
référence, ce qui n’implique pas son soutien, accord ou responsabilité quant au contenu des sites.
Technologie de compression et décompression audio discours utilisée sous licence de Nellymoser, Inc. (www.nellymoser.com).
Technologie de compression et décompression vidéo Sorenson™ Spark™ utilisée sous licence de
Sorenson Media, Inc.
Navigateur Opera ® Copyright © 1995-2002 Opera Software ASA et ses fournisseurs. Tous droits réservés.
La technologie vidéo Macromedia Flash 8 est optimisée par la technologie vidéo On2 TrueMotion. © 1992-2005 On2
Technologies, Inc. Tous droits réservés. http://www.on2.com.
Visual SourceSafe est une marque déposée ou une marque de commerce de Microsoft Corporation aux Etats-Unis et/ou dans
d’autres pays.
Copyright © 2005 Macromedia, Inc. Tous droits réservés. La copie, photocopie, reproduction, traduction ou conversion
de ce manuel, sous quelque forme que ce soit, mécanique ou électronique, est interdite sans une autorisation préalable
écrite de Macromedia, Inc. Le propriétaire ou l’utilisateur autorisé d’une copie valide du logiciel qu’accompagne ce
manuel peut néanmoins imprimer une copie de ce dernier à partir d’une version électronique afin d’apprendre à utiliser le
logiciel, à condition qu’aucune partie de ce manuel ne soit imprimée, reproduite, distribuée, revendue ou cédée dans un
autre but, y compris, mais sans limitation aucune, dans un but commercial, tel que la revente de copies de cette
documentation ou l’offre de services de maintenance rémunérés.
Remerciements
Gestion du projet : Sheila McGinn
Rédaction : Jen deHaan, Peter deHaan, Joey Lott
Rédactrice en chef : Rosana Francescato
Rédactrice en chef : Lisa Stanziano
Révision : Linda Adler, Geta Carlson, Evelyn Eldridge, John Hammett, Mary Kraemer, Noreen Maher, Jessie Wood, Anne Szabla
Gestion de la production : Patrice O’Neill, Kristin Conradi, Yuko Yagi
Conception et production des supports : Adam Barnett, Aaron Begley, Paul Benkman. John Francis, Geeta Karmarkar, Masayo
Noda, Paul Rangel, Arena Reed, Mario Reynoso
Remerciements particuliers à Jody Bleyle, Mary Burger, Lisa Friendly, Stephanie Gowin, Bonnie Loo, Mary Ann Walsh, Erick
Vera, aux testeurs des versions bêta et aux équipes d’ingénieurs et d’assurance qualité de Flash et Flash Player.
Première édition : Septembre 2005
Macromedia, Inc.
601 Townsend St.
San Francisco, CA 94103, Etats-Unis
Table des matières
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Public visé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Configuration système requise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Mise à jour des fichiers XML Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Présentation de la documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11
Ressources supplémentaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Chapitre 1 : Nouveautés du langage ActionScript de Flash 8 . . . 19
Nouveau dans ActionScript 2.0 et Flash 8. . . . . . . . . . . . . . . . . . . . . . . . 19
Modifications du modèle de sécurité pour les fichiers SWF
installés localement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Chapitre 2 : Ecriture et modification du code ActionScript 2.0 . 31
ActionScript et les événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Organisation du code ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Utilisation du panneau Actions et de la fenêtre de script. . . . . . . . . . . 36
Présentation du panneau Actions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37
Présentation de la fenêtre de script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Programmation dans le panneau Actions et la fenêtre de script . . . . 40
Présentation des fonctionnalités du panneau Actions . . . . . . . . . . . . . 63
Présentation des comportements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .67
Présentation des paramètres de publication ActionScript . . . . . . . . . 68
Chapitre 3 : A propos d’ActionScript . . . . . . . . . . . . . . . . . . . . . . .73
Présentation d’ActionScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .74
Différences entre ActionScript 1.0 et ActionScript 2.0 . . . . . . . . . . . .75
Présentation d’ActionScript et de Flash Player. . . . . . . . . . . . . . . . . . . .76
3
Chapitre 4 : Données et types de données . . . . . . . . . . . . . . . . . . 77
A propos des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Présentation des types de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Présentation des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Organisation des données dans des objets . . . . . . . . . . . . . . . . . . . . . . . 118
Attribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .121
Chapitre 5 : Eléments fondamentaux du langage et de la
syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
Présentation de la syntaxe, des instructions et des expressions . . . 124
Syntaxe à point et chemins cible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Eléments de ponctuation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Présentation des constantes et des mots-clés . . . . . . . . . . . . . . . . . . . 147
Présentation des instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
Présentation des tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
Présentation des opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .191
Chapitre 6 : Fonctions et méthodes . . . . . . . . . . . . . . . . . . . . . . . 217
Présentation des fonctions et des méthodes . . . . . . . . . . . . . . . . . . . . 217
Fonctionnement des méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
Chapitre 7 : Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
Présentation de la programmation orientée objet et de Flash . . . . 244
Ecriture de fichiers de classe personnalisée . . . . . . . . . . . . . . . . . . . . 254
Utilisation des classes personnalisées dans une application . . . . . . . 257
Exemple : Ecriture de classes personnalisées. . . . . . . . . . . . . . . . . . . .285
Exemple : Utilisation de fichiers de classe personnalisée dans
Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301
Affectation d’une classe à des symboles dans Flash . . . . . . . . . . . . 304
Compilation et exportation de classes . . . . . . . . . . . . . . . . . . . . . . . . . 306
Distinction entre classes et domaine. . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Présentation des classes de niveau supérieur et intégrées . . . . . . . . 312
Utilisation des classes intégrées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .322
Chapitre 8 : Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329
Présentation de l’héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .329
Ecriture de sous-classes dans Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
Utilisation du polymorphisme dans une application. . . . . . . . . . . . . . .338
4
Table des matières
Chapitre 9 : Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
Présentation des interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
Création d’interfaces comme types de données . . . . . . . . . . . . . . . . . 349
Fonctionnement des héritages et des interfaces . . . . . . . . . . . . . . . . .351
Exemple : Utilisation des interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
Exemple : Création d’une interface complexe . . . . . . . . . . . . . . . . . . . 355
Chapitre 10 : Gestion d’événements . . . . . . . . . . . . . . . . . . . . . . 359
Utilisation de méthodes de gestionnaire d’événement . . . . . . . . . . . 360
Utilisation des écouteurs d’événement . . . . . . . . . . . . . . . . . . . . . . . . . 363
Utilisation d’écouteurs d’événement avec des composants. . . . . . . 366
Association de gestionnaires d’événement à des boutons et
des clips . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
Diffusion d’événements à partir d’occurrences de composant . . . . 373
Création de clips avec des états de bouton . . . . . . . . . . . . . . . . . . . . . 373
Domaine du gestionnaire d’événement . . . . . . . . . . . . . . . . . . . . . . . . . 374
Domaine du mot-clé this . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
Utilisation de la classe Delegate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
Chapitre 11 : Utilisation des clips . . . . . . . . . . . . . . . . . . . . . . . . . . 381
A propos du contrôle des clips à l’aide d’ActionScript. . . . . . . . . . . . 382
Appel de plusieurs méthodes sur un seul clip. . . . . . . . . . . . . . . . . . . . 384
Chargement et déchargement des fichiers SWF . . . . . . . . . . . . . . . . 384
Modification de la position et de l’apparence d’un clip . . . . . . . . . . . 388
Déplacement des clips . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
Création de clips à l’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .391
Ajout de paramètres aux clips créés dynamiquement . . . . . . . . . . . . 395
Gestion des profondeurs de clip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397
Mise en cache et parcours de clips à l’aide d’ActionScript . . . . . . . .401
Utilisation des clips en tant que masques . . . . . . . . . . . . . . . . . . . . . . . 409
Gestion des événements clip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
Affectation d’une classe à un symbole de clip . . . . . . . . . . . . . . . . . . . .412
Initialisation des propriétés de classe. . . . . . . . . . . . . . . . . . . . . . . . . . . .413
Table des matières
5
Chapitre 12 : Utilisation du texte et des chaînes . . . . . . . . . . . . . 415
A propos des champs de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
A propos du chargement de texte et de variables dans des
champs de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .428
Utilisation des polices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434
Présentation du rendu d’un texte anti-alias . . . . . . . . . . . . . . . . . . . . . 444
Présentation de la mise en forme et du formatage du texte. . . . . . . .453
Formatage de texte avec les feuilles de style CSS . . . . . . . . . . . . . . .462
Utilisation de texte au format HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477
Exemple : Création de texte défilant . . . . . . . . . . . . . . . . . . . . . . . . . . . 492
Présentation des chaînes et de la classe String . . . . . . . . . . . . . . . . . 493
Chapitre 13 : Animation, filtres et dessins . . . . . . . . . . . . . . . . . . 515
Mise en script d’animation avec ActionScript 2.0 . . . . . . . . . . . . . . . 516
A propos de la mise en cache bitmap, du défilement et des
performances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
A propos des classes Tween et TransitionManager . . . . . . . . . . . . 529
Utilisation d’effets de filtre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .547
Utilisation des filtres avec ActionScript . . . . . . . . . . . . . . . . . . . . . . . . 555
Manipulation d’effets de filtre à l’aide de code . . . . . . . . . . . . . . . . . . . 581
Création de bitmaps à l’aide de la classe BitmapData . . . . . . . . . . . .585
A propos des modes de mélange. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .588
Présentation de l’ordre des opérations . . . . . . . . . . . . . . . . . . . . . . . . . 591
Dessin à l’aide de code ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . 591
Fonctionnement de la mise à l’échelle et des repères de découpe .607
Chapitre 14 : Création d’interactivité avec ActionScript . . . . . . 613
Evénements et interaction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614
Contrôle de la lecture d’un fichier SWF . . . . . . . . . . . . . . . . . . . . . . . . . 614
Création d’interactivité et d’effets visuels. . . . . . . . . . . . . . . . . . . . . . . . 618
Création de liaisons de données à l’exécution à l’aide
d’ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .632
Structure d’un exemple de script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .642
Chapitre 15 : Utilisation des images, du son et de la vidéo . . . 645
Chargement et utilisation de fichiers de médias externes . . . . . . . . .646
Chargement de fichiers SWF et de fichiers d’images externes . . . . 647
Chargement et utilisation de fichiers MP3 externes . . . . . . . . . . . . .652
Affectation de liaisons aux éléments de la bibliothèque . . . . . . . . . . .658
Utilisation du format vidéo FLV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 659
Création d’animation de progression pour les fichiers média . . . . . . 681
6
Table des matières
Chapitre 16 : Utilisation de données externes . . . . . . . . . . . . . . . 691
Envoi et chargement des variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 692
Utilisation du protocole HTTP pour les connexions aux scripts
côté serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 697
Transfert et téléchargement de fichier. . . . . . . . . . . . . . . . . . . . . . . . . . 702
Présentation du langage XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711
Echange de messages avec Flash Player. . . . . . . . . . . . . . . . . . . . . . . . 721
A propos de l'API externe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 726
Chapitre 17 : Fonctionnement de la sécurité . . . . . . . . . . . . . . . .737
Compatibilité avec les précédents modèles de sécurité
Flash Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Sécurité des fichiers locaux et Flash Player . . . . . . . . . . . . . . . . . . . . .
Domaines, sécurité inter-domaines et fichiers SWF . . . . . . . . . . . . .
Fichiers de régulation côté serveur pour autoriser l’accès aux
données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Accès du protocole HTTP vers le protocole HTTPS entre les
fichiers SWF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
738
739
758
766
772
Chapitre 18 : Débogage des applications . . . . . . . . . . . . . . . . . . 775
Débogage de scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 776
Utilisation du panneau Sortie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 790
Chapitre 19 : Recommandations et conventions de
programmation pour ActionScript 2.0 . . . . . . . . . . . . . . . . . . . . 797
Conventions d’appellation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 798
Insertion de commentaires dans le code. . . . . . . . . . . . . . . . . . . . . . . . .810
Conventions de programmation ActionScript . . . . . . . . . . . . . . . . . . . .813
Optimisation d’ActionScript et de Flash Player . . . . . . . . . . . . . . . . . 830
Mise en forme de la syntaxe ActionScript. . . . . . . . . . . . . . . . . . . . . . . 832
Table des matières
7
Annexe A : Messages d’erreur . . . . . . . . . . . . . . . . . . . . . . . . . . . 841
Annexe B : Opérateurs Flash 4 déconseillés. . . . . . . . . . . . . . . .847
Annexe C : Touches du clavier et valeurs de code
correspondantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 849
Annexe D : Ecriture de scripts destinés à des versions
antérieures de Flash Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .857
A propos du ciblage des versions antérieures de Flash Player . . . . 857
Utilisation de Flash 8 pour créer du contenu destiné à
Flash Player 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .858
Annexe E : Programmation orientée objet avec
ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 861
A propos d’ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .862
Création d’un objet personnalisé dans ActionScript 1.0 . . . . . . . . . . .864
Affectation de méthodes à un objet personnalisé dans
ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .865
Définition des méthodes du gestionnaire d’événement dans
ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .866
Création d’héritages dans ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . .869
Ajout de propriétés de lecture/définition à des objets dans
ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .870
Utilisation des propriétés de l’objet Function dans
ActionScript 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 872
Annexe F : Terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .875
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 885
8
Table des matières
Introduction
Macromedia Flash Basic 8 et Flash Professionnel 8 sont les outils préférés des professionnels
pour la création de contenu Web percutant. Le langage ActionScript permet de rendre les
applications Flash plus interactives, qu’il s’agisse de simples fichiers SWF animés ou
d’applications Internet plus complexes. Vous pouvez très bien utiliser Flash sans ActionScript.
Toutefois, si l’interactivité des utilisateurs est un critère important ou si vous souhaitez utiliser
des objets autres que ceux intégrés dans Flash (boutons et clips) ou créer des applications plus
complexes à partir de fichiers SWF, il est probable que vous aurez recours à ActionScript.
Pour plus d’informations, voir les sections suivantes :
Public visé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Mise à jour des fichiers XML Flash. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Configuration système requise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Présentation de la documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Ressources supplémentaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Public visé
Ce manuel suppose que vous avez déjà installé Flash Basic 8 ou Flash Professionnel 8 et savez
comment utiliser l’interface utilisateur.Vous devez également savoir comment placer des objets
sur la scène et les manipuler dans l’environnement de programmation de Flash. Si vous avez
déjà utilisé un langage de programmation, vous vous sentirez en terrain connu avec
ActionScript. Cependant, si vous êtes novice en programmation, les bases d’ActionScript sont
faciles à apprendre. Commencez par les commandes de base, puis abordez progressivement les
éléments plus complexes. Vous pouvez donc accroître l’interactivité de vos fichiers sans avoir à
apprendre (ou à écrire) beaucoup de code.
9
Configuration système requise
La configuration système requise par ActionScript 2.0 est identique à celle de Flash 8.
Ce manuel suppose que vous utilisiez les paramètres de publication par défaut pour vos
fichiers Flash : Flash Player 8 et ActionScript 2.0. Si vous modifiez ces paramètres, les
explications et les exemples de code qui figurent dans la documentation risquent de ne pas
fonctionner correctement. Si vous développez des applications pour les versions précédentes
de Flash Player, consultez l’Annexe D, Ecriture de scripts destinés à des versions antérieures de
Flash Player, page 857.
Mise à jour des fichiers XML Flash
Il est essentiel de disposer en permanence des fichiers Flash XML les plus récents. Macromedia
introduit parfois de nouvelles fonctionnalités dans les versions secondaires de Flash Player.
Lorsque ce type de version est disponible, vous devez mettre votre version de Flash à jour.
Sinon, le compilateur de Flash 8 risque de générer des erreurs si vous utilisez de nouvelles
propriétés ou méthodes non disponibles dans la version de Flash Player livrée avec votre
installation Flash.
Par exemple, Flash Player 7 (7.0.19.0) contient une nouvelle méthode pour l’objet System,
System.security.loadPolicyFile. Pour accéder à cette méthode, vous devez utiliser le
programme d’installation des mises à jour de Flash Player. Sinon, le compilateur Flash affiche
des erreurs.
Vous pouvez installer Player Updater même si ce programme a plusieurs versions d’avance sur
votre version de Flash. Ainsi, vous bénéficiez des fichiers XML nécessaires sans rencontrer
d’erreurs de compilation lorsque vous publiez des documents destinés à des versions plus
anciennes de Flash Player. Certaines nouvelles méthodes ou propriétés sont disponibles pour
les anciennes versions. Le fait de disposer des fichiers XML réduit le risque d’erreurs de
compilation lorsque vous tentez d’accéder à d’anciennes méthodes ou propriétés.
10
Introduction
Présentation de la documentation
Ce manuel passe en revue les principes généraux de la syntaxe ActionScript et explique
comment utiliser ce langage pour intervenir sur différents types d’objet. Pour plus
d’informations sur la syntaxe et l’utilisation de chaque élément, consultez le Guide de référence
du langage ActionScript 2.0.
Pour plus d’informations, voir les sections suivantes :
■
Présentation du manuel Formation à ActionScript 2.0, page 11
■
Présentation des fichiers d’exemple, page 15
■
Terminologie utilisée dans ce manuel, page 14
■
Copier et coller du code, page 14
Présentation du manuel Formation à
ActionScript 2.0
La liste suivante récapitule le contenu du manuel :
■
Chapitre 1, Nouveautés du langage ActionScript de Flash 8, décrit les nouvelles fonctions
d’ActionScript, les modifications apportées au module de compilation et débogage, ainsi
que le nouveau modèle de programmation du langage ActionScript 2.0.
■
Chapitre 2, Ecriture et modification du code ActionScript 2.0, décrit les fonctions de
l’éditeur ActionScript de Flash qui facilitent la rédaction du code.
■
Chapitre 3, A propos d’ActionScript, définit le langage ActionScript et explique comment
choisir la version d’ActionScript à utiliser.
■
Chapitre 4, Données et types de données, décrit la terminologie et les concepts de base sur les
données, les types de données et les variables. Vous aurez recours à ces concepts tout au
long du manuel.
■
Chapitre 5, Eléments fondamentaux du langage et de la syntaxe, décrit la terminologie et les
concepts de base du langage ActionScript. Vous aurez recours à ces concepts tout au long
du manuel.
■
Chapitre 6, Fonctions et méthodes, explique comment écrire différents types de fonctions et
de méthodes et comment les utiliser dans votre application.
■
Chapitre 7, Classes, explique comment créer des classes et des objets personnalisés dans
ActionScript. Ce chapitre affiche également la liste des classes intégrées dans ActionScript
et offre un bref aperçu de leur application pour accéder aux fonctions puissantes du code
ActionScript.
Présentation de la documentation
11
■
Chapitre 8, Héritage, décrit l’héritage dans le langage ActionScript et explique comment
étendre des classes personnalisées ou intégrées.
■
Chapitre 9, Interfaces, explique comment créer et utiliser les interfaces dans ActionScript.
■
Chapitre 10, Gestion d’événements, décrit les différentes façons de gérer les événements :
méthodes de gestionnaire d’événement, écouteurs d’événement et gestionnaires
d’événement de bouton et de clip.
■
Chapitre 11, Utilisation des clips, décrit les clips et le code ActionScript qui permet de les
contrôler.
■
Chapitre 12, Utilisation du texte et des chaînes, décrit les différentes façons de contrôler le
texte et les chaînes dans Flash et contient des informations sur le formatage du texte et
FlashType (rendu de texte avancé, tel que l’anti-aliasing du texte).
■
Chapitre 13, Animation, filtres et dessins, explique comment créer des images et des
animations à base de code, ajouter des filtres aux objets et dessiner à l’aide d’ActionScript.
■
Chapitre 14, Création d’interactivité avec ActionScript, décrit des méthodes simples de
création d’applications plus interactives, ce qui inclut le contrôle de la lecture des fichiers
SWF, la création de pointeurs personnalisés et la création de contrôles audio.
■
Chapitre 15, Utilisation des images, du son et de la vidéo, spécifie comment importer des
fichiers de supports externes, tels que des images bitmap, des fichiers MP3, des fichiers
FLV (Flash Video) et autres fichiers SWF, dans vos applications Flash. Ce chapitre
explique également comment utiliser la vidéo dans vos applications et comment créer des
animations de chargement avec barre de progression.
■
Chapitre 16, Utilisation de données externes, indique comment traiter les données des
sources externes en utilisant des scripts côté serveur ou client dans vos applications. Ce
chapitre explique comment intégrer des données dans vos applications.
■
Chapitre 17, Fonctionnement de la sécurité, explique comment la sécurité est mise en
oeuvre dans Flash Player, en ce qui concerne l’utilisation locale de fichiers SWF sur votre
disque dur. Ce chapitre décrit également les problèmes de sécurité inter-domaines et
explique comment charger des données à partir de serveur ou à travers des domaines.
■
Chapitre 18, Débogage des applications, porte sur le débogueur d’ActionScript dans Flash
qui facilite la création d’applications.
■
Chapitre 19, Recommandations et conventions de programmation pour ActionScript 2.0,
détaille les meilleures pratiques d’utilisation de Flash et d’écriture de code ActionScript.
Ce chapitre dresse également la liste des conventions de codage normalisées, notamment
en matière d’appellation des variables, et d’autres conventions.
■
Annexe A, Messages d’erreur, dresse la liste des messages d’erreur que le compilateur Flash
est susceptible de générer.
12
Introduction
■
Annexe B, Opérateurs Flash 4 déconseillés, dresse la liste de tous les opérateurs Flash 4
déconseillés et leur associativité.
■
Annexe C, Touches du clavier et valeurs de code correspondantes, répertorie toutes les touches
d’un clavier standard et les valeurs de code ASCII correspondantes utilisées pour identifier
les touches dans ActionScript.
■
Annexe D, Ecriture de scripts destinés à des versions antérieures de Flash Player, fournit des
consignes pour la syntaxe des scripts en fonction de la version de Flash Player ciblée.
■
Annexe E, Programmation orientée objet avec ActionScript 1.0, fournit des informations sur
l’utilisation du modèle d’objet ActionScript 1.0 pour écrire des scripts.
■
Annexe F, Terminologie, énumère la terminologie couramment utilisée en cas d’utilisation
du langage ActionScript et fournit une description de ces termes.
Ce manuel explique comment utiliser le langage ActionScript. Pour plus d’informations sur
les éléments de langage, consultez le Guide de référence du langage ActionScript 2.0.
Conventions typographiques
Ce manuel utilise les conventions typographiques suivantes :
■
La police de code indique
■
La police de code en gras,
le code ActionScript.
généralement utilisée dans les procédures, signale le code
à modifier ou à ajouter au code déjà inséré dans votre fichier FLA. Dans certains cas, elle
peut signaler le code à examiner.
■
Le texte en gras indique des données à saisir dans l’interface utilisateur, telles que le nom
d’un fichier ou d’une occurrence.
■
Le texte en italique indique un terme nouveau défini dans la suite du texte. Dans un
chemin de fichier, il peut indiquer une valeur à remplacer (par exemple par le nom d’un
répertoire de votre propre disque dur).
Présentation de la documentation
13
Terminologie utilisée dans ce manuel
Ce manuel emploie les termes suivants :
■
Vous fait référence au programmeur qui développe un script ou une application.
■
L’utilisateur désigne la personne qui exécute vos scripts et applications.
■
La compilation correspond à la phase de publication, d’exportation, de test ou de débogage
de votre document.
■
L’exécution représente le moment auquel votre script s’exécute dans Flash Player.
Les termes ActionScript tels que méthode et objet sont définis dans l’Annexe F, Terminologie,
page 875.
Copier et coller du code
Vous devez faire particulièrement attention aux caractères spéciaux lorsque vous collez des
éléments ActionScript du panneau Aide vers votre fichier FLA ou ActionScript. Parmi les
caractères spéciaux figurent des guillemets spéciaux (également appelés guillemets anglais ou
guillemets typographiques). Ces caractères ne sont pas interprétés par l’éditeur ActionScript.
Par conséquent, votre code renvoie une erreur si vous tentez de les compiler dans Flash.
Vous pouvez déterminer que vos guillemets sont des caractères spéciaux si leur code couleur
n’est pas correct. En d’autres termes, si toutes vos chaînes ne changent pas de couleur dans
l’éditeur de code, vous devez remplacer les caractères spéciaux par des guillemets droits
classiques. Si vous tapez un guillemet simple ou double directement dans l’éditeur
ActionScript, utilisez toujours un guillemet droit. Le compilateur (lors du test ou de la
publication d’un fichier SWF) renvoie une erreur et indique si votre code comporte le
mauvais type de caractère (guillemets spéciaux ou guillemets anglais).
REMARQUE
14
Vous pouvez également rencontrer des guillemets spéciaux lorsque vous collez des
éléments ActionScript à partir d’autres emplacements, tels qu’une page Web ou un
document Microsoft Word.
Introduction
Veillez à respecter les sauts de ligne lorsque vous copiez et collez du code. Si vous collez du
code à partir de différents emplacements, les sauts de la ligne de code peuvent être situés au
mauvais endroit. Assurez-vous que le code couleur de votre syntaxe est correct dans l’éditeur
ActionScript si vous pensez que les sauts de ligne peuvent poser problème. Si vous le
souhaitez, comparez votre code du panneau Actions à celui du panneau Aide pour voir s’ils
correspondent. Essayez d’activer le retour à la ligne dans l’éditeur ActionScript pour vous aider
à résoudre l’excédent de sauts de ligne dans votre code (sélectionnez Affichage > Retour à la
ligne dans la fenêtre de script ou Retour à la ligne dans le menu déroulant du panneau
Actions).
Ressources supplémentaires
En plus de ce manuel sur ActionScript, vous pouvez consulter des manuels sur d’autres sujets
liés à Flash, tels que les composants et Macromedia Flash Lite. Vous pouvez accéder à chaque
manuel dans le panneau Aide (Aide > Aide Flash), en consultant le Sommaire par défaut.
Cliquez sur le bouton Effacer pour faire apparaître chaque manuel disponible. Pour plus
d’informations, consultez la section Documentation se rapportant à d’autres sujets, page 18.
Pour plus d’informations sur les autres ressources disponibles, consultez les sections suivantes :
■
Présentation des fichiers d’exemple, page 15
■
Emplacement des fichiers PDF et de la documentation imprimée, page 16
■
Présentation de LiveDocs, page 17
■
Ressources en ligne supplémentaires, page 18
■
Documentation se rapportant à d’autres sujets, page 18
Présentation des fichiers d’exemple
De nombreux fichiers d’exemple basés sur ActionScript sont installés avec Flash. Ces fichiers
montrent comment le code fonctionne dans un fichier FLA. Ils constituent généralement un
outil d’apprentissage utile. Les chapitres de ce manuel font souvent référence à ces fichiers
mais nous vous recommandons également de consulter le dossier de fichiers d’exemple de
votre disque dur.
Parmi les fichiers d’exemple figurent des fichiers d’application FLA qui utilisent des
fonctionnalités Flash installées avec Flash. Ces applications ont été conçues pour présenter les
fonctionnalités des applications Flash aux nouveaux développeurs et illustrer le contexte de ces
fonctions pour les développeurs plus expérimentés.
Vous trouverez des exemples de fichiers source axés sur ActionScript dans le dossier Samples
de votre disque dur.
Ressources supplémentaires
15
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program
Files\Macromedia\Flash 8\Samples and Tutorials\Samples\ActionScript\.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/.
Les fichiers d’exemple suivants, axés sur les composants, vous seront certainement utiles
puisqu’ils contiennent du code ActionScript en grande quantité. Ils sont également présents
dans le dossier Samples de votre disque dur :
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program
Files\Macromedia\Flash 8\Samples and Tutorials\Samples\Components\.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/Components/.
Vous pouvez également télécharger d’autres fichiers d’exemple sur Internet. La page Web
suivante contient des liens vers d’autres fichiers d’exemple et leur description :
www.macromedia.com/go/flash_samples_fr/.
Emplacement des fichiers PDF et de la
documentation imprimée
Si vous préférez lire la documentation sur copie papier, les versions PDF de chaque manuel
d’aide sont disponibles en téléchargement. Accédez à www.macromedia.com/support/
documentation/ et sélectionnez le produit qui vous intéresse. Vous pouvez consulter ou
télécharger le PDF ou accéder à la version LiveDocs du manuel.
Généralement, vous pouvez également acquérir la version imprimée de la documentation.
Pour obtenir des informations à jour, accédez au site contenant la documentation et
sélectionnez Flash Basic 8 ou Flash Professionnel 8.
16
Introduction
Présentation de LiveDocs
Vous pouvez accéder à la documentation à partir du panneau Aide mais également sur le site
Web LiveDocs. Ce site contient toutes les pages d’aide de Flash ainsi que des commentaires
qui précisent, actualisent ou rectifient des parties de la documentation. Pour afficher la page
équivalente sur le site Web LiveDocs, il suffit de cliquer sur Commentaires sur LiveDocs au
bas d’une page du panneau Aide. Accédez à http://livedocs.macromedia.com pour consulter la
liste de toute la documentation disponible au format LiveDocs.
Le site Web LiveDocs est surveillé par des rédacteurs techniques. L’un des avantages de
LiveDocs réside dans la possibilité de consulter des commentaires qui clarifient la
documentation ou qui corrigent des problèmes rencontrés après la publication d’un logiciel.
LiveDocs n’est pas un endroit où soumettre des demandes d’assistance. Par exemple, vous ne
pouvez pas poser de questions au sujet de code que vous ne parvenez pas à faire fonctionner, ni
commenter des problèmes de logiciel ou d’installation, ni demander comment créer quelque
chose avec Flash. LiveDocs est un endroit destiné à fournir du feedback au sujet de la
documentation (par exemple si vous remarquez une phrase ou un paragraphe qui mériterait
d’être clarifié).
Lorsque vous cliquez sur le bouton permettant d’ajouter un commentaire dans LiveDocs,
vous verrez plusieurs remarques relatives au type de commentaires admis sur le système. Lisez
attentivement ces instructions, faute de quoi vous risquez de voir votre commentaire supprimé
du site Web.
Si vous voulez poser une question au sujet de Flash, posez-la dans les forums Web de
Macromedia : www.macromedia.com/support/forums/. Les forums Web sont le meilleur
endroit où poser vos questions, car ils sont consultés par de nombreux employés de
Macromedia, des volontaires de l’équipe Macromedia, des gestionnaires et membres de
groupes d’utilisateurs Macromedia, voire des rédacteurs techniques.
Les ingénieurs ne contrôlent pas le système LiveDocs mais ils surveillent la liste de souhaits
pour Flash. Si vous pensez avoir découvert un bogue dans votre logiciel ou si vous souhaitez
demander une amélioration de Flash, veuillez remplir le formulaire approprié à l’adresse
suivante : www.macromedia.com/go/wish. Si vous soumettez votre découverte de bogue ou
votre demande d’amélioration sur LiveDocs, elle ne sera pas officiellement ajoutée à la base de
données des bogues. Si vous voulez qu’un ingénieur prenne en compte votre bogue ou votre
demande, vous devez utiliser la liste de souhaits.
N’oubliez pas de faire attention aux caractères spéciaux et aux sauts de ligne lorsque vous
collez du texte à partir d’Internet, y compris à partir de LiveDocs. Macromedia a tout mis en
oeuvre pour supprimer tous les caractères spéciaux des exemples de code mais si vous
rencontrez encore des problèmes lors du collage du code, consultez la section Copier et coller
du code, page 14.
Ressources supplémentaires
17
Ressources en ligne supplémentaires
Nombre de ressources en ligne offrent une abondance d’instructions, d’aides et de procédures
qui vous guideront dans votre découverte de Macromedia Flash 8. Consultez régulièrement
les sites Web suivants pour être informé(e) des mises à jour :
Le Centre des développeurs Macromedia
(www.macromedia.com/fr/devnet_fr) est
régulièrement actualisé et propose les informations les plus récentes sur Flash, ainsi que des
conseils d’utilisateurs expérimentés, des rubriques avancées, des exemples, des astuces, des
didacticiels en plusieurs parties et d’autres mises à jour. Consultez régulièrement ce site Web
pour vous tenir au courant des nouveautés de Flash et tirer le meilleur parti de votre logiciel.
Le Centre de support Macromedia Flash
(www.macromedia.com/flash_support_fr) fournit
des TechNotes, des mises à jour de la documentation et des liens vers des ressources
supplémentaires dans la communauté Flash.
Le site Web des blogs Macromedia
(http://weblogs.macromedia.com) fournit la liste des
blogs des employés et de la communauté Macromedia (également appelés Weblogs).
Les forums Macromedia (http://webforums.macromedia.com) offrent de nombreuses
discussions sur des questions spécifiques relatives à Flash, à vos applications ou au langage
ActionScript. Ces forums sont surveillés par des volontaires de l’équipe Macromedia et
également régulièrement consultés par des employés de Macromedia. Si vous ne savez pas à
qui vous adresser ou comment résoudre un problème, commencez par consulter un forum
Flash.
La Communauté Macromedia (www.macromedia.com/community) héberge régulièrement
des MacroChats, séries de présentations en direct sur divers sujets et menées par les employés
ou les membres de la communauté Macromedia. Consultez régulièrement ce site Web afin de
vérifier la présence de mises à jour et pour vous inscrire aux Macrochats.
Documentation se rapportant à d’autres sujets
Les manuels suivants fournissent des informations supplémentaires sur des sujets
généralement associés à ActionScript 2.0 :
■
Pour plus d’informations sur les éléments qui composent le langage ActionScript,
consultez le Guide de référence du langage ActionScript 2.0.
■
Pour plus d’informations sur l’utilisation de l’environnement de programmation de Flash,
consultez la section Comment utiliser l’Aide.
■
Pour en savoir plus sur l’utilisation des composants, consultez la section Utilisation des
composants.
18
Introduction
CHAPITRE 1
1
Nouveautés du langage
ActionScript de Flash 8
Macromedia Flash Basic 8 et Macromedia Flash Professionnel 8 bénéficient de plusieurs
améliorations qui vous permettront d’écrire aisément des scripts fiables à l’aide du langage
ActionScript. Ces améliorations, décrites dans le présent chapitre, portent notamment sur de
nouveaux éléments de langage (consultez la section Nouveautés dans le langage ActionScript,
page 22), des outils d’édition améliorés (consultez la section Modifications de l’éditeur
ActionScript, page 28), des changements dans les modèles de sécurité et sur d’autres
améliorations apportées à cet outil de programmation dans ActionScript.
Pour plus d’informations, consultez les sections suivantes :
Nouveau dans ActionScript 2.0 et Flash 8. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Modifications du modèle de sécurité pour les fichiers SWF installés
localement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Nouveau dans ActionScript 2.0 et
Flash 8
Depuis son introduction il y a quelques années de cela, le langage ActionScript n’a cessé de se
développer. A chaque nouvelle version de Flash, de nouveaux mots-clés, objets, méthodes et
autres éléments de langage ont été ajoutés à ActionScript. Des améliorations s’articulant
autour d’ActionScript sont également apportées aux environnements de programmation de
Flash 8. Flash Basic 8 et Flash Professionnel 8 présentent plusieurs nouveaux éléments de
langage dédiés aux fonctionnalités fiables, tels que les filtres et les modes de fondu, et le
développement d’applications, comme par exemple l’intégration JavaScript
(ExternalInterface) et le fichier d’E/S (FileReference et FileReferenceList).
19
Cette section présente une vue d’ensemble des éléments de langage et des classes
d’ActionScript qui sont nouveaux ou modifiés dans Flash 8, ainsi que les améliorations de
l’outil de programmation qui s’articulent autour de ActionScript. Pour obtenir une liste de
suppléments spécifiques dans ActionScript 2.0, consultez la section Nouveautés dans le
langage ActionScript, page 22. Pour pouvoir utiliser ces nouveautés dans vos scripts, vous
devez cibler Flash Player 8 (lecteur par défaut) lors de la publication des documents.
Flash Basic 8 et Flash Professionnel 8 comprennent les fonctions nouvelles suivantes (sauf avis
contraire) :
■
Les améliorations de l’éditeur ActionScript vous permettent de faire apparaître des
éléments cachés dans vos scripts. Pour plus d’informations, consultez la section Affichage
des caractères masqués, page 58.
■
Les options de débogage sont désormais disponibles dans la fenêtre Script, ainsi que le
panneau des Actions, pour les fichiers ActionScript.
■
Le répertoire de configuration qui comprend des fichiers XML et des fichiers de classe a
été réorganisé. Pour plus d’informations, consultez la section Fichiers de configuration
installés avec Flash 8, page 71.
■
Vous pouvez régler une préférence pour recharger les fichiers de script modifiés lorsque
vous travaillez sur une application, ce qui vous évite de travailler avec des versions de
fichiers script plus anciennes et d’écraser des fichiers script plus récents. Pour plus
d’informations, consultez la section Présentation des préférences d’ActionScript, page 45.
■
La fonctionnalité de la fenêtre Script est disponible dans Flash Basic 8 et Flash
Professionnel 8. Ainsi, vous pouvez maintenant créer un fichier ActionScript dans l’un ou
l’autre programme.
■
L’Assistant de Script (similaire au mode normal dans des éditions plus anciennes de Flash)
vous aide à coder sans besoin de comprendre la syntaxe. Pour plus d’informations sur
l’Assistant Script, consultez la section L’Assistant de script, page 64.
■
En cours d’exécution, vous pouvez charger de nouveaux types de fichiers image, y compris
des images JPEG progressives et des fichiers GIF et PNG non-animés. Si vous chargez un
fichier animé, la première image de l’animation apparaît.
■
Vous pouvez assigner des identifiants de liaison à des fichiers bitmap et des fichiers sons
stockés dans la Bibliothèque, ainsi vous pouvez associer des images à la scène ou travailler
avec ces éléments dans des bibliothèques partagées.
■
La mémoire cache bitmap vous permet d’améliorer la performance de vos applications en
cours d’exécution en mettant sous mémoire cache une représentation bitmap de vos
occurences. Vous pouvez utiliser le code ActionScript pour accéder à cette propriété. Pour
plus d’informations, consultez la section A propos de la mise en cache bitmap, du
défilement et des performances, page 527.
20
Nouveautés du langage ActionScript de Flash 8
■
La mise à l’échelle à 9 niveaux vous permet de redimmensionner les occurences de clips
sans élargir les traits du contour du clip. Utilisez le code ActionScript pour accéder à cette
fonctionnalité dans Flash Basic 8 et Flash Professionnel 8, ou dans l’outil de
programmation Flash 8. Pour plus d’informations, consultez la section Utilisation de la
mise à l’échelle à 9 découpes dans ActionScript, page 610. Pour plus d’informations sur
l’accès à la mise à l’échelle à 9 niveaux dans l’outil de programmation, consultez la section
A propos de la mise à l'échelle à 9 découpes et des symboles de clip, page 94 dans le guide
Utilisation de Flash.
■
Vous pouvez maintenant ajouter des informations sur les métadonnées à vos fichiers FLA
dans la boîte de dialogue de publication des réglages. Vous pouvez ajouter un nom et une
description à votre fichier FLA en utilisant la boîte de dialogue pour une meilleure
visibilité de recherche en ligne.
■
Le panneau Chaînes a été amélioré et inclut désormais une prise en charge multiligne dans
le champ Chaîne et dans le fichier de langue XML. Pour plus d’informations, consultez la
section Présentation du panneau Chaînes, page 495.
■
Un nouveau nettoyeur de mémoire a été intégré dans Flash Player, qui utilise un nettoyeur
incrémentiel pour améliorer les performances.
■
Le rendement de création d’applications accessibles a été amélioré. Avec Flash Player 8, les
développeurs n’ont plus besoin d’ajouter tous les objets à l’index de tabulation pour que le
contenu soit lu correctement avec un lecteur d’écran. Pour plus d’informations sur l’index
de tabulation, consultez les sections tabIndex (propriété Button.tabIndex),
tabIndex (propriété MovieClip.tabIndex) et tabIndex (propriété
TextField.tabIndex) dans le Guide de référence du langage ActionScript 2.0.
■
Flash Player a amélioré la sécurité des fichiers locaux pour plus de sécurité lors de
l’exécution de fichiers SWF sur votre disque dur. Pour plus d’informations sur la sécurité
de fichiers locaux, consultez la section Sécurité des fichiers locaux et Flash Player,
page 739.
■
En utilisant le code ActionScript, aidez-vous de l’interface API de dessin pour contrôler le
style de traits que vous dessinez. Pour plus d’informations sur les nouveaux styles de lignes,
consultez la section Utilisation de styles de ligne, page 599.
■
En utilisant le code ActionScript, aidez-vous de l’interface API de dessin pour créer des
dégradés plus complexes avec lesquels vous remplissez des formes. Pour plus
d’informations sur les remplissages de dégradés, consultez la section Utilisation de
remplissages dégradés complexes, page 598.
■
Utilisez le code ActionScript pour appliquer plusieurs filtres à des objets sur la scène (tels
que des occurences de clips). Pour plus d’informations sur les filtres et sur ActionScript,
consultez la section Utilisation des filtres avec ActionScript, page 555.
Nouveau dans ActionScript 2.0 et Flash 8
21
■
Utilisez FileReference et FileReferenceList API pour télécharger des fichiers sur un serveur.
Pour plus d’informations, consultez la section Transfert et téléchargement de fichier,
page 702.
■
Utilisez le code ActionScript pour accéder à de nouveaux moyens avancés d’application et
de manipulation des couleurs. Pour plus d’informations, consultez les sections Définition
des valeurs de couleurs, page 624 et ColorTransform (flash.geom.ColorTransform)
dans le Guide de référence du langage ActionScript 2.0.
■
De nombreuses améliorations ont été apportées au traitement de texte, y compris de
nouvelles options, propriétés et paramètres dans les classes de champ de texte et de format
de texte. Pour plus d’informations, consultez les sections TextField et TextFormat dans
le Guide de référence du langage ActionScript 2.0.
■
Utilisez le code ActionScript pour accéder aux fonctionnalités avancées d’anti-alias (de
type Flash). Pour plus d’informations, consultez la section Présentation du rendu d’un
texte anti-alias, page 444.
■
Vous pouvez supprimer les fichiers ASO quand vous testez votre application. Sélectionnez
Contrôle > Supprimer les fichiers ASO ou Contrôle > Supprimer les fichiers ASO et tester
le clip dans l’outil de programmation. Pour plus d’informations, consultez la section
Utilisation des fichiers ASO, page 307.
Pour obtenir une liste de classes, d’éléments de langage, des méthodes et des propriétés
ajoutées à ActionScript 2.0 dans Flash 8, consultez la section Nouveautés dans le langage
ActionScript, page 22.
Nouveautés dans le langage ActionScript
Cette section dresse une liste des éléments de langage et des classes ActionScript qui ont été
ajoutés ou modifiés dans Flash 8. Les classes et les éléments de langage qui suivent sont des
nouveautés ou prises en charge dans Flash Player 8.
Les classes suivantes sont des nouveautés d’ActionScript 2.0 dans Flash 8 :
■
La classe BevelFilter (du paquet flash.filters) vous permet d’ajouter des effets de biseau aux
objets.
■
La classe BitmapData (du paquet flash.display) vous permet de créer des images bitmap
transparentes ou opaques dimensionnées de manière arbitraire et de les manipuler à votre
guise lors de l’exécution.
■
La classe BitmapFilter (du paquet flash.display) est une classe de base pour les effets de
filtres.
■
La classe BlurFilter vous permet d’appliquer un effet visuel de flou aux objets dans Flash.
22
Nouveautés du langage ActionScript de Flash 8
■
La classe ColorMatrixFilter (du paquet flash.filters) vous permet de transformer les
couleurs ARGB et les valeurs alpha.
■
La classe ColorTransform (du paquet flash.geom) vous permet de régler les valeurs des
couleurs dans un clip. La classe Color est déconseillée et doit être remplacée par la classe
ColorTransform.
■
La classe ConvolutionFilter (du paquet flash.filters) vous permet d’appliquer des effets de
filtre de convolution matricielle.
■
La classe DisplacementMapFilter (du paquet flash.filters) vous permet d’utiliser des
valeurs de pixel depuis un objet BitmapData pour déplacer un objet.
■
La classe DropShadowFilter (du paquet flash.filters) vous permet d’ajouter des projections
d’ombres à des objets.
■
La classe ExternalInterface (du paquet flash.external) vous permet de communiquer en
utilisant ActionScript avec le conteneur Flash Player (le système prenant en charge
l’application Flash, par exemple une page HTML utilisant JavaScript ou une application
de bureau).
■
La classe FileReference (du paquet flash.net) vous permet de charger et télécharger des
fichiers entre l’ordinateur d’un utilisateur et le serveur.
■
La classe FileReference (du paquet flash.net) vous permet de sélectionner un ou plusieurs
fichiers à charger.
■
La classe GlowFilter (du paquet flash.filters) vous permet d’ajouter des effets de brillance à
des objets.
■
La classe GradientBevelFilter (du paquet flash.filters) vous permet d’ajouter des effets de
biseaux dégradés à des objets.
■
La classe GradientGlowFilter (du paquet flash.filters) vous permet d’ajouter des effets de
brillance dégradée à des objets.
■
La classe IME (de la classe System) vous permet de manipuler directement l’IME (Input
Method Editor) du système d’exploitation sous lequel l’application Flash Player s’exécute
sur l’ordinateur client.
■
La classe Locale (du paquet mx.lang) vous permet de contrôler la façon dont le texte
multilingue s’affiche dans un fichier SWF.
■
La classe Matrix (du paquet flash.geom) représente une matrice de transformation qui
détermine la façon de mapper des points d’un espace de coordonnées à l’autre.
■
La classe Point (du paquet flash.geom) représente un emplacement dans un système de
coordonnées à deux dimensions ( x est l’axe horizontal et y représente l’axe vertical).
■
La classe Rectangle (du paquet flash.geom) vous permet de créer et de modifier des objets
rectangles.
Nouveau dans ActionScript 2.0 et Flash 8
23
■
La classe TextRenderer (du paquet flash.text) permet d’exploiter la fonction d’anti-alias
des polices incorporées.
■
La classe Transform (du paquet flash.geom) rassemble des données sur les transformations
de couleurs et coordonne les manipulations que vous appliquez à un objet MovieClip.
REMARQUE
Une prise en charge officielle a été ajoutée à la classe AsBroadcaster dans Flash 8.
Les nouveautés dans les éléments de langage, les méthodes et les fonctions dans les classes
existantes d’ActionScript comprennent notamment :
■
La fonction globale showRedrawRegions permet au débogueur de détourer les zones de
l’écran qui sont redessinées (c’est-à-dire des zones obsolètes qui sont mises à jour). La
fonction permet à l’utilisateur de montrer ce qui a été redessiné, mais ne vous permet pas
de redessiner les zones.
■
La propriété blendMode de la classe Button, qui règle le mode de fondu pour l’occurence
de bouton.
■
La propriété cacheAsBitmap de la classe Button, qui vous permet de cacher l’objet en tant
que représentation bitmap interne de l’occurence.
■
La propriété filters de la classe Button, qui est un tableau indexé contenant chacun des
objets filtre associés au bouton.
■
La propriété scale9Grid de la classe Button, qui est la zone rectangulaire définissant les
neuf zones de redimensionnement du bouton.
■
La propriété hasIME de la classe System.capabilities, qui indique si le système possède un
IME.
■
La propriété getUTCYear de la classe Date, qui renvoie l’année de l’objet Date spécifié,
conformément à l’heure locale.
■
La méthode isAccessible() de la classe Key retourne une valeur booléenne qui indique
si d’autres fichiers SWF peuvent accéder à la dernière touche enfoncée, en fonction des
restrictions de sécurité.
■
Le programme de traitement d’événement onHTTPStatus de la classe LoadVars retourne
le code de statut qui est revenu du serveur (par exemple, la valeur 404 pour impossible de
trouver la page). Pour plus d’informations, consultez la section onHTTPStatus
(gestionnaire LoadVars.onHTTPStatus) dans le Guide de référence du langage
ActionScript 2.0.
24
Nouveautés du langage ActionScript de Flash 8
■
La méthode attachBitmap() de la classe MovieClip, qui associe une image bitmap à un
clip. Pour plus d’informations, consultez la section BitmapData
(flash.display.BitmapData) dans le Guide de référence du langage ActionScript 2.0.
■
La méthode beginBitmapFill() de la classe MovieClip, qui remplit un clip avec une
image bitmap.
■
Les paramètres de spreadMethod, interpolationMethod et de focalPointRatio de la
méthode beginGradientFill()de la classe MovieClip. Cette méthode remplit une zone
de dessin avec une image bitmap et le bitmap peut être répété ou former une mosaïque
afin de remplir la zone.
■
La propriété blendMode de la classe MovieClip, qui règle le mode de fondu pour
l’occurence.
■
La propriété cacheAsBitmap de la classe MovieClip, qui vous permet de cacher l’objet en
tant qu’une représentation bitmap interne de l’occurence.
■
La propriété filters dans la classe MovieClip, qui est un tableau indexé contenant
chacun des objets filtre associés à l’occurrence.
■
La méthode getRect() de la classe MovieClip, qui renvoie les propriétés aux valeurs de
coordonnées minimales et maximales de l’occurrence donnée.
■
La méthode lineGradientStyle() de la classe MovieClip, qui spécifie un style de ligne
dégradée que Flash utilise lors du dessin d’un chemin.
■
Les paramètres pixelHinting, noScale, capsStyle, jointStyle et miterLimit de la
méthode lineStyle()de la classe MovieClip. Ces paramètres spécifient les types de styles
de lignes que vous pouvez utiliser en dessinant des lignes.
■
La propriété opaqueBackground de la classe MovieClip, qui règle la couleur de l’arrièreplan opaque (non transparent) du clip à la couleur spécifiée par une valeur RVB
hexadécimale.
■
La propriété scale9Grid de la classe MovieClip, qui est la zone rectangulaire définissant
les neuf zones de redimensionnement de l’occurrence.
■
La propriété scrollRect de la classe MovieClip, qui vous permet de parcourir
rapidement le contenu d’un clip et d’ouvrir une fenêtre capable d’afficher davantage de
contenu.
■
La propriété transformation de la classe MovieClip, qui vous permet des réglages se
rapportant à la matrice d’un clip, à la transformation des couleurs et aux limites des pixels.
Pour plus d’informations, consultez la section Transform (flash.geom.Transform)
dans le Guide de référence du langage ActionScript 2.0.
Nouveau dans ActionScript 2.0 et Flash 8
25
■
Le paramètre statut de MovieClipLoader. Le programme de traitement d’événements
onLoadComplete retourne le code de statut qui est ramené depuis le serveur (par exemple,
la valeur 404 pour impossible de trouver la page). Pour plus d’informations, consultez la
section onLoadComplete (écouteur d'événement
MovieClipLoader.onLoadComplete) dans le Guide de référence du langage
ActionScript 2.0.
■
Le programme de traitement d’événements onLoadError de la classe MovieClipLoader
est appelé lorsque le chargement d’un fichier chargé avec MovieClipLoader.loadClip()
a échoué.
■
Le paramètre secure de la méthode SharedObject.getLocal() détermine si l’accès à cet
objet partagé est restreint aux fichiers SWF acheminés à travers une connexion HTTPS.
Pour plus d’informations, consultez la section getLocal (méthode
SharedObject.getLocal) dans le Guide de référence du langage ActionScript 2.0.
■
La propriété de type sandbox de la classe System.security indique le type de sanbdox de
sécurité dans lequel le SWF appelant fonctionne. Pour plus d’informations, consultez la
section sandboxType (propriété security.sandboxType) dans le Guide de référence
du langage ActionScript 2.0.
■
La propriété antiAliasType de la classe TextField, qui règle le type d’anti-alias que vous
utilisez pour l’occurrence TextField.
■
La propriété filters de la classe TextField, qui est un tableau indexé contenant chacun
des objets filtre associés à la zone de texte.
■
La propriété gridFitType de la classe TextField, qui règle le type de grille que vous
utilisez pour l’occurrence. Pour plus d’informations sur les grilles et sur
TextField.gridFitType, consultez la section gridFitType (propriété
TextField.gridFitType) dans le Guide de référence du langage ActionScript 2.0.
■
La propriété sharpness de la classe TextField, qui règle le type de définition des bords de
glyphes pour l’occurrence zone de texte. Vous devez régler la méthode antiAliasType()
en mode avancé si vous utilisez cette propriété.
■
La propriété thickness de la classe TextField, qui règle l’épaisseur des bords de glyphes
pour l’occurrence zone de texte. Vous devez régler la méthode antiAliasType() en mode
avancé si vous utilisez cette propriété.
■
La valeur justify pour la propriété align de la classe TextFormat, qui vous permet de
justifier un paragraphe donné.
■
La propriété indent de la classe TextFormat, qui vous permet d’utiliser des valeurs
négatives.
■
La propriété kerning de la classe TextFormat, qui vous permet d’activer ou de désactiver
le crénage pour l’objet format de texte.
26
Nouveautés du langage ActionScript de Flash 8
■
La propriété leading de la classe TextFormat, qui vous permet d’utiliser un lignage
négatif, afin que l’espace entre les lignes soit inférieur à la hauteur de texte. Ceci vous
permet de placer des lignes de texte proches les unes des autres dans vos applications.
■
La propriété letterSpacing de la classe TextFormat, qui vous permet de spécifier la taille
de l’espace uniformément réparti entre les caractères.
■
La propriété _alpha de la classe Video, qui est le montant spécifié de transparence pour
l’objet vidéo.
■
La propriété _height de la classe Video, qui indique la hauteur de l’occurrence vidéo.
■
La propriété _name de la classe Video, qui indique le nom de l’occurrence vidéo.
■
La propriété _parent de la classe Video, qui indique l’occurrence de clip ou l’objet qui
contient l’occurrence vidéo.
■
La propriété _rotation de la classe Video, qui vous permet de régler le mouvement de
rotation de l’occurrence vidéo en degrés.
■
La propriété _visible de la classe Video, qui vous permet de régler la visibilité d’une
occurence vidéo.
■
La propriété _width de la classe Video, qui vous permet de régler la largeur de l’occurence
vidéo.
■
La propriété _x de la classe Video, qui vous permet de régler les coordonnées x de
l’occurence vidéo.
■
La propriété _xmouse de la classe Video, qui vous permet de régler les coordonnées x de la
position du pointeur de la souris.
■
La propriété _xscale de la classe Video, qui vous permet de régler le pourcentage de
redimensionnement horizontal de l’occurence vidéo.
■
La propriété _y de la classe Video, qui vous permet de régler les coordonnées y de
l’occurence vidéo.
■
La propriété _ymouse de la classe Video, qui vous permet de régler les coordonnées y de la
position du pointeur de la souris.
■
La propriété _yscale de la classe Video, qui vous permet de régler le pourcentage de
redimensionnement vertical de l’occurence vidéo.
■
Le programme de traitement d’événement onHTTPStatus de la classe XML retourne le
code de statut qui est revenu du serveur (par exemple, la valeur 404 pour impossible de
trouver la page). Pour plus d’informations, consultez la section onHTTPStatus
(XML.onHTTPStatus, gestionnaire) dans le Guide de référence du langage
ActionScript 2.0.
■
La propriété localName de la classe XMLNode, qui renvoie le nom complet de l’objet
noeud XML (y compris le préfixe et le nom local).
Nouveau dans ActionScript 2.0 et Flash 8
27
■
La propriété namespaceURIde la classe XMLNode, qui lit l’URI de l’espace de nom
résultant du préfixe du nœud XML. Pour plus d’informations, consultez la section
namespaceURI (XMLNode.namespaceURI, propriété) dans le Guide de référence du
langage ActionScript 2.0.
■
La propriété prefixde la classe XMLNode, qui lit le préfixe du nom du nœud.
■
La méthode getNamespaceForPrefix() de la classe XMLNode, qui renvoit le nom
d’espace URI se rapportant au préfixe spécifié pour le nœud.
■
La méthode getPrefixForNamespace de la classe XMLNode, qui renvoie le préfixe se
rapportant à un nom d’espace URI donné pour le nœud.
A propos des éléments de langage déconseillés
Certains éléments de langage sont déconseillés dans Flash Player 8. Pour obtenir une liste des
éléments de langage déconseillés et des méthodes alternatives d’utilisation de Flash Player 8,
consultez les sections suivantes dans le Guide de référence du langage ActionScript 2.0 :
■
Classe déconseillée
■
Fonctions déconseillées
■
Propriétés déconseillées
■
Opérateurs déconseillés
Modifications de l’éditeur ActionScript
L’éditeur ActionScript dans le panneau Actions et dans la fenêtre Script a subi différentes
mises à jour afin d’être plus fiable et plus simple à utiliser que dans les versions antérieures de
l’outil. Cette section récapitule toutes ces modifications.
Affichage des caractères masqués
Pour activer ou désactiver l’affichage des caractères
masqués, vous pouvez désormais utiliser le menu d’options contextuel de la fenêtre de script,
du panneau Débogueur et du panneau de sortie. Pour plus d’informations sur cette
fonctionnalité, consultez la section Affichage des caractères masqués, page 58.
28
Nouveautés du langage ActionScript de Flash 8
L’Assistant de script a été ajouté au panneau Actions
Dans les versions antérieures de
Flash, vous pouviez travailler dans le panneau Actions soit en mode normal, dans lequel vous
complétiez des options et des paramètres pour créer du code, soit en mode expert, dans lequel
vous ajoutiez des commandes directement dans la fenêtre de script. Ces options n’étaient plus
disponibles dans Flash MX 2004 ou Flash MX Professionnel 2004. Flash Basic 8 et Flash
Professionnel 8 permettent cependant d’utiliser le mode d’Assistant de script, semblable (mais
plus fiable) au mode normal. Pour plus d’informations sur l’Assistant Script, consultez le
Chapitre 13, Ecriture de code ActionScript avec l'Assistant de script dans le guide Utilisation de
Flash. Pour plus d’informations sur l’Assistant Script, consultez le Chapitre 13, Création d'un
événement startDrag/stopDrag à l'aide de l'Assistant de script dans le guide Utilisation de Flash.
Rechargement des fichiers modifiés
Vous pouvez recharger les fichiers script modifiés
lorsque vous travaillez sur une application. Un message d’avertissement apparaît pour vous
rappeler de recharger les fichiers script modifiés en rapport avec l’application sur laquelle vous
travaillez. Cette fonctionnalité est particulièrement profitable aux équipes qui travaillent sur
des applications en même temps, car elle vous évite de travailler avec des scripts dépassés ou
d’écraser des versions plus récentes d’un script. Si un fichier de script a été déplacé ou
supprimé, un message d’avertissement apparaît et vous rappelle d’enregistrer les fichiers selon
besoin. Pour plus d’informations, consultez la section Présentation des préférences
d’ActionScript, page 45.
Modifications du modèle de sécurité pour
les fichiers SWF installés localement
Flash Player 8 possède un nouveau modèle de sécurité améliorée dans lequel les applications
Flash et les fichiers SWF sur un ordinateur local peuvent communiquer par internet sur le
système de fichiers local, plutôt que de passer par un serveur internet à distance. Lors de la
programmation d’une application Flash, il faut indiquer si un fichier SWF est autorisé à
communiquer avec un réseau ou un système de fichiers local.
REMARQUE
Dans le cadre de cette section, un fichier SWF local est un fichier SWF installé
localement sur l’ordinateur d’un utilisateur, et non pas obtenu via un site Web, et qui ne
comprend pas de fichiers de projections (EXE).
Modifications du modèle de sécurité pour les fichiers SWF installés localement
29
Dans les versions antérieures de Flash Player, les fichiers SWF locaux pouvaient interagir avec
d’autres fichiers SWF et charger des données depuis un ordinateur à distance ou local sans
effectuer de réglages de sécurité. Dans Flash Player 8, un fichier SWF ne peut pas établir de
connexions entre le système de fichiers local et le réseau (tel qu’Internet) dans une même
application sans effectuer de réglage de sécurité. Ceci est pour votre sécurité, ainsi un fichier
SWF ne peut pas lire de fichiers sur votre disque dur et donc ne peut pas ensuite envoyer le
contenu de ces fichiers sur internet.
Cette restriction de sécurité affecte un contenu déployé localement, qu’il soit patrimonial (un
fichier FLA créé dans une version antérieure de Flash) ou qu’il ait été créé dans Flash 8. En
utilisant l’outil Flash MX 2004 ou une version antérieure, vous pouviez tester une application
Flash qui s’exécutait localement et accédait également à internet. Dans Flash Player 8, une
telle application demande désormais à l’utilisateur l’autorisation de communiquer avec
Internet.
Quand vous testez un fichier sur votre disque dur, plusieurs étapes permettent de déterminer
si le fichier est un document local fiable (sûr) ou potentiellement incertain (dangereux). Si
vous créez le fichier dans l’environnement autorisé Flash (par exemple, quand vous
sélectionnez Contrôle > Tester le clip), votre fichier est considéré comme fiable parce qu’il se
trouve dans l’environnement de test.
Dans la version Flash Player 7 et les versions antérieures, les fichiers SWF locaux étaient
autorisés à accéder au réseau et au système de fichiers local. Dans Flash Player 8, les fichiers
SWF locaux peuvent disposer de trois niveaux d’autorisation :
■
Accès au système de fichiers local uniquement (niveau par défaut). Le fichier SWF local
peut lire le système de fichiers local et les chemins de réseau de la convention UNC, mais
il ne peut pas communiquer avec Internet.
■
Accès au réseau uniquement. Le fichier SWF local ne peut accéder qu’au réseau (tel
qu’internet) et pas au système de fichiers local sur lequel il est installé.
■
Accès au système de fichiers local et au réseau. Le fichier SWF local peut lire le système de
fichiers local sur lequel il est installé, lire et écrire sur les serveurs qui lui accordent une
autorisation et peut inter-coder d’autres fichiers SWF du réseau ou du système de fichiers
local qui l’y autorisent.
Pour plus de détails sur chaque niveau d’autorisation, consultez la section Sécurité des fichiers
locaux et Flash Player, page 739.
Il y a également de légères modifications à System.security.allowDomain et des améliorations
de System.security.allowInsecureDomain. Pour plus dinformations sur la sécurité des fichiers
locaux, consultez le Chapitre 17, Fonctionnement de la sécurité.
30
Nouveautés du langage ActionScript de Flash 8
CHAPITRE 2
2
Ecriture et modification du
code ActionScript 2.0
Pour écrire du code ActionScript dans Macromedia Flash Basic 8 ou Macromedia Flash
Professionnel 8, utilisez le panneau Actions ou la fenêtre de script. Le panneau Actions et la
fenêtre de script contiennent un éditeur de code très complet (l’Editeur ActionScript) qui
comprend conseils et coloration du code, mise en forme du code, mise en évidence et
vérification de la syntaxe, débogage, numérotation des lignes, retour à la ligne automatique et
prise en charge d’Unicode. Pour plus d’informations sur l’éditeur ActionScript, consultez la
section Utilisation du panneau Actions et de la fenêtre de script, page 36.
Deux méthodes permettent d’écrire du code ActionScript dans Flash. Vous pouvez écrire des
scripts intégrés à votre document Flash (c’est-à-dire des scripts incorporés au fichier FLA) ou
des scripts externes (scripts ou classes stockés dans des fichiers externes). Vous ne pouvez pas
utiliser le panneau Actions pour écrire des scripts externes.
Pour écrire des scripts dans un fichier FLA, utilisez l’éditeur ActionScript à partir du panneau
Actions. Le panneau Actions contient l’éditeur ActionScript dans un panneau de script et les
outils de prise en charge pour simplifier l’écriture des scripts. Ces outils comprennent la boîte
à outils Actions qui vous permet d’accéder rapidement aux éléments de base du langage
ActionScript ; le navigateur de script, qui vous aide à atteindre tous les scripts de votre
document et le mode Assistant de script, qui vous signale les éléments nécessaires à la création
de scripts. Pour plus d’informations sur le panneau Actions, consultez la section Présentation
du panneau Actions, page 37. Pour plus d’informations sur l’Assistant de script, consultez la
section L’Assistant de script, page 64.
Lorsque vous devez créer un script externe, vous utilisez l’éditeur ActionScript dans la fenêtre
de script pour créer un nouveau fichier ActionScript. (Vous pouvez également utiliser votre
éditeur de texte habituel pour créer un fichier AS externe.) Dans la fenêtre de script, l’éditeur
ActionScript comprend des fonctionnalités d’aide à l’écriture de code, telles que la coloration
et les conseils, la vérification de la syntaxe, etc., tout comme dans le panneau Actions. Pour
plus d’informations sur la fenêtre de script, consultez la section Présentation de la fenêtre de
script, page 38.
31
Flash offre une assistance supplémentaire via les comportements. Les comportements sont des
fonctions ActionScript prédéfinies que vous pouvez ajouter aux objets de votre document
Flash sans avoir à créer le code ActionScript vous-même. Pour plus d’informations sur les
comportements, consultez la section Présentation des comportements, page 67.
Pour plus d’informations sur la gestion des événements, reportez-vous aux sections suivantes :
ActionScript et les événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Organisation du code ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Utilisation du panneau Actions et de la fenêtre de script. . . . . . . . . . . . . . . . . . . . . . . 36
Présentation du panneau Actions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Présentation de la fenêtre de script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Programmation dans le panneau Actions et la fenêtre de script . . . . . . . . . . . . . . . . 40
Présentation des fonctionnalités du panneau Actions . . . . . . . . . . . . . . . . . . . . . . . . . 63
Présentation des comportements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
Présentation des paramètres de publication ActionScript . . . . . . . . . . . . . . . . . . . . . 68
ActionScript et les événements
Dans Macromedia Flash Basic 8 et Macromedia Flash Professionnel 8, le code ActionScript
est exécuté lorsque survient un événement : par exemple, lors du chargement d’un clip, de la
saisie d’une image-clé sur le scénario ou lorsque l’utilisateur clique sur un bouton. Ces
événements peuvent être déclenchés par l’utilisateur ou par le système. Les utilisateurs
cliquent avec leur souris et appuient sur des touches ; le système déclenche des événements
lorsque certaines conditions sont remplies ou lorsque des traitements sont terminés (le
chargement d’un fichier SWF, le scénario atteint une certaine image, la fin du téléchargement
d’une image, etc).
Lorsqu’un événement survient, vous écrivez un gestionnaire d’événement pour y répondre par
une action. Il est important de bien comprendre le moment et l’emplacement où surviennent
les événements pour mieux identifier comment et où y répondre par une action, et quels outils
ActionScript utiliser dans chaque cas. Pour plus d’informations, consultez la section Ecriture
de scripts pour gérer les événements, page 35.
Les événements peuvent être regroupés en un certain nombre de catégories : les événements de
souris et de clavier, qui surviennent lorsqu’un utilisateur interagit avec votre application Flash
par l’intermédiaire de la souris et du clavier ; les événements de clip, qui surviennent dans des
clips et les événements d’image, qui surviennent dans les images du scénario.
Pour plus d’informations sur les types de scripts que vous pouvez écrire pour gérer des
événements, consultez la section Ecriture de scripts pour gérer les événements, page 35.
32
Ecriture et modification du code ActionScript 2.0
Evénements de souris et de clavier
Un utilisateur qui interagit avec votre application ou fichier SWF déclenche des événements
avec sa souris et son clavier. Par exemple, lorsque l’utilisateur survole un bouton, l’événement
Button.onRollOver ou on(rollOver) survient. Lorsqu’il clique sur un bouton, il déclenche
l’événement Button.onRelease. S’il appuie sur une touche du clavier, l’événement on
(keyPress) survient. Vous pouvez écrire du code sur une image ou joindre des scripts à une
occurrence pour traiter ces événements et ajouter toute l’interactivité nécessaire.
Evénements de clip
Au sein d’un clip, il est possible de réagir à un certain nombre d’événements déclenchés
lorsque l’utilisateur entre ou quitte la scène ou interagit avec elle par le biais du clavier ou de la
souris. Vous pouvez, par exemple, charger un fichier JPG ou SWF externe dans le clip lorsque
l’utilisateur entre dans la scène. Il est également possible de permettre à l’utilisateur de
déplacer les éléments de la scène par des mouvements de la souris.
Evénements d’image
Dans un scénario principal ou de clip, un événement système survient lorsque la tête de
lecture arrive dans une image-clé. Cette opération est appelée événement d’image. Les
événements d’image sont très utiles pour déclencher des actions en fonction de l’écoulement
du temps (progression dans le scénario) ou pour interagir avec les éléments actuellement
visibles sur la scène. Lorsque vous ajoutez un script à une image-clé, il s’exécute dès que la
lecture atteint cette image-clé. Un script joint à une image est appelé script d’image.
L’une des utilisations les plus courantes des scripts d’image consiste à arrêter la lecture dès
qu’une certaine image-clé est atteinte. Cette opération s’effectue avec la fonction stop().
Vous sélectionnez une image-clé, puis ajoutez la fonction stop() en tant qu’élément de script
dans le panneau Actions.
Après avoir arrêté le fichier SWF à une certaine image-clé, vous devez effectuer certaines
actions. Vous pouvez par exemple utiliser un script d’image pour mettre à jour
dynamiquement la valeur d’un intitulé, pour gérer l’interaction entre les éléments de la scène,
etc.
ActionScript et les événements
33
Organisation du code ActionScript
Vous pouvez joindre des scripts aux images-clés et aux occurrences d’objet (clips, boutons et
autres symboles). Toutefois, si votre code ActionScript est dispersé dans un grand nombre
d’images-clés et d’occurrences d’objet, le débogage de votre application sera bien plus
complexe. Il pourra même être difficile de partager votre code entre différentes applications
Flash. Il est donc important de respecter les meilleures pratiques de programmation lors de la
création de code ActionScript dans Flash.
Au lieu de joindre vos scripts à des éléments de type images-clés, clips et boutons, vous pouvez
répondre aux événements en appelant des fonctions qui résident dans un emplacement
centralisé. Une solution consiste à intégrer du code ActionScript dans la première ou la
deuxième image d’un scénario chaque fois que possible de manière à ne pas devoir rechercher
le code dans le fichier FLA. Une pratique courante consiste à créer un calque appelé actions et
à y placer votre code ActionScript.
Lorsque vous ajoutez des scripts à des éléments individuels, vous intégrez tout votre code au
fichier FLA. Si ce partage du code avec d’autres applications Flash est important pour vous,
servez-vous de la fenêtre de script ou de votre éditeur de texte favoris pour créer un fichier
ActionScript (AS) externe.
En créant un tel fichier, vous améliorez la modularité et l’organisation de votre code. Au fur et
à mesure de la croissance de votre projet, cette précaution s’avérera encore plus utile que vous
ne pouviez l’imaginer. Un fichier externe simplifie le débogage, mais également la gestion du
contrôle du code source si vous travaillez avec d’autres développeurs sur le même projet.
Pour utiliser le code ActionScript contenu dans un fichier AS externe, créez un script dans le
fichier FLA, puis utilisez l’instruction #include pour accéder au code stocké en externe,
comme dans l’exemple suivant :
#include "../core/Functions.as"
34
Ecriture et modification du code ActionScript 2.0
Vous pouvez également utiliser du code ActionScript 2.0 pour créer des classes personnalisées.
Vous devez stocker des classes personnalisées dans les fichiers AS externes et insérer des
instructions import dans un script pour exporter les classes dans le fichier SWF, sans utiliser
les instructions #include. Pour plus d’informations sur l’écriture de fichiers de classe,
consultez les sections Ecriture de fichiers de classe personnalisée, page 254 et Importation de
fichiers de classe, page 259 sur l’importation des fichiers de classe. Vous pouvez également
utiliser des composants (clips prédéfinis) pour partager du code et des fonctionnalités, par
exemple des éléments de l’interface utilisateur et des scripts.
REMARQUE
Le code ActionScript des fichiers externes est compilé dans un fichier SWF lors de la
publication, de l’exportation, du test ou du débogage d’un fichier FLA. Cela signifie que
si vous apportez des modifications à un fichier externe, vous devez enregistrer le fichier
et recompiler tous les fichiers FLA qui l’utilisent.
Lorsque vous écrivez du code ActionScript dans Flash 8, vous utilisez le panneau Actions, la
fenêtre de script, ou les deux. Vous utiliserez le panneau Actions ou la fenêtre de script selon
votre façon de répondre aux événements, d’organiser votre code et, plus important encore, vos
meilleures pratiques de programmation.
Pour plus d’informations sur les meilleures pratiques et les conventions de codage, consultez la
section Conventions de programmation ActionScript, page 813.
Lorsque vous utilisez des comportements qui sont des fonctions ActionScript prédéfinies
(consultez la section Présentation des comportements, page 67), d’autres questions
d’organisation du flux de travail et du code doivent être prises en considération.
Ecriture de scripts pour gérer les événements
L’écriture de code pour les événements se divise en deux grands groupes : les événements qui
se produisent dans le scénario (dans des images-clés) et ceux qui se produisent dans des
occurrences d’objet (clips, boutons et composants). L’interactivité de votre application ou de
votre fichier SWF peut s’éparpiller entre les nombreux éléments de votre projet et vous
pourriez être tenté d’ajouter des scripts directement à ces éléments. Macromedia vous
déconseille cependant d’ajouter directement des scripts à ces éléments (images-clés et objets).
Vous pouvez par contre répondre aux événements en appelant des fonctions qui résident dans
un emplacement centralisé, comme décrit à la section Organisation du code ActionScript.
Organisation du code ActionScript
35
Utilisation du panneau Actions et de la
fenêtre de script
Pour créer des scripts dans un fichier FLA, accédez directement à ActionScript via le panneau
Actions. Pour créer des scripts externes à intégrer ou importer dans votre application, utilisez
la fenêtre de script (Fichier > Nouveau, puis sélectionnez Fichier ActionScript) ou votre
éditeur de texte habituel.
Que vous passiez par le panneau Actions ou la fenêtre de script, vous utilisez des
fonctionnalités de l’éditeur ActionScript pour écrire, mettre en forme et modifier votre code.
Le panneau Actions et la fenêtre de script contiennent le panneau de script (dans lequel vous
saisissez votre code) et la boîte à outils Actions. Le panneau Actions offre quelques
fonctionnalités d’aide à l’écriture de code que n’offre pas la fenêtre de script. Flash offre ces
fonctionnalités dans le panneau Actions car elles sont particulièrement utiles pour la
modification de code ActionScript dans un fichier FLA.
Pour afficher le panneau Actions, effectuez l’une des opérations suivantes :
■
Choisissez Fenêtre > Actions.
■
Appuyez sur la touche F9.
Pour afficher la fenêtre de script, effectuez l’une des opérations suivantes :
■
Pour commencer à rédiger un nouveau script, choisissez Fichier > Nouveau, puis
sélectionnez Fichier ActionScript.
■
Pour ouvrir un script existant, choisissez Fichier > Ouvrir, puis ouvrez un fichier
ActionScript (AS) existant.
■
Pour modifier un script déjà ouvert, cliquez sur l’onglet du document portant le nom du
script.
Pour plus d’informations, voir les sections suivantes :
■
Présentation du panneau Actions, page 37
■
Présentation de la fenêtre de script, page 38
36
Ecriture et modification du code ActionScript 2.0
Présentation du panneau Actions
Le panneau Actions permet de créer du code ActionScript dans un document Flash (un fichier
FLA). Il se compose de trois panneaux destinés à vous aider à créer et à gérer vos scripts.
Boîte à outils Actions
Navigateur scripts
Panneau Script
Menu contextuel
Boîte à outils Actions Utilisez la boîte à outils Actions pour parcourir la liste catégorisée
des éléments du langage ActionScript (fonctions, classes, types, etc.), puis les insérer dans
le panneau de script. Pour insérer un élément de script dans le panneau de script, faites-le
simplement glisser vers ce dernier ou double-cliquez sur son entrée. Vous pouvez
également ajouter des éléments du langage dans vos scripts via le bouton Ajouter (+) de la
barre d’outils du panneau Actions. Pour plus d’informations, consultez la section
Présentation des barres d’outils du panneau Actions et de la fenêtre de script, page 41.
Navigateur de script
Le navigateur de script présente la liste hiérarchisée des éléments
Flash (clips, images et boutons) contenant des scripts. Servez-vous du navigateur de script
pour passer rapidement d’un script à l’autre dans votre document Flash.
Si vous cliquez sur un élément dans le navigateur de script, le script correspondant
s’affiche dans le panneau de script et la tête de lecture se déplace jusqu’à cette position
dans le scénario. Si vous double-cliquez sur un élément dans le navigateur de script, le
script est épinglé (verrouillé sur place). Pour plus d’informations, consultez la section
Verrouillage de scripts dans le panneau Actions, page 64.
Présentation du panneau Actions
37
Panneau de script Le panneau de script est la zone dans laquelle vous saisissez le code.
Le panneau de script fournit les outils nécessaires à la création de scripts dans un éditeur
complet (l’Editeur ActionScript) comprenant vérification et mise en forme de la syntaxe,
conseils et coloration, débogage et autres fonctionnalités qui simplifient la création des
scripts. Pour plus d’informations, consultez la section Utilisation du panneau Actions et de
la fenêtre de script, page 36.
Pour plus d’informations sur chacun des boutons de la barre d’outils du panneau Actions,
consultez la section Programmation dans le panneau Actions et la fenêtre de script, page 40.
Pour plus d’informations sur les fonctionnalités du panneau Actions, consultez les
rubriques suivantes :
■
Présentation des barres d’outils du panneau Actions et de la fenêtre de script, page 41
■
Présentation des options d’édition ActionScript, page 43
■
Présentation des conseils de code dans Flash, page 47
■
Formatage du code, page 54
■
Mise en évidence de la syntaxe, page 55
■
Utilisation des numéros de ligne et du retour à la ligne, page 56
■
Utilisation des touches de raccourci d’échappement, page 57
■
Affichage des caractères masqués, page 58
■
Utilisation de l’outil Rechercher, page 59
■
Vérification de la syntaxe et de la ponctuation, page 60
■
Importation et exportation de scripts, page 61
Présentation de la fenêtre de script
Vous pouvez écrire et modifier du code ActionScript dans la fenêtre de script pour créer un
nouveau fichier ActionScript, Flash Communication ou Flash JavaScript. Vous utilisez la
fenêtre de script pour écrire et modifier des fichiers de script externes. Cette fenêtre prend en
charge les conseils et la coloration du code ainsi que d’autres options d’édition.
La fenêtre de script permet de créer plusieurs sortes de fichiers : ActionScript externes,
communication ActionScript et Flash JavaScript. Selon le type de fichier externe créé, la boîte
à outils Actions fournit la liste complète des éléments de langage disponibles.
Lorsque vous utiliserez la fenêtre de script, vous remarquerez que certaines fonctionnalités
d’aide comme le navigateur de script, le mode Assistant de script et les comportements ne sont
pas disponibles. Cette absence est due au fait que ces fonctionnalités ne sont très utiles que
pour la création de document Flash, pas pour celle de fichier de script externe.
38
Ecriture et modification du code ActionScript 2.0
Vous remarquerez également que la plupart des options disponibles dans le panneau Actions
sont absentes de la fenêtre de script. La fenêtre de script prend en charge les options d’édition
suivantes : la boîte à outils Actions, les options chercher/remplacer, la vérification de la
syntaxe, la mise en forme automatique, les conseils de code et les options de débogage (fichiers
ActionScript uniquement). La fenêtre de script prend également en charge la numérotation
des lignes, les caractères masqués et le retour à la ligne.
Pour ouvrir la fenêtre de script :
1.
Sélectionnez Fichier > Nouveau.
2.
Sélectionnez le type de fichier externe à créer (fichier ActionScript, Flash Communication
ou Flash JavaScript).
Vous pouvez ouvrir plusieurs fichiers externes simultanément. Leurs noms s’affichent alors sur
des onglets en haut de la fenêtre de script. Pour plus d’informations sur les fonctionnalités de
la fenêtre de script, consultez les rubriques suivantes :
■
Présentation des barres d’outils du panneau Actions et de la fenêtre de script, page 41
■
Présentation des options d’édition ActionScript, page 43
■
Présentation des conseils de code dans Flash, page 47
■
Formatage du code, page 54
■
Mise en évidence de la syntaxe, page 55
■
Utilisation des numéros de ligne et du retour à la ligne, page 56
■
Utilisation des touches de raccourci d’échappement, page 57
■
Affichage des caractères masqués, page 58
■
Utilisation de l’outil Rechercher, page 59
■
Vérification de la syntaxe et de la ponctuation, page 60
■
Importation et exportation de scripts, page 61
Présentation de la fenêtre de script
39
Programmation dans le panneau Actions
et la fenêtre de script
Le panneau de script, dans lequel vous modifiez le code, est l’élément central du panneau
Actions et de la fenêtre de script. Le panneau Actions et la fenêtre de script offrent les
fonctions élémentaires d’aide à la programmation et d’édition de script, telles que les conseils
de code, la coloration, la mise en forme automatique, etc.
La barre d’outils du panneau Actions ou de la fenêtre de script (via le système de menus et
directement dans le panneau de script) propose des fonctionnalités qui vous aideront à
modifier le code.
Les sections suivantes présentent les nombreuses fonctions de l’éditeur ActionScript (panneau
Actions et fenêtre de script) :
■
Présentation des barres d’outils du panneau Actions et de la fenêtre de script, page 41
■
Présentation des options d’édition ActionScript, page 43
■
Présentation des préférences d’ActionScript, page 45
■
Présentation des conseils de code dans Flash, page 47
■
Formatage du code, page 54
■
Mise en évidence de la syntaxe, page 55
■
Utilisation des numéros de ligne et du retour à la ligne, page 56
■
Utilisation des touches de raccourci d’échappement, page 57
■
Affichage des caractères masqués, page 58
■
Utilisation de l’outil Rechercher, page 59
■
Vérification de la syntaxe et de la ponctuation, page 60
■
Importation et exportation de scripts, page 61
Pour les fonctionnalités spécifiques au panneau Actions, telles que le verrouillage de scripts et
le navigateur de script, consultez la section Présentation des fonctionnalités du panneau Actions,
page 63.
40
Ecriture et modification du code ActionScript 2.0
Présentation des barres d’outils du panneau Actions
et de la fenêtre de script
Les barres d’outils du panneau Actions et de la fenêtre de script contiennent des liens pointant
vers les fonctionnalités d’aide à la programmation qui simplifient et rationalisent l’écriture du
code dans ActionScript. Les barres d’outils diffèrent selon que vous utilisez l’éditeur
ActionScript dans le panneau Actions ou dans le panneau de script. L’illustration suivante
présente les fonctions de la barre d’outils du panneau Actions. Les options signalées par une
étoile ne sont disponibles que dans le panneau Actions.
Ajouter un nouvel élément au script
Rechercher
Options de débogage*
Insérer un chemin cible*
Afficher les conseils de code
Menu contextuel*
Assistant de script *
Référence
Format automatique
Vérifier la syntaxe
* Panneau Actions uniquement
Les fonctions de la barre d’outils sont détaillées à la section Utilisation du panneau Actions et de
la fenêtre de script, page 36. Voici une brève présentation des boutons disponibles sur les barres
d’outils du panneau Actions et de la fenêtre de script.
REMARQUE
Certaines des options suivantes ne sont disponibles que dans le panneau Actions. Elles
sont signalées par la mention Panneau Actions uniquement.
Ajouter un nouvel élément au script
Affiche tous les éléments de langage également
présents dans la boîte à outils d’ActionScript. Il suffit de sélectionner un élément dans la
liste des catégories d’éléments de langage pour l’ajouter au script.
Rechercher
Permet de rechercher et de remplacer un texte dans votre code
ActionScript. Pour plus d’informations, consultez la section Utilisation de l’outil
Rechercher, page 59.
Insérer un chemin cible Panneau Actions uniquement. Cette fonction vous aide à définir
un chemin de cible absolu ou relatif pour une action du script. Pour plus d’informations,
consultez la section Insertion de chemins cible, page 66.
Programmation dans le panneau Actions et la fenêtre de script
41
Vérifier la syntaxe
Cette fonction vous permet de rechercher les erreurs de syntaxe dans
le script en cours. Les erreurs de syntaxe sont signalées dans le panneau Sortie. Pour plus
d’informations, consultez la section Vérification de la syntaxe et de la ponctuation, page 60.
Format automatique
Cette fonction met votre script en forme en adoptant la syntaxe
de codage appropriée et en améliorant sa lisibilité. Vous pouvez définir vos préférences de
mise en forme automatique dans la boîte de dialogue Préférences, accessible via le menu
Edition et le menu contextuel du panneau Actions. Pour plus d’informations, consultez la
section Formatage du code, page 54.
Afficher les conseils de code
Si vous avez désactivé les conseils de code automatiques,
cette commande vous permet d’afficher manuellement des conseils de code pour la ligne
sur laquelle vous travaillez. Pour plus d’informations, consultez la section L’Assistant de
script, page 64.
Options de débogage
Cette commande vous permet de définir et de supprimer des
points d’arrêt dans votre script de manière à pouvoir parcourir le script ligne par ligne
pendant le débogage de votre document Flash. Les options de débogage sont désormais
disponibles dans la fenêtre de script et dans le panneau Actions, mais uniquement pour les
fichiers ActionScript. Elles ne sont pas disponibles pour les fichiers ActionScript
Communication et Flash JavaScript. Pour plus d’informations sur le débogage de vos
documents Flash, consultez la section Débogage de scripts, page 776. Pour plus
d’informations sur la définition ou la suppression de points d’arrêt, consultez la section
Définition et suppression des points d’arrêt, page 785.
Assistant de script
Panneau Actions uniquement. En mode Assistant de script, vous êtes
invité à saisir les éléments nécessaires pour créer les scripts. Pour plus d’informations,
consultez la section L’Assistant de script, page 64.
Référence
Cette fonction permet d’afficher une rubrique d’aide de référence pour
l’élément du langage ActionScript sélectionné dans la fenêtre de script. Par exemple, si
vous cliquez sur une instruction import, puis sur Référence, la rubrique d’aide relative à
import s’affiche dans le panneau Aide.
Menu contextuel Panneau Actions uniquement. Contient la plupart des commandes et
préférences s’appliquant au panneau Actions ou à la fenêtre de script. Par exemple, vous
pouvez définir la numérotation des lignes et le retour à la ligne dans l’éditeur ActionScript,
l’accès aux préférences ActionScript et l’importation ou l’exportation des scripts. Pour plus
d’informations, consultez la section Présentation des options d’édition ActionScript, page 43.
42
Ecriture et modification du code ActionScript 2.0
Présentation des options d’édition ActionScript
La fenêtre de script et le panneau Actions offrent de nombreuses fonctionnalités d’aide à la
programmation, outils qui simplifient grandement l’écriture et la maintenance de vos scripts.
Les options de ces outils sont disponibles dans la barre d’outils du panneau Actions ou de la
fenêtre de script, ainsi que dans le menu contextuel du panneau Actions. Lors de la
modification de code ActionScript dans la fenêtre de script, ces options sont disponibles dans
la barre d’outils et dans les menus de Flash.
Le panneau Actions offre davantage d’options que la fenêtre de script. En effet, ces
fonctionnalités supplémentaires sont très utiles pour la création de code ActionScript intégré
dans un document Flash, pas pour l’écriture de fichiers de script externes. Pour plus
d’informations sur les options disponibles dans la fenêtre de script, consultez la section
Présentation de la fenêtre de script, page 38.
Les options accessibles dans la fenêtre de script et dans le panneau Actions sont détaillées dans
la section Présentation des barres d’outils du panneau Actions et de la fenêtre de script, page 41.
Les options suivantes sont disponibles dans le menu contextuel du panneau Actions et dans
divers menus de la fenêtre de script.
REMARQUE
Certaines des options suivantes ne sont disponibles que dans le panneau Actions. Elles
sont signalées par la mention Panneau Actions uniquement.
Recharger les conseils de code Panneau Actions uniquement. Si vous personnalisez le
mode Assistant de script en écrivant des méthodes personnalisées, vous pouvez recharger
les conseils de code sans redémarrer Flash 8.
Verrouiller le script Panneau Actions uniquement. Cette fonction vous permet d’ancrer
le script actuellement affiché dans la fenêtre de script. Pour plus d’informations, consultez
la section Verrouillage de scripts dans le panneau Actions, page 64.
Fermer le script
Panneau Actions uniquement. Cette fonction permet de fermer le script
ouvert.
Fermer tous les scripts
Panneau Actions uniquement. Cette fonction permet de
refermer tous les scripts ouverts.
Atteindre la ligne
Cette fonction permet de localiser et de mettre en évidence la ligne
spécifiée dans la fenêtre de script.
Rechercher et remplacer
Cette fonction permet de rechercher un texte dans les scripts
affichés dans la fenêtre de script et de le remplacer par un autre. Pour plus d’informations,
consultez la section Utilisation de l’outil Rechercher, page 59.
Programmation dans le panneau Actions et la fenêtre de script
43
Rechercher à nouveau
Cette fonction permet de recommencer la recherche de la
dernière chaîne saisie dans l’outil de recherche. Pour plus d’informations, consultez la
section Utilisation de l’outil Rechercher, page 59.
Importer un script
Cette fonction permet d’importer un fichier de script (ActionScript)
dans la fenêtre de script. Pour plus d’informations, consultez la section Importation et
exportation des préférences, page 62.
Exporter le script
Cette fonction permet d’exporter le script actif dans un fichier
ActionScript (AS) externe. Pour plus d’informations, consultez la section Importation et
exportation des préférences, page 62.
Touches de raccourci Echap Ces touches permettent de saisir rapidement des
éléments de langage courants et des structures de syntaxe dans vos scripts. Par exemple,
lorsque vous appuyez sur Echap+g+p dans la fenêtre de script, la fonction gotoAndPlay()
est insérée dans le script. Lorsque cette option est activée dans le menu contextuel du
panneau Actions, toutes les touches de raccourci Echap disponibles apparaissent dans la
boîte à outils Actions. Pour plus d’informations, consultez la section Utilisation des touches
de raccourci d’échappement, page 57.
Caractères masqués Affiche les caractères masqués dans votre script : espaces,
tabulations et sauts de ligne. Pour plus d’informations, consultez la section Affichage des
caractères masqués, page 58.
Numéros de lignes
Cette fonction permet d’afficher les numéros de lignes dans la
fenêtre de script. Pour plus d’informations, consultez la section Utilisation des numéros de
ligne et du retour à la ligne, page 56.
Préférences Panneau Actions uniquement. Cette fonction affiche la boîte de dialogue
Préférences d’ActionScript. Pour plus d’informations, consultez la section Présentation des
préférences d’ActionScript, page 45.
Retour à la ligne
Pour répartir les lignes de votre script qui ne rentrent pas dans la
fenêtre de script, activez cette option dans le menu contextuel du panneau Actions. Dans
la fenêtre de script, choisissez Retour à la ligne dans le menu Affichage. Pour plus
d’informations, consultez la section Utilisation des numéros de ligne et du retour à la ligne,
page 56.
Grouper Actions avec
Panneau Actions uniquement. Cette fonction permet de
regrouper le panneau Actions (avec la boîte à outils Actions et le navigateur de script) avec
les autres panneaux de l’environnement de programmation de Flash.
Le menu contextuel du panneau Actions comprend également les commandes d’impression,
d’aide et de redimensionnement des panneaux.
44
Ecriture et modification du code ActionScript 2.0
Présentation des préférences d’ActionScript
Que vous modifiez du code dans le panneau Actions ou dans la fenêtre de script, vous pouvez
définir et modifier un seul jeu de préférences. Vous pouvez par exemple contrôler le retrait
automatique, les conseils et la coloration du code et un certain nombre d’autres
fonctionnalités de base d’édition du code.
Pour accéder aux préférences d’ActionScript :
1.
Pour accéder aux préférences ActionScript dans un fichier FLA dans le panneau Actions,
sélectionnez Préférences dans le menu contextuel ou Edition > Préférences (Windows) ou
Flash > Préférences (Macintosh), puis cliquez sur ActionScript dans la liste des catégories.
2.
Pour accéder aux préférences d’ActionScript dans la fenêtre de script, sélectionnez Edition
> Préférences, puis cliquez sur ActionScript (Windows) ou sélectionnez Flash > Préférences,
puis cliquez sur ActionScript (Macintosh).
L’illustration suivante présente les paramètres ActionScript que vous pouvez modifier dans
Flash 8.
Programmation dans le panneau Actions et la fenêtre de script
45
Vous pouvez définir les préférences suivantes :
Indentation automatique
Lorsque cette option est activée, le texte saisi après une
parenthèse ouvrante [(] ou une accolade ouvrante [{] est automatiquement mis en retrait
conformément à la valeur de taille de tabulation définie dans les préférences d’ActionScript.
Pour plus d’informations, consultez la section Formatage du code, page 54.
Taille des tabulations
Précise le nombre de caractères de retrait à appliquer à une ligne
lorsque l’indentation automatique est activée.
Conseils de code
Active les conseils de code dans la fenêtre de script. Pour plus
d’informations sur l’utilisation des conseils de code, consultez la section Présentation des
conseils de code dans Flash, page 47.
Délai
Précise le délai (en secondes) devant s’écouler avant l’affichage des conseils de code.
Police
Spécifie la police utilisée dans la fenêtre de script.
Utiliser le mappage de police dynamique Permet de vérifier que la famille de polices
sélectionnée dispose de tous les glyphes nécessaires pour tracer chaque caractère. Si ce n’est pas
le cas, Flash la remplace par une famille de police contenant les caractères nécessaires. Pour
plus d’informations, consultez la section Formatage du code, page 54.
Ouvrir/Importer et Enregistrer/Exporter
Désigne le codage de caractères utilisé à
l’ouverture, à l’enregistrement, à l’importation et à l’exportation des fichiers ActionScript.
Pour plus d’informations, consultez la section Importation et exportation de scripts, page 61.
Recharger les fichiers modifiés
Cette option vous permet de spécifier l’affichage
d’avertissements lorsqu’un fichier de script est modifié, déplacé ou supprimé. Sélectionnez
Toujours, Jamais ou Demander.
Toujours
■
Aucun avertissement ne s’affiche lorsqu’une modification est détectée. Le
fichier est automatiquement rechargé.
■
Jamais
Aucun avertissement ne s’affiche lorsqu’une modification est détectée. Le fichier
conserve son état actuel.
■
Demander
(Par défaut) Un avertissement s’affiche lorsqu’une modification est détectée.
Vous pouvez choisir de recharger ou non le fichier.
Lorsque vous élaborez des applications faisant appel à des fichiers de script externes, cette
fonctionnalité évite d’écraser un script qui a été modifié par un membre de l’équipe depuis la
dernière fois que vous avez ouvert l’application. Elle évite également de publier l’application
avec des versions de scripts antérieures. L’avertissement vous permet de fermer
automatiquement un script pour rouvrir la version plus récente, modifiée.
Coloration du code Spécifie les couleurs à appliquer au code dans vos scripts. Lorsque la
coloration du code est activée, vous pouvez choisir les couleurs à afficher dans la fenêtre de
script.
46
Ecriture et modification du code ActionScript 2.0
Langue Ouvre la boîte de dialogue Paramètres d’ActionScript. Pour plus d’informations,
consultez la section Modification du chemin de classe, page 69.
Présentation des conseils de code dans Flash
Lorsque vous utilisez le panneau Actions ou fenêtre de script, plusieurs fonctionnalités
peuvent vous aider à rédiger votre code dans une syntaxe correcte. Ces conseils de code vous
aident à écrire rapidement et précisément votre code. Les conseils de code comprennent des
infos-bulles affichant la syntaxe correcte et des menus dans lesquels vous choisissez les noms
des propriétés et des méthodes. Les sections suivantes décrivent l’utilisation de ces
fonctionnalités pour écrire du code.
■
Déclenchement des conseils de code, page 47
■
Utilisation des conseils de code, page 48
■
Typage des objets pour déclencher les conseils de code, page 51
■
Utilisation de suffixes pour déclencher les conseils de code, page 51
■
Utilisation de commentaires pour déclencher les conseils de code, page 53
Déclenchement des conseils de code
Lorsque vous travaillez dans le panneau Actions ou la fenêtre de script, Flash peut détecter
l’action saisie et afficher un conseil de code. Il existe deux styles différents de conseil de code :
une info-bulle qui présente la syntaxe complète de l’action, et un menu contextuel qui
énumère les noms possibles pour les méthodes et les propriétés (parfois appelé finalisation du
code). Un menu contextuel s’affiche pour les paramètres, les propriétés et les événements
lorsque vous typez ou nommez les objets de façon stricte, comme indiqué dans le reste de cette
section.
Les conseils de code s’affichent parfois lorsque vous double-cliquez sur un élément de la boîte
à outils Actions ou lorsque vous cliquez sur Ajouter (+) dans la barre d’outils du panneau
Actions ou de la fenêtre de script pour ajouter des actions dans la fenêtre de script. Pour plus
d’informations sur l’utilisation des conseils de code lorsqu’ils apparaissent, consultez la section
Utilisation des conseils de code, page 48.
R E MA R Q U E
Les conseils de code sont activés automatiquement pour les classes natives pour
lesquelles vous n’avez pas besoin de créer ni de nommer d’occurrence de classe, telles
que Math, Key, Mouse, etc.
Programmation dans le panneau Actions et la fenêtre de script
47
Pour être certain d’activer les conseils de code, sélectionnez leurs options dans la boîte de
dialogue Préférences d’ActionScript. Pour plus d’informations, consultez la section
Présentation du panneau Actions, page 37.
Utilisation des conseils de code
Les conseils de code sont activés par défaut. Des préférences vous permettent de désactiver les
conseils de code ou de déterminer la vitesse à laquelle ils s’affichent. Lorsque les conseils de
code sont désactivés dans les préférences, il est toujours possible d’afficher un conseil de code
pour une commande spécifique.
Pour définir des paramètres pour les conseils de code automatiques, effectuez
l’une des opérations suivantes :
■
Dans le panneau Actions ou la fenêtre de script, sélectionnez Edition > Préférences
(Windows) ou Flash > Préférences (Macintosh), cliquez sur ActionScript dans la liste des
catégories, puis activez ou désactivez les conseils de code.
■
Dans le panneau Actions, dans le menu contextuel (dans le coin supérieur droit du
panneau), choisissez Préférences puis, dans les préférences d’ActionScript, activez ou
désactivez Conseils de code.
Si vous activez les conseils de code, vous pouvez également spécifier un délai d’affichage, en
secondes. Par exemple, si vous découvrez ActionScript, il pourrait être souhaitable de ne
spécifier aucun délai, de sorte que les conseils de code s’affichent toujours immédiatement.
Toutefois, si vous connaissez la syntaxe de votre code et que vous avez besoin de conseils
uniquement pour certains éléments de langage, vous pouvez spécifier un délai de sorte que les
conseils de code ne s’affichent pas systématiquement.
Pour spécifier un délai pour les conseils de code :
1.
Dans le panneau Actions ou la fenêtre de script, sélectionnez Edition > Préférences
(Windows) ou Flash > Préférences (Macintosh) dans le menu principal.
2.
Cliquez sur ActionScript dans la liste des catégories.
3.
Faites glisser le curseur pour définir le délai.
Le délai est exprimé en secondes.
48
Ecriture et modification du code ActionScript 2.0
Pour utiliser des conseils de code de type info-bulle :
1.
Faites apparaître un conseil de code en tapant une parenthèse d’ouverture [(] après un
élément qui nécessite l’utilisation des parenthèses, tel qu’un nom de méthode, une
commande comme if ou do..while, etc.
Le conseil de code apparaît.
REMARQUE
2.
Si aucun conseil de code n’apparaît, assurez-vous que vous n’avez pas désactivé les
conseils de code dans les préférences d’ActionScript (Edition > Préférences
(Windows) ou Flash > Préférences (Macintosh), puis cliquez sur ActionScript dans la
liste des catégories). Pour afficher des conseils de code pour une variable ou un
objet que vous avez créé(e), assurez-vous que vous avez nommé correctement la
variable ou l’objet (consultez la section Utilisation de suffixes pour déclencher les
conseils de code, page 51), ou que vous avez défini strictement son type (consultez la
section Typage des objets pour déclencher les conseils de code, page 51).
Entrez une valeur pour le paramètre.
S’il existe plusieurs paramètres, séparez les valeurs par des virgules. Pour les fonctions ou
les instructions telles que la boucle for, séparez les paramètres par des points-virgules.
Des commandes étendues telles que gotoAndPlay() ou for (il s’agit de fonctions ou de
méthodes qui peuvent être invoquées selon différents jeux de paramètres) affichent un
indicateur qui vous permet de choisir le paramètre que vous souhaitez définir. Cliquez sur
les petits boutons fléchés ou appuyez sur Ctrl+Flèche gauche ou Ctrl+Flèche droite pour
choisir le paramètre.
3.
Pour annuler le conseil de code, effectuez l’une des opérations suivantes :
■
Tapez une parenthèse de fermeture [)].
■
Cliquez à l’extérieur de l’instruction.
■
Appuyez sur la touche Echap.
Programmation dans le panneau Actions et la fenêtre de script
49
Pour utiliser des conseils de code de type menu :
1.
Faites apparaître le conseil de code en tapant un point après le nom de la variable ou de
l’objet.
Le menu du conseil de code apparaît.
REMARQUE
Si aucun conseil de code n’apparaît, assurez-vous que vous n’avez pas désactivé les
conseils de code dans les préférences d’ActionScript (Edition > Préférences
(Windows) ou Flash > Préférences (Macintosh), puis cliquez sur ActionScript dans la
liste des catégories). Pour afficher des conseils de code pour une variable ou un
objet que vous avez créé(e), assurez-vous que vous avez nommé correctement la
variable ou l’objet (consultez la section Utilisation de suffixes pour déclencher les
conseils de code, page 51), ou que vous avez défini strictement son type (consultez la
section Typage des objets pour déclencher les conseils de code, page 51).
2.
Pour naviguer dans les conseils de code, utilisez les touches Flèche Haut ou Flèche Bas.
3.
Pour sélectionner un élément dans le menu, appuyez sur Entrée ou Tab, ou double-cliquez
sur cet élément.
4.
Pour annuler le conseil de code, effectuez l’une des opérations suivantes :
■
Choisissez l’un des éléments du menu.
■
Cliquez au-dessus ou en dessous de la fenêtre de menu.
■
■
50
Si vous avez déjà tapé une parenthèse d’ouverture [(], tapez une parenthèse de
fermeture [(].
Appuyez sur la touche Echap.
Ecriture et modification du code ActionScript 2.0
Pour afficher manuellement un conseil de code :
1.
Cliquez sur le code, à l’emplacement où vous souhaitez afficher des conseils, comme dans
les exemples suivants :
■
■
2.
Après le point (.) qui suit une instruction ou une commande, à l’endroit où une
propriété ou une méthode doit être entrée.
Entre les parenthèses [()] dans un nom de méthode
Effectuez l’une des opérations suivantes :
■
■
■
Cliquez sur Afficher les conseils de code dans la barre d’outils du panneau Actions ou
de la fenêtre de script.
Appuyez sur Ctrl+Barre d’espace (Windows) ou sur Commande+Barre d’espace
(Macintosh).
Dans le panneau Actions, sélectionnez Afficher les conseils de code dans le menu
contextuel.
Typage des objets pour déclencher les conseils de code
Lorsque vous utilisez ActionScript 2.0, vous pouvez définir strictement le type d’une variable
qui est basée sur une classe intégrée, telle que Button, Array, etc. Si vous faites cela, le panneau
de script affiche des conseils de code relatifs à la variable. Par exemple, supposons que vous
tapez ce qui suit :
var names:Array = new Array();
names.
Dès que vous tapez un point (.), Flash affiche la liste des méthodes et propriétés disponibles
pour les objets Array dans un menu contextuel, car vous avez défini la variable comme étant
de type tableau. Pour plus d’informations sur le typage des données, consultez la section
Affectation des types de données et typage strict, page 88. Pour plus d’informations sur
l’utilisation des conseils de code lorsqu’ils apparaissent, consultez la section Utilisation des
conseils de code, page 48.
Utilisation de suffixes pour déclencher les conseils de code
Si vous utilisez ActionScript 1 ou si vous souhaitez afficher des conseils de code pour des
objets que vous créez sans définir strictement leur type (consultez la section Typage des objets
pour déclencher les conseils de code, page 51), vous devez ajouter un suffixe spécial au nom de
chaque objet lors de sa création. Par exemple, les suffixes qui déclenchent des conseils de code
pour les classes Array et Camera sont respectivement _array et _cam. Par exemple, si vous
tapez ce qui suit :
var my_array = new Array();
var my_cam = Camera.get();
Programmation dans le panneau Actions et la fenêtre de script
51
vous pouvez taper l’un des éléments suivants (nom de variable suivi par un point) :
my_array.
my_cam.
Des conseils de saisie de code s’affichent pour les objets Array et Camera.
Pour les objets qui apparaissent sur la scène, entrez le suffixe dans le champ Nom de
l’occurrence, dans l’inspecteur des propriétés. Par exemple, pour afficher des conseils de code
pour des objets MovieClip, utilisez l’inspecteur des propriétés pour affecter des noms
d’occurrences portant le suffixe _mc à tous les objets MovieClip. Lorsque vous taperez le nom
d’une occurrence suivi d’un point, des conseils de code d’afficheront.
Même si les suffixes ne sont pas nécessaires au déclenchement des conseils de code lorsque
vous définissez strictement le type d’un objet, il est recommandé de les utiliser de façon
cohérente pour rendre vos scripts plus compréhensibles.
Le tableau suivant répertorie les suffixes requis pour la prise en charge des conseils de code
automatiques :
Type d’objet
Suffixe de variable
Array
_array
Button
_btn
Camera
_cam
Color
_color
ContextMenu
_cm
ContextMenuItem
_cmi
Date
_date
Error
_err
LoadVars
_lv
LocalConnection
_lc
Microphone
_mic
MovieClip
_mc
MovieClipLoader
_mcl
PrintJob
_pj
NetConnection
_nc
NetStream
_ns
SharedObject
_so
Sound
_sound
52
Ecriture et modification du code ActionScript 2.0
Type d’objet
Suffixe de variable
String
_str
TextField
_txt
TextFormat
_fmt
Video
_video
XML
_xml
XMLNode
_xmlnode
XMLSocket
_xmlsocket
Pour plus d’informations sur l’utilisation des conseils de code lorsqu’ils apparaissent, consultez
la section Utilisation des conseils de code, page 48.
Utilisation de commentaires pour déclencher les conseils de
code
Vous pouvez également utiliser des commentaires ActionScript pour spécifier la classe d’un
objet pour les conseils de code. L’exemple suivant indique à ActionScript que la classe de
l’occurrence theObject est Object, et ainsi de suite. Si vous vous apprêtez à saisir mc suivi
d’un point après ces commentaires, des conseils de code affichant la liste des méthodes et des
propriétés MovieClip apparaissent. Si vous vous apprêtez à saisir theArray suivi d’un point,
un menu affichant la liste des méthodes et des propriétés Array apparaît, et ainsi de suite.
// Objet theObject;
// Tableau theArray;
// MovieClip theMc;
Toutefois, Macromedia recommande d’utiliser le typage strict des données (consultez la
section Typage des objets pour déclencher les conseils de code, page 51) ou les suffixes (consultez la
section Utilisation de suffixes pour déclencher les conseils de code, page 51), car ces techniques
permettent d’obtenir des conseils de code automatiquement et rendent votre code plus
compréhensible. Pour plus d’informations sur les conseils de code, consultez la section
Utilisation des conseils de code, page 48.
Programmation dans le panneau Actions et la fenêtre de script
53
Formatage du code
Vous pouvez définir des paramètres pour déterminer si votre code est formaté et mis en retrait
automatiquement ou manuellement. En outre, vous pouvez indiquer si vous souhaitez
recourir au mappage de police dynamique, qui permet de s’assurer que les polices requises sont
appliquées quelle que soit la langue du texte.
Pour définir des options de format :
1.
Dans le panneau Actions, sélectionnez Préférences dans le menu contextuel (coin supérieur
droit du panneau). Dans la boîte de dialogue Préférences, sélectionnez Format
automatique.
Vous pouvez aussi, dans la fenêtre de script, sélectionner Edition > Préférences (Windows)
ou Flash > Préférences (Macintosh). Dans la boîte de dialogue Préférences, sélectionnez
Format automatique.
2.
Faites votre choix parmi les options de format automatique proposées.
Pour visualiser l’effet de chaque sélection, examinez le panneau Afficher un aperçu.
Après la définition des options de formatage automatique, vos paramètres s’appliquent
systématiquement au code que vous rédigez, mais pas au code existant. Vous devrez les
appliquer manuellement au code existant. Vous devez mettre en forme manuellement le code
formaté selon d’autres paramètres, importé d’un autre éditeur, etc.
Pour mettre du code en forme selon les paramètres de format automatique,
effectuez l’une des opérations suivantes :
■
Cliquez sur le bouton Format automatique dans la barre d’outils du panneau Actions ou
de la fenêtre de script.
■
Dans le panneau Actions, sélectionnez Format automatique dans le menu contextuel.
■
Appuyez sur Ctrl+Maj+F1 (Windows) ou sur Commande+Maj+F1 (Macintosh).
■
Dans la fenêtre de script, choisissez Outils > Format automatique.
Pour utiliser la fonction de mappage de police dynamique :
■
Pour activer ou désactiver la fonction de mappage de police dynamique, sélectionnez ou
désélectionnez Utiliser le mappage de police dynamique dans la boîte de dialogue
Préférences.
Le mappage de police dynamique est désactivé par défaut, car il ralentit les performances
pendant la programmation. Si vous travaillez sur du texte en plusieurs langues, activez le
mappage dynamique de polices pour vous assurer que les polices voulues sont utilisées.
54
Ecriture et modification du code ActionScript 2.0
Pour utiliser la fonction d’indentation automatique :
■
Pour activer ou désactiver la fonction d’indentation automatique, sélectionnez ou
désélectionnez Indentation automatique dans la boîte de dialogue Préférences.
Lorsque l’indentation automatique est activée, le texte saisi après une parenthèse ouvrante
[(] ou une accolade ouvrante [{] est automatiquement mis en retrait conformément à la
valeur de taille de tabulation définie dans les préférences d’ActionScript.
Pour mettre une ligne en retrait dans vos scripts, sélectionnez-la, puis appuyez sur la
touche de tabulation. Pour supprimer l’indentation, sélectionnez la ligne concernée, puis
appuyez sur les touches Maj+Tab.
Mise en évidence de la syntaxe
Dans ActionScript, comme dans tout autre langage, la syntaxe est la manière dont les éléments
sont assemblés afin d’avoir un sens. Vos scripts ne fonctionneront pas si vous utilisez une
syntaxe ActionScript incorrecte.
Lorsque vous rédigez des scripts dans Flash Basic 8 et Flash Professionnel 8, les commandes
qui ne sont pas prises en charge par la version du lecteur que vous ciblez apparaissent en jaune
dans la boîte à outils du panneau Actions. Par exemple, si la version de Flash Player SWF est
définie sur Flash 7, le code ActionScript qui n’est pris en charge que par Flash Player 8
apparaît en jaune dans la boîte à outils. (Pour plus d’informations sur la définition de la
version de Flash Player SWF, consultez le Chapitre 17, Définition d'options de publication pour
le format de fichier Flash SWF, dans le guide Utilisation de Flash.)
Vous pouvez également définir une préférence pour que les codes couleur de Flash s’intègrent
à vos scripts à mesure que vous les rédigez, afin de vous signaler les fautes de frappe. Par
exemple, supposons que vous ayez défini votre préférence de coloration de la syntaxe de sorte
à ce que les mots-clés s’affichent en bleu foncé. Lors de la saisie, si vous entrez var, le mot var
s’affiche en bleu. Toutefois, si vous tapez vae par inadvertance, le mot vae restera en noir, ce
qui indique que vous avez fait une faute de frappe. Pour plus d’informations sur les mots clés,
consultez la section Présentation des mots-clés, page 151.
Programmation dans le panneau Actions et la fenêtre de script
55
Pour définir des préférences de coloration de la syntaxe en cours de frappe,
effectuez l’une des opérations suivantes :
■
Sélectionnez Edition > Préférences (Windows) ou Flash > Préférences (Macintosh), puis
cliquez sur ActionScript dans la liste des catégories et spécifiez les paramètres de coloration
de la syntaxe.
■
Dans le menu contextuel (dans le coin supérieur droit du panneau Actions), choisissez
Préférences et définissez les paramètres Coloration de la syntaxe dans les préférences
d’ActionScript.
■
Lorsque le pointeur de la souris se trouve dans le panneau de script, appuyez sur Ctrl-U
(Windows) ou Commande-U (Macintosh).
Vous pouvez modifier les paramètres de couleur pour les mots-clés, les commentaires, les
identificateurs et les chaînes. Pour plus d’informations sur les identificateurs, consultez les
sections Terminologie, page 875 et Données de type chaîne, page 86. Pour plus d’informations
sur les commentaires, consultez la section Présentation des commentaires, page 143.
Utilisation des numéros de ligne et du retour à la ligne
Vous pouvez choisir d’afficher des numéros de ligne et de renvoyer automatiquement à la
ligne les lignes de code trop longues. D’une manière générale, l’affichage des numéros de ligne
et le retour à la ligne automatique facilitent grandement la modification du code. L’affichage
des numéros de ligne permet de parcourir et de diviser plus facilement le code lorsque vous le
modifiez. Le retour à la ligne automatique évite d’avoir à parcourir de longues lignes de code
(en particulier lorsque vous travaillez dans l’environnement auteur ou avec des résolutions
d’écran restreintes).
Pour activer ou désactiver l’affichage des numéros de ligne, effectuez l’une
des opérations suivantes :
■
Dans le panneau Actions, choisissez Numéros de ligne dans le menu contextuel.
■
Dans la fenêtre de script, choisissez Outils > Numéros de ligne.
■
Appuyez sur Ctrl+Maj+L (Windows) ou sur Commande+Maj+L (Macintosh).
Pour activer ou désactiver le retour à la ligne automatique, effectuez l’une des
opérations suivantes :
■
Dans le panneau Actions, choisissez Retour à la ligne dans le menu contextuel.
■
Dans la fenêtre de script, choisissez Outils > Retour à la ligne.
■
Appuyez sur Ctrl+Maj+W (Windows) ou sur Commande+Maj+W (Macintosh).
56
Ecriture et modification du code ActionScript 2.0
Utilisation des touches de raccourci d’échappement
Vous pouvez ajouter plusieurs éléments à un script en utilisant des touches de raccourci (en
appuyant sur la touche Echap, puis sur deux autres touches).
REMARQUE
Il ne s’agit pas des mêmes raccourcis que les raccourcis clavier qui initialisent certaines
commandes de menu.
Par exemple, lorsque vous travaillez dans le panneau de script, si vous appuyez sur Echap+d+o,
le code suivant s’insère dans votre script :
do {
} while ();
Le point d’insertion est placé immédiatement après le mot while pour que vous puissiez
commencer à saisir votre condition. De même, si vous appuyez sur Echap+c+h, le code
suivant est inséré dans votre script, et le point d’insertion est placé entre les parenthèses [()],
ce qui vous permet de commencer à taper la condition :
catch () {
}
Si vous souhaitez connaître (ou revoir) les commandes qui bénéficient de touches de raccourci
d’échappement, vous pouvez les afficher en regard des éléments dans la boîte à outils
ActionScript.
Programmation dans le panneau Actions et la fenêtre de script
57
Pour afficher ou masquer les touches de raccourci d’échappement :
■
Dans le menu déroulant du panneau Actions, sélectionnez ou désélectionnez Touches de
raccourci d’échappement.
Les touches de raccourci d’échappement apparaissent en regard des éléments dans la boîte
à outils ActionScript.
Affichage des caractères masqués
Au fur et à mesure que vous écrivez et mettez en forme votre code ActionScript, vous y insérez
des espaces, des tabulations et des sauts de ligne. Ces éléments sont bien entendu
indispensables à la clarté visuelle de votre code. Toutefois, le compilateur de Flash générera des
erreurs s’il rencontre des espaces à deux octets qui ne font pas partie d’une valeur de chaîne.
L’affichage des caractères masqués dans le panneau de script vous permet de repérer, puis de
supprimer ces espaces à deux octets.
Les symboles suivants sont utilisés pour afficher chaque caractère masqué :
espace sur un octet
.
espace sur deux octets l
tab
>>
saut de ligne
Pour rechercher des caractères masqués, effectuez l’une des opérations
suivantes :
■
Sélectionnez Caractères masqués dans le menu contextuel.
■
Appuyez sur Ctrl+Maj+8 (Windows) ou sur Commande+Maj+8 (Macintosh).
58
Ecriture et modification du code ActionScript 2.0
Lorsque les caractères masqués sont affichés, la fenêtre de script ressemble à cela :
Utilisation de l’outil Rechercher
L’outil Rechercher permet de rechercher, et éventuellement de remplacer, une chaîne de texte
dans vos scripts. Vous pouvez remplacer la première ou toutes les occurrences du texte dans
votre script. Vous pouvez également effectuer une recherche en fonction de la casse.
Pour rechercher un texte dans un script :
1.
Dans la barre d’outils du panneau Actions ou de la fenêtre de script, sélectionnez l’outil
Rechercher ou appuyez sur Ctrl+F (Windows) ou Commande+F (Macintosh).
2.
Saisissez la chaîne de texte à localiser dans le script.
3.
Cliquez sur Rechercher le suivant.
Si le texte ou les caractères sont présents dans le script, ils sont mis en surbrillance dans la
fenêtre de script.
Programmation dans le panneau Actions et la fenêtre de script
59
Pour rechercher et remplacer un texte dans un script :
1.
Dans la barre d’outils du panneau Actions ou de la fenêtre de script, sélectionnez l’outil
Rechercher ou appuyez sur Ctrl+F (Windows) ou Commande+F (Macintosh).
2.
Saisissez la chaîne de texte à localiser et remplacer dans le script.
3.
Dans le champ Remplacer, entrez la nouvelle chaîne.
4.
Cliquez sur Rechercher le suivant.
Si le script contient la chaîne, elle s’affiche en surbrillance.
5.
Cliquez sur Remplacer pour remplacer la chaîne ou cliquez sur Remplacer tout pour
remplacer toutes les occurrences de la chaîne.
Après avoir saisi une chaîne de recherche dans l’outil Rechercher, vous pouvez répéter la
recherche en choisissant Rechercher à nouveau dans le menu contextuel.
Vérification de la syntaxe et de la ponctuation
Pour déterminer à l’avance si le code que vous avez rédigé fonctionne comme prévu, vous
devez publier ou tester le fichier. Vous avez toutefois la possibilité d’effectuer une vérification
rapide sans quitter le fichier FLA. Les erreurs de syntaxe sont signalées dans le panneau Sortie.
Vous pouvez également vérifier que les jeux de parenthèses, d’accolades ou de crochets
encadrent correctement un bloc.
La syntaxe est vérifiée dans le script en cours d’édition. Lorsque ce script appelle des classes
ActionScript 2.0, ces dernières sont compilées et leur syntaxe est également vérifiée. D’autres
scripts pouvant figurer dans le fichier FLA ne sont pas vérifiés.
Pour vérifier la syntaxe, effectuez l’une des opérations suivantes :
■
Cliquez sur Vérifier la synthaxe dans la barre d’outils du panneau Actions ou de la fenêtre
de script.
■
Dans le panneau Actions, sélectionnez Vérifier la syntaxe dans le menu contextuel.
■
Sélectionnez le panneau de script (qui s’active), puis appuyez sur Ctrl+T (Windows) ou
Commande+T (Macintosh).
REMARQUE
60
Si vous vérifiez la syntaxe dans des fichiers de classe ActionScript 2.0 externes
dans la fenêtre de script, le chemin de classe global affecte ce processus. Des
erreurs risquent de se produire, même si le chemin de classe global est défini
correctement, dans la mesure où le compilateur ne sait pas que cette classe est en
cours de compilation. Pour plus d’informations sur la compilation des classes,
consultez la section Compilation et exportation de classes, page 306.
Ecriture et modification du code ActionScript 2.0
Pour vérifier l’équilibrage de la ponctuation, effectuez l’une des opérations
suivantes :
■
Cliquez entre les accolades ({}), les crochets ([]) ou les parenthèses [()] de votre script.
■
Pour Windows, appuyez sur Ctrl+’ (apostrophe) ou pour Macintosh sur Commande+’
pour sélectionner le texte entre accolades, crochets ou parenthèses.
La mise en surbrillance vous permet de vérifier si la ponctuation d’ouverture possède une
ponctuation de fermeture correspondante.
Importation et exportation de scripts
Vous pouvez importer un script dans le panneau Actions ou la fenêtre de script et exporter vos
scripts dans des fichiers ActionScript externes. Ces deux opérations s’avèrent très utiles pour
réutiliser le même code dans plusieurs applications Flash et pour le partager avec d’autres
équipes de développement.
Pour importer un fichier AS externe :
■
Pour importer un script externe dans le script utilisé affiché la fenêtre de script, placez
votre curseur à l’endroit où vous souhaitez insérer sa première ligne, puis choisissez l’une
des méthodes suivantes :
■
■
Dans le panneau Actions, choisissez Importer un script dans le menu contextuel ou
appuyez sur Ctrl+Maj+I (Windows) ou sur Commande+Maj+I (Macintosh).
Dans la fenêtre de script, choisissez Importer un script dans le menu Fichier ou
appuyez sur Ctrl+Maj+I (Windows) ou sur Commande+Maj+I (Macintosh).
Vous pouvez exporter un script à partir du panneau Actions. L’exportation n’est évidemment
pas nécessaire lorsque vous utilisez la fenêtre de script car il suffit d’enregistrer le fichier AS.
Pour exporter un script à partir du panneau Actions :
1.
Sélectionnez le script à exporter, puis choisissez Exporter un script dans le menu contextuel
ou appuyez sur Ctrl+Maj+X (Windows) ou sur Commande+Maj+X (Macintosh).
La boîte de dialogue Enregistrer sous s’ouvre.
2.
Enregistrez le fichier ActionScript (AS).
Flash prend en charge différents formats de codage de caractères (dont Unicode) et vous
permet de choisir celui à utiliser pour l’importation et l’exportation des scripts. Pour plus
d’informations, consultez les sections Importation et exportation de scripts, page 61, et
Importation et exportation des préférences, page 62.
Programmation dans le panneau Actions et la fenêtre de script
61
Prise en charge du format Unicode pour ActionScript
Flash 8 prend en charge le codage de caractères Unicode pour ActionScript. Vous pouvez donc
intégrer du texte en différentes langues dans un même fichier ActionScript. Vous pouvez par
exemple intégrer du texte en anglais, en japonais et en français dans un même fichier.
AT T E NT I O N
Lorsque vous utilisez une application qui n’est pas en anglais sur un système en anglais,
la commande Tester l’animation (consultez la section Débogage de scripts, page 776)
échoue si l’une des parties du fichier SWF comporte des caractères qui ne peuvent pas
être rendus par le système de codage MBCS (Multibyte Character Sets). Par exemple,
les chemins japonais, qui fonctionnent dans les systèmes japonais, ne fonctionnent pas
dans un système anglais. Toutes les zones de l’application utilisant le lecteur externe
sont soumises à cette restriction.
Importation et exportation des préférences
Vous pouvez définir les préférences d’ActionScript afin de spécifier le type de codage à utiliser
lors de l’importation ou de l’exportation de fichiers ActionScript. Vous avez le choix entre le
codage UTF-8 ou le codage par défaut. UTF-8 est le format Unicode 8 bits. Le codage par
défaut, ou page de code classique, est le codage pris en charge par la langue utilisée actuellement
sur votre système.
En règle générale, si vous importez ou exportez des fichiers ActionScript au format UTF-8,
choisissez UTF-8. Si vous importez ou exportez des fichiers dans la page de code classique de
votre système, choisissez Codage par défaut comme préférence.
Si le texte que contiennent vos scripts ne s’affiche pas correctement lorsque vous ouvrez ou
importez un fichier, modifiez la préférence de codage pour l’importation. Si vous obtenez un
avertissement lors de l’exportation de fichiers ActionScript, vous pouvez modifier la
préférence de codage pour l’exportation ou désactiver l’affichage de cet avertissement dans les
préférences ActionScript.
62
Ecriture et modification du code ActionScript 2.0
Pour choisir des options de codage de texte pour l’importation ou l’exportation
de fichiers ActionScript :
1.
Dans la boîte de dialogue Préférences (Edition > Préférences (Windows) ou Flash >
Préférences (Macintosh)), cliquez sur ActionScript dans la liste des catégories.
2.
Dans la section Options d’édition, effectuez au moins une des actions suivantes :
■
■
Pour l’option Ouvrir/Importer, choisissez Codage UTF-8 pour ouvrir ou importer en
utilisant le codage Unicode, ou choisissez Codage par défaut pour ouvrir ou importer
en utilisant le format de codage de la langue de votre système actuel.
Pour l’option Enregistrer/Exporter, choisissez Codage UTF-8 pour enregistrer ou
exporter en utilisant le codage Unicode, ou choisissez Codage par défaut pour
enregistrer ou exporter en utilisant le format de codage de la langue de votre système
actuel.
Pour activer ou désactiver le message d’avertissement du codage
d’exportation :
1.
Dans le menu système de Flash, sélectionnez Edition > Préférences (Windows) ou Flash >
Préférences (Macintosh), puis cliquez sur Avertissements dans la liste des catégories.
2.
Activez ou désactivez l’option Avertir des conflits de codage pendant l’exportation de
fichiers .as.
Présentation des fonctionnalités du
panneau Actions
Les fonctionnalités suivantes ne sont disponibles que dans le panneau Actions. Elles ne sont
pas accessibles dans la fenêtre de script. Bien que le panneau Action offre toutes les
fonctionnalités de la fenêtre de script, cette dernière est utilisée à d’autres fins. Le panneau
Actions doit prendre en charge quelques fonctionnalités liées aux fichiers FLA (voir à ce sujet
les sections suivantes). Pour en savoir plus sur les fonctionnalités disponibles dans la fenêtre de
script et le panneau Actions, consultez la section Programmation dans le panneau Actions et la
fenêtre de script, page 40.
Pour les fonctions disponibles uniquement dans le panneau Actions, consultez les sections :
■
L’Assistant de script, page 64
■
Verrouillage de scripts dans le panneau Actions, page 64
■
Insertion de chemins cible, page 66
Présentation des fonctionnalités du panneau Actions
63
L’Assistant de script
L’Assistant de script vous invite à saisir les éléments d’un script, en simplifiant l’ajout d’une
interactivité simple dans votre application ou votre fichier Flash SWF. Ce mode Assistant
convient parfaitement aux utilisateurs qui ne maîtrisent pas encore l’écriture de scripts ou qui,
plus simplement, apprécient l’aide apportée par cet outil.
Utilisé en combinaison avec le panneau Actions, l’Assistant de script vous invite à sélectionner
des options et à saisir des paramètres. Par exemple, au lieu d’écrire un nouveau script, vous
pouvez sélectionner un élément de langage dans la boîte à outils Actions (ou la commande
Ajouter (+) de la barre d’outils), le faire glisser vers la fenêtre de script, puis compléter le script
en vous laissant guider par l’Assistant de script.
Dans l’exemple ci-dessous, la fonction gotoAndPlay a été ajoutée dans la fenêtre de script.
L’Assistant de script affiche toutes les invites nécessaires pour utiliser cette fonction
ActionScript. Dans ce cas, il s’agit du nom de la scène, du type et du numéro d’image.
Verrouillage de scripts dans le panneau Actions
Si vous ne rassemblez pas votre code dans un même emplacement au sein d’un fichier FLA
(consultez la section Organisation du code ActionScript, page 34) ou si vous utilisez des
comportements (consultez la section Présentation des comportements, page 67), vous pouvez
verrouiller plusieurs scripts dans le panneau Actions pour faciliter le passage de l’un à l’autre.
Le verrouillage d’un script permet de conserver l’emplacement du code ouvert dans le
panneau Actions et de cliquer facilement dans l’un ou l’autre des scripts ouverts.
64
Ecriture et modification du code ActionScript 2.0
Dans l’illustration suivante, le script associé à l’emplacement en cours du scénario se trouve
sur l’image 1 du calque Nettoyage. (L’onglet le plus à gauche suit toujours votre emplacement
dans le scénario.) Ce script est également verrouillé (il est représenté par l’onglet le plus à
droite). Deux autres scripts sont verrouillés : un sur l’image 1 et l’autre sur l’image 15 du
calque Intro. Pour passer d’un script verrouillé à l’autre, cliquez sur les onglets correspondants
ou utilisez les raccourcis clavier, tels que Ctrl+Maj+. (point). Cette opération n’a aucune
incidence sur votre position actuelle dans le scénario. Comme vous pouvez le constater dans
l’illustration suivante, plusieurs scripts sont ouverts dans le panneau Actions. Cliquez sur
chaque onglet pour passer d’un script à l’autre.
C ON S E I L
Si le contenu du panneau de script ne change pas en fonction de l’emplacement
sélectionné dans le scénario, le panneau de script affiche généralement un script
verrouillé. Cliquez sur l’onglet de gauche dans la partie inférieure gauche de la fenêtre de
script pour afficher le code ActionScript associé à votre emplacement sur le scénario.
Pour verrouiller un script :
1.
Pointez sur le scénario afin que le script apparaisse dans un onglet situé en bas à gauche de
la fenêtre de script dans le panneau Actions.
2.
Effectuez l’une des opérations suivantes :
■
■
■
■
Cliquez sur l’icône en forme de punaise qui figure à droite de l’onglet.
Cliquez sur l’onglet avec le bouton droit de la souris (Windows) ou en appuyant sur la
touche Contrôle (Macintosh) et choisissez Verrouiller le script.
Choisissez Verrouiller le script dans le menu contextuel (dans le coin supérieur droit
du panneau Actions).
Lorsque le pointeur se trouve dans le panneau de script, appuyez sur Ctrl+= (signe
égal) sous Windows ou Commande+= sous Macintosh.
Pour déverrouiller un ou plusieurs scripts, effectuez l’une des opérations
suivantes :
■
Si un script verrouillé est affiché dans un onglet situé en bas à gauche de la fenêtre de
script, dans le panneau Actions, cliquez sur l’icône en forme de punaise située à droite de
l’onglet.
■
Cliquez du bouton droit de la souris (Windows) ou cliquez en appuyant sur la touche
Contrôle (Macintosh) sur l’onglet et choisissez Fermer le script ou Fermer tous les scripts.
■
Choisissez Fermer le script ou Fermer tous les scripts dans le menu contextuel (dans le
coin supérieur droit du panneau Actions).
Présentation des fonctionnalités du panneau Actions
65
■
Lorsque le pointeur se trouve dans le panneau de script, appuyez sur Ctrl+- (signe moins)
sous Windows ou Commande+- sous Macintosh.
Pour utiliser les raccourcis clavier avec des scripts verrouillés :
■
Vous pouvez utiliser les raccourcis clavier suivants avec les scripts verrouillés :
Action
Raccourci clavier
Windows
Raccourci clavier
Macintosh
Verrouiller le script
Contrôle+= (signe égal)
Commande+=
Déverrouiller le script
Contrôle+- (signe moins)
Commande+-
Déplacer le focus vers
l’onglet de droite
Ctrl+Maj+. (point)
Commande+Maj+.
Déplacer le focus vers
l’onglet de gauche
Ctrl+Maj+, (virgule)
Commande+Maj+,
Déverrouiller tous les scripts
Ctrl+Maj+- (moins)
Commande+Maj+-
Insertion de chemins cible
La plupart des actions que vous créez dans votre script affecteront des clips, des boutons et
d’autres occurrences de symbole. Pour appliquer des actions aux occurrences d’un scénario,
vous définissez un chemin cible (adresse de l’occurrence visée). Ce chemin cible peut être
absolu ou relatif.
L’outil Chemin cible, disponible dans le panneau Actions, vous invite à saisir le chemin cible
de l’action sélectionnée dans votre script.
Pour insérer un chemin cible :
1.
Sélectionnez et positionnez le curseur dans une action de votre script.
2.
Dans la barre d’outils du panneau Actions, cliquez sur Chemin cible.
La boîte de dialogue Insérer un chemin cible s’affiche.
3.
Effectuez l’une des opérations suivantes :
■
Saisissez manuellement le chemin de l’occurrence cible.
■
Sélectionnez la cible dans la liste des cibles disponibles.
4.
Sélectionnez l’option de chemin relatif ou absolu.
5.
Cliquez sur OK.
Le chemin est alors ajouté à l’action.
66
Ecriture et modification du code ActionScript 2.0
Présentation des comportements
Les comportements sont des fonctions ActionScript prédéfinies que vous pouvez ajouter aux
objets de votre document Flash sans avoir à créer le code ActionScript vous-même. Ils vous
offrent des fonctionnalités ActionScript prédéfinies telles que la navigation de cadres, le
chargement de fichiers SWF et JPEG externes, le contrôle de l’ordre d’empilement des clips et
le déplacement de clip par glisser-déposer.
Les comportements sont très pratiques pour simplifier le développement d’une application
Flash : ils vous évitent de devoir réécrire le code ActionScript ou, à l’inverse, vous permettent
de comprendre le fonctionnement du code ActionScript dans certaines situations.
Les comportements sont disponibles uniquement lorsque vous travaillez dans un document
Flash, pas dans un fichier de script externe. En général, vous sélectionnez un objet
déclencheur dans votre document, un clip ou un bouton, vous cliquez sur Ajouter dans le
panneau Comportements pour afficher les comportements disponibles, puis vous sélectionnez
le comportement désiré, comme dans l’exemple suivant :
Le comportement est ajouté à l’objet et apparaît dans le panneau Actions.
Présentation des comportements
67
Présentation des paramètres de
publication ActionScript
Il existe deux manières de modifier du code ActionScript. Vous pouvez modifier du code
ActionScript incorporé à un document Flash en passant par le panneau Actions. Vous pouvez
également modifier du code ActionScript dans un fichier de script séparé, extérieur au
document Flash, à partir de la fenêtre de script. Le panneau Actions et la fenêtre de script
étant pour l’essentiel deux affichages différents du même éditeur ActionScript, les paramètres
et les préférences ActionScript dans Flash s’appliquent à ces deux éléments.
Vous pouvez modifier les paramètres de publication d’un document Flash pour changer la
version d’ActionScript utilisée lors de la publication. Vous pouvez également définir le chemin
de classe du document actif, en ignorant le chemin de classe ActionScript global.
Pour plus d’informations sur la modification des paramètres de publication ActionScript,
consultez la section Modification des paramètres de publication ActionScript, page 68. Pour plus
d’informations sur la définition d’un chemin de classe au niveau du document ou global,
consultez la section Modification du chemin de classe, page 69.
Modification des paramètres de publication
ActionScript
Lorsque vous publiez un document Flash, par défaut, la version ActionScript 2.0 est choisie et
le chemin de classe est hérité du paramètre de chemin de classe global. Si vous devez changer
de version d’ActionScript ou définir un chemin de classe au niveau du document, modifiez les
paramètres de publication.
Pour modifier la version d’ActionScript :
1.
68
Choisissez Fichier > Paramètres de publication et cliquez sur l’onglet Flash.
Ecriture et modification du code ActionScript 2.0
2.
Sélectionnez la version d’ActionScript dans le menu déroulant.
ActionScript 2.0 est sélectionné par défaut. Si vous rédigez vos scripts dans
ActionScript 1.0 au lieu de 2.0, modifiez ce paramètre avant de publier votre document
Flash.
Le compilateur ActionScript 2.0 compile tout le code ActionScript 1.0, à l’exception des
éléments suivants : la syntaxe à barre oblique (/) utilisée pour indiquer les chemins de clip (par
exemple, parentClip/testMC:varName= "hello world") génère des erreurs de
compilation si vous sélectionnez la version ActionScript 2.0. Pour résoudre ce problème,
réécrivez votre code en remplaçant les barres obliques par la notation à point (.) ou
sélectionnez le compilateur ActionScript 1.0.
Cliquez sur le bouton Paramètres qui se trouve en regard du menu contextuel de la version
ActionScript pour modifier le chemin de classe au niveau du document. Pour plus
d’informations, consultez la section Modification du chemin de classe, page 69.
Modification du chemin de classe
ActionScript 2.0 permet également de définir un chemin de classe au niveau du document.
Cette possibilité s’avère très utile lorsque vous créez vos propres classes et souhaitez supplanter
le chemin de classe ActionScript global qui est défini dans les préférences d’ActionScript.
La modification du chemin de classe dans les paramètres de publication ne s’applique qu’au
fichier Flash actif.
Vous pouvez utiliser la boîte de dialogue Préférences pour modifier le chemin de classe global.
Pour modifier le paramètre de chemin de classe au niveau du document, utilisez la boîte de
dialogue Paramètres de publication pour le fichier FLA. Dans les deux cas, vous pouvez
ajouter des chemins de répertoires absolus (par exemple C:\mes_classes) et des chemins de
répertoires relatifs (par exemple, ../mes_classes ou ".").
Présentation des paramètres de publication ActionScript
69
Pour modifier le chemin de classe global :
1.
Sélectionnez Edition > Préférences (Windows) ou Flash > Préférences (Macintosh) pour
ouvrir la boîte de dialogue Préférences.
2.
Cliquez sur ActionScript dans la liste des catégories, puis cliquez sur Paramètres
d’ActionScript 2.0.
3.
Effectuez l’une des opérations suivantes :
■
Pour ajouter un répertoire au chemin de classe, cliquez sur Rechercher le chemin,
ouvrez le répertoire que vous souhaitez ajouter et cliquez sur OK.
Vous pouvez également cliquer sur Ajouter un nouveau chemin (+) pour ajouter une
ligne à la liste Chemin de classe. Double-cliquez sur la nouvelle ligne, tapez un chemin
relatif ou absolu et cliquez sur OK.
■
Pour modifier un répertoire de chemin de classe existant, sélectionnez le chemin dans
la liste Chemin de classe, cliquez sur Rechercher le chemin, ouvrez le répertoire que
vous souhaitez ajouter et cliquez sur OK.
Vous pouvez également double-cliquer sur le chemin dans la liste Chemin de classe,
taper le chemin désiré et cliquer sur OK.
■
Pour supprimer un répertoire du chemin de classe, sélectionnez son chemin dans la
liste Chemin de classe, puis cliquez sur Supprimer du chemin.
REMARQUE
Ne supprimez pas le chemin de classe global absolu (voir la section Chemins de
classe globaux et au niveau du document). Flash l’utilise pour accéder aux
classes intégrées. Si vous supprimez ce chemin de classe par inadvertance,
rétablissez-le en ajoutant $(LocalData)/Classes comme nouveau chemin de
classe.
Pour modifier le chemin de classe au niveau du document :
1.
Choisissez Fichier > Paramètres de publication pour ouvrir la boîte de dialogue Paramètres
de publication.
2.
Cliquez sur l’onglet Flash.
3.
Cliquez sur Paramètres en regard du menu contextuel Version d’ActionScript.
70
Ecriture et modification du code ActionScript 2.0
4.
Effectuez l’une des opérations suivantes :
■
Pour ajouter un répertoire au chemin de classe, cliquez sur Rechercher le chemin,
ouvrez le répertoire que vous souhaitez ajouter et cliquez sur OK.
Vous pouvez également cliquer sur Ajouter un nouveau chemin (+) pour ajouter une
ligne à la liste Chemin de classe. Double-cliquez sur la nouvelle ligne, tapez un chemin
relatif ou absolu et cliquez sur OK.
■
Pour modifier un répertoire de chemin de classe existant, sélectionnez le chemin dans
la liste Chemin de classe, cliquez sur Rechercher le chemin, ouvrez le répertoire que
vous souhaitez ajouter et cliquez sur OK.
Vous pouvez également double-cliquer sur le chemin dans la liste Chemin de classe,
taper le chemin désiré et cliquer sur OK.
■
Pour supprimer un répertoire du chemin de classe, sélectionnez son chemin dans la
liste Chemin de classe, puis cliquez sur Supprimer du chemin.
Pour plus d’informations sur la définition et la modification des chemins de classe, consultez
la section Définition et modification du chemin de classe, page 260.
Fichiers de configuration installés avec Flash 8
Lorsque vous installez Flash Basic 8 ou Flash Professionnel 8, plusieurs fichiers et dossiers de
configuration liés à ActionScript sont copiés dans votre système. Vous pouvez utiliser ces
fichiers pour certaines configurations dans l’environnement auteur. Comme toujours,
procédez aux modifications avec précaution et effectuez une sauvegarde des fichiers modifiés.
Dossier de classes ActionScript Ce dossier contient toutes les classes ActionScript
(fichiers AS) incluses dans Flash Professionnel 8 ou Flash Basic 8. En général, le chemin de ce
dossier est le suivant :
■
Windows : Disque dur\Documents and Settings\utilisateur\Local Settings\Application
Data\Macromedia\Flash 8Ball\langue\Configuration\Classes.
■
Macintosh : Disque dur/Utilisateurs/utilisateur/Library/Application Support/
Macromedia/Flash 8/langue/Configuration/Classes
Le dossier Classes est subdivisé en dossiers et en répertoires contenant les classes de Flash
Player 7 (FP7) et de Flash Player 8 (FP8). Il contient également un répertoire pour le
paquet mx (mx). Ce répertoire est utilisé dans les lecteurs et les fichiers ASO (aso). Pour
plus d’informations sur les fichiers ASO, consultez la section Utilisation des fichiers ASO,
page 307. Pour plus d’informations sur l’organisation de ce répertoire, consultez le fichier
Lisez-moi dans le dossier Classes.
Dossier des classes d’inclusion
Contient l’ensemble des fichiers d’inclusion ActionScript
globaux. Il est situé dans le dossier :
Présentation des paramètres de publication ActionScript
71
■
Windows : Disque dur\Documents and Settings\utilisateur\Local Settings\Application
Data\Macromedia\Flash 8Ball\langue\Configuration\Include.
■
Macintosh : Disque dur/Utilisateurs/utilisateur/Library/Application Support/
Macromedia/Flash 8/langue/Configuration/Include
Fichier de configuration ActionsPanel.xml
Contient le fichier de configuration pour les
conseils de saisie de code ActionScript. Il est situé dans le dossier :
■
Windows : Disque dur\Documents and Settings\utilisateur\Local Settings\Application
Data\Macromedia\Flash 8Ball\langue\Configuration\ActionsPanel\ActionScript_1_2.
■
Macintosh : Disque dur/Utilisateurs/utilisateur/Library/Application Support/
Macromedia/Flash 8/langue/Configuration/ActionsPanel/ActionScript_1_2.
Fichier de configuration AsColorSyntax.xml
Fichier de configuration pour la mise en
évidence de la syntaxe et des couleurs de code ActionScript. Il est situé dans le dossier :
■
Windows : Disque dur\Documents and Settings\utilisateur\Local Settings\Application
Data\Macromedia\Flash 8Ball\langue\Configuration\ActionsPanel\.
■
Macintosh : Disque dur/Utilisateurs/utilisateur/Library/Application Support/
Macromedia/Flash 8/langue/Configuration/ActionsPanel.
72
Ecriture et modification du code ActionScript 2.0
3
CHAPITRE 3
A propos d’ActionScript
Les fonctionnalités de programmation orientée objet (OOP) d’ActionScript 2.0 reposent sur
la norme ECMAScript 4 Draft Proposal en cours de développement par ECMA TC39-TG1
(consultez la section site www.mozilla.org/js/language/es4/index.html). Dans la mesure où la
proposition de la ECMA-4 n’est pas encore une norme établie car elle est encore en cours
d’élaboration, ActionScript 2.0 ne l’applique pas de façon stricte.
ActionScript 2.0 prend en charge tous les éléments standard du langage ActionScript. Il vous
permet simplement d’écrire des scripts plus proches des normes utilisées par d’autres langages
orientés objet, tels que Java. ActionScript 2.0 intéressera principalement les développeurs
Flash de niveau intermédiaire ou expert qui créent des applications nécessitant
l’implémentation de classes et de sous-classes. ActionScript 2.0 vous permet également de
déclarer le type d’objet d’une variable au moment de sa création (consultez la section
Affectation des types de données et typage strict, page 88) et améliore considérablement les erreurs
de compilateur (consultez l’Annexe A, Messages d’erreur, page 841).
Les principaux points à connaître sur ActionScript 2.0 sont les suivants :
■
Les scripts utilisant ActionScript 2.0 pour définir des classes ou des interfaces doivent être
enregistrés en tant que fichiers de script externes, avec une seule classe définie par script.
Les classes et les interfaces ne peuvent donc pas être définies dans le panneau Actions.
■
Vous pouvez importer des fichiers de classe individuels de façon implicite (en les
enregistrant dans un emplacement spécifié par des chemins de recherche généraux ou de
niveau document et en les utilisant dans un script) ou de façon explicite (en utilisant la
commande import). Vous pouvez importer des lots de fichiers (collections de fichiers de
classe placés dans un répertoire) en utilisant des caractères génériques.
■
Les applications développées avec ActionScript 2.0 sont prises en charge par Flash Player 6
et les versions ultérieures.
A T TE N T I ON
Le paramètre de publication par défaut des nouveaux fichiers créés dans Flash 8 est
ActionScript 2.0. Si vous envisagez de modifier un fichier FLA existant pour utiliser
la syntaxe ActionScript 2.0, vérifiez que le fichier FLA indique bien ActionScript 2.0
dans ses paramètres de publication. Si ce n’est pas le cas, votre fichier ne sera pas
compilé correctement, même si Flash ne génère pas d’erreurs de compilation.
73
Pour plus d’informations sur l’utilisation d’ActionScript 2.0 pour l’écriture de programmes
orientés objet dans Flash, consultez le Chapitre 7, Classes, page 243.
Bien que Macromedia recommande d’utiliser ActionScript 2.0, vous pouvez continuer à
employer la syntaxe d’ActionScript 1.0, surtout si vous travaillez sur des projets Flash plus
conventionnels, tels qu’une animation simple sans interaction avec l’utilisateur.
Présentation d’ActionScript
Les fonctions principales d’ActionScript 2.0 sont regroupées ci-dessous :
Modèle familier de programmation orientée objet (OOP) ActionScript 2.0 offre un
modèle connu de tous pour la création de programmes orientés objet. ActionScript 2.0 met en
oeuvre plusieurs concepts et mots-clés orientés objet, tels que class, interface et packages qui
vous sembleront familiers si vous avez déjà programmé en Java.
Le modèle OOP d’ActionScript 2.0 est une « formalisation syntaxique » de la méthode de
chaînage de prototype utilisée dans les précédentes versions de Macromedia Flash pour créer
des objets et établir une relation d’héritage. Avec ActionScript 2.0, vous pouvez créer des
classes personnalisées et étendre les classes intégrées de Flash.
Typage strict des données
ActionScript 2.0 vous permet également de spécifier
explicitement les types de données pour les variables et pour les paramètres et les renvois des
fonctions. Par exemple, le code suivant déclare une variable appelée userName de type chaîne
(type de données ActionScript intégré ou classe).
var userName:String = "";
Avertissements et messages d’erreur du compilateur
Les deux précédentes fonctions
(modèle OOP et typage strict des données) permettent à l’outil de programmation et au
compilateur de générer des avertissements et messages d’erreur qui vous aident à localiser les
bogues de vos applications dans Flash plus rapidement qu’auparavant.
Lorsque vous utilisez ActionScript 2.0, assurez-vous que les paramètres de publication du
fichier FLA spécifient ActionScript 2.0. Il s’agit de la configuration par défaut pour les fichiers
créés dans Flash MX 2004 et Flash 8. Toutefois, si vous ouvrez un ancien fichier FLA qui
utilise ActionScript 1.0 et que vous le modifiez en langage ActionScript 2.0, vous devez régler
les paramètres de publication du fichier FLA sur ActionScript 2.0. Sinon, votre fichier FLA ne
sera pas compilé correctement et aucune erreur ne sera générée.
74
A propos d’ActionScript
Différences entre ActionScript 1.0 et
ActionScript 2.0
Lorsque vous débutez un document ou une application dans Flash, vous devez déterminer le
mode d’organisation des fichiers associés. Vous pouvez utiliser des classes dans certains projets,
comme lorsque vous créez des applications ou des fichiers FLA complexes, bien que certains
documents excluent l’utilisation de classes. Ainsi, de nombreux exemples courts de cette
documentation n’ont pas recours à des classes. L’utilisation de classes pour stocker des
fonctionnalités n’est pas la meilleure solution ni la plus facile pour les petites applications ou
les fichiers FLA simples. Il est généralement plus efficace de placer du code ActionScript dans
le document. Essayez alors de placer l’ensemble du code sur le scénario et sur le moins
d’images possible. Evitez de placer du code sur ou dans les occurrences (telles que les boutons
ou les clips) dans un fichier FLA.
Lorsque vous créez un petit projet, il est souvent plus difficile d’utiliser des classes ou des
fichiers de code externes pour organiser le code ActionScript que d’ajouter ce code au sein du
fichier FLA. Il est parfois plus facile de regrouper l’ensemble du code ActionScript au sein du
fichier FLA que de le placer dans une classe à importer. Cela ne signifie pas que vous devez
nécessairement utiliser ActionScript 1.0. Vous pouvez décider de placer votre code dans le
fichier FLA à l’aide d’ActionScript 2.0 avec son typage strict des données et ses nouvelles
méthodes et propriétés. ActionScript 2.0 offre également une syntaxe qui applique les normes
des autres langages de programmation. Ceci facilite l’usage du langage et permet de le rendre
encore plus utile. Par exemple, il vous sera plus facile de vous familiariser avec ActionScript si
vous connaissez déjà un autre langage reposant sur les mêmes standards de structure et de
syntaxe. De même, vous pourrez appliquer les connaissances que vous allez acquérir à d’autres
langages de programmation. ActionScript 2.0 permet de bénéficier d’une approche orientée
objet pour développer des applications en appliquant un ensemble supplémentaire d’éléments
de langage, ce qui peut être avantageux pour le développement de votre application.
Dans certains cas, il n’est pas possible de choisir la version d’ActionScript à utiliser. Si vous
créez un fichier SWF destiné à une ancienne version de Flash Player, telle qu’une application
pour périphérique mobile, choisissez ActionScript1.0 pour sa compatibilité.
Néanmoins, quelle que soit la version d’ActionScript, vous devez appliquer les meilleures
pratiques. La plupart de ces pratiques, telles qu’un usage cohérent des majuscules, la saisie
automatique, l’amélioration de la lisibilité, l’exclusion de mots clés pour les noms
d’occurrence et l’application d’une convention d’appellation cohérente s’appliquent aux deux
versions.
Différences entre ActionScript 1.0 et ActionScript 2.0
75
Si vous prévoyez de mettre à jour votre application avec les versions suivantes de Flash ou si
vous devez la développer et créer du code plus complexe, utilisez ActionScript 2.0 et les classes
afin de faciliter la mise à jour et la modification de vos applications.
Présentation d’ActionScript et de Flash
Player
Si vous compilez un fichier SWF contenant du code ActionScript 2.0 dont l’option
Paramètres de publication est définie sur Flash Player 6 et ActionScript 1.0, votre code reste
fonctionnel tant qu’il n’utilise pas les classes ActionScript 2.0. Le code n’est pas sensible à la
casse, par contre Flash Player l’est. Donc, si vous compilez votre fichier SWF avec l’option
Paramètres de publication définie sur Flash Player 7 ou 8 et ActionScript 1.0, Flash impose le
typage strict des données et le respect de la casse.
Les variables type de données (typage strict) sont imposées au moment de la compilation de
Flash Player 7 et 8 si les paramètres de publication sont définis sur ActionScript 2.0.
ActionScript 2.0 compile vers le pseudo-code ActionScript 1.0 lorsque vous publiez vos
applications, et vous pouvez ainsi cibler Flash Player 6, 7, ou 8 lorsque vous travaillez avec
ActionScript 2.0.
76
A propos d’ActionScript
CHAPITRE 4
4
Données et types de
données
Ce chapitre est le premier d’une longue série qui décrit les concepts fondamentaux
d’ActionScript. Pour apprendre à créer des applications complexes, vous vous exercerez à
l’utilisation des techniques de base de la programmation. Dans ce chapitre, vous apprendrez
également à manipuler les données des fichiers FLA et à identifier les données compatibles
avec vos applications. Dans le chapitre suivant, Chapitre 5, Eléments fondamentaux du langage
et de la syntaxe vous découvrirez les instructions des formulaires et la syntaxe d’ActionScript.
Ensuite, le Chapitre 6, Fonctions et méthodes présente l’utilisation des fonctions et des
méthodes dans le langage ActionScript.
Pour plus d’informations sur les données et les types de données, consultez les sections
suivantes :
A propos des données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Présentation des types de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Présentation des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Organisation des données dans des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
Attribution. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .121
A propos des données
Le terme données fait référence aux nombres, chaînes de caractères et autres informations qui
sont manipulés au sein de Flash. Lorsque vous créez des applications ou des sites Internet, la
manipulation d’un certain nombre de données est inévitable. Vous utilisez également des
données pour créer des graphiques sophistiqués et des animations générées par des scripts.
Dans ce cas, vous devez manipuler les valeurs utilisées pour appliquer vos effets spéciaux.
Vous pouvez définir des données en variables dans Flash ou les charger à partir de fichiers
externes ou de sites utilisant XML, des services Web, des classes ActionScript intégrées, etc.
Vous pouvez stocker les données dans une base de données, puis les représenter sous
différentes formes dans un fichier SWF. Cela comprend l’affichage des informations dans des
champs de texte ou des composants et l’affichage des images dans des occurrences de clip.
77
Les types de données les plus utilisés sont les suivants : chaînes (série de caractères, telles que
des noms et des phrases), nombres, objets (tels que des clips), valeurs booléennes (true et
false), etc. Dans ce chapitre, vous apprendrez également à reconnaître les différents types de
données dans Flash et à les utiliser.
Pour plus d’informations sur les types de données, reportez-vous à la section Présentation des
types de données, page 78. Pour plus d’informations sur les variables, reportez-vous à la section
Présentation des variables, page 94.
Présentation des types de données
Le type de données décrit une information et les sortes d’opération qu’elles peuvent subir. Vous
stockez les données dans des variables. Vous utilisez les types de données lors de la création des
variables, des occurrences d’objets et des définitions de fonctions pour attribuer le type de
données que vous manipulez. Lorsque vous écrivez du code ActionScript, vous utilisez de
nombreux types de données différents.
ActionScript 2.0 définit plusieurs types de données fréquemment utilisés. Les types de
données décrivent le genre de valeur qu’une variable ou qu’un élément ActionScript peut
contenir. Après l’affectation de son type de données, une variable ne peut contenir qu’une
valeur correspondant à ce type. Pour plus d’informations sur les variables, reportez-vous à la
section Présentation des variables, page 94.
ActionScript dispose de nombreux types de données de base que vous utiliserez fréquemment
dans vos applications. Pour plus d’informations, consultez le tableau de la section Types de
données complexes et primitifs, page 79.
ActionScript dispose également de classes de base, telles que Array et Date, qui sont
considérées comme des types de données complexes ou de référence. Pour plus d’informations
sur les types de données complexes ou de référence, reportez-vous à la section Types de données
complexes et primitifs, page 79. De plus, tous les types de données et les classes sont
intégralement définis dans Guide de référence du langage ActionScript de Flash.
Vous pouvez également créer des classes personnalisées pour vos applications. Toute classe
définie par une déclaration est également considérée comme un type de données. Pour plus
d’informations sur les classes intégrées ou de base, reportez-vous à la section Présentation des
classes de niveau supérieur et intégrées, page 312. Pour plus d’informations sur la création de
classes personnalisées, consultez le Chapitre 7, Classes, page 243.
78
Données et types de données
Dans ActionScript 2.0, vous pouvez affecter des types de données aux variables lorsque vous
les déclarez. Les types de données que vous affectez peuvent être de type de base ou peuvent
représenter une classe personnalisée que vous avez créée. Pour plus d’informations, reportezvous à la section Affectation des types de données et typage strict, page 88.
Lorsque vous déboguez des scripts, vous pouvez avoir besoin de déterminer le type de données
d’une expression ou d’une variable pour comprendre son comportement. Vous pouvez
effectuer cette opération avec les opérateurs instanceof et typeof (voir la section
Identification du type des données, page 93).
Lors de l’exécution, vous pouvez convertir un type de données en un autre en utilisant l’une
des fonctions de conversion suivantes : Array(), Boolean(), Number(), Object(),
String().
Vous trouverez un exemple de fichier source, datatypes.fla, dans le dossier Samples de votre
disque dur, qui indique comment utiliser les types de données dans une application.
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\DataTypes.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/DataTypes.
Types de données complexes et primitifs
Les valeurs des différents types de données se divisent en deux principales catégories : primitive
et complexe.
Une valeur primitive (ou type de données primitif ) est une valeur stockée par ActionScript au
plus bas niveau d’abstraction, ce qui signifie que les opérations qu’elles subissent sont
généralement plus rapides et plus importantes que celles effectuées sur les types de données
complexes. Les types de données suivants définissent tous un ensemble de valeurs primitives :
Boolean, null, Number, String et undefined.
Une valeur complexe (ou type de données complexe) est une valeur non primitive qui fait
référence aux valeurs primitives. Elles sont souvent appelées types de données de référence. Les
valeurs complexes appartiennent au type de données Objet ou à un type de données basé sur
le type de données Objet. Les types de données qui définissent des ensembles de valeurs
complexes comprennent Array, Date, Error, Function et XML. Pour plus d’informations sur
ces types de données complexes, consultez les entrées correspondantes dans le Guide de
référence du langage ActionScript 2.0.
Les variables contenant des données primitives ont un comportement différent de celles
contenant des données complexes dans certaines situations. Pour plus d’informations,
reportez-vous à la section Utilisation de variables dans un projet, page 116.
Présentation des types de données
79
ActionScript dispose des types de données de base suivants que vous pouvez utiliser
fréquemment dans vos applications :
Type de
données
Description
Boolean
Primitive. Le type booléen est composé de deux valeurs : true et false.
Les variables de ce type ne prennent en charge aucune autre valeur. La
valeur par défaut d’une variable booléenne qui a été déclarée mais non
initialisée est false. Pour plus d’informations, reportez-vous à la section
Type de données Boolean, page 81.
MovieClip
Complexe. Le type de données MovieClip vous permet de contrôler les
symboles de clip au moyen des méthodes de la classe MovieClip. Pour
plus d’informations, reportez-vous à la section Données de type clip,
page 83.
null
Primitive. Ce type de données ne contient que la valeur null. Cette
valeur signifie « pas de valeur », c’est-à-dire une absence de données.
Vous pouvez affecter la valeur null dans de nombreuses situations
pour indiquer qu’une propriété ou une variable n’a pas reçu de valeur. Il
s’agit du type de données par défaut pour toutes les classes qui
définissent des types de données complexes. La classe Objet est la
seule exception à cette règle, car elle est undefined par défaut. Pour plus
d’informations, reportez-vous à la section Type de données Null,
page 84.
Number
Primitive. Ce type de données peut représenter des entiers, des entiers
non signés et des nombres en virgule flottante. Pour stocker un nombre
en virgule flottante, vous devez y insérer une virgule. Sans virgule, le
nombre est considéré comme un entier. Le type de données Numérique
peut stocker des valeurs allant de Number.MAX_VALUE (très élevées) à
Number.MIN_VALUE (très basses). Pour plus d’informations, consultez le
Guide de référence du langage ActionScript 2.0 et à la section Données
de type numérique, page 84.
Object
Complexe. Ce type de données est défini par la classe Object. La classe
Object sert de base pour toutes les définitions de classe dans
ActionScript. Elle vous permet d’organiser les objets les uns dans les
autres (objets imbriqués). Pour plus d’informations, reportez-vous à la
section Type de données Object, page 85.
80
Données et types de données
Type de
données
Description
String
Primitive. Ce type de données représente une séquence de caractères
16 bits qui peuvent comprendre des lettres, des chiffres et des
caractères de ponctuation. Les chaînes sont stockées sous forme de
caractères Unicode, au format UTF-16. Toute opération effectuée sur la
valeur d’une chaîne renvoie une nouvelle occurrence de la chaîne. Pour
plus d’informations, reportez-vous à la section Données de type chaîne,
page 86.
undefined
Primitive. Ce type de données contient une valeur : undefined. Il s’agit de
la valeur par défaut des occurrences de la classe Object. Seule la valeur
undefined peut être affectée aux variables qui appartiennent à la classe
Object. Pour plus d’informations, reportez-vous à la section Type de
données undefined, page 87.
Void
Complexe. Ce type de données contient une seule valeur : void. Vous
l’utilisez pour désigner les fonctions qui ne renvoient aucune valeur.
Void est un type de données complexe qui fait référence au type de
données Void primitif. Pour plus d’informations, reportez-vous à la
section Type de données Void, page 88.
Vous trouverez un exemple de fichier source, datatypes.fla, dans le dossier Samples de votre
disque dur, qui indique comment utiliser les types de données dans une application.
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\DataTypes.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/DataTypes.
Type de données Boolean
Une valeur booléenne est soit true (vraie), soit false (fausse). ActionScript convertit
également les valeurs true et false en 1 et 0 lorsque cela est nécessaire. Les valeurs
booléennes sont le plus souvent utilisées dans les instructions ActionScript effectuant des
comparaisons pour contrôler le déroulement d’un script.
L’exemple suivant illustre le chargement d’un fichier texte dans un fichier SWF. Il affiche un
message dans le panneau de sortie si le chargement du fichier texte échoue ou les paramètres
s’il réussit. Pour plus d’informations, consultez les commentaires de l’exemple de code.
var my_lv:LoadVars = new LoadVars();
//success est une valeur booléenne.
my_lv.onLoad = function(success:Boolean) {
//si le paramètre success est true, suivre monthNames
if (success) {
Présentation des types de données
81
trace(my_lv.monthNames);
//si le paramètre success est false, suivre un message
} else {
trace("impossible de charger le fichier texte");
}
};
my_lv.load("http://www.helpexamples.com/flash/params.txt");
L’exemple suivant permet de s’assurer que les utilisateurs entrent des valeurs dans deux
occurrences de composant TextInput. Deux variables booléennes sont créées,
userNameEntered et isPasswordCorrect. Si ces deux variables renvoient la valeur true, un
message de bienvenue est affecté à la variable de type chaîne titleMessage.
// Ajoute deux composants TextInput, un composant Label et un composant
Button sur la scène.
// Application de typage strict aux trois occurrences de composant.
var userName_ti:mx.controls.TextInput;
var password_ti:mx.controls.TextInput;
var submit_button:mx.controls.Button;
var welcome_lbl:mx.controls.Label;
//Masquer l’étiquette
welcome_lbl.visible = false;
// Crée un objet écouteur, utilisé avec le composant Button.
// Lorsque vous cliquez sur le composant Button, le programme recherche un
nom d’utilisateur et un mot de passe.
var btnListener:Object = new Object();
btnListener.click = function(evt:Object) {
// Vérifie que l’utilisateur a entré au moins un caractère dans les
occurrences
// TextInput et renvoie une valeur booléenne true/false.
var userNameEntered:Boolean = (userName_ti.text.length > 0);
var isPasswordCorrect:Boolean = (password_ti.text == "vertigo");
if (userNameEntered && isPasswordCorrect) {
var titleMessage:String = "Bienvenue " + userName_ti.text + "!";
welcome_lbl.text = titleMessage;
//afficher l’étiquette
welcome_lbl.visible = true;
}
};
submit_button.addEventListener("click", btnListener);
Pour plus d’informations, consultez les sections Utilisation des fonctions dans Flash, page 231 et
Présentation des opérateurs logiques, page 210.
82
Données et types de données
Données de type clip
Les clips sont des symboles qui peuvent lire des effets animés dans une application Flash. Ils
sont le seul type de données faisant référence à un élément graphique. Le type de données
MovieClip vous permet de contrôler les symboles de clip au moyen des méthodes de la classe
MovieClip.
N’utilisez pas de constructeur pour appeler les méthodes de la classe MovieClip. Vous pouvez
créer une instance de clip sur la scène ou créer une instance de façon dynamique. Vous pouvez
alors appeler les méthodes de la classe MovieClip avec l’opérateur point (.).
Manipulation des clips sur la scène
L’exemple suivant appelle les méthodes startDrag()
et getURL() pour différentes occurrences de clip placées sur la scène :
my_mc.startDrag(true);
parent_mc.getURL("http://www.macromedia.com/support/" + product);
Le deuxième exemple renvoie la largeur d’un clip appelé my_mc et situé sur la scène. L’instance
cible doit être un clip et la valeur renvoyée doit être une valeur numérique.
function getMCWidth(target_mc:MovieClip):Number {
return target_mc._width;
}
trace(getMCWidth(my_mc));
Création dynamique de clips
La création dynamique de clips avec ActionScript évite de
devoir les créer manuellement sur la scène ou de les affecter à partir de la bibliothèque. Par
exemple, vous pouvez créer une galerie d’images à partir d’un grand nombre d’images de
vignettes à organiser sur la scène. L’utilisation de MovieClip.createEmptyMovieClip()
permet de créer une application de bout en bout avec ActionScript.
Pour créer un clip de façon dynamique, utilisez MovieClip.createEmptyMovieClip(),
comme indiqué dans l’exemple suivant :
// Crée un clip parent pour le conteneur.
this.createEmptyMovieClip("image_mc", 9);
// Charge une image dans image_mc.
image_mc.loadMovie("http://www.helpexamples.com/flash/images/image1.jpg");
Le deuxième exemple crée un clip appelé square_mc qui utilise l’API de dessin pour dessiner
un rectangle. Les gestionnaires d’événement et les méthodes startDrag() et stopDrag() de
la classe MovieClip sont ajoutés pour permettre à l’utilisateur de faire glisser le rectangle.
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.lineTo(200, 200);
square_mc.lineTo(100, 200);
Présentation des types de données
83
square_mc.lineTo(100, 100);
square_mc.endFill();
square_mc.onPress = function() {
this.startDrag();
};
square_mc.onRelease = function() {
this.stopDrag();
};
Pour plus d’informations, consultez le Chapitre 11, Utilisation des clips, page 381 et à l’entrée
MovieClip du Guide de référence du langage ActionScript 2.0.
Type de données Null
Ce type de données ne peut contenir qu’une valeur, null. Cette valeur signifie en fait pas de
valeur et symbolise l’absence de données. Vous pouvez affecter la valeur null dans de
nombreuses situations pour indiquer qu’une propriété ou une variable n’a pas encore reçu de
valeur. Par exemple, vous pouvez affecter la valeur null dans les situations suivantes :
■
Pour indiquer qu’une variable existe, mais n’a pas encore reçu de valeur ;
■
Pour indiquer qu’une variable existe, mais ne contient plus de valeur ;
■
En tant que valeur de retour d’une fonction, afin d’indiquer qu’aucune valeur n’a pu être
retournée par la fonction ;
■
En tant que paramètre d’une fonction, afin d’indiquer qu’un paramètre est omis.
Plusieurs méthodes et fonctions renvoient null si aucune valeur n’a été définie. L’exemple
suivant démontre comment utiliser null pour vérifier si les champs du formulaire ont le
focus :
if (Selection.getFocus() == null) {
trace("no selection");
}
Données de type numérique
Ce type numérique correspond à un nombre à virgule flottante à double précision. La valeur
minimum d’un objet Number est d’environ 5e-324. Sa valeur maximum est d’environ
1,79E+308.
Vous pouvez manipuler les nombres avec les opérateurs arithmétiques d’addition (+), de
soustraction (-), de multiplication (*), de division (/), de modulo (%), d’incrémentation (++)
et de décrémentation (--). Pour plus d’informations, reportez-vous à la section Utilisation des
opérateurs numériques, page 204.
84
Données et types de données
Vous pouvez également utiliser des méthodes des classes intégrées Math et Number pour
manipuler les nombres. Pour plus d’informations sur les méthodes et les propriétés de ces
classes, consultez les entrées Math et Number du Guide de référence du langage
ActionScript 2.0.
L’exemple suivant utilise la méthode sqrt() (racine carrée) de la classe Math pour renvoyer la
racine carrée de 100 :
Math.sqrt(100);
L’exemple suivant suit un entier compris entre 10 et 17 (inclus) :
var bottles:Number = 0;
bottles = 10 + Math.floor(Math.random() * 7);
trace("There are " + bottles + " bottles");
L’exemple suivant mesure le pourcentage du clip intro_mc chargé et le représente sous forme
d’entier :
var percentLoaded:Number = Math.round((intro_mc.getBytesLoaded() /
intro_mc.getBytesTotal()) * 100);
Type de données Object
Un objet correspond à un ensemble de propriétés. Une propriété est un attribut qui décrit
l’objet. Par exemple, la transparence d’un objet (tel qu’un clip) est un attribut qui décrit son
apparence. Donc, _alpha (transparence) est une propriété. Chaque propriété possède un
nom et une valeur. La valeur d’une propriété peut être de n’importe quel type de données
Flash, même de type Object. Cela vous permet d’arranger les objets les uns dans les autres, ou
de les imbriquer.
Pour spécifier les objets et leurs propriétés, vous devez utiliser l’opérateur point (.). Par
exemple, dans le code suivant, hoursWorked est une propriété de weeklyStats, qui est une
propriété de employee :
employee.weeklyStats.hoursWorked
L’objet ActionScript MovieClip possède des méthodes qui vous permettent de contrôler les
occurrences de symbole de clip sur la scène. Cet exemple utilise les méthodes play() et
nextFrame() :
nomDoccurrenceMC.play();
mc2InstanceName.nextFrame();
Présentation des types de données
85
Vous pouvez aussi créer des objets personnalisés pour organiser les informations dans votre
application Flash. Pour ajouter de l’interactivité à votre application avec ActionScript, vous
aurez besoin de nombreuses informations : un nom d’utilisateur, son âge et son numéro de
téléphone, la vitesse d’une balle, les noms des articles contenus dans un panier d’achat, le
nombre d’images chargées ou la dernière touche utilisée sur le clavier, par exemple. La création
d’objets personnalisés vous permet d’organiser ces informations dans des groupes, de
simplifier la rédaction et de réutiliser vos scripts.
Le code ActionScript suivant affiche un exemple d’utilisation des objets personnalisés pour
organiser les informations. Il crée un nouvel objet appelé user et trois propriétés, name, age et
phone, qui sont de types chaîne et numérique.
var user:Object = new Object();
user.name = "Irving";
user.age = 32;
user.phone = "555-1234";
Pour plus d’informations, reportez-vous à la section Exemple : Ecriture de classes personnalisées,
page 285.
Données de type chaîne
Une chaîne est une séquence de caractères (lettres, chiffres et signes de ponctuation, par
exemple). Vous insérez des chaînes dans une instruction ActionScript en les plaçant entre des
guillemets droits simples (’) ou doubles (").
L’un des moyens les plus communs consiste à associer une chaîne à une variable. Par exemple,
dans l’instruction suivante, "L7" est une chaîne associée à la variable favoriteBand_str :
var favoriteBand_str:String = "L7";
Vous pouvez utiliser l’opérateur d’addition (+) pour concaténer, ou réunir, deux chaînes.
ActionScript traite les espaces au début ou à la fin d’une chaîne comme faisant partie de la
chaîne. L’expression suivante contient un espace après la virgule :
var greeting_str:String = "Welcome, " + firstName;
86
Données et types de données
Pour inclure un guillemet dans une chaîne, faites-le précéder d’une barre oblique inversée (\).
Cette opération s’appelle application d’une séquence d’échappement à un caractère. D’autres
caractères ne peuvent pas être représentés dans ActionScript sans l’emploi de séquences
d’échappement particulières. Le tableau suivant répertorie l’ensemble des caractères
d’échappement d’ActionScript :
Séquence
d’échappement
Caractère
\b
Caractère de retour arrière (ASCII 8)
\f
Caractère de changement de page (ASCII 12)
\n
Caractère de changement de ligne (ASCII 10)
\r
Caractère de retour chariot (ASCII 13)
\t
Caractère de tabulation (ASCII 9)
\"
Guillemet droit double
\'
Guillemet droit simple
\\
Barre oblique inverse
\000 - \377
Un octet spécifié en octal
\x00 - \xFF
Un octet spécifié en hexadécimal
\u0000 - \uFFFF
Un caractère Unicode 16 bits spécifié en hexadécimal
Comme sous Java, les chaînes sont inaltérables dans ActionScript. Toute opération modifiant
une chaîne renvoie une nouvelle chaîne.
La classe String est une classe intégrée du code ActionScript. Pour plus d’informations sur les
méthodes et les propriétés de la classe String, reportez-vous à l’entrée String dans le Guide de
référence du langage ActionScript 2.0.
Type de données undefined
Ce type de données n’a qu’une seule valeur, undefined. Il est affecté automatiquement à une
variable qui n’a reçu aucune valeur, que se soit du code ou de l’interaction de l’utilisateur.
La valeur undefined est affectée automatiquement. Contrairement à null, vous ne pouvez
pas l’affecter à une variable ou une propriété. Ce type de données permet de vérifier si la
variable est définie ou non. Vous pouvez alors écrire du code qui ne s’exécute que lorsque
l’application est en cours d’exécution, comme indiqué dans l’exemple suivant :
if (init == undefined) {
trace("initializing app");
init = true;
}
Présentation des types de données
87
Si votre application comporte plusieurs images, le code ne s’exécute pas une deuxième fois
parce que la variable init n’est plus « undefined ».
Type de données Void
Ce type de données n’a qu’une seule valeur, void. Il est utilisé dans la définition des fonctions
pour indiquer qu’elles ne renvoient pas de valeurs, comme indiqué dans l’exemple suivant :
//Crée une fonction renvoyant le type Void
function displayFromURL(url:String):Void {}
Affectation des types de données et typage strict
Dans Flash, les variables vous permettent de stocker des valeurs dans votre code. Vous pouvez
déclarer explicitement le type d’objet d’une variable lorsque vous la créez. Cette opération est
appelée le typage strict.
Si vous ne déclarez pas de façon explicite qu’un élément contient un nombre, une chaîne ou
tout autre type de donnée, lors de l’exécution du script, Flash Player tente d’identifier le type
de données de cet élément lorsqu’il est affecté. Si vous affectez une valeur à une variable
comme indiqué dans l’exemple suivant, lors de l’exécution du script, Flash Player évalue
l’élément situé à droite de l’opérateur et détermine qu’il est de type numérique :
var x = 3;
Dans la mesure où x n’a pas été déclaré par typage strict, le compilateur ne peut pas
déterminer son type. Ainsi, pour le compilateur, la variable x peut être de n’importe quel type.
(Voir la section Affectation d’un type de données, page 89.) Une affectation ultérieure pourra
changer le type de x. Par exemple, l’instruction x = "hello" change le type de x en chaîne.
ActionScript convertit toujours les types de données primitifs (tels que Boolean, Number,
String, null ou undefined) automatiquement lorsqu’une expression en a besoin et que les
variables ne sont pas déclarées par typage strict.
Le typage strict des données offre plusieurs avantages lors de la compilation. La déclaration
des types de données (typage strict) permet de prévenir et de diagnostiquer les erreurs de votre
code au moment de sa compilation. Pour déclarer une variable par typage strict, utilisez le
format suivant :
var variableName:datatype;
REMARQUE
88
Le typage strict des variables est parfois appelé typage fort.
Données et types de données
Les incompatibilités de type de données déclenchent des erreurs de compilation, le typage
strict facilite le débogage lors de la compilation et permet donc d’éviter d’affecter un type de
données incorrect à une variable existante. Lors de la programmation, le typage strict des
données active les conseils de code dans l’éditeur ActionScript (mais vous devez toujours
utiliser les suffixes de nom d’occurrence pour les éléments visuels).
L’utilisation du typage strict vous empêche d’affecter, par inadvertance, un type de valeur
incorrect à une variable. Flash vérifie les erreurs de typage lors de la compilation. En cas de
type de valeur incorrect, il affiche un message d’erreur. Ainsi, l’application du typage strict
permet de s’assurer que vous ne tentez pas d’accéder à des propriétés ou des méthodes qui ne
font pas partie d’un type d’objet. Le typage strict permet également de bénéficier
automatiquement des conseils de code proposés par l’éditeur d’ActionScript pour les objets.
Pour plus d’informations sur la création de variables, reportez-vous à la section Présentation des
variables, page 94. Pour plus d’informations sur l’appellation des variables, reportez-vous à la
section A propos de l’appellation des variables, page 99. Pour plus d’informations sur
l’affectation des types de données et sur les types appropriés, reportez-vous à la section
Affectation d’un type de données, page 89.
Vous trouverez un exemple de fichier source, datatypes.fla, dans le dossier Samples de votre
disque dur, qui indique comment utiliser les types de données dans une application.
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\DataTypes.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/DataTypes.
Affectation d’un type de données
Vous devez affecter des types de données chaque fois que vous définissez une variable, que
vous la déclariez à l’aide d’un mot clé var, que vous créiez un argument de fonction ou que
vous définissiez un type de retour de fonction ou une variable à utiliser dans une boucle for
ou for..in. Pour affecter un type de données, utilisez la syntaxe à deux points : le nom de la
variable est suivi de deux points, puis du type de données :
var my_mc:MovieClip;
Les types de données offrent de nombreuses possibilités : des types natifs, tels que Number,
String, Boolean, jusqu’aux classes intégrées de Flash Player 8, telles que BitmapData,
FileReference ou même les classes personnalisées écrites par vos soins ou par d’autres
développeurs. Les types de données les plus courants que vous devrez définir sont les types
intégrés, tels que Number, String, Boolean, Array ou Object, qui apparaissent dans les
exemples de code suivants.
Présentation des types de données
89
Pour affecter un type de données spécifique à un élément, spécifiez son type à l’aide d’une
syntaxe utilisant le mot-clé var ainsi que deux points, comme illustré ci-dessous :
// Typage strict de variable ou d’objet
var myNum:Number = 7;
var birthday:Date = new Date();
// Typage strict de paramètres
function welcome(firstName:String, age:Number) {
}
// Typage strict de paramètre et de valeur renvoyée
function square(myNum:Number):Number {
var squared:Number = myNum * myNum;
return squared;
}
Vous pouvez déclarer le type des objets en fonction des classes intégrées (Button, Date, etc.) et
des classes et interfaces que vous créez. Dans l’exemple suivant, si vous avez un fichier qui
s’appelle Student.as dans lequel vous avez défini une classe Student, vous pouvez spécifier que
les objets que vous créez sont de type Student :
var myStudent:Student = new Student();
Par exemple, supposons que vous tapez le code suivant :
// dans le fichier de classe Student.as
class Student {
public var status:Boolean; // Propriété des objets Student
}
// Dans le fichier FLA
var studentMaryLago:Student = new Student();
studentMaryLago.status = "enrolled"; /* Incompatibilité de types dans
l’instruction d’affectation : type String présent au lieu du type
Boolean. */
Lorsque Flash compile ce script, une erreur d’incompatibilité de types est générée, car le
fichier SWF s’attend à une valeur booléenne.
Si vous écrivez une fonction sans type de renvoi, vous pouvez déclarer le type de renvoi Void
pour cette fonction. Ou, si vous créez un raccourci vers une fonction, vous pouvez affecter le
type de données Function à la nouvelle variable. Pour indiquer le type Function ou Void pour
les objets, inspirez-vous de l’exemple suivant :
function sayHello(name_str:String):Void {
trace("Hello, " + name_str);
}
sayHello("world"); // Hello, world
var greeting:Function = sayHello;
greeting("Augustus"); // Hello, Augustus
90
Données et types de données
Un des autres avantages du typage strict des données réside dans le fait que Flash affiche
automatiquement des conseils de code pour les objets intégrés que vous déclarez par typage
stricte. Pour plus d’informations, reportez-vous à la section Affectation des types de données et
typage strict, page 88.
Les fichiers publiés avec ActionScript 1.0 ne respectent pas le typage strict des données lors de
la compilation. Par conséquent, l’attribution d’un type de valeur incorrect à une variable que
vous avez typée de façon stricte ne génère pas d’erreur de compilation.
var myNum:String = "abc";
myNum = 12;
/* Aucune erreur dans ActionScript
ActionScript 2.0 */
1.0, mais incompatibilité dans
Ceci est dû au fait que lorsque vous publiez un fichier pour ActionScript 1.0, Flash interprète
une instruction telle que var myNum:String = "abc" comme une syntaxe à barre oblique et
non comme un typage strict. (ActionScript 2.0 ne prend pas en charge la syntaxe à barre
oblique.) Il peut alors en résulter un objet affecté à une variable de type erroné. Le
compilateur ignore alors les appels de méthodes non valides et les références de propriété non
définies.
Les fichiers publiés à l’aide d’ActionScript 2.0 peuvent utiliser le typage des données en
option. Ainsi, si vous implémentez le typage strict dans votre code, assurez-vous de définir vos
paramètres de publication sur ActionScript 2.0. Vous pouvez définir les paramètres de
publication, ainsi que la version d’ActionScript à utiliser pour la publication de vos fichiers,
soit à partir du menu principal (Fichier > Paramètres de publication), soit en cliquant sur le
bouton Paramètres dans l’inspecteur des propriétés (assurez-vous que aucune occurrence n’est
sélectionnée). Pour utiliser une version spéciale d’ActionScript ou de Flash Player, ouvrez
l’onglet Flash dans la boîte de dialogue Paramètres de publication, puis sélectionnez la version
ActionScript désirée dans le menu contextuel.
Pour plus d’informations sur la vérification des types de données, reportez-vous à la section
Vérification du type des données, page 92.
Présentation des types de données
91
Vérification du type des données
Cette opération consiste à vérifier que le type d’une variable est compatible avec une
expression. Flash vérifie donc que le type que vous indiquez pour une variable convient aux
valeurs que vous affectez à celle-ci. Pour plus d’informations sur le typage strict et l’affectation
des types de données, consultez les sections Affectation des types de données et typage strict,
page 88 et Affectation d’un type de données, page 89.
La vérification des types peut être effectuée lors de la compilation ou de l’exécution. Si vous
utilisez le typage strict des données, le type est vérifié lors de la compilation. ActionScript
étant un langage typé dynamiquement, ActionScript peut également vérifier le type à
l’exécution.
Par exemple, le code suivant n’indique aucun type de données pour le paramètre xParam. A
l’exécution, vous utilisez ce paramètre pour stocker une valeur numérique Number, puis une
valeur de chaîne de caractères String. La fonction dynamicTest() utilise ensuite l’opérateur
typeof pour connaître le type du paramètre, 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");
Vous n’avez pas besoin de déclarer explicitement le type de ces données dans votre code
ActionScript. Le compilateur d’ActionScript vous permet d’utiliser des propriétés et
d’invoquer des méthodes qui n’existent pas au moment de la compilation. Ainsi, vous pouvez
créer des propriétés ou affecter des méthodes dynamiquement au moment de l’exécution.
La flexibilité offerte par la vérification dynamique du type des données implique l’utilisation
de propriétés et de méthodes inconnues au moment de la compilation. Le code étant moins
restrictif, cette flexibilité est avantageuse dans certains cas de programmation. Par exemple, le
code suivant crée une fonction nommée runtimeTest() qui appelle une méthode et renvoie
une propriété, toutes deux inconnues du compilateur. Ce code ne générera aucune erreur lors
de la compilation. Cependant, si la propriété ou la méthode est inaccessible à l’exécution, une
erreur se produira à ce moment-là.
function runtimeTest(myParam) {
myParam.someMethod();
return myParam.someProperty;
}
92
Données et types de données
Identification du type des données
Lors du test et du débogage de vos programmes, des problèmes liés aux types de données
peuvent se produire. Ou, si vous utilisez des variables non explicitement associées à un type de
données, il sera plus pratique de connaître le type d’une variable donnée. Avec ActionScript,
vous pouvez identifier le type des données d’un élément. Utilisez l’opérateur typeof pour
récupérer des informations sur les données.
Cependant, n’oubliez pas que cet opérateur ne renvoie pas d’informations sur la classe d’une
occurrence.
L’exemple suivant présente l’utilisation de l’opérateur typeof pour renvoyer la nature de
l’objet à identifier :
// Crée une nouvelle occurrence de la classe LoadVars.
var my_lv:LoadVars = new LoadVars();
/* L’opérateur typeof n’indique pas la classe, il spécifie uniquement que
myLV est un objet. */
var typeResult:String = typeof(my_lv);
trace(typeResult); // Objet
Dans cet exemple, vous créez une nouvelle variable String nommée myName, puis vous la
convertissez en type Number :
var myName:String = new String("17");
trace(myName instanceof String); // true
var myNumber:Number = new Number(myName);
trace(myNumber instanceof Number); // true
Pour plus d’informations sur ces opérateurs, reportez-vous à typeof operator et
instanceof operator dans le Guide de référence du langage ActionScript 2.0. Pour plus
d’informations sur le test et le débogage, consultez le Chapitre 18, Débogage des applications,
page 775. Pour plus d’informations sur l’héritage et les interfaces, consultez le
Chapitre 8, Héritage, page 329. Pour plus d’informations sur les classes, consultez le
Chapitre 7, Classes, page 243.
Présentation des types de données
93
Présentation des variables
Une variable est un conteneur qui stocke des informations. Le code suivant montre une
variable dans ActionScript :
var myVariable:Number = 10;
Cette variable contient une valeur numérique. L’utilisation de :Number dans le code précédent
affecte le type de valeur que la variable contient, opération appelée typage des données. Pour
plus d’informations sur le typage des données, consultez les sections Affectation des types de
données et typage strict, page 88 et Affectation d’un type de données, page 89.
Le conteneur (représenté par le nom de variable) est toujours le même dans tout votre code
ActionScript, mais son contenu (sa valeur) peut évoluer. Vous pouvez changer plusieurs fois la
valeur d’une variable dans un script. La modification de la valeur d’une variable pendant la
lecture du fichier SWF permet d’enregistrer les informations relatives aux actions de
l’utilisateur, d’enregistrer les valeurs modifiées pendant la lecture du fichier SWF ou d’évaluer
si une condition est vraie ou fausse (true ou false). La variable devra peut-être être
continuellement mise à jour pendant la lecture du fichier SWF, par exemple lorsque le score
d’un joueur change dans un jeu Flash. Les variables sont indispensables pour créer et gérer les
interactions de l’utilisateur dans un fichier SWF.
Il est toujours judicieux d’affecter une valeur à une variable lors de sa première déclaration.
L’affectation d’une valeur initiale est appelée initialisation de la variable. Cette opération est
souvent effectuée sur l’Image 1 du scénario ou depuis la classe qui est chargée au début de la
lecture du fichier SWF. Il existe différentes sorte de variables, qui sont affectées par domaine.
Pour plus d’informations sur les différentes sortes de variables et sur les domaines, consultez la
section Variables et domaine, page 105.
C ON S E I L
L’initialisation d’une variable facilite le suivi et la comparaison de sa valeur pendant la
lecture du fichier SWF.
R E M A R QU E
Flash Player 7 et ses versions ultérieures n’évaluent pas les variables non initialisées de
la même manière que Flash Player 6 et ses versions précédentes. Si vous avez écrit des
scripts pour Flash Player 6 et prévoyez d’écrire ou porter des scripts pour Flash Player 7
ou une version plus récente, vous devez comprendre ces différences pour éviter un
comportement inattendu.
Les variables peuvent contenir différents types de données. Pour plus d’informations,
reportez-vous à la section Présentation des types de données, page 78. Le type de données d’une
variable influence la façon dont sa valeur est modifiée par un script.
94
Données et types de données
Les types d’informations le plus souvent stockés dans une variable sont les URL (String), les
noms d’utilisateur (String), les résultats d’opérations mathématiques (Number), le nombre
d’occurrences d’un événement (Number) ou si un bouton a été actionné (Boolean). Chaque
fichier SWF et chaque occurrence d’objet (tel qu’un clip) dispose d’un jeu de variables, dont la
valeur est indépendante des variables figurant dans d’autres fichiers SWF ou clips.
Pour tester la valeur d’une variable, utilisez l’instruction trace() pour envoyer la valeur au
panneau de sortie. La valeur apparaît ensuite dans le panneau de sortie lorsque vous testez le
fichier SWF dans l’environnement de test. Par exemple, trace(hoursWorked) envoie la
valeur de la variable hoursWorked au panneau de sortie dans l’environnement de test. Vous
pouvez également vérifier et définir les valeurs des variables avec le débogueur dans
l’environnement de test.
Pour plus d’informations sur les variables, consultez les sections suivantes :
■
Déclaration des variables, page 95
■
Affectation des valeurs, page 96
■
A propos de l’appellation des variables, page 99
■
Utilisation de variables dans une application, page 100
■
Variables et domaine, page 105
■
A propos des valeurs par défaut, page 96
■
A propos des opérateurs et des variables, page 98
■
Chargement des variables, page 110
■
Utilisation de variables dans un projet, page 116
Déclaration des variables
Vous pouvez déclarer les variables sur une image du scénario, directement dans un objet ou
dans un fichier de classe externe.
Définissez les variables à l’aide du mot clé var et respectez leurs conventions d’appellation.
Comme dans l’exemple suivant, vous pouvez déclarer une variable nommée firstName :
var firstName:String;
Lorsque vous déclarez une variable, vous lui affectez un type de données. Dans le cas présent,
vous affectez le type String à la variable firstName. Pour plus d’informations sur l’affectation
du type de données, reportez-vous à la rubrique Affectation des types de données et typage strict,
page 88.
Présentation des variables
95
A propos des valeurs par défaut
La valeur par défaut est le contenu d’une variable avant que vous définissiez sa valeur. Vous
initialisez une variable lorsque vous lui affectez sa première valeur. Si vous déclarez une
variable sans définir sa valeur, cette variable est non initialisée. La valeur par défaut d’une
variable non initialisée est undefined. Pour plus d’informations sur la création et l’utilisation
des variables, reportez-vous à la section Présentation des variables, page 94.
Affectation des valeurs
Vous pouvez définir une valeur comme contenu actuel d’une variable. Cette valeur peut être
composée de chaînes, nombres, tableaux, objets, XML, dates ou même de classes
personnalisées que vous créez. N’oubliez pas que vous déclarez les variables dans Flash à l’aide
du mot clé var. Lorsque vous déclarez une variable, vous lui affectez également un type de
données. Vous pouvez également lui attribuer une valeur, tant que celle-ci correspond au type
de données affecté à la variable.
L’exemple suivant présente la création d’une variable nommée catName :
var catName:String;
Après la déclaration de la variable, vous pouvez lui affecter une valeur. La ligne de code
ActionScript précédente doit être suivie de cette ligne :
catName = "Pirate Eye";
REMARQUE
Pirate Eye étant une chaîne (String), sa valeur doit être entre guillemets.
Cet exemple affecte la valeur de Pirate Eye à la variable catName. Lorsque vous déclarez la
variable, vous pouvez également lui attribuer une valeur immédiatement, et non
ultérieurement comme dans les exemples précédents. Vous pouvez définir la variable catName
lors de sa déclaration, comme dans l’exemple suivant :
var catName:String = "Pirate Eye";
Si vous souhaitez afficher la valeur de la variable catName dans l’environnement de test,
utilisez l’instruction trace(). Cette instruction envoie la valeur au panneau de sortie. Vous
pouvez suivre l’évolution de la valeur de la variable catName et vérifier si les guillemets sont
absents dans son contenu actuel à l’aide du code ActionScript suivant :
var catName:String = "Pirate Eye";
trace(catName); // Pirate Eye
96
Données et types de données
N’oubliez pas que la valeur affectée doit être compatible avec le type de données déclaré
(String dans le cas présent). Si par la suite, vous tentez d’affecter un nombre à la variable
catName, par exemplecatName = 10, l’erreur suivante apparaîtra dans le panneau de sortie
lors du test du fichier SWF :
Type mismatch in assignment statement: found Number where String is
required.
Cette erreur indique que vous avez tenté d’affecter un type de données incorrect à une variable
définie.
Lorsque vous affectez une valeur numérique à une variable, les guillemets ne sont pas
nécessaires, comme le montre le code suivant :
var numWrinkles:Number = 55;
Pour modifier la valeur de numWrinkles ultérieurement dans votre code, affectez une nouvelle
valeur à l’aide du code ActionScript suivant :
numWrinkles = 60;
Lorsque vous réaffectez la valeur d’une variable existante, il n’est pas nécessaire d’utiliser le
mot clé var ni de définir le type de données de la variable (dans le cas présent, Number).
Si la valeur est numérique ou booléenne (true ou false), les guillemets sont inutiles. Des
exemples de valeurs numériques et booléennes sont présentés dans le fragment de code
suivant :
var age:Number = 38;
var married:Boolean = true;
var hasChildren:Boolean = false;
Dans l’exemple précédent, la variable age contient la valeur d’un entier (non décimal), bien
que vous puissiez utiliser une valeur décimale ou à virgule flottante telle que 38,4. Les
variables booléennes (telles que married ou hasChildren) ont deux valeurs possibles, true et
false.
Si vous souhaitez créer un tableau et lui affecter des valeurs, le format est légèrement différent,
comme dans le code suivant :
var childrenArr:Array = new Array("Pylon", "Smithers", "Gil");
Il existe une autre syntaxe (abrégée) pour créer un tableau à l’aide des opérateurs d’accès
tableau, qui utilisent les parenthèses ([]). Vous pouvez réécrire l’exemple précédent comme
suit :
var childrenArr:Array = ["Pylon", "Smithers", "Gil"];
Pour plus d’informations sur la création de tableaux et leurs opérateurs d’accès, consultez les
sections Présentation des tableaux, page 177 et Utilisation de la syntaxe à point pour cibler une
occurrence, page 129.
Présentation des variables
97
De même, vous pouvez créer un nouvel objet appelé myObj. Pour créer un nouvel objet,
utilisez l’une des méthodes suivantes. La première méthode (et la plus longue) pour créer un
tableau avec du code est la suivante :
var myObj:Object = new Object();
myObj.firstName = "Steve";
myObj.age = 50;
myObj.childrenArr = new Array("Mike", "Robbie", "Chip");
La seconde méthode (la plus courte) pour créer le tableau myObj avec du code est la suivante :
var myObj:Object = {firstName:"Steve", age:50, childrenArr:["Mike",
"Robbie", "Chip"]};
Comme le montre cet exemple, le choix de la méthode courte permet d’économiser beaucoup
de saisie et de temps, particulièrement lorsque vous définissez des occurrences d’objets. Il est
important de bien connaître cette syntaxe alternative car vous la rencontrerez en travaillant
avec d’autres équipes ou dans du code ActionScript écrit par des tiers sur Internet ou dans les
livres spécialisés.
REMARQUE
Toutes les variables n’ont pas besoin d’être définies explicitement. Certaines variables
sont créées automatiquement par Flash pour vous. Par exemple, pour connaître les
dimensions de la scène, vous pouvez utiliser les valeurs des deux variables prédéfinies
suivantes : Stage.width et Stage.height.
A propos des opérateurs et des variables
Les symboles mathématiques présents dans le code peuvent prêter à confusion. Dans
ActionScript, ces symboles sont appelés des opérateurs. Les opérateurs calculent une nouvelle
valeur à partir d’une ou plusieurs valeurs et vous les utilisez pour affecter une valeur à une
variable dans votre code. Vous utilisez l’opérateur d’égalité (=) pour affecter une valeur à une
variable :
var username:String = "Gus";
L’opérateur d’addition (+) est utilisé pour ajouter des valeurs numériques entre elles et
produire ainsi une nouvelle valeur. Si vous utilisez l’opérateur + avec des valeurs de chaînes
(string), les chaînes seront concaténées. Les valeurs manipulées avec des opérateurs sont
appelées opérandes.
Pour affecter une valeur à une variable, vous utilisez un opérateur. Par exemple, le script
suivant utilise l’opérateur d’affectation pour donner la valeur 7 à la variable numChildren :
var numChildren:Number = 7;
98
Données et types de données
Si vous devez modifier la valeur de la variable numChildren, utilisez le code suivant :
numChildren = 8;
REMARQUE
Le mot clé var n’est pas nécessaire car la variable a déjà été définie.
Pour plus d’informations sur l’utilisation des opérateurs dans le code ActionScript, reportezvous à la section Présentation des opérateurs, page 191.
A propos de l’appellation des variables
Prenez soin de bien choisir les noms que vous attribuez aux variables car, bien que leur choix
soit entièrement libre, certaines règles doivent être respectées. Le nom des variables doit suivre
les règles suivantes :
■
Toute variable doit être un identifiant.
REMARQUE
Les identifiants sont des noms de variable, de propriété, d’objet, de fonction ou de
méthode. Le premier caractère des identifiants doit être une lettre, un trait de
soulignement (_) ou un signe dollar ($). Chaque caractère qui suit peut être une lettre,
un chiffre, un trait de soulignement ou un dollar.
■
Une variable ne peut pas être un mot-clé, ni un littéral ActionScript, tel que true, false,
null ou undefined. Pour plus d’informations sur les littéraux, reportez-vous à la section
Présentation des littéraux, page 142.
■
Toute variable doit être unique dans son domaine (reportez-vous à la section Variables et
domaine, page 105).
■
Le nom d’une variable ne doit pas correspondre à un élément du langage ActionScript, tel
qu’un nom de classe.
Si vous ne respectez pas ces règles lors de l’attribution des noms de variables, des erreurs de
syntaxe ou des résultats inattendus risquent de se produire. Dans l’exemple suivant, si vous
nommez une variable new, lorsque vous testez votre document, Flash générera une erreur de
compilation :
// Ce code fonctionne comme prévu.
var helloStr:String = new String();
trace(helloStr.length); // 0
// Mais si une variable porte le même nom qu’une classe intégrée....
var new:String = "hello"; // erreur : identifiant attendu
Présentation des variables
99
var helloStr:String = new String();
trace(helloStr.length); // non défini
L’éditeur ActionScript prend en charge les conseils de code pour les classes intégrées et pour les
variables basées sur ces classes. Si vous souhaitez obtenir des conseils de code pour un type
d’objet particulier que vous avez affecté à une variable, vous pouvez définir strictement le type
de cette dernière. Les conseils de code fournissent des astuces de syntaxe sous forme d’infobulles et un menu contextuel qui accélère votre rédaction du code.
Par exemple, vous tapez le code suivant :
var members:Array = new Array();
members.
Dès que vous tapez le point (.) dans le panneau Actions, Flash affiche la liste des méthodes et
propriétés disponibles pour les objets Array.
Pour connaître les conventions de codage pour l’appellation des variables, reportez-vous à la
section Appellation des variables, page 802.
Utilisation de variables dans une application
Dans cette section, vous utilisez des variables dans des fragments de code ActionScript. Vous
devez déclarer et initialiser une variable dans un script avant de pouvoir l’utiliser dans une
expression. Les expressions sont des combinaisons d’opérandes et d’opérateurs qui
représentent une valeur. Par exemple, dans l’expression i+2, i et 2 sont des opérandes et + est
un opérateur.
Si vous n’initialisez pas une variable avant de l’utiliser dans une expression, elle reste indéfinie
et risque de provoquer des résultats inattendus. Pour plus d’informations sur la syntaxe des
expressions, consultez le Chapitre 5, Eléments fondamentaux du langage et de la syntaxe,
page 123.
Si vous utilisez une variable indéfinie comme dans l’exemple suivant, elle prend la valeur NaN
dans Flash Player 7 et les versions ultérieures, et votre script est susceptible de générer des
résultats inattendus :
var squared:Number = myNum * myNum;
trace(squared); // NaN
var myNum:Number = 6;
Dans l’exemple suivant, l’instruction déclarant et initialisant la variable myNum est placée en
premier, de sorte que squared puisse être remplacé par une valeur :
var myNum:Number = 6;
var squared:Number = myNum * myNum;
trace(squared); // 36
100
Données et types de données
La même chose se produit lorsque vous transmettez une valeur non définie à une méthode ou
à une fonction, comme dans l’exemple suivant.
Pour comparer le transfert de variables définies et non définies à une fonction :
1.
Faites glisser un composant Button du panneau Composants sur la scène.
2.
Ouvrez l’inspecteur des propriétés et tapez bad_button dans la zone de texte Nom de
l’occurrence.
3.
Tapez le code suivant dans l’image 1 du scénario.
// Ne fonctionne pas
function badClickListener(evt:Object):Void {
getURL(targetUrl);
var targetUrl:String = "http://www.macromedia.com";
}
bad_button.addEventListener("click", badClickListener);
4.
Sélectionnez Contrôle > Tester l’animation, et remarquez que le bouton ne fonctionne pas
(la page Web ne s’ouvre pas).
5.
Faites glisser un composant Button sur la scène. Sélectionnez le bouton.
6.
Ouvrez l’inspecteur des propriétés et tapez good_button dans la zone de texte Nom de
l’occurrence.
7.
Ajoutez le code ActionScript suivant à l’image 1 du scénario (à la suite du précédent code
ActionScript ajouté) :
// Fonctionne
function goodClickListener(evt:Object):Void {
var targetUrl:String = "http://www.macromedia.com";
getURL(targetUrl);
}
good_button.addEventListener("click", goodClickListener);
8.
Sélectionnez Contrôle > Tester l’animation, puis cliquez sur le second bouton ajouté à la
scène.
Ce bouton fonctionne correctement et ouvre la page Web.
Le type de données contenu dans une variable affecte les conditions et le moment où sa valeur
sera modifiée. Les types de données primitifs, tels que les chaînes et les chiffres, sont transmis
par valeur : la valeur actuelle de la variable est reprise, et non pas une référence à cette valeur.
Parmi les exemples de type de données complexes, on trouve Array et Object.
Dans l’exemple suivant, vous définissez myNum sur 15 et copiez la valeur dans otherNum.
Lorsque vous modifiez myNum en 30 (à la ligne 3 du code), la valeur de otherNum demeure 15
car otherNum ne regarde pas dans myNum pour connaître sa valeur. La variable otherNum
contient la valeur de myNum qu’elle a reçue (à la ligne 2 du code).
Présentation des variables
101
Pour utiliser des variables dans votre code ActionScript :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom var_example.fla.
2.
Sélectionnez l’image 1 du scénario, puis tapez le code suivant dans le panneau Actions :
var myNum:Number = 15;
var otherNum:Number = myNum;
myNum = 30;
trace(myNum); // 30
trace(otherNum); // 15
Lorsque vous modifiez myNum en 30 (à la ligne 3 du code), la valeur de otherNum demeure
15 car otherNum ne regarde pas dans myNum pour connaître sa valeur. La variable
otherNum contient la valeur de myNum qu’elle a reçue (à la ligne 2 du code).
3.
Choisissez Contrôle > Tester l’animation pour voir les valeurs affichées dans le panneau de
sortie.
4.
Maintenant, ajoutez le code ActionScript suivant après celui ajouté à l’étape 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
Dans ce code, la variable inValue contient une valeur primitive, 3, la valeur est donc
transmise à la fonction sqr() et la valeur renvoyée est 9. La valeur de la variable inValue
ne change pas, bien que la valeur de myNum change dans la fonction.
5.
Choisissez Contrôle > Tester l’animation pour voir les valeurs affichées dans le panneau de
sortie.
Le type de données Object peut contenir tant d’informations complexes qu’une variable de ce
type ne contient pas de valeur réelle, mais contient une référence à la valeur. Cette référence
est un alias qui désigne le contenu de la variable. Lorsque la variable a besoin de connaître sa
valeur, la référence demande le contenu et renvoie la réponse sans transférer la valeur à la
variable.
Pour plus d’informations sur le transfert d’une variable par référence, reportez-vous à la
section Transfert d’une variable par référence, page 103.
102
Données et types de données
Transfert d’une variable par référence
Les types de données Array et Object contenant une référence à une valeur au lieu de leur
valeur réelle, soyez prudent lorsque vous travaillez avec des tableaux et des objets.
L’exemple suivant montre comment transmettre un objet par référence. Lorsque vous créez
une copie du tableau, vous créez en réalité une copie de la référence (ou alias) au contenu du
tableau. Lorsque vous modifiez le contenu du second tableau, vous modifiez à la fois le
contenu du premier et du second tableau car ils pointent tous les deux vers la même valeur.
Pour transmettre un objet par référence :
1.
Sélectionnez Fichier > Nouveau puis Document Flash pour créer un nouveau fichier FLA
et l’enregistrer sous le nom copybyref.fla.
2.
Sélectionnez l’image 1 du scénario, puis tapez le code suivant dans le panneau Actions :
var myArray:Array = new Array("tom", "josie");
var newArray:Array = myArray;
myArray[1] = "jack";
trace(myArray); // tom,jack
trace(newArray); // tom,jack
3.
Choisissez Contrôle > Tester l’animation pour tester le code ActionScript.
Ce code crée un objet Array appelé myArray qui contient deux éléments. Vous créez la
variable newArray et transmettez une référence à myArray. Lorsque vous modifiez le
deuxième élément de myArray en jack, cela affecte toutes les variables qui y font
référence. L’instruction trace() envoie tom,jack au panneau Sortie.
REMARQUE
Flash utilise un index basé sur zéro, ce qui signifie que 0 est le premier élément du
tableau, 1 le deuxième, etc.
Dans l’exemple suivant, myArray contient un objet Array que vous transmettez à la fonction
zeroArray() par référence. La fonction tableauNul() accepte un objet Array comme
paramètre et définit tous les éléments de ce tableau sur 0. Elle peut modifier ce tableau car il
est transmis par référence.
Présentation des variables
103
Pour transmettre un tableau par référence :
1.
Sélectionnez Fichier > Nouveau puis Document Flash pour créer un nouveau fichier FLA
et l’enregistrer sous le nom arraybyref.fla.
2.
Ajoutez le code ActionScript suivant à l’image 1 du scénario :
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);
trace(myArr); // 0,0,0
3.
Choisissez Contrôle > Tester l’animation pour tester votre code ActionScript.
La première instruction trace() de ce code ActionScript affiche le contenu original du
tableau myArray (1,2,3). Après votre appel de la fonction zeroArray() et votre transfert
d’une référence au tableaumyArray, toutes les valeurs du tableau sont écrasées et définies
sur zéro. La prochaine instruction trace() affiche le nouveau contenu original du
tableau myArray (0,0,0). Le tableau ayant été transmis par référence et non par valeur, il
est inutile de renvoyer le contenu actualisé du tableau provenant de la fonction
zeroArray().
Pour plus d’informations sur les tableaux, reportez-vous à la section Présentation des tableaux,
page 177.
104
Données et types de données
Variables et domaine
Le domaine d’une variable fait référence au domaine dans lequel la variable est connue
(définie) et peut être référencée. Il peut s’agir d’un certain scénario ou d’une fonction, ou
d’une application entière. Pour plus d’informations sur le domaine, reportez-vous à la section
Domaine et ciblage, page 133.
Lorsque vous développez des applications Flash avec ActionScript, la compréhension du
domaine des variables est capitale. Le domaine indique non seulement où et quand vous
pouvez faire référence aux variables, mais également la durée d’existence de chaque variable
dans l’application. Lorsque vous définissez des variables dans le corps d’une fonction, elles
cessent d’exister dès que la fonction spécifiée se termine. Si vous tentez de faire référence à des
objets dans un domaine incorrect ou à des variables qui ont expiré, vous obtenez des erreurs
dans vos documents Flash, ce qui entraîne des comportements inattendus ou des défaillances
de fonctionnalité.
Il existe trois types de domaine de variable dans ActionScript :
■
Variables globales et fonctions : ces variables et ces fonctions sont visibles par tout scénario
et domaine du document. Toute variable globale est donc définie dans chaque zone de
votre code.
■
Variables de scénario : ces variables sont disponibles pour tous les scripts de ce scénario.
■
Variables locales : ces variables sont disponibles dans le corps de la fonction dans lequel
elles sont déclarées (délimité par des accolades). Les variables locales sont donc définies
dans une seule partie de votre code.
Pour consulter les recommandations sur l’utilisation des domaines et des variables, consultez
le Chapitre 5, Domaine et ciblage, page 133.
REMARQUE
Les classes ActionScript 2.0 que vous créez prennent en charge les domaines de
variables publics, privés et statiques. Pour plus d’informations, consultez les sections
Présentation des membres de classe, page 271 et Contrôle de l’accès des membres dans
vos classes, page 297.
Vous ne pouvez pas typer les variables globales de façon stricte. Pour obtenir plus
d’informations et contourner ce problème, consultez la section Variables globales, page 106.
Présentation des variables
105
Variables globales
Les variables et les fonctions globales sont visibles par tout scénario et domaine du document.
Pour déclarer (ou créer) une variable globale, faites précéder son nom de l’identifiant _global
et n’utilisez pas la syntaxe var =. Par exemple, le code suivant crée la variable globale myName :
var _global.myName = "George"; // Syntaxe incorrecte pour la variable
globale
_global.myName = "George"; // Syntaxe correcte pour la variable globale
Toutefois, si vous initialisez une variable locale portant le même nom qu’une variable globale,
vous n’avez pas accès à cette dernière dans le domaine de la variable locale, comme indiqué
dans l’exemple suivant :
_global.counter = 100; // Déclare une variable globale
trace(counter); // Accède à la variable globale et affiche 100
function count():Void {
for (var counter:Number = 0; counter <= 2; counter++) { // Variable
locale
trace(counter); // Accède à la variable locale et affiche de 0 à 2
}
}
count();
trace(counter); // Accède à la variable globale et affiche 100
Cet exemple indique uniquement que la variable globale n’est pas accessible dans le domaine
de la fonction count(). Toutefois, vous pouvez y accéder si vous lui ajoutez le préfixe
_global. Par exemple, vous pouvez y accéder si vous ajoutez le préfixe _global au
compteur, comme dans le code suivant :
trace(_global.counter);
Vous ne pouvez pas affecter des types de données stricts aux variables créées dans le domaine
_global puisque vous devez utiliser le mot-clé var lorsque vous affectez un type de données.
Par exemple, vous ne pourriez pas faire :
_global.foo:String = "foo"; //erreur de syntaxe
var _global.foo:String = "foo"; //erreur de syntaxe
Le Sandbox de Flash Player version 7 et ses versions suivantes applique des restrictions
concernant l’accès de variables globales à partir de fichiers SWF chargés à partir de domaines
de sécurité distincts. Pour plus d’informations, consultez le Chapitre 17, Fonctionnement de la
sécurité, page 737.
106
Données et types de données
Variables de scénario
Les variables de scénario sont disponibles pour tout script dans ce scénario. Pour déclarer des
variables de scénario, utilisez l’instruction var et initialisez-les dans chaque image du scénario.
Cette image et toutes les suivantes peuvent accéder à la variable, comme le montre l’exemple
suivant.
Pour utiliser des variables de scénario dans un document :
1.
Créez un nouveau document Flash et nommez-le timelinevar.fla.
2.
Ajoutez le code ActionScript suivant à l’image 1 du scénario :
var myNum:Number = 15; /* initialisé dans l’image 1, donc accessible à
toutes les images */
3.
Sélectionnez l’image 20 du scénario.
4.
Sélectionnez Insertion > Scénario > Image-clé vide.
5.
La nouvelle image-clé sélectionnée, tapez le code ActionScript suivant dans le panneau
Actions :
trace(myNum);
6.
Choisissez Contrôle > Tester l’animation pour tester le nouveau document.
La valeur 15 apparaît dans le panneau de sortie au bout d’une seconde environ. Les
documents Flash fonctionnant en boucle par défaut, la valeur 15 apparaît continuellement
dans le panneau de sortie chaque fois que la tête de lecture atteint l’image 20 dans le
scénario. Pour interrompre la boucle, ajoutez stop(); après l’instruction trace().
Vous devez déclarer toute variable de scénario avant d’y accéder dans un script. Par exemple, si
vous placez le code var myNum:Number = 15; dans l’image 20, aucun des scripts joints aux
images précédentes ne peut accéder à myNum et sont indéfinis au lieu de contenir la valeur 15.
Variables locales
Lorsque vous utilisez l’instruction var dans un bloc de fonction, vous déclarez des variables
locales. Lorsque vous déclarez une variable locale dans un bloc de fonction (également appelé
définition de fonction), elle est définie dans le domaine de ce bloc et expire à la fin du bloc. La
variable locale n’existe donc que dans cette fonction.
Par exemple, si vous déclarez une variable nommée myStr dans une fonction appelée
localScope, cette variable ne sera pas disponible en dehors de cette fonction.
function localScope():Void {
var myStr:String = "local";
}
localScope();
trace(myStr); // Non défini, car myStr n’est pas définie globalement
Présentation des variables
107
Si le nom utilisé pour votre variable locale est déjà déclaré en tant que variable de scénario, la
définition locale prévaut sur celle du scénario pendant que la variable locale est dans le
domaine. La variable de scénario persiste hors de la fonction. Par exemple, le code suivant crée
une variable de scénario de type chaîne appelée str1, puis une variable locale du même nom
dans la fonction scopeTest(). L’instruction trace placée dans la fonction génère la
définition locale de la variable, tandis que celle qui est placée hors de la fonction génère la
définition de scénario de la variable.
var str1:String = "Timeline";
function scopeTest():Void {
var str1:String = "Local";
trace(str1); // Locale
}
scopeTest();
trace(str1); // Scénario
Dans l’exemple suivant, vous constatez que certaines variables n’existent que pour les besoins
d’une fonction spécifique et qu’elles peuvent générer des erreurs si vous y faites référence hors
du domaine de cette fonction.
Pour utiliser des variables locales dans une application :
1.
Créez un nouveau document Flash.
2.
Ouvrez le panneau Actions (Fenêtre > Actions) et ajoutez le code ActionScript suivant dans
l’image 1 du scénario :
function sayHello(nameStr:String):Void {
var greetingStr:String = "Hello, " + nameStr;
trace(greetingStr);
}
sayHello("world"); // Hello, world
trace(nameStr); // non défini
trace(greetingStr); // non défini
3.
Choisissez Contrôle > Tester l’animation pour tester le document.
Flash affiche la chaîne “Hello, world” dans le panneau de sortie et undefined pour les
valeurs des variables nameStr et greetingStr car elles ne sont plus disponibles dans ce
domaine. Vous pouvez faire référence à nameStr et greetingStr uniquement lors de
l’exécution de la fonction sayHello. Dès que cette fonction se termine, ces variables
cessent d’exister.
108
Données et types de données
Les variables i et j sont souvent utilisées comme compteurs de boucles. Dans l’exemple
suivant, vous utilisez i comme variable locale qui existe uniquement dans la fonction
initArray() :
var myArr:Array = new Array();
function initArray(arrayLength:Number):Void {
var i:Number;
for(i = 0; i < arrayLength; i++) {
myArr[i] = i + 1;
}
}
trace(myArr); // <vide>
initArray(3);
trace(myArr); // 1,2,3
trace(i); // non défini
REMARQUE
Il n’est pas rare de rencontrer la syntaxe suivante pour une boucle for : for (var
i:Number = 0; i < arrayLength; i++) {...}.
Cet exemple affiche la valeur undefined dans l’environnement de test Flash car la variable i
n’est pas définie dans le scénario principal. Elle existe uniquement dans la fonction
initArray().
Vous pouvez également utiliser des variables locales pour empêcher les conflits de noms, qui
peuvent donner lieu à des résultats inattendus dans votre application. Par exemple, si vous
utilisez age comme variable locale, elle vous permet de stocker l’âge d’une personne dans un
contexte et celui d’un enfant de la personne dans un autre contexte. Dans ce cas, aucun conflit
ne se produit car ces variables sont utilisées dans des domaines distincts.
Il est toujours judicieux d’utiliser des variables locales dans le corps d’une fonction pour que
celle-ci puisse agir en tant que partie de code indépendante. Vous ne pouvez modifier une
variable locale que dans son bloc de code. Si une expression d’une fonction utilise une variable
globale, du code ou des événements extérieurs peuvent modifier sa valeur, ce qui modifierait la
fonction.
Vous pouvez affecter un type de données à une variable locale lorsque vous la déclarez, ce qui
vous évite d’affecter un type de données erroné à une variable existante. Pour plus
d’informations, consultez la section Affectation des types de données et typage strict, page 88.
Présentation des variables
109
Chargement des variables
Dans les sections suivantes, vous allez charger des variables depuis le serveur de différentes
manières ou dans un document depuis une chaîne d’URL ou FlashVars (qui permet de
transférer des variables dans Flash) dans votre code HTML. Ces pratiques présentent les
différentes méthodes d’utilisation des variables hors d’un fichier SWF.
Pour plus d’informations sur le chargement des variables (telles que des paires nom/valeur),
consultez le Chapitre 16, Utilisation de données externes, page 691.
Vous pouvez utiliser des variables de différentes manières dans un fichier SWF, selon vos
besoins. Pour plus d’informations, voir les sections suivantes :
■
Utilisation de variables depuis l’URL, page 110
■
Utilisation de FlashVars dans une application, page 113
■
Chargement des variables depuis un serveur, page 115
Utilisation de variables depuis l’URL
Lorsque vous développez une application ou un exemple simple dans Flash, vous devrez peutêtre faire passer des valeurs entre une page HTML et votre document Flash. Les valeurs
transmises portent parfois le nom de chaîne de requête ou variables de code URL. Les variables
d’URL s’avèrent très pratiques pour créer un menu dans Flash par exemple. Vous pouvez
initialiser le menu pour afficher la navigation appropriée par défaut. Ou, vous pouvez créer
une visionneuse dans Flash et définir l’image à afficher par défaut dans le site Web.
Pour utiliser des variables d’URL dans un document :
1.
Créez un document Flash et nommez-le urlvariables.fla.
2.
Sélectionnez Fichier > Enregistrer sous, puis enregistrez le document sur votre ordinateur.
3.
Sélectionnez l’image 1 du scénario, puis ajoutez le code suivant dans le panneau Actions :
this.createTextField("myTxt", 100, 0, 0, 100, 20);
myTxt.autoSize = "left";
myTxt.text = _level0.myURL;
4.
Choisissez Contrôle > Tester l’animation pour tester le fichier SWF dans Flash Player.
Le champ de texte contient la valeur undefined. Pour vous assurer que les variables sont
bien définies, vous devez vérifier leur présence dans Flash. Pour ce faire, vérifiez leurs
valeurs qui doivent être non définies.
110
Données et types de données
5.
Pour vérifier si une variable est définie, modifiez le code ActionScript que vous avez ajouté
dans le panneau Actions) à l’étape 3 pour qu’il ressemble au code suivant. Ajoutez le code
qui apparaît en gras :
this.createTextField("myTxt", 100, 0, 0, 100, 20);
myTxt.autoSize = "left";
if (_level0.myURL == undefined) {
myTxt.text = "myURL is not defined";
} else {
myTxt.text = _level0.myURL;
}
Lorsque vous publiez votre document Flash, un document HTML est créé par défaut dans
le même répertoire que le fichier SWF. Si un fichier HTML n’a pas été créé, sélectionnez
Fichier > Paramètres de publication, et assurez-vous d’avoir sélectionné HTML dans
l’onglet Formats. Puis, republiez votre document.
Le code suivant montre les lignes HTML dans le document qui sont responsables de
l’imbrication d’un document Flash dans une page HTML. Examinez bien ce code HTML
pour comprendre le fonctionnement des variables d’URL dans l’étape suivante (qui
consiste à ajouter du code pour les variables d’URL).
<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.
Pour faire passer des variables du document HTML généré à votre document Flash, vous
pouvez les ajouter à la suite du chemin d’accès et du nom de fichier (urlvariables.swf).
Ajoutez le texte en gras au fichier HTML généré sur votre ordinateur.
<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?myURL=http://
weblogs.macromedia.com" />
<param name="quality" value="high" />
<param name="bgcolor" value="#ffffff" />
Présentation des variables
111
<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.
Si vous souhaitez transmettre plusieurs variables dans Flash, vous devez séparer les paires
nom/valeur par un caractère esperluette (&). Récupérez le code suivant à l’étape 6 :
?myURL=http://weblogs.macromedia.com
Remplacez-le par le texte suivant :
?myURL=http://weblogs.macromedia.com&myTitle=Macromedia+News+Aggregator
N’oubliez pas que vous devez modifier de la même manière les deux balises object et
embed pour garantir la cohérence sur tous les navigateurs. Vous remarquerez que les mots
sont séparés par des signes +, car les valeurs sont du code URL et que le signe + représente
un espace vide.
REMARQUE
Pour connaître la liste des caractères spéciaux de code URL les plus courants,
reportez-vous à la TechNote Flash, URL Encoding: Reading special characters from
a text file.
L’esperluette (&) servant de délimiteur pour différentes paires nom/valeur, des résultats
inattendus risquent de se produire lorsque les valeurs que vous transmettez en
contiennent. Etant donné la nature des paires nom/valeur et de l’analyse, si vous faites
passer les valeurs suivantes dans Flash,
my.swf?name=Ben+&+Jerry&flavor=Half+Baked
Flash créera les variables (et les valeurs) suivantes dans le domaine racine :
'name': 'Ben ' (note space at end of value)
' Jerry': '' (note space at beginning of variable name and an empty
value)
'flavor': 'Half Baked'
Pour éviter cela, vous devez remplacer l’esperluette (&) dans la paire nom/valeur par son
équivalent en code URL (%26).
8.
Ouvrez le document urlvariables.html et localisez le code suivant :
?myURL=http://weblogs.macromedia.com&myTitle=Macromedia+News+Aggregator
Remplacez-le par le code suivant :
?myURL=Ben+%26+Jerry&flavor=Half+Baked
112
Données et types de données
9.
Enregistrez le code HTML modifié et testez de nouveau votre document Flash.
Vous constatez que Flash crée les paires nom/valeur suivantes.
'name': 'Ben & Jerry'
'flavor': 'Half Baked'
REMARQUE
Tous les navigateurs prennent en charge les chaînes d’une longueur allant jusqu’à
64 Ko (65 535 octets). Un paramètre FlashVars doit être affecté aux deux balises
object et embed pour que votre code fonctionne dans tous les navigateurs.
Utilisation de FlashVars dans une application
L’emploi de FlashVars pour faire passer des variables dans Flash est similaire à l’emploi d’URL
dans le code HTML. Avec FlashVars, au lieu d’être à la suite du nom de fichier, les variables
sont transmises dans une balise param distincte, ainsi que dans une balise embed.
Pour utiliser FlashVars dans un document :
1.
Créez un nouveau document Flash et nommez-le myflashvars.fla.
2.
Sélectionnez Fichier > Paramètres de publication et assurez-vous d’avoir sélectionné
HTML, puis cliquez sur OK pour fermer la boîte de dialogue.
3.
Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
this.createTextField("myTxt", 100, 0, 0, 100, 20);
myTxt.autoSize = "left";
if (_level0.myURL == undefined) {
myTxt.text = "myURL is not defined";
} else {
myTxt.text = _level0.myURL;
}
REMARQUE
Par défaut, le code HTML publie dans le même emplacement que myflashvars.fla.
4.
Sélectionnez Fichier > Publier pour publier les fichiers SWF et HTML.
5.
Accédez au répertoire contenant les fichiers publiés (celui où vous avez enregistré le fichier
myflashvars.fla dans votre disque dur), puis ouvrez le document HTML (myflashvars.html
par défaut) dans un éditeur HTML, tel que Dreamweaver ou Notepad.
Présentation des variables
113
6.
Ajoutez le code qui apparaît en gras ci-dessous, de sorte que votre document HTML
ressemble au code suivant :
<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="myflashvars"
align="middle">
<param name="allowScriptAccess" value="sameDomain" />
<param name="movie" value="myflashvars.swf" />
<param name="FlashVars" value="myURL=http://weblogs.macromedia.com/">
<param name="quality" value="high" />
<param name="bgcolor" value="#ffffff" />
<embed src="myflashvars.swf" FlashVars="myURL=http://
weblogs.macromedia.com/" quality="high" bgcolor="#ffffff" width="550"
height="400" name="myflashvars" align="middle"
allowScriptAccess="sameDomain" type="application/x-shockwave-flash"
pluginspage="http://www.macromedia.com/go/getflashplayer" />
</object>
Ce code fait passer une seule variable appelée myURL, qui contient la chaîne
http://weblogs.macromedia.com. Lors du chargement du fichier SWF, une propriété
appelée myURL est créée dans le domaine _level0. L’un des avantages de l’emploi de
FlashVars ou de l’URL réside dans la disponibilité immédiate des variables dans Flash dès
le chargement du fichier SWF. Ainsi, il est inutile d’écrire des fonctions supplémentaires
pour vérifier le chargement des variables, ce qui serait obligatoire si vous les chargiez à
l’aide de LoadVars ou XML.
7.
Enregistrez vos modifications du document HTML, puis fermez-le.
8.
Double-cliquez sur le fichier myflashvars.html pour tester l’application.
Le texte http://weblogs.macromedia.com, une variable du fichier HTML, apparaît
dans le fichier SWF.
REMARQUE
114
Tous les navigateurs prennent en charge les chaînes d’une longueur allant jusqu’à
64 Ko (65535 octets). Un paramètre FlashVars doit être affecté aux deux balises
object et embed pour que votre code fonctionne dans tous les navigateurs.
Données et types de données
Chargement des variables depuis un serveur
Il existe plusieurs méthodes pour charger des variables dans Flash à partir de sources externes
(telles que des fichiers texte, des documents XML, etc.). Pour plus d’informations sur le
chargement des variables (y compris des paires nom/valeur), consultez le
Chapitre 16, Utilisation de données externes, page 691.
Dans Flash, la classe LoadVars permet de charger facilement des variables, comme le montre
l’exemple suivant.
Pour charger des variables depuis un serveur :
1.
Créez un nouveau document Flash.
2.
Sélectionnez l’image 1 du scénario, puis ajoutez le code ActionScript suivant dans le
panneau Actions :
var my_lv:LoadVars = new LoadVars();
my_lv.onLoad = function(success:Boolean):Void {
if (success) {
trace(this.dayNames); // Sunday,Monday,Tuesday,...
} else {
trace("Error");
}
}
my_lv.load("http://www.helpexamples.com/flash/params.txt");
Ce code charge un fichier texte depuis un serveur distant et analyse ses paires nom/valeur.
CONSEIL
3.
Téléchargez ou affichez le fichier texte (http://www.helpexamples.com/flash/
params.txt) dans un navigateur si vous souhaitez savoir comment les variables sont
formatées.
Choisissez Contrôle > Tester l’animation pour tester le document.
Si le chargement réussi, l’événement complete est appelé et le panneau de sortie affiche la
valeur de la variable dayNames. Si le chargement du fichier texte échoue, l’argument
success est défini sur false et le panneau de sortie affiche le texte Error.
Présentation des variables
115
Utilisation de variables dans un projet
Lorsque vous développez des animations ou des applications avec Flash, il est très rare que
vous n’ayez besoin d’aucune variable. Par exemple, si vous créez un système d’ouverture de
session, vous aurez besoin de variables pour valider le nom d’utilisateur et le mot de passe ou
vérifier leur remplissage.
Pour plus d’informations sur le chargement des variables (telles que des paires nom/valeur),
consultez le Chapitre 16, Utilisation de données externes, page 691.
Dans l’exemple suivant, vous utilisez des variables pour stocker le chemin d’une image que
vous chargez avec la classe Loader, une pour l’occurrence de la classe Loader et deux fonctions
sont appelées selon le résultat, satisfaisant ou non, du chargement du fichier.
Pour utiliser des variables dans un projet :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom imgloader.fla.
2.
Sélectionnez l’image 1 du scénario, puis ajoutez le code ActionScript suivant dans le
panneau Actions :
/* Spécifie une image par défaut au cas où aucune valeur n’est transmise
par FlashVars. */
var imgUrl:String = "http://www.helpexamples.com/flash/images/
image1.jpg";
if (_level0.imgURL != undefined) {
// Si une image a été désignée, la valeur par défaut est remplacée.
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);
116
Données et types de données
La première ligne du code désigne l’image à charger dynamiquement dans votre document
Flash. Ensuite, vous vérifiez si une nouvelle valeur a été spécifiée pour imgURL à l’aide de
paramètres FlashVars ou de variables de code URL. Dans l’affirmative, l’URL de l’image
par défaut est remplacée par la nouvelle valeur. Pour plus d’informations sur l’utilisation
des variables d’URL, consultez la section Utilisation de variables depuis l’URL, page 110.
Pour plus d’informations sur FlashVars, consultez la section Utilisation de FlashVars dans
une application, page 113.
Les deux lignes de code suivantes définissent l’occurrence de MovieClip et un objet
écouteur pour la future occurrence de MovieClipLoader. L’objet écouteur du
MovieClipLoader définit deux gestionnaires d’événement, onLoadInit et onLoadError.
Ces gestionnaires sont invoqués lorsque le chargement et l’initialisation de l’image sur la
scène ont réussi, ou quand le chargement a échoué. Ensuite, vous créez une occurrence de
MovieClipLoader et vous utilisez la méthode addListener() pour ajouter l’objet
écouteur défini préalablement au MovieClipLoader. Pour finir, l’image est téléchargée et
déclenchée par votre appel de la méthode MovieClipLoader.loadClip(), qui désigne le
fichier de l’image à charger et le clip qui doit la recevoir.
3.
Choisissez Contrôle > Tester l’animation pour tester le document.
Comme vous testez le document Flash dans l’outil de programmation, aucune valeur de
imgUrl n’est transmise par FlashVars ni avec l’URL. Par conséquent, l’image par défaut
s’affiche.
4.
Enregistrez le document Flash, puis sélectionnez Fichier > Publier pour publier le fichier
sous forme de document SWF et HTML.
REMARQUE
5.
Assurez-vous que les deux options Flash et HTML sont bien sélectionnées dans la
boîte de dialogue Paramètres de publication. Choisissez Fichier > Paramètres de
publication et cliquez sur l’onglet Formats. Sélectionnez ensuite les deux options.
Si vous testez votre document dans l’outil de Flash (Contrôle > Tester l’animation) ou dans
un navigateur local (Fichier > Aperçu avant publication > HTML), vous constaterez que
l’image se centre elle-même verticalement et horizontalement sur la scène.
Présentation des variables
117
6.
Modifiez le document HTML généré dans un éditeur (tel que Dreamweaver ou Notepad),
puis modifiez le code HTML par défaut pour qu’il corresponde au texte suivant :
<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="FlashVars" value="imgURL=http://www.helpexamples.com/flash/
images/image2.jpg">
<param name="quality" value="high" />
<param name="bgcolor" value="#ffffff" />
<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"
allowScriptAccess="sameDomain" type="application/x-shockwave-flash"
pluginspage="http://www.macromedia.com/go/getflashplayer" />
</object>
7.
Testez le document HTML pour examiner les changements. L’image spécifiée dans le code
HTML apparaît dans le fichier SWF.
Pour modifier cet exemple afin d’utiliser vos propres images, modifiez la valeur FlashVars
(chaîne entre guillemets).
Organisation des données dans des
objets
Vous êtes probablement habitué(e) à manipuler les objets placés sur la scène. Supposons par
exemple que vous avez un objet MovieClip sur la scène, qui contient lui-même d’autres clips.
Les champs de texte, les clips et les boutons sont souvent considérés comme des objets dès
qu’ils sont déposés sur la scène.
Dans ActionScript, les objets sont des collections de propriétés et de méthodes. Chaque objet
possède son propre nom et est une occurrence d’une classe donnée. Les objets intégrés
proviennent de classes qui sont prédéfinies dans ActionScript. Par exemple, la classe intégrée
Date fournit des informations provenant de l’horloge système de l’ordinateur de l’utilisateur.
Vous pouvez utiliser la classe LoadVars pour charger des variables dans votre fichier SWF.
118
Données et types de données
Vous pouvez également créer des objets et des classes avec du code ActionScript. Vous pouvez
créer un objet destiné à stocker une collection de données, telles que le nom, l’adresse et le
numéro de téléphone d’une personne. Vous pouvez créer un objet destiné à stocker des
informations sur les couleurs d’une image. L’organisation des données dans des objets permet
de tenir vos documents Flash bien ordonnés. Pour des informations d’ordre général sur la
création d’une classe personnalisée destinée à stocker une collection de méthodes et de
propriétés, consultez la section Ecriture de fichiers de classe personnalisée, page 254. Pour des
informations détaillées sur les classes intégrées et personnalisées, consultez le
Chapitre 7, Classes, page 243.
Il existe plusieurs manières de créer un objet dans ActionScript. L’exemple suivant crée des
objets simples de deux manières différentes, puis passe en boucle sur leur contenu.
Pour créer des objets simples dans Flash :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom simpleObjects.fla.
2.
Sélectionnez l’image 1 du scénario et, dans le panneau Actions, tapez le code ActionScript
suivant :
// Première méthode
var firstObj:Object = new Object();
firstObj.firstVar = "hello world";
firstObj.secondVar = 28;
firstObj.thirdVar = new Date(1980, 0, 1); // 1er janvier 1980
Ce code, qui constitue une méthode pour créer un objet simple, crée une nouvelle
occurrence d’objet et définit quelques propriétés dans cet objet.
3.
Maintenant, tapez le code ActionScript suivant après celui ajouté à l’étape 2.
// Deuxième méthode
var secondObj:Object = {firstVar:"hello world", secondVar:28,
thirdVar:new Date(1980, 0, 1)};
Voici une autre manière de créer un objet. Les deux objets sont semblables. Le code cidessus crée un nouvel objet et initialise certaines propriétés sous forme courte.
4.
Pour passer en boucle sur chacun des objets précédents et afficher leur contenu, ajoutez le
code ActionScript suivant sur l’image 1 du scénario (à la suite du code déjà saisi) :
var i:String;
for (i in firstObj) {
trace(i + ": " + firstObj[i]);
}
5.
Choisissez Contrôle > Tester l’animation pour voir le texte suivant dans le panneau de
sortie :
firstVar: hello world
secondVar: 28
thirdVar: Tue Jan 1 00:00:00 GMT-0800 1980
Organisation des données dans des objets
119
Vous pouvez également utiliser des tableaux pour créer des objets. Au lieu d’avoir une série de
variables telles que firstname1, firstname2 et firstname3 pour représenter une collection
de variables, vous pouvez fabriquer un tableau contenant les mêmes données. Cette technique
est présentée ci-après.
Pour utiliser un tableau pour créer un objet :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom arrayObject.fla.
2.
Sélectionnez l’image 1 du scénario et, dans le panneau Actions, tapez le code ActionScript
suivant :
var usersArr:Array = new Array();
usersArr.push({firstname:"George"});
usersArr.push({firstname:"John"});
usersArr.push({firstname:"Thomas"});
L’organisation des variables dans des tableaux et des objets présente l’avantage de faciliter
le passage en boucle sur les variables et l’affichage de leurs valeurs, comme le montre
l’étape suivante.
3.
Tapez le code ActionScript suivant après celui ajouté à l’étape 2.
var i:Number;
for (i = 0; i < usersArr.length; i++) {
trace(usersArr[i].firstname); // George, John, Thomas
}
4.
Choisissez Contrôle > Tester l’animation pour voir le texte suivant dans le panneau de
sortie :
George
John
Thomas
L’exemple suivant présente une autre méthode de passage en boucle sur les objets. Ici, un objet
est créé et survolé répétitivement à l’aide d’une boucle for..in et chaque propriété apparaît
dans le panneau de sortie :
var myObj:Object = {var1:"One", var2:"Two", var3:18, var4:1987};
var i:String;
for (i in myObj) {
trace(i + ": " + myObj[i]);
}
// Résultats :
/*
var1: One
var2: Two
var3: 18
var4: 1987
*/
120
Données et types de données
Pour plus d’informations sur les boucles, consultez le Chapitre 5, Utilisation des boucles for,
page 171. Pour plus d’informations sur les boucles for..in, consultez la section Utilisation des
boucles for..in, page 172. Pour plus d’informations sur les objets, consultez le
Chapitre 7, Classes, page 243.
Attribution
ActionScript 2.0 vous permet d’attribuer un type de données à un autre. Cette opération
signifie que vous convertissez la valeur que l’objet ou la variable contient en un type différent.
Les résultats de cette attribution dépendent des types de données impliqués. Pour changer le
type de données d’un objet, vous mettez le nom de l’objet entre parenthèses (()) et le faites
précéder du nom du nouveau type. Par exemple, le code suivant prend une valeur booléenne
et la transforme en entier numérique.
var myBoolean:Boolean = true;
var myNumber:Number = Number(myBoolean);
Pour plus d’informations sur l’attribution, consultez les sections suivantes :
■
Attribution des objets, page 121
Attribution des objets
La syntaxe de l’attribution est type(élément) : le compilateur doit se comporter comme si le
type de données de l’élément était type. L’attribution est avant tout un appel de fonction qui
renvoie null si l’attribution échoue lors de l’exécution (dans les fichiers publiés pour Flash
Player version 7 ou plus récente). L’exécution des fichiers publiés pour Flash Player 6 n’est pas
prise en charge en cas d’échec de l’attribution. Si l’attribution réussit, l’appel de fonction
renvoie l’objet original. Cependant, le compilateur ne peut pas déterminer si une attribution
échoue lors de l’exécution et ne génère pas d’erreurs de compilation dans ces cas.
Le code suivant illustre cette situation :
// 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); // Fonctionne
curAnimal = new Cat();
bark(curAnimal); // Ne fonctionne pas
Attribution
121
Dans cet exemple, vous avez indiqué au compilateur que foo est un objet Dog, et le
compilateur suppose donc que foo.bark() est une instruction autorisée. Toutefois, le
compilateur ne sait pas que l’attribution échouera (c’est-à-dire que vous avez tenté d’attribuer
un objet Cat au type Animal), et aucune erreur de compilation ne se produit. Toutefois, si
vous incorporez une vérification dans votre script de manière à vous assurer que l’attribution
réussit, vous pouvez trouver des erreurs d’attribution à l’exécution, comme le montre
l’exemple suivant.
function bark(myAnimal:Animal) {
var foo:Dog = Dog(myAnimal);
if (foo) {
foo.bark();
}
}
Vous pouvez attribuer une expression à une interface. Si l’expression est un objet qui
implémente l’interface ou si elle possède une classe de base qui implémente l’interface,
l’attribution réussit. Sinon, l’attribution échoue.
REMARQUE
L’attribution de valeurs Null ou non définies renvoie undefined.
Vous pouvez remplacer les types de données primitifs qui disposent d’une fonction de
conversion globale correspondante par un opérateur d’attribution du même nom. C’est
pourquoi les fonctions de conversion globales sont prioritaires par rapport aux opérateurs
d’attribution. Par exemple, vous ne pouvez pas attribuer Array dans la mesure où la fonction
de conversion Array() est prioritaire par rapport à l’opérateur d’attribution.
Cet exemple définit deux variables de chaîne (firstNum et secondNum), qui s’ajoutent l’une à
l’autre. Résultat initial : les nombres sont concaténés au lieu d’être ajoutés car ils sont de type
String. La deuxième instruction trace convertit les deux nombres en type de données Number
avant d’exécuter l’addition qui donne le résultat correct. La conversion des données est
importante lorsque vous manipulez des données chargées à l’aide de XML ou FlashVars,
comme le montre l’exemple suivant :
var firstNum:String = "17";
var secondNum:String = "29";
trace(firstNum + secondNum); // 1729
trace(Number(firstNum) + Number(secondNum)); // 46
Pour plus d’informations sur les fonctions de conversion des données, consultez l’entrée de
chaque fonction de conversion dans le Guide de référence du langage ActionScript 2.0 :
Fonction Array, Fonction Boolean, Fonction Number, Fonction Object et Fonction
String.
122
Données et types de données
CHAPITRE 5
5
Eléments fondamentaux du
langage et de la syntaxe
L’apprentissage de la syntaxe et des instructions d’ActionScript revient à apprendre à associer
des mots pour construire des phrases, à rassembler ensuite au sein de paragraphes. Le langage
ActionScript atteint ce niveau de simplicité. Par exemple, en français, une phrase se termine
par un point, tandis que les instructions de code ActionScript se terminent par un pointvirgule. En langage ActionScript, vous pouvez taper une instruction stop() pour
interrompre la lecture en boucle d’une occurrence de clip ou d’un fichier SWF. Vous pouvez
également écrire des milliers de lignes de code pour mettre au point une application bancaire
interactive. ActionScript peut donc accomplir des tâches très simples ou très complexes.
Dans le Chapitre 4, Données et types de données, vous allez découvrir comment ActionScript
manipule les données et comment les mettre en forme dans votre code. Ce chapitre décrit la
rédaction d’instructions dans ActionScript avec la syntaxe appropriée. Il contient un grand
nombre d’extraits de code et d’exemples qui présentent les concepts de base de ce langage. Les
chapitres suivants contiennent des exemples de code plus longs et de plus en plus complexes
qui combinent et simplifient à la fois les bases présentées dans ce chapitre.
Les règles générales décrites dans cette section s’appliquent à l’ensemble du code ActionScript.
La plupart des termes ActionScript font également l’objet de règles individuelles. Pour en
savoir plus sur les règles qui s’appliquent à un terme particulier, consultez l’entrée
correspondante du Guide de référence du langage ActionScript 2.0.
Les nouveaux utilisateurs peuvent éprouver des difficultés à créer des programmes
ActionScript de façon élégante. Pour plus de détails sur l’application des règles décrites dans
cette section, consultez le Chapitre 19, Recommandations et conventions de programmation pour
ActionScript 2.0, page 797.
REMARQUE
Dans ce chapitre, vous allez ajouter du code ActionScript directement dans une image
du scénario. Dans les chapitres suivants, vous utiliserez des classes pour isoler votre
code ActionScript du fichier FLA.
123
Pour plus d’informations sur l’utilisation des concepts de base du langage et de la syntaxe
ActionScript, consultez les rubriques suivantes :
Présentation de la syntaxe, des instructions et des expressions . . . . . . . . . . . . . . . 124
Syntaxe à point et chemins cible. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Eléments de ponctuation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Présentation des constantes et des mots-clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Présentation des instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
Présentation des tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
Présentation des opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .191
Présentation de la syntaxe, des
instructions et des expressions
Le langage ActionScript est composé de classes intégrées. Pour formuler vos instructions de
sorte que le code puisse être compilé et exécuté correctement dans Flash, il est nécessaire
d’utiliser la syntaxe ActionScript appropriée. Ici, le terme syntaxe fait référence à la grammaire
et à l’orthographe du langage de programmation. Le compilateur ne pouvant pas interpréter la
syntaxe incorrecte, des erreurs ou des avertissements apparaissent dans le panneau de sortie
lorsque le document est testé dans l’environnement de test. La syntaxe est donc un ensemble
de règles et de consignes qui vous aide à rédiger correctement votre code ActionScript.
Une instruction est une action spécifique que vous demandez au fichier FLA d’exécuter. Par
exemple, vous pouvez utiliser une instruction conditionnelle pour déterminer si quelque
chose est vrai ou existe. Vous pouvez ensuite exécuter les actions spécifiées, telles que des
fonctions ou des expressions, selon si la condition est vraie ou non. L’instruction if est une
instruction conditionnelle qui évalue une condition afin de déterminer la prochaine action du
code.
// instruction if
if (condition) {
// instructions ;
}
Pour plus d’informations sur les instructions, consultez la section Présentation des instructions,
page 153.
124
Eléments fondamentaux du langage et de la syntaxe
Une expression diffère d’une instruction et désigne toute combinaison valide de symboles
ActionScript représentant une valeur. Les expressions ont des valeurs alors que les valeurs et les
propriétés ont des types. Une expression peut être composée d’opérateurs et d’opérandes, de
valeurs, de fonctions et de procédures, et suit les règles de priorité et d’association
d’ActionScript. En général, Flash Player interprète l’expression et renvoie une valeur que vous
pouvez utiliser dans votre application.
Par exemple, le code suivant est une expression :
x + 2
Dans l’expression précédente, x et 2 sont des opérandes et + est un opérateur. Pour plus
d’informations sur les opérateurs et les opérandes, consultez la section Présentation des
opérateurs, page 191. Pour plus d’informations sur les objets et les propriétés, consultez la
section Type de données Object, page 85.
La mise en forme de votre code ActionScript conditionne également la facilité de sa
maintenance. Par exemple, il est extrêmement difficile de comprendre la logique d’un fichier
FLA qui ne comporte ni indentation ni commentaire, ou dont le formatage et les conventions
d’appellation sont incohérents. Lorsque les blocs ActionScript (tels que les boucles et les
instructions if ) sont placés en retrait, le code est plus facile à lire et déboguer en cas de
problème. Pour plus d’informations sur la mise en forme du code ActionScript, consultez la
section Mise en forme de la syntaxe ActionScript, page 832. Ces sections contiennent également
des exemples de mise en forme appropriée du code ActionScript.
Pour plus d’informations sur les concepts de base du langage et de la syntaxe, consultez les
rubriques suivantes :
■
Différences entre ActionScript et JavaScript
■
Respect de la casse
Différences entre ActionScript et JavaScript
ActionScript est similaire au langage de programmation JavaScript. Pour utiliser le code
ActionScript, la connaissance de JavaScript n’est pas indispensable, mais elle en facilite
considérablement l’apprentissage.
Cet ouvrage n’a pas pour but d’enseigner la programmation générale. Il existe de nombreuses
sources qui fournissent des informations complémentaires sur les concepts de programmation
généraux et sur le langage JavaScript.
■
La spécification ECMAScript (ECMA-262) édition 3 est issue de JavaScript et sert de
norme internationale pour le langage JavaScript. ActionScript est basé sur cette
spécification. Pour plus d’informations, consultez le site www.ecma-international.org/
publications/standards/Ecma-262.htm.
Présentation de la syntaxe, des instructions et des expressions
125
■
Le site Java Technology offre des didacticiels sur la programmation orientée objet
(http://java.sun.com/docs/books/tutorial/java/index.html) qui portent
essentiellement sur le langage Java, mais permettent de comprendre les concepts qui
s’appliquent également à ActionScript.
Les principales différences qui existent entre ActionScript et JavaScript sont les suivantes :
■
ActionScript ne prend pas en charge les objets spécifiques aux navigateurs que sont les
documents, fenêtres et ancres, par exemple.
■
ActionScript ne pas entièrement en charge tous les objets JavaScript intégrés.
■
ActionScript ne prend pas en charge certaines constructions syntaxiques JavaScript, telles
que les étiquettes d’instructions.
■
Dans ActionScript, la fonction eval() ne peut effectuer que des références aux variables.
■
ActionScript 2.0 prend en charge plusieurs fonctionnalités qui ne figurent pas dans la
spécification ECMA-262, telles que les classes et le typage fort. Un grand nombre de ces
fonctionnalités sont modélisées d’après la spécification ECMAScript (ECMA-262) édition
3 (voir www.ecma-international.org/publications/standards/Ecma-262.htm).
■
ActionScript ne prend pas en charge les expressions régulières ayant recours à
l’objet RegExp, contrairement à Macromedia Central, qui prend en charge cet
objet. Pour plus d’informations sur Macromedia Central, consultez le site
www.macromedia.com/software/central.
Respect de la casse
Lorsque vous rédigez du code ActionScript pour Flash Player 7 et ses versions ultérieures,
votre code respecte la casse. Cela signifie que les variables dont la casse diffère sont considérées
comme différentes. Le code ActionScript suivant illustre cette particularité :
// Combinaison de majuscules/minuscules
var firstName:String = "Jimmy";
// Tout en minuscules
trace(firstname); // non défini
Vous pouvez également écrire :
// Dans un
// et avec
//
// Définit
cat.hilite
CAT.hilite
fichier destiné à Flash Player 8
ActionScript 1.0 ou 2.0
les propriétés de deux objets différents
= true;
= true;
// Crée trois variables différentes
var myVar:Number = 10;
126
Eléments fondamentaux du langage et de la syntaxe
var myvar:Number = 10;
var mYvAr:Number = 10;
REMARQUE
Il n’est pas conseillé de différencier les variables, ou tout autre identifiant, uniquement
par le changement de la casse. Pour plus d’informations sur l’appellation des variables,
consultez le Chapitre 19, Recommandations et conventions de programmation pour
ActionScript 2.0, page 797.
Lorsque vous publiez pour les anciennes versions de Flash Player (version 6 et antérieures), le
logiciel recherche la chaîne Jimmy dans le panneau de sortie. Flash Player 7 et les versions
ultérieures étant sensibles à la casse, firstName et firstname sont deux variables distinctes
(avec ActionScript 1.0 ou 2.0). Ce concept est essentiel. Si vous avez créé des fichiers FLA
pour Flash Player 6 ou une version antérieure en utilisant indifféremment la casse dans vos
variables, des problèmes risquent de survenir lors de la conversion du fichier ou de
l’application pour une version plus récente de Flash Player.
Il est donc fortement conseillé d’adopter des conventions cohérentes en matière d’utilisation
des majuscules/minuscules, comme celles employées dans ce manuel. Vos variables, vos classes
et les noms de vos fonctions seront ainsi plus simples à distinguer. Ne vous contentez pas de
changer la casse pour différencier deux identifiants. Modifiez plutôt le nom de l’occurrence,
de la variable ou de la classe, pas seulement sa casse. Pour plus d’informations sur les
conventions de codage, consultez le Chapitre 19, Recommandations et conventions de
programmation pour ActionScript 2.0, page 797.
Le respect de la casse peut avoir un impact considérable lorsque vous travaillez avec un service
Web qui utilise ses propres règles pour l’appellation des variables et la casse des variables
renvoyées par le serveur au fichier SWF. Par exemple, si vous utilisez un service Web
ColdFusion, les noms de propriété provenant d’une structure ou d’un objet peuvent rester en
majuscules, comme FIRSTNAME. Vous devez conserver la même casse dans Flash pour ne pas
provoquer de résultats imprévus.
R EM A R Q U E
Le respect de la casse affecte également les variables externes que vous chargez dans
un fichier SWF, par exemple celles qui sont chargées avec LoadVars.load().
La différentiation des majuscules et des minuscules est implémentée pour les scripts externes,
tels que les fichiers de classe ActionScript 2.0, les scripts importés avec la commande
#include et les scripts d’un fichier FLA. Si vous subissez des erreurs lors de l’exécution et
exportez vos données vers plusieurs versions de Flash Player, vous devez vérifier les scripts
externes et les scripts des fichiers FLA pour vous assurer qu’ils appliquent les mêmes
majuscules.
Présentation de la syntaxe, des instructions et des expressions
127
Cette différentiation est implémentée au niveau de chaque fichier SWF. Lorsqu’une
application Flash Player 8 stricte (qui respecte la casse) appelle un fichier SWF Flash Player 6
non strict, le code ActionScript exécuté dans ce dernier ne respecte pas la casse. Par exemple, si
vous utilisez loadMovie() pour charger un fichier SWF Flash Player 6 dans un fichier SWF
Flash Player 8, celui de la version 6 ne tient pas compte des majuscules, contrairement à celui
de la version 8.
Lorsque la coloration de la syntaxe est activée, les éléments du langage dont la casse est
correcte apparaissent en bleu par défaut. Pour plus d’informations, consultez la section
Présentation des mots réservés, page 151.
Syntaxe à point et chemins cible
Dans ActionScript, un opérateur point (.) (syntaxe à point) est utilisé pour accéder aux
propriétés ou méthodes associées à un objet ou à une occurrence de la scène. Il est également
utilisé pour identifier le chemin cible d’une occurrence (telle qu’un clip), d’une variable, d’une
fonction ou d’un objet.
Une expression en syntaxe à point commence par le nom de l’objet ou du clip suivi d’un point
et se termine par l’élément que vous souhaitez spécifier. La rédaction des expressions en
syntaxe à point est décrite dans les sections suivantes.
Pour contrôler un clip, un fichier SWF chargé ou un bouton, vous devez spécifier un chemin
cible. Les chemins cible sont des adresses hiérarchiques de noms d’occurrences de clips, de
variables et d’objets dans un fichier SWF. Pour spécifier le chemin cible d’un clip ou d’un
bouton, vous devez lui affecter un nom d’occurrence. Pour nommer une occurrence de clip,
sélectionnez-la et saisissez son nom dans l’inspecteur des propriétés. Il est également possible
de nommer l’occurrence dans le code si vous la créez avec ActionScript. Vous pouvez utiliser le
chemin cible pour affecter une action à un clip ou pour obtenir ou définir la valeur d’une
variable ou propriété.
Pour plus d’informations sur la nomination d’une occurrence et l’utilisation de la syntaxe à
point pour cibler une occurrence, consultez les sections suivantes :
■
Utilisation de la syntaxe à point pour cibler une occurrence, page 129.
■
Domaine et ciblage, page 133
■
Utilisation du bouton Chemin cible, page 135
■
Syntaxe à barre oblique, page 135
Pour plus d’informations sur les objets et les propriétés, consultez la section Type de données
Object, page 85.
128
Eléments fondamentaux du langage et de la syntaxe
Utilisation de la syntaxe à point pour cibler une
occurrence
Pour rédiger un code ActionScript qui contrôle une occurrence, telle qu’un clip, ou manipule
les éléments d’un fichier SWF chargé, vous devez indiquer son nom et son adresse dans le
code, c’est-à-dire son chemin cible. Pour cibler (ou faire référence à) des objets dans un fichier
SWF, vous utilisez la syntaxe à point (également appelée notation avec point). Par exemple,
vous devez cibler une occurrence de clip ou de bouton avant de pouvoir lui appliquer une
action. La syntaxe à point vous aide à créer le chemin vers l’occurrence cible. Ce chemin vers
l’occurrence ciblée est parfois appelé chemin cible.
La hiérarchie des fichiers FLA est particulière. Vous pouvez créer des occurrences sur la scène
ou utiliser ActionScript. Vous pouvez même créer des occurrences à l’intérieur d’autres
occurrences ou en imbriquer au sein de plusieurs autres occurrences. Tant que vous la
nommez, vous pouvez manipuler n’importe quelle occurrence.
Les occurrences sont nommées par l’attribution d’un nom d’occurrence, que vous pouvez
spécifier de deux manières différentes (présentées ci-dessous) :
■
Manuellement en sélectionnant l’occurrence et en saisissant son nom dans l’inspecteur des
propriétés (lorsque l’occurrence est sur la scène).
■
Dynamiquement avec ActionScript. Dans ce cas, vous créez l’occurrence avec
ActionScript et lui affectez un nom dès sa création.
Pour affecter un nom d’occurrence à l’occurrence dans l’inspecteur de propriétés, tapez un
nom dans la zone de texte Nom de l’occurrence.
Vous pouvez également attribuer un nom d’occurrence à un objet créé à l’aide d’ActionScript.
Comme le montre le code suivant, cette opération peut être très simple :
this.createEmptyMovieClip("pic_mc", this.getNextHighestDepth());
pic_mc.loadMovie("http://www.helpexamples.com/flash/images/image1.jpg");
Ce code crée un nouveau clip et lui affecte le nom d’occurrence pic_mc. Vous pouvez ensuite
manipuler l’occurrence pic_mc à l’aide du code, par exemple en y chargeant une image,
comme l’illustre le code précédent.
Pour plus d’informations sur l’utilisation des domaines, consultez les sections Domaine et
ciblage, page 133 et Variables et domaine, page 105.
Syntaxe à point et chemins cible
129
Ciblage d’une occurrence
Pour qu’une occurrence fonctionne dans votre fichier SWF, vous devez la cibler, puis lui
indiquer quoi faire, par exemple lui affecter une action à exécuter ou modifier ses propriétés.
En général, il est nécessaire de définir l’emplacement de cette occurrence dans le fichier SWF
(par exemple le scénario dans lequel elle se trouve ou l’occurrence dans laquelle elle est
imbriquée) par la création d’un chemin cible. N’oubliez pas que vous avez fourni la plupart
des occurrences via leurs noms d’occurrence dans votre fichier FLA, puis ajouté du code dans
le fichier FLA qui utilise ces noms. Dans ce cas, vous ciblez cette occurrence particulière, puis
lui indiquez une action à exécuter (par exemple déplacer la tête de lecture ou ouvrir une page
Web). Pour plus d’informations sur les objets et les propriétés, consultez la section Type de
données Object, page 85.
Pour cibler une occurrence :
1.
Choisissez Fichier > Nouveau, puis sélectionnez un document Flash.
2.
Choisissez Fichier > Enregistrer sous et nommez le fichier target.fla.
3.
A l’aide de l’outil Ovale, tracez une forme sur la scène. Dessinez un ovale de taille et de
couleur quelconques.
4.
Utilisez l’outil Sélection pour sélectionner l’ovale sur la scène.
C ON S E I L
N’oubliez pas, au besoin, de sélectionner le trait et le remplissage.
5.
Choisissez Modifier > Convertir en symbole, sélectionnez l’option Clip, puis cliquez sur
OK pour créer le symbole.
6.
Sélectionnez le clip sur la scène et donnez-lui le nom d’occurrence myClip dans l’inspecteur
des propriétés.
7.
Insérez un nouveau calque et renommez-le actions.
8.
Ajoutez le code ActionScript suivant dans l’image 1 du calque actions :
myClip._xscale = 50;
Cette ligne de code cible l’occurrence myClip sur la scène. Le code ActionScript réduit de
moitié la largeur d’origine de l’occurrence. Le code étant sur le même scénario que le
symbole de clip, il suffit de cibler l’occurrence par son nom. Si cette occurrence se trouvait
sur un autre scénario ou était imbriquée dans une autre occurrence, le chemin cible devrait
être modifié en conséquence.
130
Eléments fondamentaux du langage et de la syntaxe
Ciblage d’une occurrence imbriquée
Il est également possible de cibler des occurrences imbriquées dans d’autres occurrences.
Supposons par exemple que vous souhaitez placer une seconde occurrence de clip dans
l’occurrence myClip de l’exercice présenté à la section Ciblage d’une occurrence, page 130.
Vous pouvez également cibler cette occurrence imbriquée à l’aide d’ActionScript. Avant de
commencer l’exercice suivant, vous devez terminer l’exercice de la section Ciblage d’une
occurrence, page 130, puis exécuter cette procédure pour cibler une occurrence imbriquée.
Pour cibler une occurrence imbriquée :
1.
Ouvrez le fichier target.fla à partir de la procédure sur le ciblage d’une occurrence et
renommez-le target2.fla.
2.
Double-cliquez sur l’occurrence myClip sur la scène.
3.
Sélectionnez l’outil Ovale et tracez un autre ovale dans l’occurrence myClip.
4.
Sélectionnez la nouvelle forme, puis choisissez Modifier > Convertir en symbole.
5.
Sélectionnez l’option Clip et cliquez sur OK.
6.
Sélectionnez la nouvelle occurrence et saisissez myOtherClip dans le champ Nom de
l’occurrence de l’inspecteur des propriétés.
7.
Dans la barre d’édition, cliquez sur Scène 1 pour revenir au scénario principal.
8.
Ajoutez le code ActionScript suivant dans l’image 1 du calque actions :
myClip.myOtherClip._xscale = 50;
Ce code ActionScript réduit de 50 % la largeur de l’occurrence myOtherClip. Le fichier
target.fla ayant modifié la propriété _xscale des occurrences myClip, et myOtherClip
étant un symbole imbriqué, vous remarquerez que la largeur de myOtherClip est
maintenant de 25 % de la largeur d’origine.
Si vous travaillez avec des clips imbriqués possédant leurs propres scénarios, vous pouvez
manipuler la tête de lecture dans le scénario d’une occurrence imbriquée à l’aide d’un code
similaire au fragment suivant :
myClip.nestedClip.gotoAndPlay(15);
myClip.someOtherClip.gotoAndStop("tweenIn");
Remarquez que le clip que vous manipulez (tel que nestedClip) apparaît juste avant l’action.
Vous remarquerez également cette tendance dans les sections suivantes.
Votre accès n’est pas limité aux méthodes et aux propriétés prédéfinies des occurrences de la
scène présentées dans les exemples précédents. Vous pouvez également définir une variable à
l’intérieur d’un clip, comme dans le code suivant qui définit une variable dans le clip starClip :
starClip.speed = 1.1;
starClip.gravity = 0.8;
Syntaxe à point et chemins cible
131
Si des variables de vitesse ou de gravité existaient déjà dans l’occurrence du clip starClip, les
valeurs précédentes ont été remplacées dès la définition des nouvelles valeurs. Vous pouvez
ajouter de nouvelles propriétés au clip starClip puisque la classe MovieClip a été définie avec
le mot-clé dynamic. Le mot-clé dynamic indique que les objets basés sur la classe spécifiée
(dans le cas présent, MovieClip) peuvent ajouter des propriétés dynamiques et y accéder
pendant la période d’exécution. Pour plus d’informations sur l’instruction dynamic, reportezvous à dynamic statement dans le Guide de référence du langage ActionScript 2.0.
Ciblage dynamique d’occurrences et de contenu chargé
Vous pouvez également créer un objet à l’aide d’ActionScript, puis utiliser un chemin de cible.
Par exemple, le code ActionScript suivant permet de créer un clip. Vous pouvez ensuite
modifier la rotation de ce clip à l’aide d’ActionScript, comme dans l’exemple suivant :
Pour cibler une occurrence de clip créée de façon dynamique :
1.
Créez un nouveau document FLA, puis enregistrez-le sous le nom targetClip.fla.
2.
Insérez un nouveau calque et renommez-le actions.
3.
Ajoutez le code ActionScript suivant dans l’image 1 du calque actions :
this.createEmptyMovieClip("rotateClip", this.getNextHighestDepth());
trace(rotateClip);
rotateClip._rotation = 50;
4.
Choisissez Contrôle > Tester l’animation pour tester votre document.
Vous savez que vous avez créé un clip par la présence de l’instruction trace, mais rien n’est
visible sur la scène. Bien que vous ayez ajouté le code qui crée l’occurrence de clip, vous ne
verrez rien sur la scène avant d’avoir ajouté un élément au clip. Vous pouvez par exemple
charger une image dans le clip.
5.
Revenez dans l’environnement de programmation, puis ouvrez le panneau Actions.
6.
Tapez le code ActionScript suivant à la suite du code ajouté à l’étape 3 :
rotateClip.loadMovie("http://www.helpexamples.com/flash/images/
image1.jpg");
Ce code charge une image dans le clip rotateClip que vous avez créé. Vous ciblez
l’occurrence rotateClip avec ActionScript.
7.
Choisissez Contrôle > Tester l’animation pour tester votre document.
Une image doit à présent s’afficher sur la scène avec une rotation de 50º dans le sens des
aiguilles d’une montre.
Vous pouvez également cibler ou identifier des parties de fichiers SWF chargés dans un fichier
SWF de base.
132
Eléments fondamentaux du langage et de la syntaxe
Pour identifier un fichier SWF chargé :
■
Utilisez _levelX, où X est le numéro du niveau spécifié dans la fonction loadMovie() qui
a chargé le fichier SWF.
Par exemple, un fichier SWF chargé au niveau 99 a pour chemin cible _level99. Dans
l’exemple suivant, un fichier SWF est chargé au niveau 99 et sa visibilité est définie sur
false :
//Charge le SWF sur le niveau 99.
loadMovieNum("contents.swf", 99);
// Définit la visibilité du niveau 99 sur false.
loaderClip.onEnterFrame = function(){
_level99._visible = false;
};
C O N S E IL
Il est généralement recommandé d’éviter l’utilisation de niveaux si vous pouvez
charger le contenu dans des clips à différents niveaux. La méthode
MovieClip.getNextHighestDepth() vous permet de créer des occurrences de clip sur
la scène de façon dynamique, sans qu’il soit nécessaire de vérifier s’il existe déjà une
occurrence à une profondeur spécifique.
Définition de variables à l’aide d’un chemin
Vous pouvez définir des variables pour des occurrences imbriquées dans d’autres occurrences.
Par exemple, pour définir une variable pour un formulaire placé dans un autre formulaire,
utilisez le code suivant. L’occurrence submitBtn est à l’intérieur de formClip sur le scénario
principal :
this.formClip.submitBtn.mouseOver = true;
Vous pouvez déclarer une méthode ou une propriété d’un objet particulier (tel qu’un clip ou
un champ de texte) à l’aide de ce modèle. Par exemple, la propriété d’un objet serait
myClip._alpha = 50;
Domaine et ciblage
Lorsque vous imbriquez des occurrences, le clip qui contient un second clip est appelé parent
de l’occurrence imbriquée. L’occurrence imbriquée est elle appelée occurrence enfant. La scène
principale et le scénario principal sont eux-mêmes avant tout un clip et peuvent donc être
ciblés en tant que tels. Pour plus d’informations sur le domaine, consultez la section Variables
et domaine, page 105.
Syntaxe à point et chemins cible
133
Le code ActionScript vous permet de cibler des occurrences et des scénarios parents. Pour
cibler le scénario actif, utilisez le mot-clé this. Par exemple, lorsque vous ciblez un clip appelé
myClip situé sur le scénario principal, utilisez
this.myClip.
Vous pouvez même éventuellement abandonner le mot-clé this et utiliser simplement
myClip
Le mot-clé this facilite la compréhension et la cohérence du code. Pour plus d’informations
sur les pratiques de programmation conseillées, consultez le Chapitre 19, Recommandations et
conventions de programmation pour ActionScript 2.0, page 797.
Si vous suivez le clip pour l’un des fragments de code ci-dessus, _level0.myClip apparaît
dans le panneau de sortie. Toutefois, si du code ActionScript est placé à l’intérieur du clip
myClip alors que vous voulez cibler le scénario principal, vous devez cibler le parent du clip
(c’est-à-dire la scène principale). Double-cliquez sur un clip et placez le code ActionScript
suivant sur le scénario du clip :
trace("me: " + this);
trace("my parent: " + this._parent);
Testez le fichier SWF. Le message suivant s’affiche dans le panneau de sortie :
me: _level0.myClip
my parent: _level0
Il indique que vous avez ciblé le scénario principal. Vous pouvez utiliser un parent pour créer
un chemin relatif vers un objet. Par exemple, si le clip dogClip est imbriqué dans le clip
d’animation animalClip, l’instruction suivante de l’occurrence dogClip indique à animalClip
d’arrêter l’animation :
this._parent.stop();
Si vous connaissez bien Flash et ActionScript, vous avez certainement remarqué que certains
utilisent le domaine _root. Le domaine _root fait généralement référence au scénario
principal du document Flash actif. Dans la mesure du possible, évitez d’utiliser le domaine
_root. Et utilisez les chemins cible relatifs au lieu de _root.
Si vous utilisez _root dans votre code, des erreurs risquent de survenir si vous chargez le
fichier SWF dans un autre document Flash. Lors du chargement du fichier SWF dans un
autre fichier SWF, le domaine _root du fichier chargé peut pointer vers le domaine racine du
fichier SWF dans lequel il est chargé au lieu de faire référence à son propre domaine racine.
L’opération peut donc entraîner des réactions inattendues, voire une défaillance totale de la
fonctionnalité.
134
Eléments fondamentaux du langage et de la syntaxe
Utilisation du bouton Chemin cible
Il n’est pas toujours simple de savoir à quoi correspond un chemin cible donné ou quel
chemin cible est nécessaire pour tel fragment de code. Si vous ciblez une occurrence située sur
la scène, le bouton Chemin cible permet d’identifier le chemin qui y conduit.
Pour utiliser le bouton Chemin cible :
1.
Dans le panneau Actions (Fenêtre > Actions), cliquez sur le bouton Insérer un chemin
cible. Les clips de votre document actif s’affichent dans une boîte de dialogue.
2.
Sélectionnez l’une des occurrences dans la liste.
3.
Cliquez sur OK.
4.
Le chemin cible de l’occurrence sélectionnée s’affiche dans la fenêtre de script.
Syntaxe à barre oblique
La syntaxe à barre oblique était utilisée dans Flash 3 et 4 pour indiquer le chemin cible d’un
clip ou d’une variable. Cette syntaxe est prise en charge par ActionScript 1.0 dans Flash
Player 7 et les versions antérieures, mais pas dans ActionScript 2.0 et Flash Player 7 ou 8.
L’utilisation de cette syntaxe est donc déconseillée, sauf lorsque vous n’avez pas le choix, par
exemple lors de la création d’un contenu destiné spécifiquement à Flash Player 4 ou Flash
Lite 1.1 (et versions antérieures). Pour plus d’informations sur Flash Lite, consultez la page du
produit Flash Lite.
Eléments de ponctuation
Le langage de Flash comprend plusieurs éléments de ponctuation. Les plus courants sont les
points-virgules (;), les deux-points (:), les parenthèses [()] et les accolades ({}). Chacun de
ces éléments a une signification précise dans le langage de Flash et permet de définir des types
de données, de clore des instructions ou de structurer le code ActionScript. Les sections
suivantes abordent l’emploi de ces éléments de ponctuation dans votre code.
Pour plus d’informations sur les éléments de ponctuation, consultez les sections suivantes :
■
Points-virgules et deux points, page 136
■
Accolades, page 137
■
Parenthèses, page 141
■
Présentation des littéraux, page 142
■
Présentation des commentaires, page 143
Eléments de ponctuation
135
Pour plus d’informations sur l’opérateur point (.) et les opérateurs d’accès tableau ([]),
consultez la section Utilisation des opérateurs point et d’accès au tableau, page 200. Pour plus
d’informations sur les espaces blancs et le formatage du code, consultez la section Mise en
forme de la syntaxe ActionScript, page 832.
Points-virgules et deux points
Comme le montre les deux lignes de code suivantes, les instructions ActionScript se terminent
par un point-virgule (;) :
var myNum:Number = 50;
myClip._alpha = myNum;
Vous pouvez cependant omettre ce caractère car le compilateur ActionScript suppose alors que
chaque ligne de code représente une instruction distincte. Néanmoins, la meilleure pratique
consiste à utiliser des points-virgules, car cela rend le code plus lisible. Lorsque vous cliquez
sur le bouton de formatage automatique du panneau Actions ou de la fenêtre de script, des
points-virgules sont ajoutés par défaut à la fin de vos instructions.
REMARQUE
L’ajout d’un point-virgule à la fin de chaque instruction permet de placer plusieurs
instructions sur une même ligne, mais dans ce cas, la lecture de votre code est rendue
plus difficile.
Les points-virgules sont également employés dans les boucles for. Comme l’illustre l’exemple
suivant, le point-virgule permet de séparer les paramètres : L’exemple fait une boucle de 0 à 9,
puis affiche chaque nombre dans le panneau de sortie :
var i:Number;
for (i = 0; i < 10; i++) {
trace(i); // 0,1,...,9
}
Le caractère deux points (:) est utilisé dans le code pour affecter des types de données aux
variables. Pour affecter un type de données spécifique à un élément, spécifiez son type à l’aide
d’une syntaxe utilisant le mot-clé var ainsi que deux points, comme illustré ci-dessous :
// typage strict de variable ou objet
var myNum:Number = 7;
var myDate:Date = new Date();
// typage strict de paramètres
function welcome(firstName:String, myAge:Number) {
}
// typage strict de paramètre et de valeur renvoyée
function square(num:Number):Number {
var squared:Number = num * num;
136
Eléments fondamentaux du langage et de la syntaxe
return squared;
}
Vous pouvez déclarer le type des données des objets en fonction des classes intégrées (Button,
Date, MovieClip, etc.) et des classes et interfaces que vous créez. Le code suivant crée un
nouvel objet de type personnalisé Student :
var firstStudent:Student = new Student();
Vous pouvez également spécifier que les objets sont de type Function ou Void. Pour plus
d’informations sur l’affectation du type de données, consultez le Chapitre 4, Données et types
de données, page 77.
Accolades
Les accolades ({}) permettent de regrouper des événements, des définitions de classe et des
fonctions ActionScript dans des blocs. L’accolade d’ouverture doit être placée sur la même
ligne que la déclaration.
REMARQUE
Vous pouvez également placer l’accolade d’ouverture sur la ligne qui suit la déclaration,
mais il est conseillé de la placer sur la même ligne, pour plus de cohérence. Pour plus
d’informations sur les accolades et les conventions de programmation, consultez le
Chapitre 19, Recommandations et conventions de programmation pour ActionScript 2.0,
page 797.
Placez les instructions entre accolades lorsqu’elles appartiennent à une structure de contrôle
(par exemple if..else ou for), même lorsque cette dernière ne comporte qu’une seule
instruction. Cette pratique conseillée permet d’éviter les erreurs dans le code ActionScript,
telles que les oublis d’accolades. L’exemple suivant montre un code dont la forme est
médiocre :
var numUsers:Number;
if (numUsers == 0)
trace("no users found.");
Bien que ce code puisse être validé, sa présentation est médiocre dans la mesure où les
accolades ne sont pas placées autour des instructions.
CONSEIL
Si vous cliquez sur le bouton Vérifier la syntaxe, des accolades seront ajoutées à cette
instruction.
Dans ce cas, le fait d’ajouter une seconde instruction après l’instruction trace permet de
l’exécuter, que la variable numUsers soit égale à 0 ou non, ce qui risque de déboucher sur des
résultats imprévus. Pour cette raison, ajoutez des accolades de façon à obtenir le code suivant :
Eléments de ponctuation
137
var numUsers:Number;
if (numUsers == 0) {
trace("no users found");
}
L’exemple suivant crée un objet écouteur et une occurrence MovieClipLoader.
var imgUrl:String = "http://www.helpexamples.com/flash/images/image1.jpg";
this.createEmptyMovieClip("img_mc", 100);
var mclListener:Object = new Object();
mclListener.onLoadStart = function() {
trace("starting");
};
mclListener.onLoadInit = function(target_mc:MovieClip):Void {
trace("success");
};
mclListener.onLoadError = function(target_mc:MovieClip):Void {
trace("failure");
};
var myClipl:MovieClipLoader = new MovieClipLoader();
myClipl.addListener(mclListener);
myClipl.loadClip(imgUrl, img_mc);
Le prochain exemple affiche un simple fichier de classe qui permet de créer un objet Student.
Vous étudierez les fichiers de classe de manière approfondie dans le Chapitre 7, Classes,
page 243.
Pour utiliser des accolades dans un fichier ActionScript :
1.
Choisissez Fichier > Nouveau, puis sélectionnez Fichier ActionScript.
2.
Choisissez Fichier > Enregistrer sous et nommez le nouveau document Student.as.
3.
Ajoutez le code ActionScript suivant dans le fichier AS.
// Student.as
class Student
private var
private var
private var
private var
{
_id:String;
_firstName:String;
_middleName:String;
_lastName:String;
public function Student(id:String, firstName:String,
middleName:String, lastName:String) {
this._id = id;
this._firstName = firstName;
this._middleName = middleName;
this._lastName = lastName;
}
public function get firstName():String {
return this._firstName;
}
public function set firstName(value:String):Void {
138
Eléments fondamentaux du langage et de la syntaxe
this._firstName = value;
}
// ...
}
4.
Enregistrez le fichier de classe.
5.
Choisissez Fichier > Nouveau, puis cliquez sur Document Flash pour créer un nouveau
fichier FLA.
6.
Enregistrer le fichier FLA sous le nom student_test.fla.
7.
Saisissez le code ActionScript suivant sur l’image 1 du scénario 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.
Choisissez Fichier > Enregistrer pour enregistrer les modifications dans le fichier
student_test.fla.
9.
Choisissez Contrôle > Tester l’animation pour tester les fichiers FLA et AS.
Le prochain exemple montre l’emploi des accolades avec les fonctions.
Pour utiliser des accolades avec des fonctions :
1.
Choisissez Fichier > Nouveau, puis Document Flash pour créer un nouveau fichier FLA.
2.
Choisissez Fichier > Enregistrer sous et nommez le fichier checkform.fla.
3.
Faites glisser une occurrence de composant Label du panneau Composants jusqu’à la scène.
4.
Ouvrez l’inspecteur des propriétés (Fenêtre > Propriétés > Propriétés) et, l’occurrence du
composant Label étant sélectionnée, saisissez le nom status_lbl dans le champ Nom de
l’occurrence.
5.
Saisissez 200 dans le champ W (largeur) pour définir la largeur du composant sur
200 pixels.
6.
Faites glisser une occurrence du composant TextInput sur la scène et nommez-la
firstName_ti.
7.
Faites glisser une occurrence du composant Button sur la scène et nommez-la
submit_button.
Eléments de ponctuation
139
8.
Sélectionnez l’image 1 du scénario et, dans le panneau Actions, ajoutez le code ActionScript
suivant :
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.
Choisissez Fichier > Enregistrer pour enregistrer le document Flash.
10. Choisissez
Contrôle > Tester l’animation pour tester le code dans l’environnement de
programmation.
Dans le fichier SWF, un message d’erreur apparaît si vous cliquez sur l’occurrence Button
de la scène alors que le composant firstName_ti TextInput ne contient pas de texte.
Cette erreur s’affiche dans le composant Label et signale à l’utilisateur qu’il doit saisir un
prénom.
L’exemple suivant d’utilisation des accolades présente la création et la définition de propriétés
à l’intérieur d’un objet. Dans cet exemple, les propriétés sont définies dans l’objet en plaçant
les noms des variables entre des accolades ({}) :
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
*/
140
Eléments fondamentaux du langage et de la syntaxe
Vous pouvez également utiliser des accolades vides comme syntaxe raccourcie pour la fonction
new Object(). Le code suivant crée par exemple une occurrence d’objet vide :
var myObject:Object = {};
CONSEIL
N’oubliez pas de vérifier que chaque accolade d’ouverture est bien associée à une
accolade de fermeture.
Parenthèses
Comme l’illustrent les lignes de code suivantes, la définition d’une fonction dans ActionScript
se fait en plaçant les paramètres entre parenthèses [()] :
function myFunction(myName:String, myAge:Number, happy:Boolean):Void {
// Insérez votre code ici.
}
Lorsque vous appelez une fonction, vous incluez également tous les paramètres transmis à la
fonction entre parenthèses, comme dans l’exemple suivant :
myFunction("Carl", 78, true);
Vous pouvez utiliser les parenthèses pour supplanter l’ordre de priorité d’ActionScript ou pour
faciliter la compréhension de vos instructions ActionScript. Cela signifie que vous pouvez
modifier l’ordre dans lequel les valeurs sont calculées en en plaçant certaines entre parenthèses,
comme dans l’exemple suivant :
var computedValue:Number = (circleClip._x + 20) * 0.8;
Du fait de l’ordre de priorité, si vous n’utilisez pas de parenthèses ou que vous utilisez deux
instructions distinctes, la multiplication est d’abord calculée, et la première opération est donc
20 * 0,8. Le résultat, 16, est ensuite ajouté à la valeur actuelle de circleClip._x, puis affecté à la
variable computedValue.
Si vous n’utilisez pas de parenthèses, vous devez ajouter une instruction pour évaluer
l’expression, comme indiqué dans l’exemple suivant :
var tempValue:Number = circleClip._x + 20;
var computedValue:Number = tempValue * 0.8;
Comme pour les crochets et les accolades, vous devez vous assurer que chaque parenthèse
d’ouverture est bien associée à une parenthèse de fermeture.
Eléments de ponctuation
141
Présentation des littéraux
Un littéral est une valeur qui apparaît directement dans le code. Ce sont des valeurs constantes
(qui ne changent pas) dans les documents Flash. true, false, 0, 1, 52 ou la chaîne “foo” en
sont des exemples.
Voici quelques exemples de littéraux :
17
"hello"
-3
9.4
null
undefined
true
false
Les littéraux peuvent également être regroupés pour former des littéraux composés. Les
littéraux de tableau sont placés entre crochets ([]) et utilisent la virgule (,) pour séparer les
éléments du tableau. Un littéral de tableau permet donc d’initialiser un tableau. Les exemples
suivants présentent deux tableaux initialisés par des littéraux de tableau. Vous pouvez utiliser
l’instruction new et transmettre le littéral composé sous forme de paramètre au constructeur
de classe Array, ou affecter directement les valeurs littérales lors de l’instanciation des
occurrences d’une classe ActionScript intégrée.
// Utilisation de l’instruction new.
var myStrings:Array = new Array("alpha", "beta", "gamma");
var myNums:Array = new Array(1, 2, 3, 5, 8);
// affectation directe d’un littéral
var myStrings:Array = ["alpha", "beta", "gamma"];
var myNums:Array = [1, 2, 3, 5, 8];
Les littéraux permettent également d’initialiser un objet générique. Un objet générique est une
occurrence de la classe Object. Les littéraux d’objet sont placés entre accolades ({}) et utilisent
la virgule (,) pour séparer les propriétés de l’objet. Chaque propriété est déclarée avec le
caractère deux points (:), séparant le nom et la valeur de la propriété.
Vous pouvez créer un objet générique via l’instruction new et transmettre le littéral d’objet
sous forme de paramètre au constructeur de classe Object ou affecter directement le littéral
d’objet à l’occurrence déclarée. L’exemple suivant crée un objet générique et initialise l’objet
avec trois propriétés, propA, propB et propC, de valeurs respectives 1, 2 et 3.
// Utilisation de l’instruction new.
var myObject:Object = new Object({propA:1, propB:2, propC:3});
// affectation directe d’un littéral
var myObject:Object = {propA:1, propB:2, propC:3};
142
Eléments fondamentaux du langage et de la syntaxe
Ne confondez pas un littéral de chaîne avec un objet String. Dans l’exemple suivant, la
première ligne de code crée le littéral de chaîne firstStr, et la deuxième ligne de code, l’objet
String secondStr :
var firstStr:String = "foo"
var secondStr:String = new String("foo")
Utilisez des littéraux de chaîne sauf si, pour optimiser les performances vous avez
spécifiquement besoin d’un objet String. Pour plus d’informations sur les chaînes, consultez la
section Présentation des chaînes et de la classe String, page 493.
Présentation des commentaires
Les commentaires permettent d’annoter votre code à l’aide de descriptions claires qui sont
ignorées par le compilateur. Vous pouvez insérer ces commentaires dans votre code pour
décrire sa fonction ou les données renvoyées au document. Les commentaires permettent de se
souvenir des choix de programmation importants et sont extrêmement utiles pour toute
personne qui lit et doit comprendre votre code. Les commentaires doivent expliquer
clairement l’objectif du code et ne pas se contenter de le paraphraser. Toute section qui ne
s’explique pas d’elle-même dans le code doit faire l’objet de commentaires.
Il est vivement recommandé d’utiliser des commentaires pour ajouter des notes aux scripts.
Les commentaires documentent les décisions prises lors de la programmation, en expliquant le
pourquoi et le comment. Ils facilitent la compréhension du code ActionScript. Par exemple,
vous devez décrire toute solution de contournement dans les commentaires. Ainsi, vous (ou
tout autre développeur) pourrez aisément localiser les sections de code concernées pour les
mettre à jour ou les corriger. De même, lorsqu’un problème est ensuite corrigé dans la version
suivante de Flash ou Flash Player, vous pouvez améliorer le code ActionScript en supprimant
ce contournement devenu inutile.
Evitez de surcharger vos commentaires. Une ligne de signes égal (=) ou d’astérisques (*)
créant un bloc ou une séparation autour du commentaire est un bon exemple de
commentaire surchargé. Dans ce cas, utilisez des espaces blancs pour séparer les
commentaires du code ActionScript. Si vous formatez le code ActionScript à l’aide du
bouton Format automatique du panneau Actions ou de la fenêtre de script, l’espace blanc
sera supprimé. N’oubliez pas de rajouter un espace blanc dans votre code, ou d’utiliser des
lignes de commentaires uniques (//) pour conserver l’espacement. Il est ensuite plus facile de
supprimer ces lignes après la mise en forme du code que d’essayer de déterminer où se
trouvaient les espaces.
Eléments de ponctuation
143
Avant le déploiement de votre projet, retirez du code tous les commentaires inutiles, tels que
« Définition des variables x et y » ou autres commentaires évidents pour les autres
développeurs. Si votre code ActionScript comporte trop de commentaires, envisagez la
réécriture de certaines sections. La nécessité d’inclure de nombreux commentaires sur le
fonctionnement du code ActionScript dénote généralement d’une programmation maladroite
et peu intuitive.
Lorsque la coloration de la syntaxe est activée, les commentaires apparaissent en gris par
défaut. Quelle que soit leur longueur, la taille du fichier exporté n’est pas affectée. Les
commentaires ne sont pas soumis aux règles de syntaxe ou de mots-clés d’ActionScript.
REMARQUE
L’emploi de commentaires est particulièrement important lorsque le code ActionScript
est destiné à la formation. Ajoutez des commentaires à votre code si vous créez des
exemples d’application dans le but de former les utilisateurs à la programmation Flash ou
si vous rédigez des articles et des didacticiels sur ActionScript.
Commentaires sur une ligne
Ces commentaires sont limités à une ligne dans votre code. Vous pouvez alors commenter une
seule ligne de code ou décrire brièvement l’objectif d’un fragment de code. Pour indiquer
qu’une ligne ou portion de ligne est un commentaire, faites-la précéder de deux barres
obliques (//), comme dans le code suivant :
// Le code suivant définit une variable locale pour l’âge.
var myAge:Number = 26;
Les commentaires sur une ligne portent généralement sur une petite section de code. Utilisez
ce type de commentaires lorsque le contexte le permet. Les exemples suivants incluent un
commentaire sur une ligne :
while (condition) {
// Traiter la condition avec des instructions
}
Commentaires sur plusieurs lignes
Ces commentaires, également appelé blocs de commentaires, conviennent lorsque les
commentaires comprennent plusieurs lignes. Les développeurs les utilisent pour décrire des
fichiers, des structures de données, des méthodes et des descriptions de fichiers. Ces blocs sont
généralement placés au début d’un fichier et avant ou à l’intérieur d’une méthode.
Pour créer un bloc de commentaires, entrez /* au début des lignes de commentaire, puis */ à
la fin du bloc. Cette technique permet de créer des commentaires longs sans avoir à ajouter
des // au début de chaque ligne. L’utilisation des // sur de plusieurs lignes consécutives peut
entraîner des problèmes en cas de modification des commentaires.
144
Eléments fondamentaux du langage et de la syntaxe
Le format d’un commentaire sur plusieurs lignes est le suivant.
/*
Le code ActionScript suivant initialise les variables utilisées dans les
systèmes principaux et secondaires. Ces variables permettent d’identifier
les options qui ont été activées par l’utilisateur.
*/
CONSEIL
Si vous placez les caractères de commentaire (/* et */) sur des lignes distinctes au début
et à la fin du commentaire, vous pouvez les supprimer facilement en les faisant précéder
de deux barres obliques (//) (par exemple, ///* et //*/). Cette fonction permet d’ajouter et
de retirer facilement les commentaires de votre code.
En plaçant de gros pavés de code dans un bloc de commentaires, vous pouvez tester des
sections spécifiques du script. Par exemple, lors de l’exécution du script suivant, le code
intégré dans le bloc de commentaires n’est pas exécuté :
// Le code suivant s’exécute.
var x:Number = 15;
var y:Number = 20;
// Le code suivant est commenté et ne sera pas exécuté.
/*
// Crée un nouvel objet Date
var myDate:Date = new Date();
var currentMonth:Number = myDate.getMonth();
// Convertit le chiffre du mois en nom
var monthName:String = calcMonth(currentMonth);
var year:Number = myDate.getFullYear();
var currentDate:Number = myDate.getDate();
*/
// Le code ci-dessous s’exécute.
var namePrefix:String = "My name is";
var age:Number = 20;
C ON S E I L
Il est recommandé de faire précéder chaque bloc de commentaires d’une ligne vierge.
Eléments de ponctuation
145
Commentaires en fin de ligne
Ces commentaires permettent d’ajouter un commentaire dans une ligne de votre code. Ils
apparaissent sur la même ligne que votre code ActionScript. Les développeurs les utilisent
généralement pour décrire le contenu d’une variable ou une valeur renvoyée par une ligne du
code ActionScript. Le format des commentaires en fin de ligne est le suivant :
var myAge:Number = 26; // Variable pour mon âge
trace(myAge); // 26
Déplacez les commentaires vers la droite, de sorte que les lecteurs les différencient bien du
code. Dans la mesure du possible, alignez-les, comme illustré ci-dessous.
var myAge:Number = 28;
var myCountry:String = "Canada";
var myCoffee:String = "Hortons";
//mon âge
//mon pays
//mon café préféré
Si vous utilisez la fonction de formatage automatique (bouton Format automatique du
panneau Actions), les commentaires en fin de ligne sont déplacés à la ligne suivante. Ajoutez
ces commentaires après avoir formaté votre code ou changez-les de place après avoir utilisé la
fonction de formatage automatique.
Commentaires dans les classes
Ces commentaires permettent de documenter le contenu de vos classes et de vos interfaces et
facilitent la compréhension des développeurs. Faites débuter tous vos fichiers de classe par un
commentaire fournissant le nom de classe, son numéro de version, sa date et votre droit de
propriété. Par exemple, vous pouvez documenter votre classe de la façon suivante :
/**
Classe Pelican
version 1.2
10/10/2005
copyright Macromedia, Inc.
*/
Servez-vous de blocs de commentaires pour décrire les fichiers, les structures de données et les
méthodes. Ces blocs sont généralement placés au début d’un fichier et avant ou à l’intérieur
d’une méthode.
Un fichier d’interface ou de classe comporte généralement deux types de commentaire : des
commentaires de documentation et des commentaires d’implémentation. Les commentaires
de documentation décrivent le cahier des charges du code, mais pas son implémentation. Ils
documentent les interfaces, les classes, les méthodes et les constructeurs. Les commentaires
d’implémentation décrivent le code ou l’implémentation de sections spécifiques du code.
146
Eléments fondamentaux du langage et de la syntaxe
Incluez un commentaire de documentation par classe, interface ou membre, et placez-le
directement avant la déclaration. Si vous devez faire des ajouts à vos commentaires de
documentation, utilisez des commentaires d’implémentation (sous forme de blocs de
commentaires ou de commentaires sur une ligne). Les commentaires d’implémentation
suivent directement la déclaration.
Ces deux types de commentaires utilisent des séparateurs légèrement différents. Les
commentaires de documentation sont séparés par /** et */, tandis que les commentaires
d’implémentation sont séparés par /* et */.
CONSEIL
N’incluez pas les commentaires non directement relatifs à la classe en cours de lecture.
Par exemple, n’incluez pas de commentaires décrivant le package correspondant.
Vous pouvez également utiliser des commentaires sur une ligne, des blocs de commentaires et
des commentaires de fin de ligne dans les fichiers de classe. Pour plus d’informations sur ces
types de commentaires, consultez les sections suivantes :
■
Commentaires sur une ligne, page 144
■
Commentaires sur plusieurs lignes, page 144
■
Commentaires en fin de ligne, page 146
Présentation des constantes et des
mots-clés
Les constantes et les mots-clés sont la base de la syntaxe ActionScript. Les constantes sont des
propriétés dont la valeur est fixe et non modifiable. Elles ne changent donc jamais, même
pendant l’exécution de l’application.
Flash comprend plusieurs constantes prédéfinies qui peuvent simplifier le développement
d’application. Vous pouvez observer un exemple de constantes dans la classe Key, qui
comprend de nombreuses propriétés, comme Key.ENTER ou Key.PGDN. Lorsque vous utilisez
des constantes, vous n’avez pas besoin de vous souvenir que les valeurs de code des touches
Entrée et Page suivante sont 13 et 34. Ces constantes ne simplifient pas seulement le
développement et le débogage, mais facilitent la compréhension de votre code par vos
collègues développeurs.
Les mots-clés utilisés par ActionScript permettent d’exécuter des types d’actions spécifiques. Il
s’agit également de mots réservés et vous ne pouvez donc pas les utiliser comme identifiants
(noms de variable, de fonction, d’étiquette, etc.). Voici quelques exemples de mots-clés
réservés : if, else, this, function et return.
Présentation des constantes et des mots-clés
147
Pour plus d’informations sur les constantes et les mots-clés, consultez les rubriques suivantes :
■
Utilisation des constantes, page 148
■
Présentation des mots-clés, page 151
■
Présentation des mots réservés, page 151
Pour plus d’informations sur les objets et les propriétés, consultez la section Type de données
Object, page 85. Vous trouverez la liste des constantes du langage ActionScript (telles que
false et NaN) dans la catégorie Eléments du langage ActionScript > Constantes du Guide de
référence du langage ActionScript 2.0.
Utilisation des constantes
Les constantes sont des propriétés de valeurs fixes non modifiables. En d’autres termes, elles ne
changent jamais, même pendant l’exécution de l’application. Le langage ActionScript contient
un grand nombre de constantes prédéfinies. Par exemple, les constantes BACKSPACE, ENTER,
SPACE et TAB sont des propriétés de la classe Key qui font référence aux touches du clavier. La
constante Key.TAB a toujours la même signification : elle indique la touche Tab du clavier. Les
constantes sont très utiles pour comparer des valeurs et utiliser des valeurs qui ne changent pas
dans votre application.
Pour savoir si un utilisateur appuie sur la touche Entrée, vous pouvez utiliser l’instruction
suivante :
var keyListener:Object = new Object();
keyListener.onKeyDown = function() {
if (Key.getCode() == Key.ENTER) {
trace("Are you ready to play?");
}
};
Key.addListener(keyListener);
Pour que le code ActionScript précédent fonctionne, il peut être nécessaire de désactiver les
raccourcis clavier dans l’environnement de programmation. Dans le menu principal,
choisissez Contrôle > Tester l’animation puis, avec un aperçu du fichier SWF dans le lecteur,
choisissez Contrôle > Désactiver les raccourcis clavier dans la fenêtre d’aperçu du fichier SWF.
Flash ne vous permet pas de créer vos propres valeurs de constantes, sauf lorsque vous créez
vos propres classes personnalisées avec des variables de membre privé. Vous ne pouvez pas
créer de variable en « lecture seule » dans Flash.
Les variables doivent être en minuscules ou comprendre un mélange de minuscules et
majuscules. Toutefois, les constantes (variables qui ne changent pas) doivent être en
majuscules. Séparez les mots par un caractère de soulignement, comme dans l’exemple suivant
de code ActionScript :
148
Eléments fondamentaux du langage et de la syntaxe
var BASE_URL:String = "http://www.macromedia.com"; // constante
var MAX_WIDTH:Number = 10;
// constante
Tapez les constantes statiques en majuscules et séparez les mots par des caractères de
soulignement. Ne codez pas directement les constantes numériques, sauf si leur valeur est 1, 0
ou -1, que vous pouvez utiliser dans le cadre d’une boucle for en tant que valeur de compteur.
Vous pouvez utiliser des constantes pour les situations où vous devez faire référence à une
propriété dont la valeur ne change jamais. Ceci permet d’identifier les erreurs typographiques
qui risquent de passer inaperçues avec des littéraux. Ceci vous permet également de centraliser
la modification des valeurs. Pour plus d’informations sur les littéraux, consultez la section
Présentation des littéraux, page 142.
Par exemple, la définition de classe de l’exemple suivant crée trois constantes qui respectent la
convention d’appellation utilisée par ActionScript 2.0.
Pour utiliser des constantes dans une application :
1.
Choisissez Fichier > Nouveau, puis Fichier ActionScript pour créer un fichier AS.
2.
Nommez ce fichier ConstExample.as.
3.
Saisissez le code suivant dans la fenêtre de 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";
}
La propriété EXAMPLE_STATIC est statique, c’est-à-dire qu’elle s’applique à la classe entière
et non à une occurrence particulière de la classe. Pour accéder à une propriété statique
d’une classe, vous devez utiliser le nom de la classe à la place du nom de l’occurrence. Vous
ne pouvez pas accéder à une propriété statique par l’intermédiaire d’une occurrence de
classe.
4.
Créez un nouveau document Flash, puis enregistrez-le sous le nom const.fla.
5.
Dans le panneau Actions, entrez le code suivant dans l’image 1 du scénario :
trace(ConstExample.EXAMPLE_STATIC); // Sortie : Global access
Lorsque la propriété EXAMPLE_STATIC est déclarée statique, utilisez ce code pour accéder à
sa valeur.
Présentation des constantes et des mots-clés
149
6.
Choisissez Contrôle > Tester l’animation pour tester votre document.
La mention Global accesss’affiche dans le panneau de sortie.
7.
Dans le panneau Actions, saisissez le code suivant après celui que vous avez ajouté à
l’étape 5.
trace(ConstExample.EXAMPLE_PUBLIC); // Erreur
trace(ConstExample.EXAMPLE_PRIVATE); // Erreur
8.
Choisissez Contrôle > Tester l’animation pour tester votre document.
Les propriétés EXAMPLE_PUBLIC et EXAMPLE_PRIVATE ne sont pas statiques. Lorsque vous
tentez d’accéder à leurs valeurs à travers la classe, le message d’erreur suivant apparaît :
The property being referenced does not have the static attribute.
Pour accéder à une propriété non statique, vous devez passer par l’occurrence de la classe.
La propriété EXAMPLE_PUBLIC étant publique, le code peut y accéder en dehors de la
définition de la classe.
9.
Dans le panneau Actions, supprimez l’instruction trace que vous avez ajoutée lors des
étapes 5 et 7.
10. Tapez
le code suivant dans le panneau Actions :
var myExample:ConstExample = new ConstExample();
trace(myExample.EXAMPLE_PUBLIC); // Sortie : Public access
Ce code crée l’occurrence myExample et accède à la propriété EXAMPLE_PUBLIC.
11.
Choisissez Contrôle > Tester l’animation pour tester votre document.
La mention Public access s’affiche dans le panneau de sortie.
12. Dans
13.
le panneau Actions, supprimez l’instruction trace que vous avez ajoutée à l’étape 10.
Tapez le code suivant dans le panneau Actions.
trace(myExample.EXAMPLE_PRIVATE); // erreur
La propriété EXAMPLE_PRIVATE étant privée, elle n’est accessible qu’à l’intérieur de la
définition de la classe.
14. Choisissez
Contrôle > Tester l’animation pour tester votre document.
La mention The member is private and cannot be accessed s’affiche dans le
panneau de sortie.
Pour plus d’informations sur les classes intégrées et la création de classes personnalisées,
consultez le Chapitre 7, Classes, page 243.
150
Eléments fondamentaux du langage et de la syntaxe
Présentation des mots-clés
Les mots-clés sont des termes ActionScript qui ont une fonction spéciale. Par exemple, le motclé var permet de déclarer une variable. Le mot-clé var est présenté dans le code suivant :
var myAge:Number = 26;
Il s’agit de mots réservés dont la signification est particulière : par exemple, le mot-clé class
permet de définir une nouvelle classe ActionScript et le mot-clé var de déclarer des variables
locales. Voici d’autres exemples de mots-clés réservés : if, else, this, function et return.
Les mots-clés ne peuvent pas servir d’identifiants (noms de variable, fonction ou étiquette) et
il est préférable de ne pas les utiliser ailleurs que dans vos fichiers FLA pour d’autres éléments
(tels que des noms d’occurrences). Vous avez déjà largement utilisé le mot-clé var, en
particulier si vous avez lu le Chapitre 4, Données et types de données, page 77. ActionScript
réserve les mots du langage à un usage spécifique. De ce fait, vous ne pouvez pas les utiliser
comme identifiants (noms de variable, de fonction ou d’étiquette). Vous trouverez la liste de
ces mots-clés dans la section Présentation des mots réservés, page 151.
Présentation des mots réservés
Les mots réservés ne peuvent pas servir d’identifiants dans votre code car leur utilisation est
réservée à ActionScript. Ces mots réservés incluent les mots-clés, correspondant à des
instructions ActionScript, et les mots réservés pour une utilisation future. Cela signifie que
vous ne pouvez pas les utiliser comme noms de variables, d’occurrences, de classes
personnalisées, etc., sans provoquer des problèmes techniques.
Le tableau suivant regroupe les mots-clés réservés de Flash qui provoquent des erreurs dans vos
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
Présentation des constantes et des mots-clés
151
static
switch
tellTarget
this
throw
try
typeof
var
void
while
with
Le tableau suivant énumère la liste des mots-clés réservés pour une utilisation future par
ActionScript ou la spécification ECMAScript (ECMA-262) édition 4. Il est également
préférable d’éviter l’emploi des mots-clés suivants dans votre code :
abstract
enum
export
short
byte
long
synchronized
char
debugger
protected
double
volatile
float
throws
transient
goto
Tous les noms de classes intégrées, de classes de composants et d’interfaces sont des mots
réservés et ne doivent pas être employés comme identifiants dans votre code :
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
152
Eléments fondamentaux du langage et de la syntaxe
StyleManager
System
TextArea
TextField
TextFormat
TextInput
TextSnapshot
TransferObject
Tree
TreeDataProvider
TypedValue
UIComponent
UIEventDispatcher
UIObject
Video
WebService
XML
XMLConnector
WebServiceConnector Window
XUpdateResolver
D’autres termes, qui ne sont pas des mots réservés, ne doivent pas non plus servir
d’identifiants (par exemple les noms de variables ou d’occurrences) dans votre code
ActionScript. Ces mots sont utilisés par les classes intégrées qui composent le langage
ActionScript. N’utilisez donc pas non plus les noms des propriétés, méthodes, classes,
interfaces, classes de composants et valeurs comme noms de variables, classes ou occurrences
dans votre code.
Pour savoir à quoi ces noms correspondent, consultez le Guide de référence du langage
ActionScript 2.0 et recherchez les autres sections d’utilisation et d’instruction dans le panneau
Aide du manuel Formation à ActionScript 2.0 dans Flash.
Présentation des instructions
Une instruction est une action spécifique que vous demandez au fichier FLA d’exécuter. Par
exemple, vous pouvez utiliser une instruction conditionnelle pour déterminer si quelque
chose est vrai ou existe. Votre code peut ensuite exécuter les actions spécifiées, telles que des
fonctions ou des expressions, selon si la condition est vraie ou non.
Par exemple, l’instruction if est une instruction conditionnelle qui évalue une condition afin
de déterminer l’action suivante du code.
// instruction if
if (condition) {
// instructions;
}
Dans un autre exemple, l’instruction return renvoie un résultat sous forme de valeur de la
fonction dans laquelle elle s’exécute.
Il existe différents moyens pour formater ou rédiger du code ActionScript. Chacun choisit sa
propre utilisation de la syntaxe et espace ou place différemment ses instructions ou accolades
({}) dans le code. Il existe malgré tout des consignes générales à respecter lors de l’écriture
d’un code ActionScript bien présenté.
Présentation des instructions
153
Ne placez qu’une seule instruction par ligne pour améliorer la lisibilité de votre code
ActionScript. Vous trouverez ci-dessous des exemples d’utilisation conseillée ou déconseillée
des instructions :
theNum++;
// recommandé
theOtherNum++; // recommandé
aNum++; anOtherNum++; // déconseillé
Affectez les variables en tant qu’instructions distinctes. Examinez
l’exemple de code
ActionScript suivant :
var myNum:Number = (a = b + c) + d;
Ce code imbrique une affectation dans le code, ce qui devient difficile à lire. Si l’affectation
des variables s’effectue par des instructions distinctes, le code devient plus lisible, comme dans
l’exemple suivant :
var a:Number = b + c;
var myNum:Number = a + d;
Les sections suivantes présentent la composition d’instructions spécifiques dans ActionScript.
Pour plus d’informations sur la rédaction et la mise en forme des événements, consultez le
Chapitre 10, Gestion d’événements, page 359.
Pour plus d’informations sur chaque instruction, consultez les sections suivantes :
■
Présentation des instructions composées, page 154
■
Présentation des conditions, page 155
■
Répétition d’actions à l’aide de boucles, page 166
Présentation des instructions composées
Une instruction composée contient plusieurs instructions placées entre des accolades ({}). Ces
instructions composées peuvent contenir n’importe quel type d’instruction ActionScript.
Voici un exemple d’instruction composée typique :
Les instructions placées entre accolades sont en retrait par rapport à l’instruction composée,
comme dans l’exemple de code ActionScript suivant :
var a:Number = 10;
var b:Number = 10;
if (a == b) {
// Ce code est en retrait.
trace("a == b");
trace(a);
trace(b);
}
154
Eléments fondamentaux du langage et de la syntaxe
Cette instruction composée contient plusieurs instructions mais se comporte comme une
seule instruction dans votre code ActionScript. L’accolade d’ouverture est placée à la fin de
l’instruction composée. L’accolade de fermeture débute une ligne et s’aligne sur le début de
l’instruction composée.
Pour plus d’informations sur l’utilisation des accolades, consultez la section Accolades,
page 137.
Présentation des conditions
Les conditions permettent de déterminer si une chose est vraie ou existe. Vous pouvez ensuite
éventuellement répéter une action (à l’aide de boucles) ou exécuter des actions définies, par
exemple des fonctions ou des expressions, selon l’état d’une condition (vraie ou fausse). Par
exemple, vous pouvez déterminer si une certaine variable est définie ou a une certaine valeur,
puis exécuter un bloc de code en fonction du résultat. De même, vous pourriez modifier les
graphiques de votre document Flash selon l’heure de l’horloge système de l’utilisateur ou les
conditions météorologiques de sa région.
Pour exécuter une action en fonction d’une condition ou pour la répéter (boucle), vous
pouvez utiliser les instructions if, else, else if, for, while, do while, for..in ou
switch.
Pour plus d’informations sur les conditions disponibles, et leur rédaction, consultez les
sections suivantes :
■
Rédaction des conditions, page 156
■
Utilisation de l’instruction if, page 156
■
Utilisation de l’instruction if..else, page 158
■
Utilisation de l’instruction if..else if, page 159
■
Utilisation de l’instruction switch, page 160
■
Utilisation des instructions try..catch et try..catch..finally, page 162
■
Opérateur conditionnel et syntaxe alternative, page 165
Présentation des instructions
155
Rédaction des conditions
Les instructions qui vérifient l’état d’une condition commencent par le terme if. Si cette
condition renvoie true, ActionScript exécute l’instruction suivante. Si la condition renvoie
(false), ActionScript passe à l’instruction suivante à l’extérieur du bloc de code.
CO NS EIL
Pour optimiser les performances de votre code, vérifiez d’abord les conditions les plus
probables.
Les instructions suivantes testent trois conditions. Le terme else if spécifie d’autres tests à
effectuer si les conditions précédentes sont false.
if ((passwordTxt.text.length == 0) || (emailTxt.text.length == 0)) {
gotoAndStop("invalidLogin");
} else if (passwordTxt.text == userID){
gotoAndPlay("startProgram");
}
Dans ce fragment de code, si la longueur des champs passwordTxt ou emailTxt est 0 (lorsque
l’utilisateur ne les a pas renseignés par exemple), le document Flash redirige vers l’étiquette
d’image invalidLogin. Si les champs passwordTxt et emailTxt contiennent des valeurs et
que leur contenu correspond à la variable userID, le fichier SWF est redirigé vers l’étiquette
d’image startProgram.
Pour vérifier une condition parmi d’autres, utilisez l’instruction switch, plutôt que plusieurs
instructions else if. Pour plus d’informations sur les instructions switch, consultez la
section Utilisation de l’instruction switch, page 160.
Pour apprendre à rédiger les différents types de conditions dans vos applications ActionScript,
consultez les sections suivantes.
Utilisation de l’instruction if
L’instruction if permet d’exécuter une suite d’instructions si une certaine condition est vraie
(true).
// instruction if
if (condition) {
// instructions;
}
Vous utiliserez fréquemment les instructions if lorsque vous travaillerez sur un projet Flash.
Par exemple, si vous construisez un site Flash réclamant l’identification des utilisateurs pour
l’accès à certaines pages, utilisez une instruction if pour vérifier si l’utilisateur a renseigné les
champs Nom d’utilisateur et Mot de passe.
156
Eléments fondamentaux du langage et de la syntaxe
Si le nom d’utilisateur et le mot de passe doivent être validés via une base de données externe,
vous souhaiterez probablement vous assurer que la combinaison nom d’utilisateur/mot de
passe saisie par l’utilisateur correspond à un enregistrement de la base de données. Vous
souhaiterez également vérifier que l’utilisateur est bien autorisé à accéder à la partie du site
spécifiée.
Si vous créez des animations à l’aide de script dans Flash, vous pouvez utiliser l’instruction if
pour vérifier qu’une occurrence de la scène reste dans les limites de celle-ci. Par exemple, si
une balle descend sous l’axe des y, il peut être nécessaire de déceler le moment où elle heurte le
bord inférieur de la scène pour modifier sa direction et la faire rebondir.
Pour utiliser une instruction if :
1.
Choisissez Fichier > Nouveau, puis Document Flash.
2.
Sélectionnez l’image 1 du scénario et saisissez le code ActionScript suivant dans le panneau
Actions :
// Création d’une chaîne pour gérer les heures AM et PM
var amPm:String = "AM";
// aucun paramètre ne renvoie de date, la date/heure en cours est
renvoyée
var current_date:Date = new Date();
// si l’heure en cours est supérieure ou égale à 12, définition de la
chaîne amPm sur « PM ».
if (current_date.getHours() >= 12) {
amPm = "PM";
}
trace(amPm);
3.
Choisissez Contrôle > Tester l’animation pour tester le code ActionScript.
Dans ce code, vous créez une chaîne qui gère la mention AM ou PM en fonction de l’heure
de la journée. Si l’heure est supérieure ou égale à 12, la chaîne amPM est définie sur PM.
Enfin, vous suivez la chaîne amPm et lorsque l’heure devient supérieure ou égale à 12, la
mention PM s’affiche. Dans le cas contraire, la mention AM apparaît.
Présentation des instructions
157
Utilisation de l’instruction if..else
L’instruction conditionnelle if..else permet de tester une condition, puis d’exécuter un
bloc de code lorsque cette condition est positive et d’en exécuter un autre dans le cas contraire.
Par exemple, le code suivant vérifie si la valeur de x est supérieure à 20 et génère une
instruction trace() dans l’affirmative ou une autre instruction trace() dans le cas
contraire :
if (x > 20) {
trace("x is > 20");
} else {
trace("x is <= 20");
}
Si vous ne souhaitez pas exécuter un autre bloc de code, vous pouvez utiliser l’instruction if
sans l’instruction else.
L’instruction if..else est similaire à l’instruction if. Par exemple, si vous utilisez
l’instruction if pour vérifier que le nom et le mot de passe saisis par les utilisateurs
correspondent bien à une valeur stockée dans la base de données, vous pouvez ensuite
rediriger les utilisateurs selon si leurs identifiants sont corrects. En cas d’identification valide,
l’utilisateur peut être dirigé vers une page d’accueil par le bloc if. Si l’identification échoue,
vous pouvez rediriger l’utilisateur vers le formulaire d’identification et afficher un message
d’erreur via le bloc else.
Pour utiliser une instruction if..else dans un document :
1.
Sélectionnez Fichier > Nouveau, puis sélectionnez Document Flash pour créer un nouveau
fichier FLA.
2.
Sélectionnez l’image 1 du scénario et saisissez le code ActionScript suivant dans le panneau
Actions :
// création d’une chaîne chargée de gérer la mention AM/PM en fonction de
l’heure de la journée.
var amPm:String;
// aucun paramètre ne renvoie de date, la date/heure en cours est
renvoyée.
var current_date:Date = new Date();
// si l’heure en cours est supérieure ou égale à 12, définition de la
chaîne amPm sur « PM ».
if (current_date.getHours() >= 12) {
amPm = "PM";
} else {
amPm = "AM";
}
trace(amPm);
158
Eléments fondamentaux du langage et de la syntaxe
3.
Choisissez Contrôle > Tester l’animation pour tester le code ActionScript.
Dans ce code, vous créez une chaîne qui gère la mention AM ou PM en fonction de l’heure
de la journée. Si l’heure est supérieure ou égale à 12, la chaîne amPM est définie sur PM.
Enfin, vous suivez la chaîne amPm et lorsque l’heure devient supérieure ou égale à 12, la
mention PM s’affiche. La mention AM s’affiche dans le panneau de sortie.
Utilisation de l’instruction if..else if
L’instruction conditionnelle if..else if permet de tester plusieurs conditions. L’instruction
if..else if utilise la syntaxe suivante :
// instruction else-if
if (condition) {
// instructions;
} else if (condition) {
// instructions;
} else {
// instructions;
}
Vous pouvez utiliser un bloc if..else if dans vos projets Flash lorsque vous voulez vérifier
une série de conditions. Par exemple, si vous souhaitez afficher à l’écran une image qui diffère
selon l’heure à laquelle l’utilisateur se connecte, vous pouvez créer une suite d’instructions if
qui détermine s’il s’agit du matin, de l’après-midi, du soir ou de la nuit. Vous pouvez ensuite
afficher l’image appropriée.
Le code suivant regarde non seulement si la valeur de x est supérieure à 20, mais également si
la valeur de x est négative :
if (x > 20) {
trace("x is > 20");
} else if (x < 0) {
trace("x is negative");
}
Présentation des instructions
159
Pour utiliser une instruction if..else if dans un document :
1.
Choisissez Fichier > Nouveau, puis Document Flash.
2.
Sélectionnez l’image 1 du scénario et saisissez le code ActionScript suivant dans le panneau
Actions :
var now_date:Date = new Date();
var currentHour:Number = now_date.getHours();
// si l’heure est inférieure à 11 H (AM)...
if (currentHour < 11) {
trace("Good morning");
// sinon.. si l’heure est inférieure à 15 H (3PM)...
} else if (currentHour < 15) {
trace("Good afternoon");
// sinon.. s’il n’est pas encore 20 H (8PM)...
} else if (currentHour < 20) {
trace("Good evening");
// sinon, l’heure est comprise entre 8PM et 11:59PM
} else {
trace("Good night");
}
3.
Choisissez Contrôle > Tester l’animation pour tester le code ActionScript.
Dans ce code, vous créez une chaîne appelée currentHour qui gère le nombre de l’heure
en cours (par exemple, s’il est 6:19 pm, currentHour gère le nombre 18). Pour obtenir
l’heure en cours, utilisez la méthode getHours() de la classe Date. Vous utilisez ensuite
l’instruction if..else if pour envoyer les informations au panneau de sortie, selon le
nombre renvoyé. Pour plus d’informations, consultez les commentaires du fragment de
code précédent.
Utilisation de l’instruction switch
L’instruction switch crée une structure arborescente pour des instructions ActionScript.
Comme pour l’instruction if, l’instruction switch teste une condition et exécute des
instructions si cette condition renvoie la valeur true (vrai).
Dans le cadre d’une instruction switch, l’instruction break force Flash à ignorer le reste des
instructions de ce bloc « case » et passe à la première instruction suivant l’instruction switch
qui l’encadre. Si le bloc « case » ne contient pas d’instruction « break », une condition appelée
« fall through » survient. Dans ce cas, l’instruction « case » suivante s’exécute également
jusqu’à ce que survienne une instruction « break » ou que l’instruction switch se termine. Ce
comportement est illustré dans l’exemple suivant où la première instruction case ne contenant
pas d’instruction break, les deux blocs de code des deux premiers cas (A et B) s’exécutent.
160
Eléments fondamentaux du langage et de la syntaxe
Toutes les instructions switch doivent inclure un cas default. Le cas default doit toujours
être le dernier cas d’une instruction switch et comprendre également une instruction break
afin d’éviter l’apparition d’une erreur fall-through en cas d’ajout d’un autre cas. Par exemple,
si la condition de l’exemple suivant donne A, les deux instructions pour les cas A et B
s’exécutent, dans la mesure où le cas A ne comporte pas d’instruction break. Lorsqu’un cas ne
comporte pas d’instruction break, remplacez ce dernier par un commentaire, comme indiqué
dans l’exemple suivant, après case A. Lorsque vous rédigez des instructions switch, utilisez le
format suivant :
switch (condition) {
case A :
// instructions
// fall-through
case B :
// instructions
break;
case Z :
// instructions
break;
default :
// instructions
break;
}
Pour utiliser une instruction switch dans un document :
1.
Choisissez Fichier > Nouveau, puis Document Flash.
2.
Sélectionnez l’image 1 du scénario et saisissez le code ActionScript suivant dans le panneau
Actions :
var listenerObj:Object = new Object();
listenerObj.onKeyDown = function() {
// Utilisation de la méthode String.fromCharCode() pour renvoyer une
chaîne.
switch (String.fromCharCode(Key.getAscii())) {
case "A" :
trace("you pressed A");
break;
case "a" :
trace("you pressed a");
break;
case "E" :
case "e" :
/* E ne présentant pas d’instruction break, ce bloc s’exécute si
vous appuyez sur e ou E. */
trace("you pressed E or e");
break;
case "I" :
case "i" :
Présentation des instructions
161
trace("you pressed I or i");
break;
default :
/* Si la touche enfoncée ne correspond à aucun des cas ci-dessus, le
cas default s’exécute. */
trace("you pressed some other key");
}
};
Key.addListener(listenerObj);
3.
Choisissez Contrôle > Tester l’animation pour tester le code ActionScript.
Tapez des lettres au clavier, y compris les lettres a, e ou i. Lorsque vous appuyez sur ces
trois touches, les instructions trace apparaissent dans le code ActionScript précédent. La
ligne de code crée un nouvel objet que vous utilisez comme écouteur de la classe Key. Vous
utilisez cet objet pour notifier l’événement onKeyDown() lorsque l’utilisateur appuie sur
une touche. La méthode Key.getAscii() renvoyant le code ASCII de la dernière touche
pressée ou relâchée par l’utilisateur, vous n’avez pas besoin d’utiliser la méthode
String.fromCharCode() pour renvoyer une chaîne contenant les caractères représentés
par les valeurs ASCII dans les paramètres. Le cas « E » ne présentant pas d’instruction
break, le bloc s’exécute si l’utilisateur appuie sur la touche e ou E. Si la touche pressée ne
correspond à aucun des trois premiers cas, le cas default s’exécute.
Utilisation des instructions try..catch et try..catch..finally
L’utilisation des blocs try..catch..finally vous permet d’ajouter un traitement des erreurs
dans vos applications Flash. Les mots-clés try..catch..finally vous permettent d’entourer
un bloc de code dans lequel une erreur peut survenir, et de réagir à cette erreur. Lorsqu’un
code figurant dans le bloc try renvoie une erreur (via l’instruction throw), le contrôle est
transmis au bloc catch lorsque ce dernier existe. Le contrôle est ensuite transmis au bloc de
code finally, s’il en existe un. Le bloc finally facultatif s’exécute toujours, qu’une erreur ait
été renvoyée ou non.
Si le code figurant dans le bloc try ne renvoie pas d’erreur (s’il se termine normalement), le
code du bloc finally est tout de même exécuté.
R E M AR QU E
Le bloc finally s’exécute même si le bloc try se termine avec une instruction return.
Rédigez les instructions try..catch et try..catch..finally à l’aide du format suivant :
// try-catch
try {
162
Eléments fondamentaux du langage et de la syntaxe
// instructions
} catch (myError) {
// instructions
}
//try-catch-finally
try {
// instructions
} catch (myError) {
// instructions
} finally {
// instructions
}
Chaque fois que votre code renvoie une erreur, vous pouvez rédiger des gestionnaires d’erreurs
pour traiter cette défaillance en douceur et prendre les mesures appropriées. Vous pouvez
tenter de charger des données externes depuis un service Web ou un fichier texte ou afficher
un message d’erreur à l’utilisateur. Vous pouvez même utiliser le bloc catch pour tenter de
vous connecter à un service Web qui signale l’erreur à l’administrateur, de sorte qu’il puisse
vérifier le bon fonctionnement de l’application.
Pour utiliser le bloc try..catch..finally pour valider les données avant de diviser
certains nombres :
1.
Choisissez Fichier > Nouveau, puis Document Flash.
2.
Sélectionnez l’image 1 du scénario et saisissez le code ActionScript suivant dans le panneau
Actions :
var n1:Number = 7;
var n2:Number = 0;
try {
if (n2 == 0) {
throw new Error("Unable to divide by zero");
}
trace(n1/n2);
} catch (err:Error) {
trace("ERROR! " + err.toString());
} finally {
delete n1;
delete n2;
}
3.
Sélectionnez Contrôle > Tester l’animation pour tester le document.
4.
Le panneau de sortie affiche le message Unable to divide by zero (Division par zéro
impossible).
Présentation des instructions
163
5.
Revenez dans l’environnement de programmation et modifiez la ligne de code suivante :
var n2:Number = 0;
en
var n2:Number = 2;
6.
Choisissez Contrôle > Tester l’animation pour tester de nouveau le document.
Si la valeur de n2 est égale à zéro, une erreur est renvoyée et récupérée par le bloc catch
qui affiche un message dans le panneau de sortie. Si la valeur de y est différente de zéro, le
panneau de sortie présente le résultat de n1 divisé par n2. Le bloc finally s’exécute dans
tous les cas et supprime les valeurs des variables n1 et n2 du document Flash.
Vous n’êtes pas limité au renvoi de nouvelles occurrences de la classe Error lorsqu’une erreur
survient. Vous pouvez également étendre cette classe pour créer vos propres erreurs
personnalisées, comme l’illustre l’exemple suivant.
Pour créer une erreur personnalisée :
1.
Choisissez Fichier > Nouveau et créez un fichier ActionScript.
2.
Choisissez Fichier > Enregistrer sous et nommez le fichier DivideByZeroException.as.
3.
Saisissez le code ActionScript suivant dans la fenêtre de script :
// Dans DivideByZeroException.as:
class DivideByZeroException extends Error {
var message:String = "Divide By Zero error";
}
4.
Enregistrez le fichier ActionScript.
5.
Créez un nouveau document Flash nommé exception_test.fla dans le même répertoire que
le fichier ActionScript et enregistrez-le.
6.
Dans le panneau Actions, saisissez le code ActionScript suivant sur l’image 1 du scénario
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());
}
164
Eléments fondamentaux du langage et de la syntaxe
7.
Enregistrez le document Flash, puis choisissez Contrôle > Tester l’animation pour tester le
fichier dans l’environnement de test.
La valeur de n2 étant égale à 0, Flash renvoie votre classe d’erreur personnalisée
DivideByZeroException et affiche le message Divide By Zero error dans le panneau de
sortie. Si, à la ligne deux, vous modifiez la valeur de n2 de 0 en -1, et testez de nouveau le
document Flash, le message An unknown error occurred; n2 cannot be less than
zero (Erreur inconnue. n2 ne peut pas être inférieur à zéro) apparaît dans le panneau de
sortie. La saisie de n’importe quelle valeur n2 supérieure à 0 entraîne l’affichage du résultat
de la division dans le panneau de sortie. Pour plus d’informations sur la création de classes
personnalisées, consultez le Chapitre 7, Classes, page 243.
Opérateur conditionnel et syntaxe alternative
Si vous aimez les raccourcis, vous pouvez utiliser l’opérateur conditionnel (?:), également
appelé expressions conditionnelles. L’opérateur conditionnel permet de convertir des
instructions if..else simples en une seule ligne de code. Il permet donc de réduire la
quantité de code rédigé dans un même objectif, mais le rend du même coup plus difficile à
lire.
La condition suivante est écrite en version longue et permet de vérifier que la variable numTwo
est supérieure à zéro, ce qui renvoie le résultat numOne/numTwo ou une chaîne de carrot :
var numOne:Number = 8;
var numTwo:Number = 5;
if (numTwo > 0) {
trace(numOne / numTwo); // 1.6
} else {
trace("carrot");
}
L’utilisation d’une expression conditionnelle permet d’écrire ce même code dans le format
suivant :
var numOne:Number = 8;
var numTwo:Number = 0;
trace((numTwo > 0) ? numOne/numTwo : "carrot");
Comme vous pouvez le voir, la syntaxe abrégée nuit à la lisibilité et doit donc être évitée. Si
vous êtes obligé d’utiliser des opérateurs conditionnels, placez la première condition (avant le
point d’interrogation [?]) entre parenthèses. Cette précaution améliore la lisibilité du code
ActionScript. Vous trouverez ci-dessous un exemple de code ActionScript dont la lisibilité a
été améliorée :
var numOne:Number;
(numOne >= 5) ? numOne : -numOne;
Présentation des instructions
165
Vous pouvez écrire une instruction conditionnelle qui renvoie une valeur booléenne, comme
dans l’exemple suivant :
if (cartArr.length > 0) {
return true;
} else {
return false;
}
Cependant, comparé avec le code précédent, le code ActionScript de l’exemple suivant est
préférable :
return (cartArr.length > 0);
Le deuxième fragment de code est plus concis et comporte moins d’expressions à évaluer. Il est
plus facile à lire et à comprendre.
Lorsque vous écrivez des conditions complexes, il est conseillé de les regrouper entre
parenthèses [()]. Si vous n’utilisez pas de parenthèses, vous (ou toute autre personne
travaillant sur le code ActionScript) risquez de subir des erreurs au niveau de la priorité des
opérateurs. Pour plus d’informations sur la priorité des opérateurs, consultez la section Priorité
et associativité des opérateurs, page 194.
Par exemple, le code suivant ne met pas la condition entre parenthèses :
if (fruit == "apple" && veggie == "leek") {}
Le code suivant met les conditions entre parenthèses de manière appropriée :
if ((fruit == "apple") && (veggie == "leek")) {}
Répétition d’actions à l’aide de boucles
ActionScript peut répéter une action un certain nombre de fois ou tant qu’une condition
spécifique existe. Les boucles permettent de répéter une suite d’instructions lorsqu’une
condition particulière est true (vraie). Il existe quatre types de boucles dans ActionScript :
for, for..in, while et do..while. Chaque type de boucle se comporte légèrement
différemment et sert des objectifs distincts.
166
Eléments fondamentaux du langage et de la syntaxe
La plupart des boucles utilisent un compteur d’un certain type pour contrôler le nombre
d’exécutions d’une boucle. Chaque exécution d’une boucle est appelée itération. Vous pouvez
déclarer une variable et rédiger une instruction qui augmente ou diminue sa valeur à chaque
exécution de la boucle. Dans l’action for, le compteur et l’instruction qui l’incrémente font
partie de l’action.
Boucle
Description
Boucles for
Répéter une action en utilisant un compteur intégré.
Boucles for..in
Effectuer une itération sur les enfants d’un clip ou d’un objet.
Boucles while
Répéter une action tant qu’une condition est vraie.
Boucles do..while
Similaires aux boucles while, sauf que l’expression est évaluée à la fin
du bloc de code et la boucle est toujours exécutée au moins une fois.
La plus répandue est la boucle for, qui passe sur un bloc de code un nombre de fois prédéfini.
Par exemple, pour exécuter une série d’instructions sur chaque élément d’un tableau, utilisez
une boucle for et exécutez-la de 0 jusqu’au nombre d’éléments du tableau. La boucle
for..in est également très utile lorsque vous souhaitez faire une boucle sur chaque paire
nom/valeur d’un objet, puis exécuter un type d’action spécifique. Cela peut se révéler très
pratique lors du débogage de projets Flash si vous devez afficher les valeurs chargées à partir de
sources externes, telles que des services Web ou des fichiers texte/XML externes. Les deux
derniers types de boucles (while et do..while) sont très pratiques lorsqu’il s’agit de passer en
boucle sur une série d’instructions, sans nécessairement connaître le nombre de passages
nécessaires. Dans ce cas, utilisez une boucle while qui tourne tant qu’une certaine condition
est vraie.
ActionScript peut répéter une action un certain nombre de fois ou tant qu’une condition
spécifique existe. Utilisez les actions while, do..while, for et for..in pour créer des
boucles. Cette section présente des informations générales sur ces boucles. Pour plus
d’informations sur chacune de ces boucles, consultez les procédures suivantes.
Présentation des instructions
167
Pour répéter une action tant qu’une condition existe :
■
Utilisez l’instruction while.
La boucle while évalue une expression et exécute le code dans le corps de la boucle si
l’expression est true. L’expression est évaluée à nouveau après l’exécution de chaque
instruction du corps. Dans l’exemple suivant, la boucle est exécutée à quatre reprises :
var i:Number = 4;
while (i > 0) {
myClip.duplicateMovieClip("newMC" + i, i, {_x:i*20, _y:i*20});
i--;
}
Vous pouvez utiliser l’instruction do..while pour créer le même genre de boucle qu’avec
une boucle while. Dans une boucle do..while, l’expression est évaluée à la fin du bloc de
code et la boucle est toujours exécutée au moins une fois.
Ceci est illustré par l’exemple suivant :
var i:Number = 4;
do {
myClip.duplicateMovieClip("newMC" + i, i, {_x:i*20, _y:i*20});
i--;
} while (i > 0);
Pour plus d’informations sur l’instruction while, consultez la section Utilisation des
boucles while, page 174.
Pour répéter une action en utilisant un compteur intégré :
■
Utilisez l’instruction for.
La plupart des boucles utilisent un compteur d’un certain type pour contrôler le nombre
d’exécutions d’une boucle. Chaque exécution d’une boucle est appelée itération. Vous
pouvez déclarer une variable et rédiger une instruction qui augmente ou diminue sa valeur
à chaque exécution de la boucle. Dans l’action for, le compteur et l’instruction qui
l’incrémente font partie de l’action.
Dans l’exemple suivant, la première expression (var i:Number = 4) est l’expression
initiale qui est évaluée avant la première itération. La deuxième expression (i > 0) est la
condition contrôlée avant chaque exécution de la boucle. La troisième expression (i--) est
appelée post-expression et est évaluée après chaque exécution de la boucle.
for (var i:Number = 4; i > 0; i--) {
myClip.duplicateMovieClip("newMC" + i, i, {_x:i*20, _y:i*20});
}
Pour plus d’informations sur l’instruction for, consultez la section Utilisation des
for, page 171.
168
Eléments fondamentaux du langage et de la syntaxe
boucles
Pour passer en boucle sur les enfants d’un clip ou d’un objet :
■
Utilisez l’instruction for..in.
Les enfants sont composés d’autres clips, fonctions, objets et variables. L’exemple suivant
utilise l’instruction trace pour envoyer les résultats dans le panneau de sortie :
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]);
}
Cet exemple donne les résultats suivants dans le panneau de sortie :
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
Vous pouvez souhaiter que votre script boucle sur un type particulier d’enfants, par
exemple, seulement sur les enfants d’un clip. Pour ce faire, utilisez for..in en
conjonction avec l’opérateur typeof. Dans l’exemple suivant, une occurrence de clip
enfant (appelée occurrence2) est située dans une occurrence de clip sur la scène. Ajoutez
l’ActionScript suivant à l’Image 1 du scénario :
for (var myName in this) {
if (typeof (this[monNom]) == "clip") {
trace("J’ai un clip enfant appelé " + monNom);
}
}
Pour plus d’informations sur l’instruction for..in, consultez la section Utilisation des
boucles for..in, page 172.
AVERTISSEMENT
Dans Flash, les itérations s’exécutent très rapidement dans Flash Player, mais les
boucles dépendent essentiellement du processeur. La quantité de ressources
consommées par le processeur évolue en fonction du nombre d’itérations de la
boucle et du nombre d’instructions exécutées dans chaque bloc. Les boucles mal
écrites peuvent générer des problèmes de performance et de stabilité.
Pour plus d’informations sur chaque instruction, consultez les sections suivantes de ce
chapitre, telles que Utilisation des boucles while, page 174, et leurs entrées respectives dans le
Guide de référence du langage ActionScrip 2.0.
Présentation des instructions
169
Création et terminaison des boucles
L’exemple suivant présente un simple tableau de noms de mois. Une boucle for itère de 0 au
nombre d’éléments présents dans le tableau et affiche chaque élément dans le panneau de
sortie.
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]);
}
Lorsque vous manipulez des tableaux, simples ou complexes, vous devez connaître la
condition appelée boucle sans fin. Comme son nom l’indique, il s’agit d’une boucle qui n’a
aucune condition de fin. Cela entraîne un véritable problème (le blocage de votre application
Flash) : votre document Flash ne répond plus dans le navigateur Web ou a un comportement
incohérent. Le code suivant est un exemple de boucle sans fin :
// MAUVAIS CODE- crée une boucle sans fin
// A vos risques et périls !
var i:Number;
for (i = 0; i < 10; i--) {
trace(i);
}
La valeur de i est initialisée sur 0 et la condition de fin survient lorsque i est supérieur ou égal
à 10, la valeur de i étant décrémentée après chaque itération. L’erreur vous saute
probablement déjà aux yeux : si la valeur de i diminue après chaque itération, la condition de
fin n’arrive jamais. Le résultat varie selon les ordinateurs, et la rapidité du blocage dépend de la
cadence du processeur et d’autres facteurs. Par exemple, la boucle s’exécute environ 142 620
fois avant d’afficher un message d’erreur sur un ordinateur donné.
Le message d’erreur suivant s’affiche dans une boîte de dialogue :
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?
Lorsque vous utilisez des boucles (et en particulier while et do..while), n’oubliez jamais de
vérifier que la boucle peut se terminer correctement, et ne continue pas sans fin.
Pour plus d’informations sur le contrôle des boucles, consultez la section Utilisation de
l’instruction switch, page 160.
170
Eléments fondamentaux du langage et de la syntaxe
Utilisation des boucles for
La boucle for permet de faire une itération sur une variable dans une plage de valeurs
spécifiques. La boucle for est très utile lorsque vous savez exactement combien de fois une
série d’instructions ActionScript doit être répétée. Elle peut se révéler très utile lorsque vous
souhaitez dupliquer un clip de la scène un certain nombre de fois ou passer en boucle dans un
tableau et exécuter une tâche sur chacun de ses éléments. La boucle for répète une action à
l’aide d’un compteur intégré. Le compteur et l’instruction qui l’incrémente font tous deux
partie de l’instruction for. Rédigez les instructions for au format suivant :
for (init; condition; update) {
// instructions;
}
Vous devez fournir trois expressions dans une instruction for : une variable définie sur une
valeur initiale, une instruction conditionnelle qui détermine le moment où la boucle prend fin
et une expression qui modifie la valeur de la variable à chaque boucle. Par exemple, le code
suivant boucle à cinq reprises. La valeur de la variable i commence à 0 et termine à 4. La sortie
indique les nombres 0 à 4, chacun sur sa propre ligne.
var i:Number;
for (i = 0; i < 5; i++) {
trace(i);
}
Dans l’exemple suivant, la première expression (i = 0) est l’expression initiale évaluée avant la
première itération. La deuxième expression (i < 5) est la condition contrôlée avant chaque
exécution de la boucle. La troisième expression (i++) est appelée post-expression et est évaluée
après chaque exécution de la boucle.
Pour créer une boucle for :
1.
Choisissez Fichier > Nouveau, puis Document Flash.
2.
Créez un clip sur la scène.
3.
Dans le panneau Bibliothèque, cliquez du bouton droit sur le symbole du clip et choisissez
Liaison dans le menu contextuel.
4.
Cochez la case Exporter pour ActionScript, puis tapez libraryLinkageClassName dans le
champ Classe. Cliquez sur OK.
5.
Sélectionnez l’image 1 du scénario et saisissez le code ActionScript suivant dans le panneau
Actions :
var i:Number;
for (i = 0; i < 5; i++) {
this.attachMovie("libraryLinkageClassName", "clip" + i + "_mc", i,
{_x:(i * 100)});
}
Présentation des instructions
171
6.
Choisissez Contrôle > Tester l’animation pour tester le code dans Flash Player.
Remarquez la duplication des cinq clips en haut de la scène. Ce code ActionScript
reproduit le symbole de clip de la bibliothèque et repositionne les clips sur la scène, aux
coordonnées x de 0, 100, 200, 300 et 400 pixels. La boucle s’exécute à cinq reprises, une
valeur comprise entre 0 et 4 étant affectée à la variable i. A la dernière itération, la valeur
de i devient 4 et la seconde expression (i < 5) n’étant plus vraie, la boucle s’arrête.
Vous devez inclure un espace après chaque expression d’une instruction for. Pour plus
d’informations, reportez-vous à for statement dans le Guide de référence du langage
ActionScript 2.0.
Utilisation des boucles for..in
L’instruction for..in permet d’exécuter une boucle (ou de faire une itération) sur les enfants
d’un clip, les propriétés d’un objet ou les éléments d’un tableau. Les enfants, référencés
précédemment, sont composés d’autres clips, fonctions, objets et variables. La boucle for..in
est souvent utilisée pour passer en boucle sur les occurrences d’un scénario ou sur les paires
clé/valeur d’un objet. Ce passage en boucle sur des objets se révèle efficace pour déboguer les
applications car il permet de voir les données renvoyées par les services Web ou les documents
externes, tels que les fichiers texte ou XML.
Par exemple, utilisez une boucle for...in pour faire une itération sur les propriétés d’un
objet générique (les propriétés d’un objet n’étant pas conservées dans un ordre particulier, elles
apparaissent dans un ordre imprévisible) :
var myObj:Object = {x:20, y:30};
for (var i:String in myObj) {
trace(i + ": " + myObj[i]);
}
Ce code donne les résultats suivants dans le panneau de sortie :
x: 20
y: 30
Vous pouvez également faire une itération sur les éléments d’un tableau :
var myArray:Array = ["one", "two", "three"];
for (var i:String in myArray) {
trace(myArray[i]);
}
172
Eléments fondamentaux du langage et de la syntaxe
Ce code donne les résultats suivants dans le panneau de sortie :
three
two
one
Pour plus d’informations sur les objets et les propriétés, consultez la section Type de données
Object, page 85.
REMARQUE
Vous ne pouvez pas itérer sur les propriétés d’un objet lorsqu’il s’agit d’une occurrence
de classe personnalisée, sauf si la classe est dynamique. Et même dans ce dernier cas,
vous ne pouvez faire d’itération que sur les propriétés ajoutées dynamiquement.
REMARQUE
Les accolades ({}), qui servent normalement à entourer le bloc d’instructions que la
boucle for..in doit exécuter, peuvent être omises si une seule instruction s’exécute.
L’exemple suivant utilise une boucle for..in sur les propriétés d’un objet :
Pour créer une boucle for :
1.
Choisissez Fichier > Nouveau, puis Document Flash.
2.
Sélectionnez l’image 1 du scénario et saisissez le code ActionScript suivant dans le panneau
Actions :
var myObj:Object = {name:"Tara", age:27, city:"San Francisco"};
var i:String;
for (i in myObj) {
trace("myObj." + i + " = " + myObj[i]);
}
3.
Choisissez Contrôle > Tester l’animation pour tester le code dans Flash Player.
Lorsque vous testez le fichier SWF, le message suivant s’affiche dans le panneau de sortie :
myObj.name = Tara
myObj.age = 27
myObj.city = San Francisco
Si vous écrivez une boucle for..in dans un fichier de classe (fichier ActionScript externe), les
membres de l’occurrence ne seront plus disponibles dans la boucle, contrairement aux
membres statiques. Cependant, si vous écrivez une boucle for..in dans un fichier FLA pour
une occurrence de la classe, les membres de l’occurrence restent disponibles, mais pas les
membres statiques. Pour plus d’informations sur la rédaction de fichiers de classe, consultez le
Chapitre 7, Classes, page 243. Pour plus d’informations, reportez-vous à for..in statement
dans le Guide de référence du langage ActionScript 2.0.
Présentation des instructions
173
Utilisation des boucles while
L’instruction while permet de répéter une action tant qu’une condition existe, comme
l’instruction if qui se répète tant que la condition est true (vraie).
Une boucle while évalue une expression et exécute le code présent dans la boucle si
l’expression est true. Si la condition renvoie true, une instruction ou une série d’instructions
est exécutée avant de revenir en arrière et d’évaluer de nouveau la condition. Lorsque la
condition renvoie false (faux), l’instruction ou la série d’instructions est ignorée et la boucle
se termine. Les boucles while se révèlent très utiles lorsque vous ne savez pas précisément
combien de boucles doivent être exécutées sur un bloc de code.
Par exemple, ce code envoie les nombres suivants dans le panneau de sortie :
var i:Number = 0;
while (i < 5) {
trace(i);
i++;
}
Les nombres suivants doivent s’afficher dans le panneau de sortie :
0
1
2
3
4
L’un des inconvénients de while par rapport à for est que les risques de boucles sans fin sont
plus importants avec les boucles while. Par exemple, le code qui utilise la boucle for ne
passera pas la compilation si vous omettez l’expression qui incrémente la variable du
compteur, alors que le code qui utilise la boucle while sera compilé. Et sans l’expression qui
incrémente i, la boucle se poursuit sans fin.
Pour créer et utiliser une boucle while dans un fichier FLA, procédez comme dans cet
exemple.
Pour créer une boucle while :
1.
Choisissez Fichier > Nouveau, puis Document Flash.
2.
Ouvrez le panneau Composants et faites glisser un composant DataSet sur la scène.
3.
Ouvrez l’inspecteur des propriétés (Fenêtre > Propriétés > Propriétés) et entrez le nom
d’occurrence users_ds.
4.
Sélectionnez l’image 1 du scénario et saisissez le code ActionScript suivant dans le panneau
Actions :
var users_ds:mx.data.components.DataSet;
//
users_ds.addItem({name:"Irving", age:34});
174
Eléments fondamentaux du langage et de la syntaxe
users_ds.addItem({name:"Christopher", age:48});
users_ds.addItem({name:"Walter", age:23});
//
users_ds.first();
while (users_ds.hasNext()) {
trace("name:" + users_ds.currentItem["name"] + ", age:" +
users_ds.currentItem["age"]);
users_ds.next();
}
5.
Sélectionnez Contrôle > Tester l’animation pour tester le document.
Les informations suivantes apparaissent dans le panneau de sortie :
name:Irving, age:34
name:Christopher, age:48
name:Walter, age:23
Pour plus d’informations, reportez-vous à while statement dans le Guide de référence du
langage ActionScript 2.0.
Présentation des boucles do..while
Vous pouvez utiliser l’instruction do..while pour créer le même genre de boucle qu’avec une
boucle while. Toutefois, dans une boucle do..while, l’expression est évaluée à la fin du bloc
de code (après son exécution) et la boucle est toujours exécutée au moins une fois. Les
instructions ne sont exécutées que lorsque la condition est true (vraie).
Le code suivant présente un exemple simple de boucle do..while générant une sortie même
lorsque la condition n’est pas remplie.
var i:Number = 5;
do {
trace(i);
i++;
} while (i < 5);
// Sortie : 5
Lorsque vous utilisez des boucles, faites attention à ne pas créer de boucle sans fin. Si la
condition d’une boucle do..while renvoie true (vrai) en permanence, une boucle sans fin est
créée et entraîne l’affichage d’un avertissement ou le blocage de Flash Player. Si vous
connaissez le nombre d’itérations nécessaires, choisissez plutôt une boucle for. Pour plus
d’informations et des exemples de do..while statement, consultez le Guide de référence du
langage ActionScript 2.0.
Présentation des instructions
175
Utilisation de boucles imbriquées dans le code ActionScript
L’exemple suivant décrit la construction d’un tableau d’objets et l’affichage de chaque valeur
dans la structure imbriquée. Cet exemple présente l’utilisation de la boucle for pour effectuer
une itération sur chaque élément du tableau et de la boucle for..in pour effectuer une
itération sur chaque paire clé/valeur dans les objets imbriqués.
Pour imbriquer une boucle dans une autre :
1.
Créez un nouveau document Flash.
2.
Choisissez Fichier > Enregistrer sous et nommez le document loops.fla.
3.
Ajoutez le code suivant à l’image 1 du scénario :
var myArr:Array = new Array();
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.
Choisissez Contrôle > Tester l’animation pour tester votre code.
Les informations suivantes apparaissent dans le panneau de sortie.
0
name: One
value: 1
1
name: Two
value: 2
Comme vous connaissez le nombre d’éléments présents dans le tableau, vous pouvez
utiliser une simple boucle for pour passer sur chaque élément. Chaque objet du tableau
pouvant présenter des paires nom/valeur différentes, vous pouvez utiliser une boucle
for..in pour effectuer une itération sur chaque valeur et afficher les résultats dans le
panneau de sortie.
176
Eléments fondamentaux du langage et de la syntaxe
Présentation des tableaux
Un tableau est un objet dont les propriétés sont identifiées par des nombres représentant leurs
positions dans la structure. Avant tout, un tableau est une liste d’éléments. Il est important de
ne pas oublier que tous les éléments d’un tableau ne sont pas obligatoirement du même type
de données. Vous pouvez combiner des nombres, des dates, des chaînes, des objets ou même
ajouter un tableau imbriqué dans chaque index de tableau.
L’exemple suivant présente un simple tableau de noms de mois.
var myArr:Array = new Array();
myArr[0] = "January";
myArr[1] = "February";
myArr[2] = "March";
myArr[3] = "April";
Le tableau précédent de noms de mois peut également être réécrit comme suit :
var myArr:Array = new Array("January", "February", "March", "April");
Vous pouvez également utiliser une syntaxe abrégée :
var myArr:Array = ["January", "February", "March", "April"];
Un tableau correspond à une structure de données. On peut le comparer à un bâtiment au
sein duquel chaque étage contiendrait un morceau de données différent (tel que la
comptabilité au niveau 3 et l’ingénierie au niveau 5). Ainsi, il est possible de stocker des types
de données différents, y compris d’autres tableaux, dans un même tableau. Chaque niveau du
bâtiment peut contenir de nombreux types de contenus (la direction et la comptabilité peuvent
partager le niveau 3).
Le tableau contient des éléments, qui correspondent à chaque étage du bâtiment. Chaque
élément occupe une position numérique (l’index), à laquelle vous faites référence dans le
tableau. De la même façon, chaque niveau du bâtiment est associé à un numéro d’étage.
Chaque élément peut contenir une part de données (un nombre, une chaîne, une valeur
booléenne ou même un tableau ou un objet) ou être vide.
Vous pouvez également contrôler et modifier le tableau lui-même. Par exemple, vous pouvez
déménager le service d’ingénierie au rez-de-chaussée du bâtiment. Les tableaux vous
permettent de déplacer les valeurs qu’ils contiennent et de modifier leur taille (disons de
rénover le bâtiment et d’ajouter ou de supprimer des étages). Ainsi, vous pouvez ajouter ou
supprimer des éléments et déplacer les valeurs vers d’autres éléments.
De ce fait, le bâtiment (tableau) contient des étages (éléments) numérotés (index), et chaque
étage contient un ou plusieurs services (valeurs).
Présentation des tableaux
177
Pour plus d’informations sur la modification des tableaux, consultez la section Modification
des tableaux, page 180. Pour plus d’informations sur l’utilisation des tableaux et des index,
consultez la section Utilisation des tableaux, page 178. Pour plus d’informations sur l’ajout ou
la suppression d’éléments, consultez la section Ajout et suppression d’éléments, page 182. Pour
plus d’informations sur l’opérateur d’accès au tableau, consultez la section Utilisation des
opérateurs point et d’accès au tableau, page 200.
Vous trouverez un exemple de fichier source, array.fla, dans le dossier Samples de votre disque
dur. Cet exemple illustre la manipulation des tableaux à l’aide d’ActionScript. Le code de cet
exemple crée un tableau et trie, ajoute et supprime des éléments de deux composants List.
Trouvez le fichier d’exemple dans les répertoires suivants :
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\Arrays.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Arrays.
Utilisation des tableaux
Vous pouvez utiliser des tableaux de différentes manières dans vos projets. Vous pouvez y
stocker des listes d’objets, par exemple un lot d’articles renvoyés. Si vous chargez les données à
partir de serveurs Web distants, vous pouvez même les recevoir sous forme de tableaux
d’objets imbriqués. Les tableaux contiennent souvent des données de format similaire. Par
exemple, si vous développez une application audio dans Flash, vous pouvez stocker la liste de
lecture de l’utilisateur sous forme de tableau d’informations sur les chansons, stockées dans
des objets. Chaque objet contient le titre du morceau, le nom de l’interprète, la durée de la
chanson, l’emplacement du ficher audio (par exemple MP3) ou toute autre information
devant être associée à un fichier particulier.
L’emplacement d’un élément au sein du tableau est appelé index. Tous les tableaux sont basés
sur zéro, ce qui signifie que le premier élément du tableau est [0], le deuxième est [1], etc.
Il existe différents types de tableaux, comme vous le découvrirez dans les sections suivantes.
Les tableaux les plus courants utilisent un index numérique pour rechercher un élément
particulier dans un tableau indexé. Le second type de tableau, appelé tableau associatif,
recherche les informations à l’aide d’un index de texte, non numérique. Pour plus
d’informations sur les tableaux les plus courants, consultez la section Présentation des tableaux,
page 177. Pour plus d’informations sur les tableaux associatifs, consultez la section Création de
tableaux associatifs, page 187. Pour plus d’informations sur les tableaux multidimensionnels,
consultez la section Création de tableaux multidimensionnels, page 184. Pour plus
d’informations sur l’opérateur d’accès au tableau, consultez la section Utilisation des opérateurs
point et d’accès au tableau, page 200.
178
Eléments fondamentaux du langage et de la syntaxe
La classe intégrée Array vous permet d’accéder aux tableaux et de les manipuler. Pour créer un
objet Array, utilisez le constructeur new Array() ou l’opérateur d’accès au tableau ([]). Pour
accéder aux éléments d’un tableau, utilisez également l’opérateur d’accès ([]). L’exemple
suivant utilise un tableau indexé.
Pour utiliser des tableaux dans votre code :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom basicArrays.fla.
2.
Ajoutez l’ActionScript suivant à l’Image 1 du scénario :
// définition d’un nouveau tableau
var myArr:Array = new Array();
// définition des valeurs de deux index
myArr[1] = "value1";
myArr[0] = "value0";
// itération sur les éléments du tableau
var i:String;
for (i in myArr) {
// suivi des paires clé/valeur
trace("key: " + i + ", value: " + myArr[i]);
}
Dans la première ligne de code ActionScript, vous définissez un nouveau tableau pour
stocker les valeurs. Vous définissez ensuite les données (value0 et value1) sur deux index
du tableau. Vous utilisez une boucle for..in pour faire une itération sur chaque élément
de ce tableau et afficher les paires clé/valeur dans le panneau de sortie à l’aide d’une
instruction trace.
3.
Choisissez Contrôle > Tester l’animation pour tester votre code.
Le texte suivant apparaît dans le panneau de sortie :
key: 0, value: value0
key: 1, value: value1
Pour plus d’informations sur les boucles for..in, consultez la section Utilisation des
boucles for..in, page 172.
Pour plus d’informations sur la création des différents types de tableaux, consultez les sections
suivantes :
■
Création de tableaux indexés, page 183
■
Création de tableaux multidimensionnels, page 184
■
Création de tableaux associatifs, page 187
Vous trouverez un exemple de fichier source, array.fla, dans le dossier Samples de votre disque
dur. Cet exemple illustre la manipulation des tableaux à l’aide d’ActionScript. Le code de cet
exemple crée un tableau et trie, ajoute et supprime des éléments de deux composants List.
Trouvez le fichier d’exemple dans les répertoires suivants :
Présentation des tableaux
179
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\Arrays.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Arrays.
Modification des tableaux
Vous pouvez également contrôler et modifier le tableau avec ActionScript. Vous pouvez
déplacer des valeurs dans le tableau ou modifier la taille de celui-ci. Par exemple, pour
échanger les données de deux index d’un tableau, vous pouvez utiliser le code suivant :
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
Vous vous demandez peut-être pourquoi vous avez dû créer une variable temporaire dans
l’exemple précédent. En fait, la copie du contenu de l’index 4 du tableau dans l’index 2 et vice
versa, aurait entraîné la perte du contenu original de l’index 2 du tableau. En copiant la valeur
de l’un des index dans une variable temporaire, vous enregistrez la valeur et la recopiez ensuite
dans votre code. Par exemple, si vous utilisez le code suivant, vous pouvez voir que la valeur de
l’index 2 du tableau (Accounting) a été perdue. Vous avez maintenant deux équipes
d’ingénieurs mais plus de comptables.
// méthode incorrecte (pas de variable temporaire)
buildingArr[2] = buildingArr[4];
buildingArr[4] = buildingArr[2];
trace(buildingArr); //
undefined,undefined,Engineering,undefined,Engineering
Vous trouverez un exemple de fichier source, array.fla, dans le dossier Samples de votre disque
dur. Cet exemple illustre la manipulation des tableaux à l’aide d’ActionScript. Le code de cet
exemple crée un tableau et trie, ajoute et supprime des éléments de deux composants List.
Trouvez le fichier d’exemple dans les répertoires suivants :
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\Arrays.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Arrays.
180
Eléments fondamentaux du langage et de la syntaxe
Référencement et recherche de longueur
Pour manipuler les tableaux, il est souvent nécessaire de connaître le nombre d’éléments qu’ils
contiennent. Cette information se révèle très utile pour l’écriture des boucles for chargées
d’effectuer une itération sur chaque élément du tableau et d’exécuter une série d’instructions.
Le code suivant en est un exemple :
var monthArr:Array = new Array("Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
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
Dans l’exemple précédent, vous créez un tableau et le remplissez avec les noms de mois. Le
contenu est affiché, de même que la longueur du tableau. Une boucle for fait une itération
sur chaque élément du tableau, met la valeur en majuscule, et le contenu du tableau est affiché
de nouveau.
Dans le code ActionScript suivant, si vous créez un élément à l’index 5 d’un tableau, la
longueur du tableau renvoie 6 (le tableau étant basé sur zéro), et non le nombre réel
d’éléments du tableau auquel vous vous attendiez :
var myArr:Array = new Array();
myArr[5] = "five";
trace(myArr.length); // 6
trace(myArr); // undefined,undefined,undefined,undefined,undefined,five
Pour plus d’informations sur les boucles for, consultez la section Utilisation des boucles for,
page 171. Pour plus d’informations sur l’opérateur d’accès au tableau, consultez la section
Utilisation des opérateurs point et d’accès au tableau, page 200.
Vous trouverez un exemple de fichier source, array.fla, dans le dossier Samples de votre disque
dur. Cet exemple illustre la manipulation des tableaux à l’aide d’ActionScript. Le code de cet
exemple crée un tableau et trie, ajoute et supprime des éléments de deux composants List.
Trouvez le fichier d’exemple dans les répertoires suivants :
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\Arrays.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Arrays.
Présentation des tableaux
181
Ajout et suppression d’éléments
Chaque élément d’un tableau occupe une position numérique (l’index), à laquelle vous faites
référence. Chaque élément peut contenir des données ou être vide. Un élément peut contenir
les données suivantes : un nombre, une chaîne, une valeur booléenne ou encore un tableau ou
un objet.
Lorsque vous créez des éléments dans un tableau, il est préférable, dans la mesure du possible,
de créer les index en séquence. Le débogage de vos applications s’en trouvera simplifié. A la
section Référencement et recherche de longueur, page 181, vous avez vu que si vous affectez une
seule valeur à l’index 5 d’un tableau, la longueur du tableau renvoie 6. Cinq valeurs indéfinies
sont alors insérées dans le tableau.
L’exemple suivant décrit la création d’un nouveau tableau, la suppression d’un élément au
niveau d’un index particulier et l’ajout et le remplacement des données d’un index du
tableau :
var monthArr:Array = new Array("Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
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
Bien que vous ayez supprimé l’élément à l’index 5, la longueur du tableau demeure 12 car
l’élément de l’index 5 n’a pas entièrement disparu mais a été remplacé par une chaîne vide.
Vous trouverez un exemple de fichier source, array.fla, dans le dossier Samples de votre disque
dur. Cet exemple illustre la manipulation des tableaux à l’aide d’ActionScript. Le code de cet
exemple crée un tableau et trie, ajoute et supprime des éléments de deux composants List.
Trouvez le fichier d’exemple dans les répertoires suivants :
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\Arrays.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Arrays.
182
Eléments fondamentaux du langage et de la syntaxe
Création de tableaux indexés
Les tableaux indexés stockent des suites d’une ou plusieurs valeurs. Vous pouvez rechercher les
éléments par leur position dans le tableau, ce que vous avez peut-être fait dans les sections
précédentes. Le premier index correspond toujours au nombre 0. L’index est ensuite
incrémenté d’une unité pour chaque élément ajouté consécutivement au tableau. Vous pouvez
créer un tableau indexé en appelant le constructeur de classe Array ou en initialisant le tableau
avec un littéral de tableau. L’exemple suivant permet de créer des tableaux à l’aide du
constructeur Array et d’un littéral de tableau.
Pour créer un tableau indexé :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom indexArray.fla.
2.
Ajoutez l’ActionScript suivant à l’Image 1 du scénario :
var myArray:Array = new Array();
myArray.push("one");
myArray.push("two");
myArray.push("three");
trace(myArray); // one,two,three
Dans la première ligne de code ActionScript, vous définissez un nouveau tableau pour
stocker les valeurs.
3.
Choisissez Contrôle > Tester l’animation pour tester votre code.
Le texte suivant apparaît dans le panneau de sortie :
one,two,three
4.
Revenez dans l’outil de programmation, puis supprimez le code dans le panneau Actions.
5.
Ajoutez l’ActionScript suivant à l’Image 1 du scénario :
var myArray:Array = ["one", "two", "three"];
trace(myArray); // one,two,three
Dans ce code, vous utilisez le littéral de tableau pour définir un nouveau tableau pour
votre code. Ce code est similaire à celui que vous avez écrit à l’étape 2. Lorsque vous le
testez, le même résultat apparaît dans le panneau de sortie.
Présentation des tableaux
183
Création de tableaux multidimensionnels
ActionScript permet d’implémenter des tableaux imbriqués correspondant avant tout à des
tableaux de tableaux. Les tableaux imbriqués, également appelés tableaux multidimensionnels,
sont considérés comme des matrices ou des grilles. Lorsque vous programmez, vous pouvez
utiliser les tableaux multidimensionnels pour reproduire ce type de structures. Par exemple,
un échiquier est une grille de huit colonnes et huit lignes qui peut être reproduit sous forme
de tableau contenant huit éléments, chacun d’eux correspondant également à un tableau
contenant huit éléments.
Prenons par exemple une liste de tâches stockée sous forme de tableau indexé de chaînes :
var tasks:Array = ["wash dishes", "take out trash"];
Pour stocker une liste de tâches distincte pour chaque jour de la semaine, vous pouvez créer
un tableau multidimensionnel avec un élément pour chaque jour. Chaque élément contient à
son tour un tableau indexé qui stocke la liste des tâches.
A T TE N T I O N
Lorsque vous utilisez l’opérateur d’accès au tableau, le compilateur ActionScript ne peut
pas vérifier si l’élément accédé est une propriété valide de l’objet.
Pour créer un tableau multidimensionnel de base et récupérer les éléments du
tableau :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom multiArray1.fla.
2.
Ajoutez l’ActionScript suivant à l’Image 1 du scénario :
var twoDArray:Array = new Array(new Array("one","two"), new
Array("three", "four"));
trace(twoDArray);
Ce tableau, twoDArray, se compose de deux éléments. Ces éléments sont eux-mêmes des
tableaux de deux éléments. Dans ce cas, twoDArray est le tableau principal qui contient
deux tableaux imbriqués.
3.
Choisissez Contrôle > Tester l’animation pour tester le code. Les informations suivantes
apparaissent dans le panneau de sortie :
one,two,three,four
4.
Reprenez l’outil de programmation et ouvrez le panneau Actions. Commentez l’instruction
trace, comme suit :
// trace(twoDArray);
184
Eléments fondamentaux du langage et de la syntaxe
5.
Ajoutez le code ActionScript suivant à la suite de votre code dans l’image 1 du scénario :
trace(twoDArray[0][0]); // un
trace(twoDArray[1][1]); // quatre
Pour récupérer les éléments d’un tableau multidimensionnel, utilisez plusieurs opérateurs
d’accès ([]) après le nom du tableau de niveau supérieur. Le premier opérateur [] fait
référence à l’index du tableau de niveau supérieur. Les opérateurs d’accès au tableau
suivants font référence aux éléments des tableaux imbriqués.
6.
Choisissez Contrôle > Tester l’animation pour tester le code. Les informations suivantes
apparaissent dans le panneau de sortie :
one
four
Vous pouvez utiliser des boucles for imbriquées pour créer des tableaux multidimensionnels.
L’exemple suivant décrit cette procédure.
Pour créer un tableau multidimensionnel à l’aide d’une boucle for :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom multiArray2.fla.
2.
Ajoutez l’ActionScript suivant à l’Image 1 du scénario :
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);
Ce code ActionScript crée un tableau 3 x 3 et définit la valeur de chaque nœud sur son
index. Vous suivez ensuite le tableau (mainArr).
3.
Choisissez Contrôle > Tester l’animation pour tester le code.
Les informations suivantes apparaissent dans le panneau de sortie :
[0][0],[0][1],[0][2],[1][0],[1][1],[1][2],[2][0],[2][1],[2][2]
Vous pouvez également utiliser des boucles for imbriquées pour effectuer une itération sur les
éléments d’un tableau multidimensionnel, comme l’illustre l’exemple suivant.
Présentation des tableaux
185
Pour utiliser une boucle for pour effectuer une itération sur un tableau
multidimensionnel :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom multiArray3.fla.
2.
Ajoutez l’ActionScript suivant à l’Image 1 du scénario :
// De l’exemple précédent
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 + "]";
}
}
Dans ce code, issu de l’exemple précédent, la boucle extérieure effectue une itération sur
chaque élément de mainArray. La boucle intérieure effectue une itération sur chaque
tableau imbriqué et renvoie chaque nœud du tableau.
3.
Ajoutez le code ActionScript suivant dans l’image 1 du scénario, à la suite du code saisi à
l’étape 2 :
// Itération sur les éléments
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]);
}
}
Ce code ActionScript effectue une itération sur les éléments du tableau. Vous utilisez la
propriété length de chaque tableau comme condition de la boucle.
4.
Choisissez Contrôle > Tester l’animation pour voir les éléments qui apparaissent dans le
panneau de sortie. Les informations suivantes apparaissent dans le panneau de sortie :
[0][0]
[0][1]
[0][2]
[1][0]
[1][1]
[1][2]
[2][0]
[2][1]
[2][2]
186
Eléments fondamentaux du langage et de la syntaxe
Pour plus d’informations sur l’utilisation des tableaux, consultez la section Utilisation des
tableaux, page 178. Pour plus d’informations sur les éléments de tableaux, consultez la section
Ajout et suppression d’éléments, page 182. Pour plus d’informations sur l’opérateur d’accès au
tableau, consultez la section Utilisation des opérateurs point et d’accès au tableau, page 200.
Création de tableaux associatifs
Un tableau associatif, similaire à un objet, se compose de clés et de valeurs non triées. Pour
organiser les valeurs stockées, les tableaux associatifs utilisent des clés à la place des index
numériques. Chaque clé est une chaîne unique et n’est associée et utilisée que pour accéder à
une seule valeur. Le type des données de cette valeur peut être Number, Array, Object, etc.
Lorsque vous créez du code pour rechercher la valeur associée à une clé, vous indexez ou
effectuez une recherche. Vous utiliserez probablement les tableaux associatifs dans cet objectif.
L’association entre une clé et une valeur est généralement appelée liaison. La clé et la valeur
sont mises en correspondance. Par exemple, un carnet d’adresses peut être considéré comme un
tableau associatif, les noms étant les clés et les adresses de messagerie les valeurs.
REMARQUE
Les tableaux associatifs sont des collections non triés de paires de clés et de valeurs.
Votre code ne doit pas s’attendre à ce que les clés d’un tel tableau se présentent dans un
ordre précis.
Lorsque vous utilisez des tableaux associatifs, vous pouvez appeler l’élément désiré à l’aide
d’une chaîne plutôt que d’un nombre, souvent plus simple à mémoriser. L’inconvénient est
que ces tableaux ne sont pas très utiles dans une boucle car ils n’utilisent pas de nombre
comme valeur d’index. Ils sont cependant très utiles lorsque vous avez fréquemment besoin de
faire des recherches par valeurs de clés. Par exemple, dans le cas d’un tableau de noms et d’âges
très sollicité, vous pouvez utiliser un tableau associatif.
L’exemple suivant décrit la création d’un objet et la définition d’une série de propriétés dans
un tableau associatif.
Présentation des tableaux
187
Pour créer un tableau associatif simple :
1.
Créez un nouveau document Flash.
2.
Saisissez le code ActionScript suivant sur l’image 1 du scénario :
// Définition de l’objet à utiliser comme tableau associatif.
var someObj:Object = new Object();
// Définition d’une série de propriétés.
someObj.myShape = "Rectangle";
someObj.myW = 480;
someObj.myH = 360;
someObj.myX = 100;
someObj.myY = 200;
someObj.myAlpha = 72;
someObj.myColor = 0xDFDFDF;
// Affichage d’une propriété à l’aide d’un opérateur point et de la
syntaxe d’accès au tableau.
trace(someObj.myAlpha); // 72
trace(someObj["myAlpha"]); // 72
La première ligne de code ActionScript définit un nouvel objet (someObj) utilisé comme
tableau associatif. Ensuite, vous définissez une série de propriétés dans someObj. Pour
finir, vous affichez une propriété sélectionnée à l’aide d’un opérateur point et de la syntaxe
d’accès au tableau.
REMARQUE
3.
Deux méthodes permettent d’accéder aux variables d’un tableau associatif : la syntaxe
à point (someObj.myColor) et la syntaxe de tableau (someObj[‘myColor’]).
Choisissez Contrôle > Tester l’animation pour tester votre code ActionScript.
Le panneau de sortie affiche le nombre 72 à deux reprises, représentant les deux niveaux
alpha que vous avez suivis.
Deux méthodes permettent de créer des tableaux associatifs dans ActionScript 2.0 :
■
Utiliser un constructeur Object
■
Utiliser un constructeur Array
Les deux méthodes sont présentées dans les exemples suivants.
REMARQUE
188
L’exemple précédent utilisait un constructeur Object pour créer le tableau associatif.
Eléments fondamentaux du langage et de la syntaxe
Si vous créez un tableau associatif via un constructeur Object, vous profiter de l’initialisation
de votre tableau à l’aide d’un littéral d’objet. Une occurrence de la classe Object, également
appelée objet générique, présente le même fonctionnement qu’un tableau associatif. En fait,
les occurrences Object sont essentiellement des tableaux associatifs. Vous pouvez utiliser ces
tableaux pour des fonctions de type dictionnaire, lorsque les clés de chaîne sont plus pratiques
que les index numériques. Chaque nom de propriété de l’objet générique devient la clé qui
permet d’accéder à une valeur stockée. Pour plus d’informations sur les littéraux, consultez la
section Présentation des littéraux, page 142. Pour plus d’informations sur les classes, consultez
le Chapitre 7, Classes, page 243.
Pour créer un tableau associatif à l’aide d’un constructeur Object :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom assocArray.fla.
2.
Ajoutez l’ActionScript suivant à l’Image 1 du scénario :
var monitorInfo:Object = {type:"Flat Panel", resolution:"1600 x 1200"};
trace(monitorInfo["type"] + ", " + monitorInfo["resolution"]);
Ce code crée un tableau associatif appelé monitorInfo et utilise un littéral d’objet pour
initialiser le tableau avec deux paires clé/valeur.
REMARQUE
Si vous n’avez pas besoin d’initialiser le tableau lors de la déclaration, vous pouvez
utiliser le constructeur Object pour créer le tableau :
var monitorInfo:Object = new Object();
3.
Choisissez Contrôle > Tester l’animation.
Le panneau de sortie affiche le texte suivant :
Flat Panel, 1600 x 1200
4.
Ajoutez le code ActionScript suivant dans l’image 1 du scénario, à la suite du code saisi
précédemment :
monitorInfo["aspectRatio"] = "16:10";
monitorInfo.colors = "16.7 million";
trace(monitorInfo["aspectRatio"] + ", " + monitorInfo.colors);
Après avoir créé le tableau à l’aide d’un littéral d’objet ou d’un constructeur de classe
Object, vous pouvez lui ajouter de nouvelles valeurs en utilisant l’opérateur crochets ([])
ou l’opérateur point (.), comme l’illustre le code suivant. Le code que vous venez de saisir
ajoute deux nouvelles valeurs au tableau monitorInfo.
Présentation des tableaux
189
5.
Choisissez Contrôle > Tester l’animation.
Le panneau de sortie affiche le texte suivant :
16:10, 16.7 million
Remarquez que les clés peuvent contenir des espaces. Cela est possible dans le cas de
l’opérateur crochets, mais génère une erreur avec l’opérateur point. L’utilisation d’espace
dans le nom de vos clés n’est donc pas conseillée. Pour plus d’informations sur les
opérateurs crochets et point, consultez la section Présentation des opérateurs, page 191.
Pour plus d’informations sur le code correctement formaté, consultez la section Mise en
forme de la syntaxe ActionScript, page 832.
Le second moyen pour créer un tableau associatif consiste à utiliser le constructeur Array, puis
l’opérateur crochets ([]) ou point (.) pour ajouter les paires de clé/valeur dans le tableau. Si
vous déclarez votre tableau associatif comme étant de type Array, vous ne pouvez pas utiliser
de littéral d’objet pour l’initialiser.
REMARQUE
L’utilisation du constructeur Array pour créer un tableau associatif ne présente aucun
avantage. Ce constructeur convient mieux à la création des tableaux indexés.
L’exemple suivant présente l’utilisation du constructeur Array pour créer un tableau associatif.
Pour créer un tableau associatif à l’aide du constructeur Array :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom assocArray2.fla.
2.
Ajoutez l’ActionScript suivant à l’Image 1 du scénario :
var monitorInfo:Array = new
monitorInfo["type"] = "Flat
monitorInfo["resolution"] =
trace(monitorInfo["type"] +
Array();
Panel";
"1600 x 1200";
", " + monitorInfo["resolution"]);
Ce code crée un tableau associatif appelé monitorInfo à l’aide du constructeur Array et
ajoute les clés appelées type et resolution, avec leurs valeurs.
3.
Choisissez Contrôle > Tester l’animation.
Le panneau de sortie affiche le texte suivant :
Flat Panel, 1600 x 1200
R E M AR QU E
190
L’utilisation du constructeur Array pour créer un tableau associatif ne présente aucun
avantage. Ce constructeur convient mieux à la création des tableaux indexés.
Eléments fondamentaux du langage et de la syntaxe
Les tableaux associatifs sont essentiellement des occurrences de la classe Object et l’utilisation
du constructeur Array pour créer des tableaux associatifs ne présente aucun avantage. Même si
vous créez un tableau associatif à l’aide du constructeur new Array(), vous ne pouvez utiliser
aucune méthode ou propriété de la classe Array (telle que sort() ou length) lorsque vous
utilisez un tableau associatif. Si vous souhaitez utiliser des paires clé/valeur au lieu d’un index
numérique, vous devez utiliser la classe Object et non un tableau associatif.
Présentation des opérateurs
Cette section décrit des règles générales au sujet de types courants d’opérateurs, de la priorité
des opérateurs et de leur associativité.
Les opérateurs sont des caractères qui spécifient comment combiner, comparer ou modifier les
valeurs d’une expression. Une expression est une instruction que Flash peut évaluer et qui
renvoie une valeur. Pour créer une expression, vous pouvez associer des opérateurs et des
valeurs ou appeler une fonction. Pour plus d’informations sur les expressions, consultez la
section Présentation de la syntaxe, des instructions et des expressions, page 124.
Une expression mathématique, par exemple, utilise des opérateurs numériques pour
manipuler les valeurs que vous utilisez. +, <, * et = sont des exemples d’opérateurs. Une
expression se compose d’opérateurs et d’opérandes. Elle désigne toute combinaison valide de
symboles ActionScript représentant une valeur. Un opérande est une partie du code sur
laquelle l’opérateur exécute une action. Par exemple, dans l’expression x + 2, x et 2 sont des
opérandes et + est un opérateur.
Dans votre code, vous utilisez fréquemment des expressions et des opérateurs. Pour créer une
expression, vous pouvez associer des opérateurs et des valeurs ou appeler une fonction.
REMARQUE
Cette section décrit brièvement l’utilisation de chaque type d’opérateur. Pour plus
d’informations sur chaque opérateur, y compris les opérateurs spéciaux qui ne font pas
partie des catégories suivantes, consultez le Guide de référence du langage
ActionScript 2.0.
Les parties de votre code sur lesquelles les opérateurs agissent sont appelés opérandes. Vous
pouvez utiliser l’opérateur d’addition (+) pour ajouter des valeurs à un littéral numérique, par
exemple pour ajouter la valeur d’une variable appelée myNum.
myNum + 3;
Dans cet exemple, myNum et 3 sont des opérandes.
Présentation des opérateurs
191
Cette section décrit les règles générales qui régissent les types courants d’opérateurs, leur
priorité et leur associativité.
■
Utilisation d’opérateurs pour manipuler les valeurs, page 193
■
Priorité et associativité des opérateurs, page 194
■
Utilisation d’opérateurs avec des chaînes, page 198
■
Utilisation des opérateurs point et d’accès au tableau, page 200
■
Présentation des opérateurs de suffixe, page 202
■
Présentation des opérateurs unaires, page 202
■
Présentation des opérateurs de multiplication, page 203
■
Présentation des opérateurs d’ajout, page 203
■
Utilisation des opérateurs numériques, page 204
■
Présentation des opérateurs relationnels, page 205
■
Présentation des opérateurs d’égalité, page 205
■
Utilisation des opérateurs relationnels et d’égalité, page 206
■
Présentation des opérateurs d’affectation, page 209
■
Utilisation des opérateurs d’affectation, page 210
■
Présentation des opérateurs logiques, page 210
■
Utilisation des opérateurs logiques, page 211
■
Présentation des opérateurs de décalage au niveau du bit, page 212
■
Présentation des opérateurs logiques au niveau du bit, page 213
■
Utilisation des opérateurs au niveau du bit, page 213
■
Présentation de l’opérateur conditionnel, page 215
■
Utilisation des opérateurs dans un document, page 215
Pour plus d’informations sur les opérateurs qui n’entrent pas dans ces catégories, consultez le
Guide de référence du langage ActionScript 2.0, qui contient des informations sur tous les
opérateurs disponibles.
Les sections suivantes présentent quelques utilisations courantes des opérateurs. Pour plus
d’informations sur l’utilisation de plusieurs opérateurs dans un même code, consultez la
section Utilisation des opérateurs dans un document, page 215.
192
Eléments fondamentaux du langage et de la syntaxe
Utilisation d’opérateurs pour manipuler les valeurs
Les opérateurs sont souvent utilisés pour manipuler des valeurs dans Flash. Par exemple, vous
pouvez créer un jeu dans lequel le score change selon les interactions de l’utilisateur avec les
occurrences de la scène. Vous pouvez utiliser une variable pour stocker la valeur et des
opérateurs pour manipuler la valeur de la variable.
Par exemple, vous pouvez augmenter la valeur d’une variable appelée myScore. L’exemple
suivant décrit l’utilisation des opérateurs + (addition) et += (affectation d’addition) pour
ajouter et incrémenter des valeurs de votre code.
Pour manipuler les valeurs à l’aide d’opérateurs :
1.
Créez un nouveau document Flash.
2.
Ouvrez le panneau Actions (Fenêtre > Actions) et saisissez le code suivant dans la fenêtre
de script :
// Exemple un
var myScore:Number = 0;
myScore = myScore + 1;
trace("Example one: " + myScore); // 1
// Exemple deux
var secondScore:Number = 1;
secondScore += 3;
trace("Example two: " + secondScore); // 4
3.
Choisissez Contrôle > Tester l’animation.
Le panneau de sortie affiche le texte suivant :
Example one: 1
Example two: 4
L’opérateur d’addition est très simple car il se contente d’additionner deux valeurs. Dans le
premier exemple de code, il additionne la valeur actuelle de myScore avec le nombre 1,
puis stocke le résultat dans la variable myScore.
Le deuxième exemple de code utilise l’opérateur d’affectation d’addition pour ajouter et
affecter une nouvelle valeur en une même étape. Vous pouvez réécrire la ligne myScore =
myScore + 1 (de l’exercice précédent) sous la forme myScore++ ou encore myScore += 1.
L’opérateur d’incrémentation (++) est un moyen simple de dire myScore = myScore + 1, car
il traite simultanément une incrémentation et une affectation. Vous pouvez voir un exemple
de ce type d’opérateur dans le code ActionScript suivant :
var myNum:Number = 0;
myNum++;
trace(myNum); // 1
myNum++;
trace(myNum); // 2
Présentation des opérateurs
193
Notez que le code précédent ne contient pas d’opérateur d’affectation, mais repose sur un
opérateur d’incrémentation.
Vous pouvez manipuler la valeur d’une variable à l’aide d’opérateurs tant qu’une condition est
true (vraie). Par exemple, vous pouvez utiliser l’opérateur d’incrémentation (++) pour
incrémenter la variable i tant que la condition est vraie. Dans le code suivant, la condition est
true tant que i est inférieur à 10. Tant que cette condition est vraie, i est incrémenté d’une
unité via i++.
var i:Number;
for (i = 1; i < 10; i++) {
trace(i);
}
Le panneau de sortie affiche les nombres 1 à 9, c’est-à-dire i dont la valeur est incrémentée
jusqu’à ce que la condition de fin soit atteinte (i égale 10). La dernière valeur affichée est 9.
De ce fait, la valeur de i est 1 lorsque la lecture du fichier SWF commence, puis 9 à la fin du
suivi.
Pour plus d’informations sur les conditions et les boucles, consultez la section Présentation des
instructions, page 153.
Priorité et associativité des opérateurs
Lorsque plusieurs opérateurs sont utilisés dans la même instruction, certains sont prioritaires
par rapport à d’autres. La priorité et l’associativité des opérateurs déterminent leur ordre de
traitement. La hiérarchie d’ActionScript détermine l’ordre d’exécution des opérateurs. Le
tableau décrivant cette hiérarchie est présenté à la fin de cette section.
Bine qu’il soit évident, pour ceux qui connaissent bien l’arithmétique ou la programmation de
base, que le compilateur traite l’opérateur de multiplication (*) avant l’opérateur d’addition
(+), le compilateur a besoin d’instructions claires quant à l’ordre à appliquer aux opérateurs.
L’ensemble de ces instructions est appelé ordre de priorité des opérateurs.
L’utilisation des opérateurs de multiplication et d’addition constitue un exemple de priorité
des opérateurs :
var mySum:Number;
mySum = 2 + 4 * 3;
trace(mySum); // 14
Le résultat de cette instruction est 14, car la multiplication est prioritaire. Ainsi, 4 * 3 est
d’abord calculé, puis 2 est ajouté au résultat.
194
Eléments fondamentaux du langage et de la syntaxe
Vous pouvez contrôler l’ordre des opérations en plaçant les expressions entre parenthèses.
ActionScript définit une priorité par défaut que l’opérateur parenthèses (()) permet de
modifier. Si l’addition est mise entre parenthèses, ActionScript l’effectue en premier :
var mySum:Number;
mySum = (2 + 4) * 3;
trace(mySum); // 18
Dans ce cas, le résultat est 18.
Il est également possible que des opérateurs aient la même priorité. Dans ce cas, l’associativité
détermine leur ordre d’exécution. L’associativité peut aller de gauche à droite ou de droite à
gauche.
Examinons de nouveau l’opérateur de multiplication. Comme il présente une associativité de
gauche à droite, les deux instructions sont identiques.
var mySum:Number;
var myOtherSum:Number;
mySum = 2 * 4 * 3;
myOtherSum = (2 * 4) * 3;
trace(mySum); // 24
trace(myOtherSum); // 24
Il arrive que plusieurs opérateurs de même priorité apparaissent dans la même expression.
Dans ce cas, le compilateur utilise les règles d’associativité pour identifier le premier opérateur
à traiter. Tous les opérateurs binaires, sauf les opérateurs d’affectation, sont associatifs gauche,
ce qui signifie que les opérateurs de gauche sont traités avant ceux de droite. Les opérateurs
d’affectation et l’opérateur conditionnel (?:) sont associatifs droit, ce qui signifie que les
opérateurs de droite sont traités avant ceux de gauche. Pour plus d’informations sur
l’affectation des opérateurs, consultez la section Utilisation des opérateurs d’affectation,
page 210. Pour plus d’informations sur l’opérateur conditionnel, consultez la section
Présentation de l’opérateur conditionnel, page 215.
Prenons par exemple les opérateurs inférieur à (<) et supérieur à (>), qui ont le même ordre de
priorité. Lorsque les deux opérateurs sont employés dans la même expression, celui de gauche
est traité en premier puisque tous deux sont associatifs gauche. Cela signifie que les deux
instructions suivantes donnent le même résultat :
trace(3 > 2 < 1);
// false
trace((3 > 2) < 1); // false
L’opérateur supérieur à (>) est traité en premier, donnant un résultat true puisque l’opérande
3 est supérieur à l’opérande 2. La valeur true est alors transmise à l’opérateur inférieur à (<),
avec l’opérande 1. L’opérateur inférieur à (<) convertit la valeur true en valeur numérique 1 et
compare cette valeur au second opérande 1 pour renvoyer la valeur false (la valeur 1 n’est pas
inférieure à 1).
Présentation des opérateurs
195
N’oubliez pas l’ordre des opérandes dans votre code ActionScript, en particulier lorsque vous
élaborez des conditions complexes et que vous savez combien de fois elles sont vraies. Par
exemple, si vous savez que i sera supérieur à 50 dans votre condition, vous devez commencer
par écrire i<50. Ce chiffre sera ainsi vérifié en premier et la seconde condition écrite n’a pas
besoin d’être vérifiée systématiquement.
Le tableau suivant répertorie l’ensemble des opérateurs ActionScript et leur associativité et les
classe par ordre de priorité décroissante. Pour plus d’informations et des recommandations
d’utilisation des opérateurs et des parenthèses, consultez le Chapitre 19, Mise en forme de la
syntaxe ActionScript, page 832.
Opérateur
Description
Associativité
Priorité la plus élevée
x++
Post-incrémentation
Gauche à droite
x--
Post-décrémentation
Gauche à droite
.
Accès à la propriété de l’objet
Gauche à droite
[ ]
Elément de tableau
Gauche à droite
( )
Parenthèses
Gauche à droite
function ( )
Appel de fonction
Gauche à droite
++x
Pré-incrémentation
Droite à gauche
--x
Pré-décrémentation
Droite à gauche
-
Négation unaire, telle que x = -1
Gauche à droite
~
NOT au niveau du bit
Droite à gauche
!
NOT logique
Droite à gauche
new
Affectation d’objet
Droite à gauche
delete
Désaffectation d’objet
Droite à gauche
typeof
Type d’objet
Droite à gauche
void
Renvoie une valeur non définie
Droite à gauche
*
Multiplier
Gauche à droite
/
Diviser
Gauche à droite
%
Modulo
Gauche à droite
+
Unaire plus
Droite à gauche
-
Unaire moins
Droite à gauche
<<
Décalage gauche au niveau du bit
Gauche à droite
196
Eléments fondamentaux du langage et de la syntaxe
Opérateur
Description
Associativité
>>
Décalage droit au niveau du bit
Gauche à droite
>>>
Décalage droit au niveau du bit (non signé)
Gauche à droite
instanceof
Occurrence de (recherche la classe dont l’objet
est une occurrence)
Nécessite Flash Player 6 ou version ultérieure
Gauche à droite
<
Inférieur à
Gauche à droite
<=
Inférieur ou égal à
Gauche à droite
>
Supérieur à
Gauche à droite
>=
Supérieur ou égal à
Gauche à droite
==
Egal
Gauche à droite
!=
Différent
Gauche à droite
&
AND au niveau du bit
Gauche à droite
^
XOR au niveau du bit
Gauche à droite
|
OR au niveau du bit
Gauche à droite
&&
ET logique
Gauche à droite
||
OU logique
Gauche à droite
?:
Conditionnel
Droite à gauche
=
Affectation
Droite à gauche
*=, /=, %=, +=, =, &=, |=, ^=,
<<=, >>=, >>>=
Affectation de composant
Droite à gauche
,
Virgule
Gauche à droite
Priorité la moins élevée
Présentation des opérateurs
197
Utilisation d’opérateurs avec des chaînes
Les opérateurs de comparaison ne comparent les chaînes que si les deux opérandes sont des
chaînes. L’opérateur d’égalité stricte (===) est l’une des exceptions à cette règle. Si un seul
opérande est une chaîne, ActionScript convertit les deux opérandes en nombres et effectue
une comparaison numérique. Pour plus d’informations sur les opérateurs numériques,
consultez la section Utilisation des opérateurs numériques, page 204.
A l’exception de l’opérateur d’égalité (==), les opérateurs de comparaison (>, >=, < et <=)
n’affectent pas les chaînes de la même façon que les autres valeurs.
Ces opérateurs comparent les chaînes pour déterminer celle qui apparaît en premier dans
l’ordre alphabétique. Les chaînes en majuscule ont priorité sur celles qui sont en minuscule.
Cela signifie que le terme « Egg » vient avant « 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
Dans ce code ActionScript, la méthode sort() de la classe Array trie le contenu du tableau
dans l’ordre alphabétique. Vous voyez alors que la valeur « Egg » vient avant la valeur
« chicken » car la majuscule E vient avant la minuscule c. Pour comparer des chaînes
indépendamment de la casse, vous devez les convertir en majuscule ou en minuscule avant la
comparaison. Pour plus d’informations sur les opérateurs de comparaison, consultez les
sections Présentation des opérateurs d’égalité, page 205 et Utilisation des opérateurs relationnels et
d’égalité, page 206.
Les méthodes toLowerCase() ou toUpperCase() permettent de convertir les chaînes en une
même casse avant de les comparer. Dans l’exemple suivant, les deux chaînes sont converties en
minuscule puis comparées. Le terme « chicken » vient maintenant avant « egg » :
var c:String = "chicken";
var e:String = "Egg";
trace(c.toLowerCase() < e.toLowerCase()); // true
R E M AR QU E
198
Les opérateurs de comparaison ne comparent que deux chaînes. Par exemple, ils ne
comparent pas les valeurs lorsqu’un opérande est une valeur numérique. Si l’un des
opérandes est une chaîne, ActionScript convertit les deux opérandes en nombres et
effectue une comparaison numérique.
Eléments fondamentaux du langage et de la syntaxe
Les opérateurs permettent de manipuler des chaînes. Vous pouvez utiliser l’opérateur
d’addition (+) pour concaténer deux opérandes de chaînes. Vous avez peut-être déjà fait cette
opération si vous avez écrit des instructions trace. Par exemple, vous pouvez écrire le code
suivant :
var myNum:Number = 10;
trace("The variable is " +
myNum + ".");
Lorsque vous testez le code, le résultat suivant s’affiche dans le panneau de sortie :
The variable is 10.
Dans l’exemple précédent, l’instruction trace utilise l’opérateur + pour concaténer au lieu
d’additionner. Lorsque vous manipulez des chaînes et des nombres, Flash préfère parfois
concaténer plutôt qu’additionner numériquement.
Par exemple, vous pouvez concaténer deux chaînes à partir de variables différentes dans un
seul champ de texte. Dans le code ActionScript suivant, la variable myNum fait une
concaténation avec une chaîne, et cette dernière affiche le champ myTxt sur la scène.
this.createTextField("myTxt", 11, 0, 0, 100, 20);
myTxt.autoSize = "left";
var myNum:Number = 10;
myTxt.text = "One carrot. " + myNum + " large eggplants.";
myTxt.text += " Lots of vegetable broth.";
Ce code donne le résultat suivant dans un champ de texte avec le nom d’occurrence myTxt :
One carrot. 10 large eggplants. Lots of vegetable broth.
L’exemple précédent décrit l’utilisation des opérateurs d’addition (+) et d’affectation
d’addition (+=) pour concaténer les chaînes. Remarquez comment la troisième ligne de code
utilise l’opérateur d’addition pour concaténer la valeur de la variable myNum dans le champ de
texte, et comment la quatrième ligne utilise l’opérateur d’affectation d’addition pour
concaténer une chaîne sur la valeur existante du champ de texte.
Si un seul opérande de chaîne de texte est une chaîne, Flash convertit l’autre opérande en
chaîne. De ce fait, la valeur de myNum est convertie en une chaîne dans l’exemple précédent.
R E M A R QU E
ActionScript traite les espaces au début ou à la fin d’une chaîne comme faisant partie de
la chaîne.
Présentation des opérateurs
199
Utilisation des opérateurs point et d’accès au tableau
Vous pouvez utiliser les opérateurs point (.) et d’accès au tableau ([]) pour accéder aux
propriétés ActionScript intégrées ou personnalisées. Vous utilisez les opérateurs point pour
cibler certains index dans un objet. Par exemple, si l’un de vos objets contient des
informations d’utilisateur, vous pouvez indiquer un certain nom de clé dans l’opérateur
d’accès au tableau afin de récupérer le nom de l’utilisateur, comme l’illustre le code
ActionScript suivant :
var someUser:Object = {name:"Hal", id:2001};
trace("User's name is: " + someUser["name"]); // Le nom de l’utilisateur
est : Hal
trace("User's id is: " + someUser["id"]); // L’ID de l’utilisateur est :
2001
Par exemple, le code ActionScript suivant utilise l’opérateur point pour définir certaines
propriétés à l’intérieur des objets :
myTextField.border = true;
year.month.day = 9;
myTextField.text = "My text";
Les opérateurs point et d’accès au tableau sont très similaires. L’opérateur point prend un
identifiant en tant que propriété, mais l’opérateur d’accès au tableau évalue le contenu en
nom, puis accède à la valeur de la propriété de ce nom. L’opérateur d’accès au tableau permet
de définir et extraire de façon dynamique les variables et les noms d’occurrence.
L’opérateur d’accès au tableau se révèle très utile lorsque vous ignorez quelles clés sont stockées
dans un objet. Dans ce cas, vous pouvez utiliser une boucle for..in pour effectuer une
itération sur un objet ou un clip et afficher son contenu.
Pour utiliser les opérateurs point et d’accès au tableau :
1.
Dans un nouveau document Flash, créez un clip sur le scénario principal.
2.
Sélectionnez le clip et ouvrez l’inspecteur des propriétés.
3.
Saisissez le nom d’occurrence de myClip.
4.
Ajoutez l’ActionScript suivant à l’Image 1 du scénario :
myClip.spam = 5;
trace(myClip.spam); // 5
Pour définir une valeur dans l’occurrence myClip du scénario actif, vous pouvez utiliser les
opérateurs point ou d’accès au tableau, comme dans ce code ActionScript. Si vous écrivez
une expression dans l’opérateur d’accès au tableau, ce dernier évalue d’abord l’expression,
puis utilise le résultat comme nom de variable.
200
Eléments fondamentaux du langage et de la syntaxe
5.
Sélectionnez Contrôle > Tester l’animation pour tester le document.
Le panneau de sortie affiche 5.
6.
Revenez dans l’environnement de programmation, puis remplacez la première ligne de
code ActionScript par ce qui suit :
myClip["spam"] = 10;
7.
Sélectionnez Contrôle > Tester l’animation pour tester le document.
Le panneau de sortie affiche 10.
8.
Revenez dans l’environnement de programmation et double-cliquez sur l’occurrence
myClip.
9.
Ajoutez quatre nouvelles occurrences dans l’occurrence myClip.
10. Utilisez l’inspecteur des propriétés pour donner les noms d’occurrences suivants aux quatre
nouvelles occurrences : nestedClip1, nestedClip2, nestedClip3, nestedClip4.
11.
Ajoutez le code suivant à l’image 1 du scénario principal :
var i:Number;
for (i = 1; i <= 4; i++) {
myClip["nestedClip" + i]._visible = false;
}
Ce code ActionScript désactive la visibilité de chaque clip imbriqué.
12. Choisissez
Contrôle > Tester l’animation pour tester le code ActionScript que vous venez
d’ajouter.
Les quatre occurrences imbriquées sont à présent invisibles. Vous utilisez l’opérateur
d’accès au tableau pour effectuer une itération sur chaque clip imbriqué dans l’occurrence
myClip et définir sa propriété de visibilité dynamiquement. Vous gagnez ainsi du temps
car vous n’avez plus besoin de cibler chaque occurrence de façon spécifique.
Vous pouvez également utiliser l’opérateur d’accès au tableau du côté gauche d’une
affectation, ce qui vous permet de définir les noms d’occurrence, de variable et d’objet
dynamiquement :
myNum[i] = 10;
Dans ActionScript 2.0, l’opérateur crochets permet d’accéder aux propriétés d’un objet créées
dynamiquement, pour le cas où la définition de la classe de cet objet ne fournit pas l’attribut
dynamique. Vous pouvez également créer des tableaux multidimensionnels à l’aide de cet
opérateur. Pour plus d’informations sur la création de tableaux multidimensionnels à l’aide
d’opérateurs d’accès au tableau, consultez la section Création de tableaux multidimensionnels,
page 184.
Présentation des opérateurs
201
Présentation des opérateurs de suffixe
Les opérateurs de suffixe prennent un opérateur et incrémentent ou décrémentent sa valeur.
Bien que ces opérateurs soient des opérateurs unaires, ils sont classés à part du fait de leur
priorité supérieure et de leur comportement particulier. Pour plus d’informations sur les
opérateurs unaires, consultez la section Présentation des opérateurs unaires, page 202.
Lorsque vous utilisez un opérateur de suffixe dans une expression plus grande, la valeur de
l’expression est renvoyée avant le traitement de cet opérateur. Par exemple, le code suivant
montre comment la valeur de l’expression xNum++ est renvoyée avant l’incrémentation de la
valeur.
var xNum:Number = 0;
trace(xNum++); // 0
trace(xNum); // 1
Lorsque vous suivez ce code, le texte suivant s’affiche dans le panneau de sortie :
0
1
Les opérateurs de ce tableau ont le même ordre de priorité :
Opérateur Opération effectuée
++
Incrémentation (suffixe)
--
Décrémentation (suffixe)
Présentation des opérateurs unaires
Les opérateurs unaires prennent un opérande. Les opérateurs d’incrémentation (++) et de
décrémentation (--) de ce groupe sont des opérateurs de préfixe, c’est-à-dire qu’ils apparaissent
avant l’opérande dans une expression. Ils peuvent aussi apparaître après l’opérande, auquel cas
il s’agit d’opérateurs de suffixe. Pour plus d’informations sur les opérateurs de suffixe,
consultez la section Présentation des opérateurs de suffixe, page 202.
Les opérateurs de préfixe diffèrent de leur équivalent suffixe car l’opération d’incrémentation
ou de décrémentation est effectuée avant le renvoi de la valeur de l’expression globale. Par
exemple, le code suivant montre comment la valeur de l’expression xNum++ est renvoyée avant
l’incrémentation de la valeur.
var xNum:Number = 0;
trace(++xNum); // 1
trace(xNum); // 1
202
Eléments fondamentaux du langage et de la syntaxe
Tous les opérateurs de ce tableau ont le même ordre de priorité :
Opérateur Opération effectuée
++
Incrémentation (préfixe)
--
Décrémentation (préfixe)
+
Unaire +
!
Unaire - (négation)
typeof
Renvoie les informations de type
void
Renvoie une valeur non définie
Présentation des opérateurs de multiplication
Les opérateurs de multiplication prennent deux opérandes et effectuent des multiplications,
des divisions ou des calculs de modulo. Les autres opérateurs numériques comprennent les
opérateurs d’ajout. Pour plus d’informations sur les opérateurs d’ajout, consultez la section
Présentation des opérateurs d’ajout, page 203.
Tous les opérateurs de ce tableau ont le même ordre de priorité :
Opérateur Opération effectuée
*
Multiplication
/
Division
%
Modulo
Pour plus d’informations sur les opérateurs de multiplication, consultez la section Utilisation
des opérateurs numériques, page 204.
Présentation des opérateurs d’ajout
Les opérateurs d’ajout prennent deux opérandes et effectuent des calculs d’addition ou de
soustraction. Les autres opérateurs numériques comprennent les opérateurs de multiplication.
Pour plus d’informations sur les opérateurs de multiplication, consultez la section Présentation
des opérateurs de multiplication, page 203.
Les opérateurs de ce tableau ont le même ordre de priorité :
Opérateur Opération effectuée
+
Addition
-
Soustraction
Présentation des opérateurs
203
Pour plus d’informations sur l’utilisation des opérateurs d’ajout, consultez la section
Utilisation des opérateurs numériques, page 204.
Utilisation des opérateurs numériques
Les opérateurs numériques permettent d’ajouter, de soustraire, de diviser et de multiplier des
valeurs dans ActionScript. Vous pouvez effectuer différentes sortes d’opérations arithmétiques.
Le plus courant est l’opérateur d’incrémentation, généralement présenté sous la forme i++.
Cet opérateur permet d’effectuer d’autres opérations. Pour plus d’informations sur l’opérateur
d’incrémentation, consultez la section Utilisation d’opérateurs pour manipuler les valeurs,
page 193.
L’incrémentation peut être placé avant (pré-incrémentation) ou après (post-incrémentation) une
opérande.
Pour comprendre les opérateurs numériques du langage ActionScript :
1.
Créez un nouveau document Flash.
2.
Saisissez le code ActionScript suivant sur l’image 1 du scénario :
// Exemple un
var firstScore:Number = 29;
if (++firstScore >= 30) {
// devrait suivre
trace("Success! ++firstScore is >= 30");
}
// Exemple deux
var secondScore:Number = 29;
if (secondScore++ >= 30) {
// ne devrait pas suivre
trace("Success! secondScore++ is >= 30");
}
3.
Choisissez Contrôle > Tester l’animation pour tester le code ActionScript.
Le bloc de code « Exemple un » suit, mais pas celui de « Exemple deux ». Le premier
exemple utilise une pré-incrémentation (++firstScore) pour incrémenter et calculer
firstScore avant sa vérification par rapport à 30. De ce fait, firstScore est incrémenté
à 30, puis testé par rapport à 30.
L’exemple deux utilise lui une post-incrémentation (secondScore++), c’est-à-dire que
l’évaluation est effectuée après le test. Ainsi, 29 est comparé à 30, puis incrémenté à 30
après l’évaluation.
Pour plus d’informations sur la priorité des opérateurs, consultez la section Priorité et
associativité des opérateurs, page 194.
204
Eléments fondamentaux du langage et de la syntaxe
Lorsque vous transférez des données à partir de sources externes (tels que des fichiers XML,
FlashVars, des services Web, etc.), faites très attention en utilisant les opérateurs numériques.
Flash traite parfois les nombres comme des chaînes car le fichier SWF n’est pas conscient de
leur type de données. Ainsi, l’addition de 3 et 7 pourrait donner 37 car les deux nombres
peuvent être concaténés comme des chaînes au lieu d’être additionnés numériquement. Dans
ce cas, vous devez convertir manuellement les données de chaînes en nombres via la fonction
Number().
Présentation des opérateurs relationnels
Les opérateurs relationnels prennent deux opérandes, comparent leur valeurs et renvoient une
valeur booléenne. Tous les opérateurs de ce tableau ont le même ordre de priorité :
Opérateur Opération effectuée
<
Inférieur à
>
Supérieur à
<=
Inférieur ou égal à
>=
Supérieur ou égal à
instanceof
Vérifie la chaîne prototype
in
Vérifie les propriétés des objets
Pour plus d’informations sur l’utilisation des opérateurs relationnels, consultez la section
Utilisation des opérateurs relationnels et d’égalité, page 206.
Présentation des opérateurs d’égalité
Les opérateurs d’égalité prennent deux opérandes, comparent leur valeurs et renvoient une
valeur booléenne. Tous les opérateurs de ce tableau ont le même ordre de priorité :
Opérateur Opération effectuée
==
Egalité
!=
Inégalité
===
Egalité stricte
!==
Inégalité stricte
Pour plus d’informations sur l’utilisation des opérateurs d’égalité, consultez la section
Utilisation des opérateurs relationnels et d’égalité, page 206.
Présentation des opérateurs
205
Utilisation des opérateurs relationnels et d’égalité
Ces opérateurs, également appelés opérateurs de comparaison, comparent les valeurs des
expressions et renvoient une valeur booléenne : true (vrai) ou false (faux). Ces opérateurs
sont fréquemment employés dans des boucles et des instructions conditionnelles pour
spécifier la condition de fin de la boucle.
Vous pouvez utiliser l’opérateur d’égalité (==) pour déterminer si les valeurs ou les références
de deux opérandes sont égales et si cette comparaison renvoie une valeur booléenne. Les
valeurs d’opérandes de type chaîne, nombre ou booléen effectuent la comparaison à l’aide
d’une valeur. Les opérandes de type objet et tableau sont comparés par une référence.
Dans cet exemple, vous pouvez observer l’utilisation de l’opérateur d’égalité pour tester la
longueur du tableau et afficher un message dans le panneau de sortie lorsque le tableau ne
contient pas d’élément.
var myArr:Array = new Array();
if (myArr.length == 0) {
trace("the array is empty.");
}
Lorsque vous choisissez Contrôle > Tester l’animation, la chaîne the array is empty (le
tableau est vide) s’affiche dans le panneau de sortie.
Vous pouvez utiliser l’opérateur d’égalité pour comparer des valeurs, mais pas pour les définir.
Une erreur courante consiste à utiliser l’opérateur d’affectation (=) pour contrôler l’égalité.
Pour utiliser les opérateurs relationnels et d’égalité dans votre code :
1.
Créez un nouveau document Flash.
2.
Saisissez le code ActionScript suivant sur l’image 1 du scénario :
var myNum:Number = 2;
if (myNum == 2) {
// action
trace("It equals 2");
}
Dans ce code ActionScript, vous utilisez l’opérateur d’égalité (==) pour vérifier l’égalité.
Vous vérifiez si la variable myNum est égale à 2.
3.
Choisissez Contrôle > Tester l’animation.
La chaîne It equals 2 (est égal à 2) s’affiche dans le panneau de sortie.
4.
Revenez dans l’environnement de programmation et modifiez :
var myNum:Number = 2;
en :
var myNum:Number = 4;
206
Eléments fondamentaux du langage et de la syntaxe
5.
Choisissez de nouveau Contrôle > Tester l’animation.
La chaîne It equals 2 (est égal à 2) ne s’affiche pas dans le panneau de sortie.
6.
Revenez dans l’environnement de programmation et modifiez :
if (myNum == 2) {
en
if (myNum = 2) {
7.
Choisissez de nouveau Contrôle > Tester l’animation.
La chaîne It equals 2 (est égal à 2) s’affiche de nouveau dans le panneau de sortie.
A l’étape 6, vous affectez la valeur 2 à myNum, au lieu de comparer myNum à 2. Dans ce cas,
l’instruction if s’exécute quelle que soit la valeur précédente de myNum, ce qui peut donner
des résultats imprévus lors du test du document Flash.
Pour plus d’informations sur l’utilisation appropriée de l’opérateur d’affectation, consultez
la section Utilisation des opérateurs d’affectation, page 210.
L’opérateur d’égalité stricte (===) est similaire à l’opérateur d’égalité, sauf qu’il n’effectue pas
de conversion de type. Si les deux opérandes sont de types différents, l’opérateur d’égalité
renvoie false (faux). L’opérateur d’inégalité stricte (!==) renvoie l’inverse de l’opérateur
d’égalité stricte.
Le code ActionScript suivant présente la principale différence entre l’opérateur d’égalité (==)
et l’opérateur d’égalité stricte (===) :
var num1:Number = 32;
var num2:String = new String("32");
trace(num1 == num2); // true
trace(num1 === num2); // false
D’abord, vous définissez les variables numériques : num1 et num2. Si vous comparez les
variables à l’aide de l’opérateur d’égalité, Flash tente de convertir les valeurs dans le même type
de données, puis les compare afin de vérifier leur égalité. Lorsque vous utilisez l’opérateur
d’égalité stricte (===), Flash n’effectue aucune conversion de type de données avant de
comparer les valeurs. En résultat, Flash voit les variables comme deux valeurs distinctes.
Dans l’exemple suivant, vous allez utiliser l’opérateur supérieur ou égal à (>=) pour comparer
les valeurs et exécuter le code en fonction de la valeur saisie par l’utilisateur dans un champ de
texte.
Présentation des opérateurs
207
Pour utiliser l’opérateur supérieur ou égal à dans votre code :
1.
Sélectionnez Fichier > Nouveau, puis sélectionnez Document Flash pour créer un nouveau
fichier FLA.
2.
Ajoutez le code suivant à l’image 1 du scénario principal :
this.createTextField("myTxt", 20, 0, 0, 100, 20);
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.lineTo(100, 20);
submit_mc.lineTo(0, 20);
submit_mc.lineTo(0, 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.
Choisissez Contrôle > Tester l’animation pour tester le code ActionScript.
Vous pouvez également vérifier si certaines conditions sont vraies, puis exécuter un autre
bloc si la condition ne l’est pas.
4.
Modifiez la condition de votre code ActionScript de la façon suivante.
if (myNum == 10) {
trace("Your number is 10");
} else {
trace("Your number is not 10");
}
5.
Choisissez Contrôle > Tester l’animation pour tester de nouveau le code ActionScript.
208
Eléments fondamentaux du langage et de la syntaxe
A l’exception de l’opérateur d’égalité stricte (===), les opérateurs de comparaison ne
comparent des chaînes que si les deux opérandes sont des chaînes. Si un seul opérande est une
chaîne, les deux opérandes sont convertis en nombres et une comparaison numérique est
effectuée. Pour plus d’informations sur les chaînes et les opérateurs, consultez la section
Utilisation d’opérateurs avec des chaînes, page 198. Pour plus d’informations sur l’impact de
l’ordre et de la priorité des opérateurs sur votre code ActionScript, consultez la section Priorité
et associativité des opérateurs, page 194.
Présentation des opérateurs d’affectation
Les opérateurs d’affectation prennent deux opérandes et affectent une valeur à l’un d’eux en
fonction de la valeur de l’autre. Tous les opérateurs de ce tableau ont le même ordre de
priorité :
Opérateur Opération effectuée
=
Affectation
*=
Affectation de multiplication
/=
Affectation de division
%=
Affectation modulo
+=
Affectation d’addition
-=
Affectation de soustraction
<<=
Affectation de décalage gauche au niveau du bit
>>=
Affectation de décalage droit au niveau du bit
>>>=
Affectation de décalage droit au niveau du bit non signé
&=
Affectation AND au niveau du bit
^=
Affectation XOR au niveau du bit
|=
Affectation OR au niveau du bit
Pour plus d’informations sur l’utilisation des opérateurs d’affectation, consultez la section
Utilisation des opérateurs d’affectation, page 210.
Présentation des opérateurs
209
Utilisation des opérateurs d’affectation
L’opérateur d’affectation (=) permet d’affecter une valeur donnée à une variable. Vous pouvez
affecter une chaîne à une variable, comme suit :
var myText:String = "ScratchyCat";
Vous pouvez également utiliser l’opérateur d’affectation pour affecter plusieurs variables dans
la même expression. Dans l’instruction suivante, la valeur 10 est affectée aux variables numOne,
numTwo et numThree.
var numOne:Number;
var numTwo:Number;
var numThree:Number;
numOne = numTwo = numThree = 10;
Vous pouvez aussi utiliser des opérateurs d’affectation composés pour combiner des
opérations. Ces opérateurs agissent sur les deux opérandes, puis affectent la nouvelle valeur au
premier. Par exemple, les deux instructions suivantes donnent le même résultat :
var myNum:Number = 0;
myNum += 15;
myNum = myNum + 15;
L’utilisation de l’opérateur d’affectation peut poser problème si vous tentez d’ajouter des
valeurs dans une expression, comme le montre l’exemple suivant :
trace("the sum of 5 + 2 is: " + 5 + 2); // La somme de 5 + 2 est : 52
Flash concatène les valeurs 5 et 2 au lieu de les additionner. Pour contourner le problème,
vous pouvez placer l’expression 5+2 entre parenthèses, comme dans le code suivant :
trace("the sum of 5 + 2 is: " + (5 + 2)); // La somme de 5 + 2 est : 7
Présentation des opérateurs logiques
Les opérateurs logiques comparent des valeurs booléennes (true et false) et renvoient une
troisième valeur booléenne dépendant de la comparaison. Par exemple, si deux opérandes
renvoient true, l’opérateur logique ET (&&) renvoie true. Si l’un des opérandes, ou les deux,
renvoie(nt) true, l’opérateur logique OU (||) renvoie true.
Les opérateurs logiques prennent deux opérandes et renvoient une valeur booléenne. L’ordre
de priorité de ces opérateurs diffère et ils sont présentés dans le tableau suivant par ordre
décroissant de priorité :
Opérateur Opération effectuée
&&
ET logique
||
OU logique
210
Eléments fondamentaux du langage et de la syntaxe
Pour plus d’informations sur l’utilisation des opérateurs logiques, consultez la section
Utilisation des opérateurs logiques, page 211.
Utilisation des opérateurs logiques
Les opérateurs logiques sont souvent utilisés en complément des opérateurs de comparaison
pour déterminer la condition d’une instruction if, comme dans l’exemple suivant.
Pour utiliser des opérateurs logiques dans votre code :
1.
Choisissez Fichier > Nouveau et créez un document Flash.
2.
Dans le panneau Actions, entrez le code ActionScript suivant sur l’image 1 du scénario :
this.createTextField("myTxt", 20, 0, 0, 100, 20);
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.lineTo(100, 20);
submit_mc.lineTo(0, 20);
submit_mc.lineTo(0, 0);
submit_mc.endFill();
submit_mc._x = 110;
submit_mc.onRelease = function():Void {
var myNum:Number = Number(myTxt.text);
if (isNaN(myNum)) {
trace("Please enter a number");
return;
}
if ((myNum > 10) && (myNum < 20)) {
trace("Your number is between 10 and 20");
} else {
trace("Your number is NOT between 10 and 20");
}
};
Dans ce code ActionScript, créez un champ de texte au moment de l’exécution. Si vous
entrez un nombre dans ce champ de texte, puis cliquez sur un bouton de la scène, Flash
utilise l’opérateur logique pour afficher un message dans le panneau de sortie. Le message
dépend de la valeur du nombre saisi dans le champ.
Présentation des opérateurs
211
Lorsque vous utilisez des opérandes, faites bien attention à l’ordre employé, en particulier avec
des conditions complexes. Le code suivant présente l’utilisation de l’opérateur logique AND
pour vérifier qu’un nombre est compris entre 10 et 20. Selon le résultat, un message approprié
s’affiche. Si le nombre est inférieur à 10 ou supérieur à 20, un autre message s’affiche dans le
panneau de sortie.
submit_mc.onRelease = function():Void {
var myNum:Number = Number(myTxt.text);
if (isNaN(myNum)) {
trace("Please enter a number");
return;
}
if ((myNum > 10) && (myNum < 20)) {
trace("Your number is between 10 and 20");
} else {
trace("Your number is NOT between 10 and 20");
}
};
Présentation des opérateurs de décalage au niveau
du bit
Ces opérateurs prennent deux opérandes et décalent les bits du premier selon la valeur
spécifiée dans le second. Tous les opérateurs de ce tableau ont le même ordre de priorité :
Opérateur Opération effectuée
<<
Décalage gauche au niveau du bit
>>
Décalage droit au niveau du bit
>>>
Décalage droit non signé au niveau du bit
Pour plus d’informations sur l’utilisation des opérateurs au niveau du bit, consultez la section
Utilisation des opérateurs au niveau du bit, page 213. Pour des informations spécifiques sur
chaque opérateur au niveau du bit, consultez la section correspondante du Guide de référence
du langage ActionScript 2.0.
212
Eléments fondamentaux du langage et de la syntaxe
Présentation des opérateurs logiques au niveau du bit
Ces opérateurs prennent deux opérandes et effectuent des opérations logiques au niveau des
bits. La priorité de ces opérateurs diffère et ils sont présentés dans le tableau suivant par ordre
décroissant de priorité :
Opérateur Opération effectuée
&
AND au niveau du bit
^
XOR au niveau du bit
|
OR au niveau du bit
Pour plus d’informations sur l’utilisation des opérateurs au niveau du bit, consultez la section
Utilisation des opérateurs au niveau du bit, page 213. Pour des informations spécifiques sur
chaque opérateur au niveau du bit, consultez la section correspondante du Guide de référence
du langage ActionScript 2.0.
Utilisation des opérateurs au niveau du bit
Les opérateurs au niveau du bit manipulent (en interne) les nombres à virgule flottante pour
les transformer en entiers 32 bits. L’opération exacte dépend de l’opérateur, mais toutes les
opérations au niveau du bit évaluent chaque bit d’un entier 32 bits séparément pour calculer
une nouvelle valeur. Pour obtenir la liste des opérateurs de décalage au niveau du bit,
consultez la section Présentation des opérateurs de décalage au niveau du bit, page 212. Pour
obtenir la liste des opérateurs logiques au niveau du bit, consultez la section Présentation des
opérateurs logiques au niveau du bit, page 213.
L’utilisation d’opérateurs au niveau du bit dans Flash n’est pas très fréquente, mais peut se
révéler très utile dans certains cas. Par exemple, vous pouvez créer une matrice d’autorisations
pour un projet Flash, sans créer de variables distinctes pour chaque type d’autorisation. Dans
ce cas, vous pouvez utiliser des opérateurs du niveau du bit.
L’exemple suivant décrit l’utilisation de l’opérateur OR au niveau du bit avec la méthode
Array.sort() pour spécifier les options de tri.
Présentation des opérateurs
213
Pour utiliser l’opérateur OR au niveau du bit :
1.
Choisissez Fichier > Nouveau et créez un document Flash.
2.
Saisissez le code ActionScript suivant dans le panneau Actions :
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
La première ligne définit un tableau de noms aléatoires et les suit dans le panneau de
sortie. Vous appelez ensuite la méthode Array.sort() et spécifiez deux options de tri à
l’aide des valeurs constantes Array.CASEINSENSITIVE et Array.DESCENDING. Cette
méthode trie les éléments du tableau en ordre inverse (de z à a). La recherche ne respecte
pas la casse. Les lettres a et A sont traitées à l’identique, plutôt que d’obtenir un Z avant un
a.
3.
Choisissez Contrôle > Tester l’animation pour tester votre code ActionScript. Le texte
suivant apparaît dans le panneau de sortie :
Bob,Dan,doug,bill,Hank,tom
tom,Hank,doug,Dan,Bob,bill
Cinq options sont disponibles dans la méthode de tri :
■
1 ou Array.CASEINSENSITIVE (binaire = 1)
■
2 ou Array.DESCENDING (binaire = 10)
■
4 ou Array.UNIQUESORT (binaire = 100)
■
8 ou Array.RETURNINDEXEDARRAY (binaire = 1000)
■
16 ou Array.NUMERIC (binaire = 10000)
Trois méthodes différentes permettent de définir les options de tri d’un tableau :
my_array.sort(Array.CASEINSENSITIVE | Array.DESCENDING); // Constantes
my_array.sort(1 | 2); // Nombres
my_array.sort(3); // Ajout de nombres
Bien que cela ne soit pas immédiatement évident, les valeurs des nombres des options de tri
sont en fait des chiffres au niveau du bit (binaire ou base 2). La valeur de la constante
Array.CASEINSENSITIVE est égale à la valeur numérique 1, correspondant également à la
valeur binaire de 1. La valeur de la constante Array.DECENDING est égale à la valeur
numérique 2 ou la valeur binaire 10.
L’utilisation des nombres binaires prête parfois à confusion. Ils n’ont que deux valeurs
possibles, 1 ou 0, raison pour laquelle 2 est représenté par 10. Sous forme binaire, le nombre 3
devient 11 (1+10), le nombre 4 devient 100, 5 devient 101, etc.
214
Eléments fondamentaux du langage et de la syntaxe
Le code ActionScript suivant présente le tri d’un tableau de valeurs numériques par ordre
décroissant via l’utilisation de l’opérateur AND au niveau du bit pour additionner les
constantes Array.DESCENDING et Array.NUMERIC.
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 (binaire -- base 2)
trace(scores.sort(flags)); // 202,198,100,40,20,1
Présentation de l’opérateur conditionnel
L’opérateur conditionnel est un opérateur ternaire, c’est-à-dire qu’il prend trois opérandes. Il
correspond à une méthode abrégée de l’application de l’instruction conditionnelle if..else :
Opérateur Opération effectuée
?:
Conditionnel
Pour plus d’informations sur l’utilisation des opérateurs conditionnels, consultez la section
Opérateur conditionnel et syntaxe alternative, page 165.
Utilisation des opérateurs dans un document
Dans l’exemple suivant, vous utilisez la méthode Math.round() pour arrondir des calculs
selon un nombre arbitraire de décimales. Cette méthode arrondit la valeur du paramètre x à
l’entier immédiatement supérieur ou inférieur et renvoie la valeur. En modifiant légèrement le
code ActionScript, vous pouvez faire en sorte que Flash arrondisse les résultats à un certain
nombre de décimales.
Dans le prochain exemple, vous utilisez également les opérateurs de division et de
multiplication pour calculer la note de l’utilisateur en divisant le nombre de réponses correctes
par le nombre total de questions. La note de l’utilisateur peut ensuite être multipliée par un
certain nombre et être présentée sous forme de pourcentage entre 0 % et 100 %. Vous utilisez
ensuite l’opérateur d’addition pour concaténer la note de l’utilisateur dans une chaîne affichée
dans le panneau de sortie.
Présentation des opérateurs
215
Pour utiliser des opérateurs dans votre code ActionScript :
1.
Créez un nouveau document Flash.
2.
Saisissez le code ActionScript suivant sur l’image 1 du scénario principal :
var correctAnswers:Number = 11;
var totalQuestions:Number = 13;
// Arrondi au nombre entier le plus proche
//var score:Number = Math.round(correctAnswers / totalQuestions * 100);
// Arrondi à deux chiffres après la virgule
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.
Choisissez Contrôle > Tester l’animation.
Le panneau de sortie affiche le texte suivant :
You got 11 out of 13 answers correct, for a score of 84.62%.
Lorsque vous appelez la méthode Math.round() dans cet exemple, la note est arrondie au
nombre entier le plus proche (85) et s’affiche dans le panneau de sortie. Si vous multipliez
le nombre par 100 avant d’appeler la méthode Math.round(), puis le divisez par 100,
Flash arrondit la note à deux chiffres après la virgule. Ainsi, la note est plus précise.
4.
Affectez la valeur 3 à la variable correctAnswers, puis choisissez Contrôle > Tester
l’animation pour tester de nouveau le fichier SWF.
Si vous développez une application de test, vous pouvez créer une série de questions vrai/faux
ou à choix multiples à l’aide des composants RadioButton et Label. Lorsque l’utilisateur a
terminé et clique sur le bouton pour soumettre son questionnaire rempli, vous pouvez
comparer ses réponses aux clés de correction, puis calculer sa note.
216
Eléments fondamentaux du langage et de la syntaxe
6
CHAPITRE 6
Fonctions et méthodes
Lorsque vous créez du code et des classes ActionScript et utilisez des méthodes, il est
important de bien comprendre les fonctions. Vous allez exploiter plusieurs sortes de fonctions.
Ce chapitre vous permet de découvrir les fonctions et les méthodes : comment les utiliser dans
vos applications lorsque vous avez recours à des classes intégrées et comment les écrire. Dans le
Chapitre 7, Classes, vous allez créer des classes personnalisées dans lesquelles vous écrirez
régulièrement des fonctions. Vous découvrirez également comment écrire des fonctions dans
des fichiers de classe ActionScript.
Vous pouvez utiliser des fonctions dans votre code pour ajouter de l’interactivité, des
animations et d’autres effets à vos applications. Ce chapitre traite des types de fonction que
vous pouvez écrire dans vos applications Flash. Pour obtenir des d’informations sur les
fonctions et les méthodes, ainsi que des exercices dans lesquels vous pouvez écrire et utiliser
des fonctions et des méthodes dans Flash, consultez les rubriques suivantes :
Présentation des fonctions et des méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
Fonctionnement des méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
Présentation des fonctions et des
méthodes
Ces éléments sont des blocs de code ActionScript que vous pouvez réutiliser n’importe où
dans un fichier SWF. Vous pouvez écrire une fonction dans le fichier FLA ou dans un fichier
ActionScript externe, puis l’appeler depuis tout emplacement de vos documents. Les
méthodes sont simplement des fonctions placées dans la définition d’une classe ActionScript.
Vous pouvez définir des fonctions pour exécuter une série d’instructions sur des valeurs
transmises. Vos fonctions peuvent également renvoyer des valeurs. Une fois définie, une
fonction peut être appelée à partir de tout scénario, y compris celui d’un fichier SWF chargé.
217
Si vous transmettez des valeurs en tant que paramètres à une fonction, cette dernière peut
exécuter des calculs à l’aide de ces valeurs. Chaque fonction possède ses propres
caractéristiques. Certaines vous demandent de transmettre des types de valeurs ou certaines
valeurs. Si vous transmettez à une fonction plus de valeurs qu’elle n’en réclame, les valeurs
excédentaires sont ignorées. Si vous omettez un paramètre obligatoire, la fonction lui attribue
le type de données non défini. Cet oubli peut provoquer des erreurs au moment de
l’exécution. Une fonction peut également renvoyer des valeurs (consultez la section Renvoi de
valeurs des fonctions, page 238).
REMARQUE
Pour appeler une fonction, sa définition doit se trouver dans l’image que la tête de lecture
a atteinte.
Une fonction bien rédigée peut être considérée comme une « boîte noire ». Si cette fonction
contient des commentaires pertinents et judicieusement placés, au sujet de son entrée, sa
sortie et son rôle, toute personne qui l’utilise n’a pas nécessairement besoin de comprendre son
fonctionnement interne.
La syntaxe de base d’une simple fonction nommée est la suivante :
function traceMe() {
trace("your message");
}
traceMe();
Pour plus d’informations sur l’écriture des fonctions nommées, consultez la section Ecriture
des fonctions nommées, page 223.
La syntaxe de base d’une simple fonction nommée se basant sur l’exemple précédent en
transmettant un paramètre, yourMessage, est la suivante :
function traceMe(yourMessage:String) {
trace(yourMessage);
}
traceMe("How you doing?");
Si vous souhaitez transmettre plusieurs paramètres, vous pouvez utiliser le code suivant :
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);
218
Fonctions et méthodes
Pour plus d’informations sur la transmission de paramètres, consultez la section Transmission
de paramètres à une fonction, page 236.
Vous pouvez écrire de nombreux types de fonction. Pour plus d’informations sur l’écriture de
fonctions et pour obtenir des liens vers des sections sur l’écriture de types de fonction
particuliers, consultez la section Types de méthodes et de fonctions, page 219. Pour un exemple
comparatif entre les méthodes et les fonctions, consultez la section Fonctionnement des
méthodes, page 240.
REMARQUE
Pour plus d’informations sur l’écriture de code à l’aide de l’Assistant de script, consultez
les sections Utilisation de l'Assistant de script pour rédiger du code ActionScript,
page 378, Création d'un événement startDrag/stopDrag à l'aide de l'Assistant de script,
page 382 et le didacticiel ActionScript : Utilisation de l'Assistant Script (qui débute par
Ouverture du document de démarrage, page 227).
Pour plus d’informations sur les fonctions et les méthodes, consultez les rubriques suivantes :
Types de méthodes et de fonctions, page 219
■
Types de méthodes et de fonctions
Les fonctions qui appartiennent à une classe sont considérées comme les méthodes de cette
classe. Dans vos applications, vous pouvez utiliser plusieurs types de fonction, dont des
fonctions intégrées, des fonctions nommées et définies par l’utilisateur, des fonctions
anonymes, des fonctions de rappel, des fonctions constructeur et des littéraux de fonction. Les
sections suivantes contiennent des informations sur la façon de définir ces fonctions.
Vous pouvez également écrire des fonctions dans un fichier ActionScript. Vous les utilisez
comme méthodes dans vos scripts. Dans l’exemple suivant, la classe Person affiche une
méthode de constructeur et des méthodes de classe, d’occurrence et d’accesseur (lecture et
définition). Les commentaires contenus dans cet exemple de code indiquent où ont lieu ces
méthodes dans le code.
R E M A R QU E
Pour plus d’informations sur la rédaction de fichiers de classe comme celui-ci, consultez
le Chapitre 7, Classes, page 243.
class Personne {
public static var numPeople:Number = 0;
// Membres d’occurrence
private var _speed:Number;
// Constructeur
Présentation des fonctions et des méthodes
219
public function Person(speed:Number) {
Person.numPeople++;
this._speed = speed;
}
// Méthodes statiques
public static function getPeople():Number {
return Person.numPeople;
}
// Méthodes d’occurrence
public function walk(speed:Number):Void {
this._speed = speed;
}
public function run():Void {
this._speed *= 2;
}
public function rest():Void {
this._speed = 0;
}
// Lecture/définition (méthodes d’accesseur)
public function get speed():Number {
return this._speed;
}
}
Pour consulter une démonstration complète sur la façon d’écrire des méthodes comme celle
de l’exemple de code précédent, consultez le Chapitre 7, Classes, page 243. Les méthodes
utilisées dans votre code peuvent appartenir à une classe intégrée au langage ActionScript.
MovieClip et Math sont des exemples de classes de niveau supérieur que vous pouvez utiliser
dans une application. Lorsque vous utilisez des méthodes issues de ces classes dans votre code,
il s’agit de fonctions écrites dans la classe intégrée (similaire à l’exemple de code précédent).
Vous pouvez également utiliser les méthodes d’une classe personnalisée que vous créez vousmême.
Les fonctions qui n’appartiennent pas à une classe sont appelées fonctions de niveau supérieur
(ou encore fonctions prédéfinies ou intégrées). Cela signifie que vous pouvez les appeler sans
constructeur. Voici des exemples de fonctions intégrées au niveau supérieur du langage
ActionScript : trace() et setInterval().
Pour ajouter un appel de fonction de niveau supérieur à votre code, il vous suffit d’ajouter une
seule ligne de code dans la fenêtre de script du panneau Actions. Par exemple, tapez ce qui
suit :
trace("my message");
220
Fonctions et méthodes
Lorsque vous testez le fichier SWF avec cette ligne de code unique, la fonction trace() de
niveau supérieur est appelée et du texte apparaît dans le panneau de sortie.
N’oubliez pas que lorsque vous souhaitez affecter une méthode à une propriété, vous devez
omettre les parenthèses après le nom de la méthode puisque vous transmettez une référence à
la fonction :
my_mc.myMethod = aFunction;
Toutefois, lorsque vous invoquez une méthode dans votre code, vous devez inclure les
parenthèses à la suite du nom de la méthode :
my_mc.myMethod();
REMARQUE
Pour plus d’informations sur les fonctions de niveau supérieur, consultez la section
Présentation des fonctions de niveau supérieur et intégrées, page 222.
Vous pouvez également définir des fonctions de nombreuses autres manières. Pour plus
d’informations sur chaque type de fonction, consultez les sections suivantes :
■
Présentation des fonctions de niveau supérieur et intégrées, page 222
■
Ecriture des fonctions nommées, page 223
■
Ecriture de fonctions anonymes et de rappel, page 224
■
Présentation des littéraux de fonction, page 227
■
Ciblage et appel de fonctions définies par l’utilisateur, page 229
■
Présentation des fonctions constructeur, page 228
Pour plus d’informations sur l’écriture et l’utilisation des fonctions et méthodes, consultez les
sections suivantes. Pour plus d’informations sur l’utilisation des fonctions, consultez la section
Utilisation des fonctions dans Flash, page 231. Pour plus d’informations sur l’utilisation des
méthodes, consultez la section Fonctionnement des méthodes, page 240.
R E M A R QU E
Pour plus d’informations sur l’écriture de code à l’aide de l’Assistant de script, consultez
les sections Utilisation de l'Assistant de script pour rédiger du code ActionScript,
page 378, Création d'un événement startDrag/stopDrag à l'aide de l'Assistant de script,
page 382 et le didacticiel ActionScript : Utiliser le mode Assistant de script (qui débute
par Ouverture du document de démarrage, page 227).
Présentation des fonctions et des méthodes
221
Présentation des fonctions de niveau supérieur et intégrées
Comme l’indique la section Présentation des fonctions et des méthodes, page 217, une fonction
est un bloc de code ActionScript qui peut être réutilisé n’importe où dans un fichier SWF. Si
vous transmettez des valeurs en tant que paramètres à une fonction, cette dernière agit en
conséquence. Une fonction peut également renvoyer des valeurs.
Vous pouvez utiliser les fonctions qui sont intégrées au langage ActionScript. Elles peuvent
être de niveau supérieur, comme l’indique la section Types de méthodes et de fonctions,
page 219, ou faire partie d’une classe intégrée, telle que Math ou MovieClip, que vous utilisez
comme méthode dans votre application.
Dans ActionScript, les fonctions intégrées vous permettent d’effectuer certaines tâches et
d’accéder à des informations. Par exemple, à l’aide de la fonction getTimer(), vous pouvez
obtenir la durée, en millisecondes, de la lecture du fichier SWF. A l’aide de la fonction
getVersion(), vous pouvez obtenir le numéro de la version du Flash Player qui héberge le
fichier. Les fonctions appartenant à un objet sont appelées méthodes. Les fonctions qui
n’appartiennent pas à un objet sont appelées fonctions de niveau supérieur et se trouvent dans
les sous-catégories de la catégorie Fonctions globales du panneau Actions.
Certaines fonctions vous obligent à transmettre certaines valeurs. Si vous transmettez plus de
paramètres qu’il n’est nécessaire à la fonction, les valeurs supplémentaires sont ignorées. Si
vous ne transmettez pas un paramètre requis, les paramètres vides reçoivent le type de données
undefined, ce qui peut provoquer des erreurs lors de l’exécution du script.
REMARQUE
Pour appeler une fonction, sa définition doit se trouver dans l’image que la tête de lecture
a atteinte.
Les fonctions de niveau supérieur sont faciles à utiliser. Pour appeler une fonction, utilisez
tout simplement son nom et transmettez les paramètres requis par cette fonction. (Pour plus
d’informations sur les paramètres requis, reportez-vous à l’entrée de la fonction dans le Guide
de référence du langage ActionScript 2.0). Par exemple, ajoutez le code ActionScript suivant à
l’image 1 du scénario :
trace("mon message");
222
Fonctions et méthodes
Lorsque vous testez le fichier SWF, mon message apparaît dans le panneau de sortie. Voici
deux autres exemples de fonctions de niveau supérieur : setInterval() et getTimer().
L’exemple qui suit indique comment utiliser ces deux actions ensemble. Ajoutez le code
suivant à l’image 1 du scénario :
function myTimer():Void {
trace(getTimer());
}
var intervalID:Number = setInterval(myTimer, 100);
Ce code crée un minuteur simple à l’aide de getTimer() et utilise les fonctions de niveau
supérieur setInterval() et trace() pour afficher le temps de lecture écoulé (en
millisecondes) du fichier SWF dans Flash Player.
L’appel d’une fonction de niveau supérieur est identique à celui d’une fonction définie par
l’utilisateur. Pour plus d’informations, consultez la section Ciblage et appel de fonctions définies
par l’utilisateur, page 229. Pour plus d’informations sur les différentes fonctions, consultez les
sections correspondantes du Guide de référence du langage ActionScript 2.0.
Ecriture des fonctions nommées
Une fonction nommée est un type de fonction que vous créez généralement dans votre code
ActionScript pour effectuer tous types d’actions. Lorsque vous créez un fichier SWF, les
fonctions nommées sont d’abord compilées, ce qui signifie que vous pouvez y faire référence à
tout endroit de votre code, tant que la fonction a été définie dans l’image en cours ou une
image précédente. Par exemple, si une fonction est définie dans l’Image 2 d’un scénario, vous
ne pouvez pas accéder à cette fonction dans l’Image 1 du scénario.
Le format standard des fonctions nommées est le suivant :
function functionName(parameters) {
// Bloc de la fonction
}
Cet élément de code contient les parties suivantes :
est le nom unique de la fonction. Tous les noms des fonctions d’un
document doivent être uniques.
■
functionName
■
parameters contient un ou plusieurs des paramètres que vous transmettez à la fonction.
Les paramètres sont parfois appelés arguments. Pour plus d’informations sur les
paramètres, consultez la section Transmission de paramètres à une fonction, page 236.
■
// Bloc de la fonction
contient tout le code ActionScript exécuté par la fonction.
Cette partie contient les instructions « actives ». Vous pouvez y placer le code à exécuter.
Le commentaire // Bloc de la fonction est un espace réservé au code correspondant
au bloc de la fonction.
Présentation des fonctions et des méthodes
223
Pour utiliser une fonction nommée :
1.
Créez un nouveau document appelé namedFunc.fla.
2.
Importez un petit fichier audio dans la bibliothèque. Pour ce faire, cliquez sur Fichier >
Importer > Importer dans la bibliothèque, puis sélectionnez un fichier audio.
3.
Cliquez sur le fichier audio avec le bouton droit de la souris, puis sélectionnez Liaison.
4.
Tapez mySoundID dans le champ Identifiant.
5.
Sélectionnez l’image 1 du scénario, puis ajoutez le code suivant dans le panneau Actions :
function myMessage() {
trace("mySoundID completed");
}
var my_sound:Sound = new Sound();
my_sound.attachSound("mySoundID");
my_sound.onSoundComplete = myMessage;
my_sound.start();
Dans ce code, vous créez une fonction nommée appelée myMessage, que vous utiliserez
ensuite dans le script pour appeler une fonction trace().
6.
Choisissez Contrôle > Tester l’animation pour tester le fichier SWF.
Pour créer votre propre fonction dans ActionScript, utilisez l’instruction function. N’oubliez
pas que les paramètres sont facultatifs. Cependant, même sans paramètres, vous devez inclure
les parenthèses. Le contenu placé entre accolades ({}) est appelé bloc de fonction.
Vous pouvez écrire des fonctions dans le scénario principal ou dans des fichiers ActionScript
externes, y compris des fichiers de classe.
Vous pouvez également écrire des fonctions constructeur dans des fichiers de classe à l’aide de
ce format. Toutefois, dans ce cas, le nom de la fonction correspond à la classe. Pour plus
d’informations sur les fonctions constructeur, consultez la section Ecriture de la fonction
constructeur, page 291. Consultez également le Chapitre 7, Classes, page 243 pour obtenir des
exemples et plus d’informations sur l’écriture de fonctions dans des classes.
Ecriture de fonctions anonymes et de rappel
Une fonction nommée est une fonction à laquelle vous faites référence dans votre script avant
ou après l’avoir définie, tandis qu’une fonction anonyme est une fonction sans nom qui se
référence elle-même. Vous faites référence à la fonction anonyme lors de sa création. En
rédigeant votre code ActionScript, vous créerez de nombreuses fonctions anonymes.
Les fonctions anonymes sont fréquemment utilisées avec les gestionnaires d’événements. Pour
écrire une fonction anonyme, vous pouvez stocker un littéral de fonction dans une variable.
Ainsi, vous pouvez faire référence à la fonction ultérieurement dans votre code. L’exemple
suivant montre l’écriture d’une fonction anonyme.
224
Fonctions et méthodes
Pour écrire une fonction anonyme :
1.
Créez un clip sur la scène, puis sélectionnez-le.
2.
Ouvrez l’inspecteur des propriétés et tapez my_mc dans la zone de texte Nom de
l’occurrence.
3.
Sélectionnez l’image 1 du scénario, puis tapez le code suivant dans le panneau Actions :
var myWidth = function () {
trace(my_mc._width);
};
// Plus loin, vous pouvez ajouter dans le code
myWidth();
4.
Choisissez Contrôle > Tester l’animation.
La largeur du clip apparaît dans le panneau de sortie.
Vous pouvez également créer une fonction dans un objet, tel que XML ou LoadVars. Vous
pouvez associer une fonction anonyme à un événement donné pour créer une fonction de
rappel. Une fonction appelle une fonction de rappel après un événement spécifique, tel que la
fin d’un téléchargement (onLoad()) ou la fin d’une animation (onMotionFinished()).
Par exemple, vous avez parfois besoin d’écrire du code ActionScript pour manipuler des
données chargées dans un fichier SWF à partir du serveur. Après avoir chargé les données dans
un fichier SWF, vous pouvez y accéder depuis cet emplacement. Il est important d’utiliser
ActionScript pour s’assurer que les données ont bien été entièrement chargées. Vous pouvez
utiliser les fonctions de rappel pour envoyer un signal indiquant que les données ont bien été
chargées dans le document.
Dans la fonction de rappel suivante, dans laquelle vous chargez un document XML distant,
vous associez une fonction anonyme à l’événement onLoad(). Vous utilisez XML.load() et la
fonction de rappel, comme le montre l’exemple suivant. Tapez le code suivant dans l’image 1
du scénario :
var my_xml:XML = new XML();
my_xml.onLoad = function(success:Boolean):Void {
trace(success);
};
my_xml.load("http://www.helpexamples.com/crossdomain.xml");
Dans le fragment de code suivant, vous constatez que le gestionnaire d’événement onLoad()
utilise une fonction anonyme pour gérer l’événement onLoad().
Pour plus d’informations sur les fonctions de rappel, consultez le Chapitre 10, Gestion
d’événements, page 359.
Présentation des fonctions et des méthodes
225
Vous pouvez utiliser des fonctions anonymes avec la fonction setInterval(), comme le
montre le code suivant, qui utilise setInterval() pour appeler la fonction anonyme environ
toutes les 100 millisecondes (soit toutes les secondes) :
setInterval(function() {trace("interval");}, 1000);
A la place des fonctions anonymes, vous pouvez utiliser des fonctions nommées. Ces dernières
sont souvent plus faciles à interpréter et à comprendre (sauf dans certaines circonstances, par
exemple dans le cas de fonctions de rappel). Vous pouvez également pré-référencer une
fonction nommée, ce qui signifie que vous y faites référence avant qu’elle n’existe dans le
scénario.
Vous ne pouvez pas référencer une fonction anonyme n’importe où dans votre code (sauf si
vous l’affectez à une variable), alors que vous pouvez le faire avec une fonction nommée.
Supposons par exemple que votre fichier FLA comporte des fonctions anonymes sur
l’Image 5, comme indiqué ci-dessous :
//avec un clip appelé my_mc qui correspond au scénario
stop();
var myWidth = function () {
trace(my_mc._width);
};
Si vous placez le code suivant sur l’Image 1, il ne peut pas faire référence à la fonction :
myWidth();
De la même manière, le code suivant placé sur n’importe quelle image ne fonctionne pas :
myWidth();
var myWidth:Function = function () {
trace(my_mc._width);
};
En revanche, ce code fonctionne correctement :
var myWidth:Function = function () {
trace(my_mc._width);
};
myWidth();
R E MA R Q U E
226
Vous pouvez également placer myWidth() sur n’importe quelle image suivant l’image qui
contient la fonction myWidth.
Fonctions et méthodes
Lorsque vous définissez une fonction nommée, vous pouvez l’appeler dans un script d’image
même si le code équivalent avec une fonction anonyme ne fonctionne pas :
// le code suivant fonctionne car vous appelez une fonction nommée :
myWidth();
function myWidth() {
trace("foo");
}
// le code suivant ne fonctionne pas car vous appelez une fonction anonyme :
myWidth();
var myWidth:Function = function () {
trace("foo");
};
Pour plus d’informations, consultez la section Ecriture des fonctions nommées, page 223.
REMARQUE
Pour plus d’informations sur l’écriture de code à l’aide de l’Assistant de script, consultez
les sections Utilisation de l'Assistant de script pour rédiger du code ActionScript,
page 378, Création d'un événement startDrag/stopDrag à l'aide de l'Assistant de script,
page 382 et le didacticiel ActionScript : Utilisation de l’Assistant Script (qui débute par
Ouverture du document de démarrage, page 227).
Présentation des littéraux de fonction
Un littéral de fonction est une fonction sans nom que vous déclarez dans une expression et non
dans une instruction. Ces fonctions littérales s’avèrent très pratiques lorsque vous devez
utiliser une fonction momentanément ou une fonction dans votre code à la place d’une
expression. La syntaxe des littéraux de fonction est la suivante :
function (param1, param2, etc) {
// instructions
};
Par exemple, le code suivant utilise un littéral de fonction en tant qu’expression :
var yourName:String = "Ester";
setInterval(function() {trace(yourName);}, 200);
R EM A R Q U E
Lorsque vous redéfinissez un littéral de fonction, la nouvelle définition de fonction
remplace l’ancienne.
Vous pouvez stocker un littéral de fonction dans une variable afin d’y accéder ultérieurement
dans votre code. Pour ce faire, vous utilisez une fonction anonyme. Pour plus d’informations,
consultez la section Ecriture de fonctions anonymes et de rappel, page 224.
Présentation des fonctions et des méthodes
227
Présentation des fonctions constructeur
Le constructeur d’une classe est une fonction spéciale appelée automatiquement lorsque vous
créez une occurrence de classe en utilisant le mot-clé new (tel que var my_xml:XML = new
XML();). La fonction constructeur porte le même nom que la classe qui la contient. Par
exemple, une classe Person personnalisée que vous créez contiendrait la fonction constructeur
suivante :
public function Person(speed:Number) {
Person.numPeople++;
this._speed = speed;
}
Vous pouvez alors créer une nouvelle occurrence à l’aide de :
var myPerson:Person = new Person();
REMARQUE
Si vous ne déclarez aucune fonction constructeur explicitement dans votre fichier de
classe, c’est-à-dire, si vous ne créez pas de fonction dont le nom correspond à celui de
la classe, le compilateur crée automatiquement une fonction constructeur vide.
Une classe ne peut contenir qu’une fonction constructeur ; les fonctions constructeur
étendues ne sont pas autorisées dans ActionScript 2.0. En outre, une fonction constructeur ne
peut pas avoir de type de renvoi. Pour plus d’informations sur l’écriture de fonctions
constructeur dans des fichiers de classe, consultez la section Ecriture de la fonction constructeur,
page 291.
Définition des fonctions globales et de scénario
Dans la section Présentation des fonctions et des méthodes, page 217, vous avez découvert les
différentes sortes de fonctions disponibles dans Flash. Comme les variables, les fonctions sont
associées au scénario du clip qui les définit, et vous devez utiliser un chemin cible pour les
appeler. Comme pour les variables, vous pouvez utiliser l’identifiant _global pour déclarer
une fonction globale accessible à tous les scénarios et les domaines sans employer de chemin
cible. Pour définir une fonction globale, faites précéder son nom de l’identifiant _global,
comme illustré ci-dessous :
_global.myFunction = function(myNum:Number):Number {
return (myNum * 2) + 3;
};
trace(myFunction(5)) // 13
Pour plus d’informations sur _global et le domaine, consultez la section Variables et domaine,
page 105.
228
Fonctions et méthodes
Pour définir une fonction de scénario, utilisez l’instruction function suivie du nom de la
fonction, des paramètres qui doivent être transmis à la fonction et des instructions
ActionScript qui indiquent le rôle de la fonction.
L’exemple suivant illustre une fonction nommée areaOfCircle et dotée du paramètre
radius :
function areaOfCircle(radius:Number):Number {
return (Math.PI * radius * radius);
}
trace (areaOfCircle(8));
Vous pouvez également définir des fonctions de nombreuses autres manières. Pour plus
d’informations sur chaque type de fonction, consultez les sections suivantes :
■
Présentation des fonctions de niveau supérieur et intégrées, page 222
■
Ecriture des fonctions nommées, page 223
■
Ecriture de fonctions anonymes et de rappel, page 224
■
Présentation des littéraux de fonction, page 227
■
Présentation des fonctions constructeur, page 228
■
Ciblage et appel de fonctions définies par l’utilisateur, page 229
Pour plus d’informations sur l’appellation des fonctions, consultez la section Appellation des
fonctions, page 231. Pour des exemples concrets d’emploi de fonctions dans un fichier de classe
externe, consultez la section Utilisation des fonctions dans Flash, page 231 et le
Chapitre 7, Classes, page 243.
REMARQUE
Pour plus d’informations sur l’écriture de code à l’aide de l’Assistant de script, consultez
les sections Utilisation de l'Assistant de script pour rédiger du code ActionScript,
page 378, Création d'un événement startDrag/stopDrag à l'aide de l'Assistant de script,
page 382 et le didacticiel ActionScript : Utilisation de l’Assistant Script (qui débute par
Ouverture du document de démarrage, page 227).
Ciblage et appel de fonctions définies par l’utilisateur
Les fonctions définies par l’utilisateur sont celles que vous créez vous-même pour les utiliser
dans vos applications, à la différence des fonctions des classes intégrées qui exécutent des
fonctions prédéfinies. Vous choisissez leur nom et ajoutez des instructions dans le bloc de la
fonction. Les sections précédentes traitent de l’écriture de différentes fonctions (fonctions de
rappel, nommées et sans nom). Pour plus d’informations sur l’appellation des fonctions,
consultez la section Appellation des fonctions, page 231. Pour l’utilisation des fonctions,
consultez la section Utilisation des fonctions dans Flash, page 231.
Présentation des fonctions et des méthodes
229
Vous pouvez utiliser un chemin cible pour appeler une fonction d’un scénario, quel qu’il soit,
à partir de n’importe quel autre scénario, y compris celui d’un fichier SWF chargé. Pour
appeler une fonction, tapez le chemin cible dans son nom, si nécessaire, puis transmettez tous
les paramètres requis entre parenthèses. Il existe plusieurs formes de syntaxe pour les fonctions
définies par l’utilisateur. Le code suivant utilise un chemin pour appeler la fonction
initialize() qui a été définie dans le scénario actuel et n’exige aucun paramètre :
this.initialize();
L’exemple suivant utilise un chemin relatif pour appeler la fonction list() qui a été définie
dans le clip functionsClip :
this._parent.functionsClip.list(6);
Pour plus d’informations sur l’écriture des fonctions nommées, consultez la section Ecriture
des fonctions nommées, page 223. Pour plus d’informations sur les paramètres, consultez la
section Transmission de paramètres à une fonction, page 236.
Vous pouvez également définir vos propres fonctions nommées. Par exemple, la fonction
nommée suivante helloWorld() est définie par l’utilisateur :
function helloWorld() {
trace("Hello world!");
};
L’exemple suivant montre comment utiliser une fonction définie par l’utilisateur dans un
fichier FLA.
Pour créer et appeler une simple fonction définie par l’utilisateur :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom udf.fla.
2.
Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
function traceHello(name:String):Void {
trace("hello, " + name + "!");
}
traceHello("world"); // hello, world!
Le code précédent crée une fonction définie par l’utilisateur appelée traceHello() qui
prend un argument, name, et suit un message de bienvenue. Pour appeler la fonction
définie par l’utilisateur, vous pouvez appeler traceHello à partir du même scénario que la
définition de fonction et transmettre une seule valeur de chaîne.
3.
Choisissez Contrôle > Tester l’animation pour tester le document Flash.
230
Fonctions et méthodes
Pour plus d’informations sur les fonctions nommées, consultez la section Ecriture des fonctions
nommées, page 223. Les classes contiennent de nombreuses fonctions définies par l’utilisateur.
Pour plus d’informations sur l’écriture des fonctions dans des fichiers de classe, consultez la
section Utilisation des fonctions dans Flash, page 231. Consultez également les sections
suivantes dans le Chapitre 7, Classes : Utilisation des méthodes et des propriétés d’un fichier de
classe, page 265, Présentation des méthodes et propriétés (membres) publiques, privées et statiques,
page 267 et Présentation des membres de classe, page 271.
Appellation des fonctions
Les noms de fonction doivent commencer par une minuscule. Ils doivent décrire la valeur
renvoyée par la fonction, le cas échéant. Par exemple, si la fonction renvoie le titre d’une
chanson, nommez-la getCurrentSong().
Etablissez des normes d’appellation pour regrouper les fonctions similaires (celles qui sont
apparentées par leur fonctionnalité), car ActionScript n’autorise pas la surcharge. Dans le cas
de la programmation orientée objet (OOP), la surcharge consiste à autoriser des
comportements différents pour vos fonctions, selon les types de données qui leurs sont passés.
Comme avec les variables, vous ne pouvez pas utiliser de caractères spéciaux et le nom de
méthode ne peut pas débuter par un chiffre. Pour plus d’informations, consultez la section
Conventions d’appellation, page 798. Pour plus d’informations sur l’appellation des méthodes,
consultez la section Appellation des méthodes, page 242.
Utilisation des fonctions dans Flash
Cette section présente l’utilisation des fonctions dans une application. Certains des exemples
de code suivants utilisent du code ActionScript qui réside dans le fichier FLA. Les autres
placent les fonctions dans un fichier de classe à titre de comparaison. Pour obtenir plus
d’informations et des exemples sur l’utilisation des fonctions dans un fichier de classe,
consultez le Chapitre 7, Classes, page 243. Pour obtenir des informations détaillées et des
instructions sur la façon d’écrire des fonctions pour un fichier de classe, consultez la section
Exemple : Ecriture de classes personnalisées, page 285.
Pour réduire la somme de travail nécessaire, ainsi que la taille de votre fichier SWF, réutilisez
des blocs de code existants chaque fois que possible. Pour ce faire, vous pouvez appeler la
même fonction à plusieurs reprises, au lieu de créer du code de toutes pièces à chaque fois. Les
fonctions peuvent comporter du code générique, ce qui permet d’utiliser les mêmes blocs à
des fins légèrement différentes dans un fichier SWF. Le recyclage du code permet de créer des
applications efficaces et de réduire la quantité de code ActionScript à écrire, et donc la durée
du développement.
Présentation des fonctions et des méthodes
231
Vous pouvez créer des fonctions dans un fichier FLA ou de classe ou écrire du code
ActionScript qui réside dans un composant à base de code. Les exemples suivants présentent la
création de fonctions sur un scénario et dans un fichier de classe.
CO NS EIL
En réunissant vos scripts dans des fichiers de classe ou des composants à base de
code, vous pouvez facilement partager, distribuer et réutiliser vos blocs de code.
L’utilisateur peut installer votre composant, le faire glisser sur la scène et utiliser le code
que vous avez stocké dans le fichier, tel que le flux de travail pour les composants à base
de code disponibles dans (Fenêtre > Bibliothèques communes > Classes).
L’exemple suivant montre comment créer et appeler une fonction dans un fichier FLA.
Pour créer et appeler une fonction dans un fichier FLA :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom basicFunction.fla.
2.
Choisissez Fenêtre > Actions pour ouvrir le panneau Actions.
3.
Tapez le code ActionScript suivant dans la fenêtre de script :
function helloWorld() {
// instructions ici
trace("Hello world!");
};
Ce code ActionScript définit la fonction (nommée et définie par l’utilisateur) appelée
helloWorld(). Si vous testez votre fichier SWF à ce stade, rien ne se produit. Par
exemple, vous ne voyez pas l’instruction trace dans le panneau de sortie. Pour ce faire,
vous devez appeler la fonction helloWorld().
4.
Tapez la ligne suivante à la suite de la fonction :
helloWorld();
Ce code appelle la fonction helloWorld().
5.
Choisissez Contrôle > Tester l’animation pour tester le fichier FLA.
Le texte suivant apparaît dans le panneau de sortie : Hello world!
Pour plus d’informations sur la transmission de valeurs (paramètres) à une fonction, consultez
la section Transmission de paramètres à une fonction, page 236.
Il existe plusieurs manières pour écrire des fonctions dans le scénario principal. Les plus
utilisées sont les fonctions nommées et anonymes. Par exemple, vous pouvez utiliser la syntaxe
suivante pour créer des fonctions :
function myCircle(radius:Number):Number {
return (Math.PI * radius * radius);
}
trace(myCircle(5));
232
Fonctions et méthodes
Les fonctions anonymes sont souvent plus difficiles à interpréter. Comparez le code suivant au
précédent.
var myCircle:Function = function(radius:Number):Number {
// Bloc de fonction ici
return (Math.PI * radius * radius);
};
trace(myCircle(5));
Vous pouvez également placer des fonctions dans des fichiers de classe si vous utilisez
ActionScript 2.0, comme l’illustre l’exemple suivant :
class Cercle {
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);
}
}
Pour plus d’informations sur l’écriture de fonctions dans un fichier de classe, consultez le
Chapitre 7, Classes, page 243.
Comme l’indique l’exemple de code précédent, vous n’avez pas besoin de placer des fonctions
sur un scénario. L’exemple suivant place également des fonctions dans un fichier de classe.
Cette technique est judicieuse lorsque vous créez des applications volumineuses à l’aide
d’ActionScript 2.0 car elle vous permet de réutiliser facilement votre code dans plusieurs
applications. Lorsque vous devez utiliser de nouveau les fonctions dans d’autres applications,
vous pouvez importer la classe existante sans avoir à ré-écrire le code de toutes pièces ou
dupliquer les fonctions dans la nouvelle application.
Présentation des fonctions et des méthodes
233
Pour créer des fonctions dans un fichier de classe :
1.
Créez un nouveau document ActionScript, puis enregistrez-le sous le nom Utils.fla.
2.
Tapez le code ActionScript suivant dans la fenêtre de script :
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.
Sélectionnez Fichier > Enregistrer pour enregistrer le fichier ActionScript.
4.
Créez un document Flash et enregistrez-le sous le nom classFunctions.fla dans le même
répertoire que Utils.as.
5.
Choisissez Fenêtre > Actions pour ouvrir le panneau Actions.
6.
Tapez le code ActionScript suivant dans la fenêtre de script :
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
234
Fonctions et méthodes
7.
Choisissez Contrôle > Tester l’animation pour tester les documents. Le texte suivant
apparaît dans le panneau de sortie :
month: 7
min: -3
max: 34
REMARQUE
Pour plus d’informations sur l’écriture de code à l’aide de l’Assistant de script,
consultez les sections Utilisation de l'Assistant de script pour rédiger du code
ActionScript, page 378, Création d'un événement startDrag/stopDrag à l'aide de
l'Assistant de script, page 382 et le didacticiel ActionScript : Utilisation de l’Assistant
Script (qui débute par Ouverture du document de démarrage, page 227).
Utilisation de variables dans les fonctions
Les variables locales sont des outils qui simplifient grandement l’organisation du code et en
facilitent la compréhension. Lorsqu’une fonction utilise des variables locales, elle peut les
cacher à tous les autres scripts du fichier SWF. Les variables locales ont un domaine limité au
corps de la fonction et sont détruites à la sortie de celle-ci. Flash traite également tous les
paramètres transmis à une fonction en tant que variables locales.
REMARQUE
Vous pouvez également utiliser des variables normales dans une fonction. Cependant, si
vous modifiez des variables normales dans une fonction, il est judicieux de commenter
ces changements.
Pour utiliser des variables dans les fonctions :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom flashvariables.fla.
2.
Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
var myName:String = "Ester";
var myAge:String = "65";
var myFavSoftware:String = "Flash";
function traceMe(yourFavSoftware:String, yourName:String,
yourAge:String) {
trace("I’m " + yourName + ", I like " + yourFavSoftware + ", and I’m "
+ yourAge + ".");
}
traceMe(myFavSoftware, myName, myAge);
3.
Choisissez Contrôle > Tester l’animation pour tester le document Flash.
Pour plus d’informations sur la transmission de paramètres, consultez la section Transmission
de paramètres à une fonction, page 236. Pour plus d’informations sur les variables et les
données, consultez le Chapitre 4, Données et types de données, page 77.
Présentation des fonctions et des méthodes
235
Transmission de paramètres à une fonction
Les paramètres, également appelés arguments, sont les éléments sur lesquels une fonction
exécute son code. Dans cet ouvrage, les termes paramètre et argument sont interchangeables.
Vous pouvez transmettre des paramètres (valeurs) à une fonction. Vous pouvez ensuite utiliser
ces paramètres pour le traitement de la fonction. Vous utilisez les valeurs au sein du bloc de la
fonction (ses instructions).
Certains paramètres sont obligatoires, d’autres sont facultatifs. Vous pouvez même avoir des
paramètres obligatoires et facultatifs dans la même fonction. Si vous ne transmettez pas
suffisamment de paramètres à une fonction, Flash définit les valeurs des paramètres
manquants sur undefined, ce qui peut générer des résultats inattendus dans votre fichier
SWF.
La fonction suivante, appelée myFunc(), prend le paramètre someText :
function myFunc(someText:String):Void {
trace(someText);
}
Après la transmission du paramètre, vous pouvez transmettre une valeur à la fonction lorsque
vous appelez celle-ci. Cette valeur apparaît dans le panneau de sortie, comme suit :
myFunc("This is what traces");
Lorsque vous appelez la fonction, vous devez toujours transmettre le nombre de paramètres
spécifié sauf si votre fonction recherche des valeurs indéfinies et si les valeurs par défaut sont
définies en conséquence. La fonction substitue les valeurs transmises aux paramètres de la
définition de la fonction. Si l’un des paramètres est manquant, Flash lui affecte la valeur
undefined. Dans votre code ActionScript, vous êtes fréquemment amené(e) à transmettre des
paramètres aux fonctions.
Vous pouvez également transmettre plusieurs paramètres à la même fonction, aussi
simplement que dans l’exemple suivant :
var birthday:Date = new Date(1901, 2, 3);
trace(birthday);
Les paramètres sont séparés par des virgules. De nombreuses fonctions intégrées du langage
ActionScript possèdent plusieurs paramètres. Par exemple, la méthode startDrag() de la
classe MovieClip prend cinq paramètres : lockCenter, left, top, right et bottom.
startDrag(lockCenter:Boolean, left:Number, top:Number, right:Number,
bottom:Number):Void
236
Fonctions et méthodes
Pour transmettre un paramètre à une fonction :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom parameters.fla.
2.
Ajoutez le code suivant à l’image 1 du scénario :
function traceMe(yourMessage:String):Void {
trace(yourMessage);
}
traceMe("Comment allez-vous ?");
Les premières lignes du code créent une fonction définie par l’utilisateur, appelée
traceMe(), qui prend un seul paramètre, yourMessage. La dernière ligne du code appelle
la fonction traceMe() et transmet la valeur de chaîne “Comment allez-vous ?”.
3.
Choisissez Contrôle > Tester l’animation pour tester le document Flash.
L’exemple suivant montre comment transmettre plusieurs paramètres à une fonction.
Pour transmettre plusieurs paramètres à une fonction :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom functionTest.fla.
2.
Ajoutez le code suivant à l’image 1 du scénario principal :
function getArea(width:Number, height:Number):Number {
return width * height;
}
La fonction getArea() réclame deux paramètres : width et height.
3.
Tapez le code suivant à la suite de la fonction :
var area:Number = getArea(10, 12);
trace(area); // 120
L’appel de la fonction getArea() affecte les valeurs 10 et 12 aux paramètres width et
height, respectivement, et vous enregistrez la valeur renvoyée dans l’occurrence area.
Ensuite, vous suivez les valeurs enregistrées dans l’occurrence area.
4.
Choisissez Contrôle > Tester l’animation pour tester le fichier SWF.
La mention 120 s’affiche dans le panneau de sortie.
Les paramètres de la fonction getArea() sont similaires aux valeurs d’une variable locale :
ils existent tant que la fonction est appelée et cessent d’exister à la sortie de la fonction.
Dans l’exemple suivant, le code ActionScript renvoie la valeur NaN (Non numérique) si vous
ne renseignez pas suffisamment de paramètres dans la fonction addNumbers().
Présentation des fonctions et des méthodes
237
Pour transmettre un nombre variable de paramètres à une fonction :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom functionTest2.fla.
2.
Ajoutez le code suivant à l’image 1 du scénario 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 (Non numérique), c est undefined
trace(addNumbers(1, 4, 6, 8)); // 11
Si vous ne transmettez pas suffisamment de paramètres à la fonction addNumbers, la
valeur undefined est affectée par défaut aux arguments manquants. Si vous en
transmettez trop, les arguments excédentaires sont ignorés.
3.
Choisissez Contrôle > Tester l’animation pour tester le document Flash.
Flash affiche alors les valeurs suivantes : 11, NaN, 11.
Renvoi de valeurs des fonctions
Utilisez l’instruction return pour renvoyer les valeurs des fonctions. L’instruction return
indique la valeur renvoyée par une fonction. L’instruction return renvoie le résultat d’une
évaluation sous la forme d’une valeur de la fonction dans laquelle une expression est exécutée.
L’instruction return renvoie son résultat immédiatement au code appelant.
Pour plus d’informations, consultez la section return statement du Guide de référence du
langage ActionScript 2.0.
Les règles suivantes régissent l’emploi de l’instruction return dans les fonctions :
■
Si vous spécifiez un type de renvoi autre que Void pour une fonction, vous devez inclure
une instruction return suivie par la valeur renvoyée dans la fonction.
■
Si vous spécifiez un type de renvoi Void, l’instruction return est inutile, mais dans ce cas,
elle ne doit être suivie par aucune valeur.
■
Quel que soit le type de renvoi choisi, vous pouvez utiliser une instruction return pour
quitter la fonction en son milieu.
■
Si vous ne spécifiez pas de type de renvoi, l’incorporation d’une instruction return est
facultative.
Par exemple, la fonction suivante renvoie le carré du paramètre myNum et spécifie que la valeur
renvoyée doit être de type Number :
function sqr(myNum:Number):Number {
return myNum * myNum;
}
238
Fonctions et méthodes
Certaines fonctions effectuent une série de tâches sans renvoyer de valeur. L’exemple suivant
renvoie la valeur traitée. Vous récupérez cette valeur dans une variable, puis vous utilisez cette
variable dans votre application.
Pour renvoyer une valeur et la récupérer dans une variable :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom return.fla.
2.
Ajoutez le code suivant à l’image 1 du scénario principal :
function getArea(width:Number, height:Number):Number {
return width * height;
}
La fonction getArea() réclame deux paramètres : width et height.
3.
Tapez le code suivant à la suite de la fonction :
var area:Number = getArea(10, 12);
trace(area); // 120
L’appel de la fonction getArea() affecte les valeurs 10 et 12 aux paramètres width et
height, respectivement, et vous enregistrez la valeur renvoyée dans l’occurrence area.
Ensuite, vous suivez les valeurs enregistrées dans l’occurrence area.
4.
Choisissez Contrôle > Tester l’animation pour tester le fichier SWF.
La mention 120 s’affiche dans le panneau de sortie.
Les paramètres de la fonction getArea() sont similaires aux valeurs d’une variable locale :
ils existent tant que la fonction est appelée et cessent d’exister à la sortie de la fonction.
Présentation des fonctions imbriquées
Vous pouvez appeler une fonction de l’intérieur d’une autre fonction. Ainsi, vous pouvez
imbriquer des fonctions les unes dans les autres pour qu’elles exécutent des tâches spéciales
dans Flash.
Par exemple, vous pouvez imbriquer plusieurs fonctions dans un scénario pour exécuter des
tâches spécifiques sur une chaîne. Tapez le code suivant dans l’image 1 du scénario :
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;
}
// Appel de la fonction.
formatText();
Présentation des fonctions et des méthodes
239
Choisissez Contrôle > Tester l’animation pour tester la fonction imbriquée. Les deux
fonctions formatText() et changeString() sont appliquées à la chaîne lorsque vous appelez
la fonction formatText().
Fonctionnement des méthodes
Les méthodes sont des fonctions associées à une classe. La classe peut être personnalisée ou
intégrée au langage ActionScript. Pour en savoir plus sur la comparaison entre les méthodes et
les fonctions, consultez les sections Présentation des fonctions et des méthodes, page 217 et Types
de méthodes et de fonctions, page 219.
Par exemple, sortOn() est une méthode intégrée associée à la classe Array (sortOn est une
fonction de la classe Array prédéfinie intégrée à Flash).
Pour utiliser la méthode sortOn() dans un fichier FLA :
1.
Créez un nouveau document Flash et enregistrez-le sous le nom methods.fla.
2.
Ajoutez le code suivant à l’image 1 du scénario :
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);
}
Vous utilisez la méthode sortOn() de la classe Array pour créer un nouvel objet Array
appelé userArr. Ce nouveau tableau est rempli par trois objets contenant un prénom et
un âge, puis il est trié sur la base de la valeur de la propriété firstname de chaque objet.
Pour finir, vous passez en boucle sur chaque élément du tableau, vous affichez le prénom
dans le panneau de sortie et vous triez les noms par ordre alphabétique.
3.
Choisissez Contrôle > Tester l’animation pour tester le fichier SWF.
Ce code donne les résultats suivants dans le panneau de sortie :
Dan
George
Socks
240
Fonctions et méthodes
Comme le démontre la section Ecriture des fonctions nommées, page 223, lorsque vous écrivez
le code suivant sur l’image 1 du scénario, votre code ActionScript définit une fonction appelée
eatCabbage().
function eatCabbage() {
trace("tastes bad");
}
eatCabbage();
Toutefois, si vous écrivez la fonction eatCabbage() dans un fichier de classe et que vous
appelez, par exemple, la fonction eatCabbage() dans le fichier FLA, eatCabbage() est
considérée comme une méthode.
Les exemples suivants montrent comment créer des méthodes dans une classe.
Pour comparer des méthodes et des fonctions :
1.
Créez un nouveau fichier ActionScript, sélectionnez Fichier > Enregistrer sous, puis
enregistrez-le sous le nom EatingHabits.as.
2.
Tapez le code ActionScript suivant dans la fenêtre de script :
class EatingHabits {
public function eatCabbage():Void {
trace("tastes bad");
}
}
3.
Enregistrez les modifications apportées au fichier EatingHabits.as.
4.
Créez un nouveau document Flash, sélectionnez Fichier > Enregistrer sous, nommez-le
methodTest.fla, puis enregistrez ce fichier dans le même répertoire que EatingHabits.as.
5.
Tapez le code ActionScript suivant dans l’image 1 du scénario :
var myHabits:EatingHabits = new EatingHabits();
myHabits.eatCabbage();
Lorsque vous utilisez ce code ActionScript, vous appelez la méthode eatCabbage() de la
classe EatingHabits.
R EM A R Q U E
Lorsque vous utilisez des méthodes d’une classe intégrée (en plus de la classe
personnalisée que vous avez créée précédemment dans cette procédure), vous
utilisez une méthode sur un scénario.
Fonctionnement des méthodes
241
6.
A la suite de la ligne ActionScript précédente, ajoutez le code suivant :
function eatCarrots():Void {
trace("tastes good");
}
eatCarrots();
Dans ce code, vous écrivez et appelez la fonction eatCarrots().
7.
Choisissez Contrôle > Tester l’animation pour tester le fichier SWF.
Appellation des méthodes
Utilisez de préférence des verbes pour nommer les méthodes et des casses différentes pour les
mots concaténés, en conservant la première lettre en minuscule. Par exemple, vous pouvez
nommer les méthodes de la façon suivante :
sing();
boogie();
singLoud();
danceFast();
Les verbes sont généralement associés aux noms des méthodes dans la mesure où ces dernières
exécutent une opération sur un objet. Comme avec les variables, vous ne pouvez pas utiliser de
caractères spéciaux et le nom de méthode ne peut pas débuter par un chiffre. Pour plus
d’informations, consultez la section Conventions d’appellation, page 798.
242
Fonctions et méthodes
7
CHAPITRE 7
Classes
Ce chapitre présente l’utilisation et l’écriture des classes avec ActionScript 2.0. Les classes sont
le cœur d’ActionScript 2.0 et leur importance s’est encore accrue dans cette version de
Macromedia Flash. Vous vérifierez par vous-même la véracité de cette assertion tout au long
de ce chapitre.
Ce chapitre commence par présenter la terminologie de base et ses rapports avec les classes et
la programmation orientée objet (OOP). Vous découvrez ensuite un exemple de fichier de
classe, avec le fonctionnement de chacune de ses sections et l’organisation de la classe. Le reste
du chapitre vous guidera dans la création de vos propres classes personnalisées et dans leur
utilisation au sein de vos documents Flash. Vous découvrez les chemins de classe de Flash et
apprenez à documenter vos classes de sorte que les personnes amenées à lire ou utiliser votre
code puissent aisément le comprendre, ainsi que l’objectif général de vos classes.
Cette section contient les exemples de code qui permettent de se familiariser avec la création
de classes dans ActionScript 2.0. A la fin de ce chapitre, vous devriez pouvoir écrire un fichier
de classe typique, comprendre et reconnaître les classes de Flash et être à même de lire sans
peine les fichiers de classes créés par d’autres personnes.
Si vous ne maîtrisez pas la rédaction de scripts ActionScript 2.0, consultez le
Chapitre 5, Eléments fondamentaux du langage et de la syntaxe, page 123 et le
Chapitre 19, Recommandations et conventions de programmation pour ActionScript 2.0,
page 797.
Pour plus d’informations sur l’utilisation des classes intégrées et personnalisée de données,
consultez les rubriques suivantes :
Présentation de la programmation orientée objet et de Flash . . . . . . . . . . . . . . . . 244
Ecriture de fichiers de classe personnalisée. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
Utilisation des classes personnalisées dans une application . . . . . . . . . . . . . . . . . . 257
Exemple : Ecriture de classes personnalisées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .285
Exemple : Utilisation de fichiers de classe personnalisée dans Flash. . . . . . . . . . . 301
Affectation d’une classe à des symboles dans Flash . . . . . . . . . . . . . . . . . . . . . . . . 304
Compilation et exportation de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
243
Distinction entre classes et domaine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Présentation des classes de niveau supérieur et intégrées. . . . . . . . . . . . . . . . . . . . 312
Utilisation des classes intégrées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .322
Présentation de la programmation
orientée objet et de Flash
ActionScript 2.0 est un langage orienté objet. Ces langages reposent sur le concept de classes et
d’occurrences. Une classe définit toutes les propriétés qui distinguent une série d’objets. Par
exemple, une classe User représente un groupe d’utilisateurs qui utilisent votre application.
Puis, vous avez une instanciation de la classe, laquelle, pour la classe User, correspond à l’un
des utilisateurs individuels—l’un des membres de la classe. L’instanciation produit une
occurrence de la classe User qui présente toutes les propriétés de sa classe parent (la classe User).
Les classes sont également considérées comme des types de données ou des modèles, que vous
pouvez créer pour définir un nouveau type d’objet. Par exemple, si vous avez besoin du type
de données Lettuce dans votre application, vous pouvez écrire la classe Lettuce. L’opération
définit l’objet Lettuce et vous permet d’affecter ensuite vos méthodes Lettuce (wash()) et vos
propriétés (leafy ou bugs). Pour définir une classe, vous utilisez le mot-clé class dans un
fichier de script externe. Pour créer ce fichier de script externe dans l’outil de programmation
de Flash, choisissez Fichier > Nouveau puis sélectionnez Fichier ActionScript.
Flash Player 8, disponible dans Flash Basic 8 et Flash Professionnel 8, apporte quelques
fonctionnalités nouvelles au langage ActionScript, telles que des effets de filtre, le chargement
et le téléchargement de fichiers et l’API externe. ActionScript 2.0 reprend plusieurs concepts
et mots-clés de la programmation orientée objet (tels que class, interface et package)
provenant d’autres langages, tels que Java. Le langage de programmation vous permet de créer
des structures logicielles réutilisables, évolutives, fiables et faciles à maintenir. En fournissant
aux utilisateurs une aide à la programmation et des informations de débogage approfondies, il
réduit également les délais de développement. ActionScript2.0 permet de créer des objets et
d’établir des héritages, de créer des classes personnalisées et d’étendre les classes intégrées et de
niveau supérieur de Flash. Dans ce chapitre, vous allez apprendre à créer des classes
personnalisées et à les utiliser.
244
Classes
Flash Basic 8 et Flash Professionnel 8 comprennent près de 65 classes intégrées et de niveau
supérieur couvrant à peu près tous les types de données, de base ou primitifs (Array, Boolean,
Date, etc.), jusqu’aux erreurs et événements personnalisés, ainsi que plusieurs moyens de
charger du contenu externe (XML, images, données binaires brutes, etc.). Vous pouvez
également écrire vos propres classes personnalisées et les intégrer dans vos documents Flash,
ou encore étendre les classes de niveau supérieur et ajouter vos propres fonctionnalités ou
modifier celles qui existent. Par exemple, la section Présentation des membres de classe,
page 271, de ce chapitre explique comment créer une classe personnalisée qui contient des
propriétés personnalisées pour le nom et l’âge des individus. Vous pouvez ensuite traiter cette
classe personnalisée comme un nouveau type de données dans vos documents et en créer une
nouvelle occurrence à l’aide du nouvelopérateur.
Pour plus d’informations sur l’utilisation des OOP, consultez les rubriques suivantes :
■
Avantages de l’utilisation des classes, page 245
■
Présentation des packages, page 246
■
Présentation des valeurs et des types de données, page 249
■
Bases de la programmation orientée objet., page 250
Avantages de l’utilisation des classes
En programmation orientée objet, une classe définit une catégorie d’objets. Une classe décrit
les propriétés (données) et les méthodes (comportements) d’un objet, comme un plan
d’architecte décrit les caractéristiques d’un immeuble. Vous écrivez votre classe personnalisée
dans un fichier ActionScript (AS) externe et pouvez ensuite l’importer dans votre application
lorsque vous compilez le fichier FLA.
Les classes se révèlent très utiles lors du développement d’applications Flash volumineuses car
elles permettent d’organiser une grande partie de la complexité du code dans des fichiers de
classes externes. Lorsque vous déplacez une bonne partie du code vers une classe
personnalisée, vous simplifiez non seulement la réutilisation ultérieure du code, mais vous
pouvez également « masquer » certaines des méthodes et propriétés des autres parties du code
ActionScript. Vous évitez ainsi que les utilisateurs accèdent à des informations confidentielles
ou puissent modifier des données qui ne doivent pas l’être.
En utilisant une classe, vous pouvez également étendre les classes existantes et ajouter de
nouvelles fonctionnalités ou modifier celles qui existent. Par exemple, si vous créez trois classes
très similaires, vous pouvez écrire une classe de base, puis deux autres classes qui étendent la
première. Ces deux classes peuvent ajouter des méthodes et des propriétés supplémentaires,
ainsi il n’est pas nécessaire de créer trois fichiers de classe dupliquant tous le même code et la
même logique.
Présentation de la programmation orientée objet et de Flash
245
La possibilité de réutilisation du code est un autre avantage des classes. Par exemple, si vous
créez une classe personnalisée qui crée une barre de progression personnalisée via l’interface de
programmation d’applications de dessin (API), vous pouvez enregistrer la classe de la barre de
progression dans votre chemin de classe, puis réutiliser le même code dans tous vos documents
Flash en important la classe personnalisée Pour plus d’informations sur la configuration du
chemin de classe, consultez les sections Importation de fichiers de classe, page 259 et Définition
et modification du chemin de classe, page 260.
Présentation des packages
Lorsque vous créez des classes, placez vos fichiers de classe ActionScript dans des packages. Un
package est un répertoire qui contient un ou plusieurs fichiers de classe et qui réside dans un
répertoire de chemin de classe désigné (consultez les sections Importation de fichiers de classe,
page 259 et Définition et modification du chemin de classe, page 260). Un package peut
également contenir d’autres packages, appelés sous-packages, chacun possédant ses propres
fichiers de classe.
Comme les variables, les noms de packages doivent être des identifiants. Ainsi, le premier
caractère peut être une lettre, un caractère de soulignement (_) ou le signe dollar ($), et chaque
caractère suivant doit être une lettre, un nombre, un caractère de soulignement ou le signe
dollar. Il y a des façons conseillées de nommer des packages, par exemple en évitant d’utiliser
des caractères de soulignement ou le signe dollar. Pour plus d’informations sur les appellations
des packages, consultez la section Appellation des packages, page 808.
Les packages sont généralement utilisés pour organiser des classes connexes. Vous pouvez par
exemple avoir trois classes connexes, Square, Circle et Triangle, définies dans Square.as,
Circle.as et Triangle.as. Supposons que vous ayez enregistré les fichiers ActionScript dans un
répertoire spécifié dans le chemin de classe, comme dans l’exemple suivant:
// Dans Square.as :
class Square {}
// Dans Circle.as :
class Circle {}
// Dans Triangle.as :
class Triangle {}
Étant donné que ces trois classes sont connexes, vous pouvez choisir de les placer dans un
package (répertoire) nommé Shapes. Dans ce cas, le nom pleinement qualifié de la classe
contient le chemin du package, ainsi que le nom de classe simple. Les chemins de package
sont symbolisés par une syntaxe de point (.), chaque point représentant un sous-répertoire.
246
Classes
Par exemple, si vous placez tous les fichiers ActionScript qui définissent une forme dans le
répertoire Shapes, vous devrez alors changer le nom de chaque fichier de classe pour répercuter
le nouvel emplacement, comme suit :
// Dans Shapes/Square.as :
class Shapes.Square {}
// Dans Shapes/Circle.as :
class Shapes.Circle {}
// Dans Shapes/Triangle.as :
class Shapes.Triangle {}
Pour faire référence à une classe qui réside dans un répertoire de package, vous pouvez soit
spécifier son nom pleinement qualifié, soit importer son package à l’aide de l’instruction
import. Pour plus d’informations, consultez la section Fonctionnement des packages, page 248.
Comparaison des classes et des packages
En programmation orientée objet, une classe définit une catégorie d’objets. Les classes sont
avant tout des types de données que vous pouvez créer pour définir un nouveau type d’objet
dans votre application. La classe décrit les propriétés (données) et les comportements (méthodes)
d’un objet, comme un plan d’architecte décrit les caractéristiques d’un immeuble. Les
propriétés (variables définies au sein d’une classe) et les méthodes d’une classe sont
collectivement appelées membresde la classe. Pour utiliser les propriétés et méthodes définies
par une classe, vous devez tout d’abord créer une occurrence de cette classe (sauf pour les
classes comportant tous les membres statiques (consultez les sections Présentation des membres
(statiques) de classe, page 325, telle que la classe de niveau supérieur Math, et Méthodes et
propriétés statiques, page 269). La relation entre une occurrence et sa classe est similaire à la
relation entre une maison et ses plans.
Dans Flash, les packages sont des répertoires qui contiennent un ou plusieurs fichiers de classe
et résident dans un chemin de classe désigné. Placez tous les fichiers de classes personnalisées
connexes dans un même répertoire Par exemple, vous pourriez avoir trois classes appelées
SteelWidget, PlasticWidget et WoodWidget définies dans SteelWidget.as, PlasticWidget.as et
WoodWidget.as et les organiser dans le package Widget. Pour plus d’informations sur les
packages, consultez les sections Fonctionnement des packages, page 248 et Création et mise en
package de vos fichiers de classe, page 288.
Présentation de la programmation orientée objet et de Flash
247
Fonctionnement des packages
Les packages sont des répertoires qui contiennent un ou plusieurs fichiers de classe et résident
dans un répertoire de chemin de classe désigné. Par exemple, le package flash.filters est un
répertoire sur votre disque dur contenant plusieurs fichiers de classe pour chaque type de filtre
(tels que BevelFilter, BlurFilter, DropShadowFilter, etc.) dans Flash 8.
REMARQUE
Pour utiliser l’instruction import, vous devez spécifier ActionScript 2.0 et Flash Player 6
ou une version plus récente dans l’onglet Flash de la boîte de dialogue Paramètres de
publication de votre fichier FLA.
L’instruction import permet d’accéder aux classes sans spécifier leur nom complet, avec
qualificatifs. Par exemple, si vous souhaitez utiliser la classe BlurFilter dans un script, vous
devez y faire référence avec son nom suivi de tous ses attributs (flash.filters.BlurFilter) ou
l’importer. Si vous l’importez, vous pouvez y faire référence avec son nom de classe
(BlurFilter). Le code ActionScript suivant démontre les différences entre l’utilisation de
l’instruction import et l’utilisation des noms de classes pleinement qualifiés.
Si vous n’importez pas la classe BlurFilter, votre code devra comporter les noms de classes
pleinement qualifiés (le nom du package suivi par le nom de classe) afin d’utiliser le filtre :
// sans importation
var myBlur:flash.filters.BlurFilter = new flash.filters.BlurFilter(10, 10,
3) ;
Le même code, écrit avec une instruction import, vous permet d’accéder à BlurFilter en
utilisant seulement le nom de classe au lieu de devoir toujours utiliser le nom complet du
service. Cela peut éviter d’avoir à retaper, et réduire ainsi les éventuelles erreurs de
typographies :
// avec importation
import flash.filters.BlurFilter ;
var myBlur:BlurFilter = new BlurFilter(10, 10, 3);
Si vous importez plusieurs classes au sein d’un package (par exemple, BlurFilter,
DropShadowFilter, et GlowFilter) il vous est possible d’utiliser l’une des deux méthodes pour
importer chaque classe. La première méthode d’importation de classes multiples est
d’importer chaque classe en utilisant une instruction import séparée, comme indiqué dans le
fragment suivant :
import flash.filters.BlurFilter ;
import flash.filters.DropShadowFilter ;
import flash.filters.GlowFilter ;
248
Classes
L’utilisation d’instructions import individuelles pour chaque classe dans un package peut
prendre beaucoup de temps et conduire à des erreurs de typographie. La deuxième méthode
d’importation de classes dans un package est d’utiliser un import générique, qui importe
toutes les classes dans le niveau donné d’un package. L’ActionScript suivante montre un
exemple d’utilisation d’un import générique :
import flash.filters.*; // importe chaque classe dans le package
flash.filters
L’instruction import s’applique uniquement au script courant (image ou objet) dans lequel
elle est appelée. Par exemple, supposons que vous deviez importer l’ensemble des classes du
package macr.util dans l’image 1 d’un document Flash. Dans cette image, vous pouvez faire
référence aux classes de ce package par leur nom de classe au lieu de leurs noms complets. Si
vous souhaitez cependant utiliser le nom de classe dans un autre script d’image, vous devez
faire référence aux classes de ce package par leur nom complet, ou ajouter une instruction
import à l’autre image qui importe les classes dans ce package.
Lors de l’utilisation d’instructions import, Il est également important de noter que les classes
sont importées seulement pour le niveau indiqué. Par exemple, si vous avez importé toutes les
classes dans le package mx.transitions, seules les classes du répertoire /transitions/ sont
importées, et non toutes les classes des sous-répertoires (telles les classes du package
mx.transitions.easing).
CONSEIL
Si vous importez une classe, mais ne l’utilisez pas dans votre script, cette dernière n’est
pas exportée avec le fichier SWF. Ceci signifie que vous pouvez importer des packages
volumineux sans vous soucier de la taille du fichier SWF. Le pseudo-code binaire
associé à une classe n’est inclus dans un fichier SWF que si cette classe est
véritablement utilisée.
Présentation des valeurs et des types de données
Les données, les valeurs et les types sont des concepts importants lorsque vous commencez à
écrire des classes et à les utiliser. Vous avez étudié les fichiers et types dans le
Chapitre 4, Données et types de données, page 77. Lorsque vous travaillez avec des classes,
n’oubliez pas que les types de données décrivent la nature des informations qu’une variable ou
qu’un élément ActionScript peut contenir, par exemple Boolean, Number et String. Pour plus
d’informations, consultez Présentation des types de données, page 78.
Présentation de la programmation orientée objet et de Flash
249
Les expressions ont des valeurs alors que les valeurs et les propriétés ont des types. Les valeurs
que vous pouvez définir et obtenir pour et à partir d’une propriété de votre classe doivent être
compatibles avec cette propriété. La compatibilité de type signifie que le type d’une valeur est
compatible avec le type utilisé, comme dans l’exemple suivant :
var myNum:Number = 10;
Pour plus d’informations sur le typage strict des données, consultez la section Affectation des
types de données et typage strict, page 88.
Bases de la programmation orientée objet.
Au cours des sections suivantes, vous allez vous familiariser avec la terminologie employée tout
au long de ce chapitre avant de commencer à écrire du code ActionScript. Cette brève
introduction aux principes du développement orienté objet vous aide à mieux comprendre les
exemples et les sections de ce chapitre et du reste de ce manuel. Ces principes sont présentés
de façon plus approfondie dans le reste de ce chapitre ; ainsi que les détails de leur
implémentation dans Flash 8.
Les sections suivantes utilisent l’analogie d’un chat en démontrant comment les chats peuvent
être comparés à des concepts de programmation orientée objet.
Objets
Pensez à un objet du monde réel, un chat, par exemple. Supposons qu’un chat ait des
propriétés (ou états), telles que nom, âge et couleur, et des comportements, tels que dormir,
manger et ronronner. Dans le monde de la programmation orientée objet, les objets ont
également des propriétés et des comportements. En utilisant les techniques de programmation
orientée objet, vous pouvez modeler un objet du monde réel (comme un chat) ou quelque
chose de plus abstrait (un processus chimique, par exemple).
R E M A R QU E
Le mot comportement est utilisé ici au sens général et ne fait pas référence au panneau
Comportements de l’environnement de programmation de Flash.
Pour plus d’informations sur les objets, consultez la section Type de données Object, page 85.
250
Classes
Occurrences et membres de classe
Reprenons, si vous le voulez bien, l’analogie du chat. Supposons qu’il existe des chats de
couleur, d’âge et de nom différents, qui mangent et ronronnent de façon différente.
Indépendamment de leurs différences individuelles, tous les chats appartiennent à la même
catégorie, qui en termes de programmation orientée objet serait appelée une classe : la classe
des chats. Dans la terminologie de la programmation orientée objet, chaque chat est une
occurrence de la classe Cat.
De même, en programmation orientée objet, une classe définit un modèle de type d’objets.
Les caractéristiques et comportements qui appartiennent à une classe sont appelés membres de
cette classe. Les caractéristiques (dans l’exemple du chat, nom, âge et couleur) sont appelées
propriétés de la classe et sont représentées sous forme de variables. Les comportements (jouer,
dormir) sont appelés méthodes de la classe et sont représentés sous forme de fonctions.
Pour plus d’informations sur les occurrences et membres de classe, consultez les sections
Présentation des membres de classe, page 271 et Utilisation de membres de classe, page 275.
Héritage
L’un des principaux avantages de la programmation orientée objet est que vous pouvez créer
des sous-classes de la classe ou étendre la classe. La sous-classe hérite alors de l’ensemble des
propriétés et méthodes de la classe. La sous-classe définit en général des méthodes et propriétés
supplémentaires ou annule les méthodes ou propriétés définies dans la super-classe. Les sousclasses peuvent également supplanter (apporter leurs propres définitions) les méthodes
définies dans une super-classe.
L’un des principaux avantages de l’utilisation de la structure super-classe/sous-classe est qu’il
est plus simple de réutiliser un code similaire entre divers classes. Par exemple, vous pouvez
créer une super-classe appelée Animal, contenant les caractéristiques et les comportements
communs à tous les animaux. Vous pouvez ensuite créer plusieurs sous-classes qui héritent de
la super-classe Animal et ajoutent les caractéristiques et les comportements d’un type d’animal
spécifique.
Vous pouvez créer une classe Chat qui hérite d’une autre classe. Par exemple, vous créez une
classe Mammifère qui définit certaines propriétés et certains comportements communs à tous
les mammifères. Vous pouvez alors créer une sous-classe Chat qui permet d’étendre la classe
Mammifère. Une autre sous-classe, la classe Siamois par exemple, peut étendre la classe Chat
(sous-classe), et ainsi de suite.
Présentation de la programmation orientée objet et de Flash
251
L’écriture de sous-classes vous permet de réutiliser le code. Au lieu de créer à nouveau le code
commun aux deux classes, il vous suffit d’étendre la classe existante.
CONSEIL
Dans une application complexe, la définition de la structure hiérarchique des classes
représente une partie essentielle du processus de conception. Assurez-vous de bien
définir cette hiérarchie avant de démarrer la programmation.
Pour plus d’informations sur les héritages et les sous-classes, consultez le Chapitre 8, Héritage,
page 329.
Interfaces
En programmation orientée objet, les Interfaces peuvent être décrites comme des modèles de
définitions de classe, et les classes qui les implémentent servent à implémenter ce modèle de
méthodes. En utilisant l’analogie du chat, une interface est similaire à un modèle de chat : Le
modèle vous informe des parties dont vous avez besoin, mais pas nécessairement de quelle
façon ces parties sont assemblées, ou comment elles travaillent.
Vous pouvez utiliser les interfaces pour ajouter de la structure et une facilité de maintenance à
vos applications. Étant donné qu’ActionScript 2.0 ne prend en charge que l’extension d’une
seule superclasse, vous pouvez utiliser des interfaces comme forme d’héritage multiple limité.
Une interface peut également être considérée comme un « contrat de programmation »
destiné à imposer des relations entre des classes non connexes. Par exemple, supposons que
vous travailliez avec une équipe de programmeurs et que chacun de vous travaille sur une
partie (classe) différente de la même application. Lors de la réalisation de l’application, vous
vous mettez d’accord sur un ensemble de méthodes utilisées par les différentes classes pour
communiquer. Ainsi, vous créez une interface qui déclare ces méthodes, leurs paramètres et
leurs types de retour. Toute classe qui implémente cette interface doit fournir des définitions
pour ces méthodes ; dans le cas contraire, il se produit une erreur du compilateur.
Pour plus d’informations sur les héritages, consultez le Chapitre 8, Héritage, page 329. Pour
plus d’informations sur les interfaces, consultez le Chapitre 9, Interfaces, page 343.
252
Classes
Encapsulation
Dans une conception orientée objet intelligente, les objets sont considérés comme des « boîtes
noires » qui contiennent ou encapsulent des fonctionnalités. Un programmeur doit pouvoir
interagir avec un objet en ne connaissant que ses propriétés, ses méthodes et ses événements
(son interface de programmation), sans connaître les détails de son implémentation. Cette
approche permet aux programmeurs d’atteindre un niveau supérieur d’abstraction et met en
place un cadre de structuration pour la création de systèmes complexes.
L’encapsulation permet à ActionScript 2.0 d’inclure, par exemple, le contrôle de l’accès des
membres, de sorte que les détails de l’implémentation restent privés et invisibles pour tout
codage en dehors d’un objet. Le code situé en dehors d’un objet doit interagir avec l’interface
de programmation de l’objet plutôt qu’avec les détails d’implémentation (qui peuvent être
dissimulés dans les méthodes et propriétés privées). Cette approche présente des avantages
importants. Par exemple, elle permet au créateur de l’objet de changer son implémentation
sans modifier le code externe à l’objet, tant que l’interface de programmation reste inchangée.
Pour plus d’informations sur l’encapsulation, consultez la section Utilisation de l’encapsulation,
page 283.
Polymorphisme
La programmation orientée objet permet d’exprimer les différences entre les classes
individuelles par une technique appelée polymorphisme, qui permet aux classes de supplanter
les méthodes de leurs super-classes et de définir des implémentations spécialisées de ces
méthodes. Dans Flash, les sous-classes peuvent définir des implémentations spécialisées de
méthodes héritées de sa superclasse, mais ne peuvent accéder à l’implémentation de la
superclasse, comme dans d’autres langages de programmation.
Par exemple, vous pouvez commencer par une classe appelée Mammifère qui comporte les
méthodes play() et sleep(). Vous créez ensuite les sous-classes Chat, Singe et Chien pour
étendre la classe Mammifère. Les sous-classes supplantent la méthode play() de la classe
Mammal, de façon à représenter de façon plus réaliste ces types d’animaux. La classe Singe
implémente la méthode play() pour se balancer aux arbres ; la classe Chat implémente la
méthode play() pour courir après une pelote ; la classe Chien implémente la méthode
play() pour rapporter une balle. Dans la mesure où la fonctionnalité sleep() reste similaire
quel que soit l’animal, vous utilisez l’implémentation de super-classe.
Pour plus d’informations sur le polymorphisme, consultez le Chapitre 8, Héritage, page 329 et
la section Utilisation du polymorphisme dans une application, page 338.
Présentation de la programmation orientée objet et de Flash
253
Ecriture de fichiers de classe
personnalisée
L’exemple suivant présente les différentes parties d’un fichier de classe. Vous apprenez à écrire
une classe et à la modifier pour étendre son utilisation avec Flash. Vous découvrez également
les différentes parties d’une classe et comment les importer, de même que des informations sur
la manipulation des fichiers de classe personnalisée dans Flash.
Nous allons commencer par une classe très simple. L’exemple suivant présente l’organisation
d’une classe simple appelée UserClass.
Pour définir une classe, utilisez le mot-clé class dans un fichier de script externe (et non dans
le script en cours de rédaction dans le panneau Actions). La structure de la classe concerne
également les fichiers d’interface. Cette structure est illustrée ci-dessous, suite à quoi vous allez
créer une classe.
■
Le fichier de classe commence par des commentaires de documentation qui incluent une
description générale du code, en plus des informations sur l’auteur et la version.
■
Ajoutez vos instructions d’importation (le cas échéant).
■
Ecrivez une instruction de package, une déclaration de classe ou d’interface, comme suit :
class UserClass {...}
■
Incluez tout commentaire d’implémentation de classe ou d’interface nécessaire. Dans ces
commentaires, ajoutez des informations pertinentes pour l’ensemble de la classe ou de
l’interface.
■
Ajoutez toutes vos variables statiques. Ecrivez les variables de classe publiques en premier,
suivies des variables de classe privées.
■
Ajoutez des variables d’occurrence. Ecrivez les variables de membre publiques en premier,
suivies des variables de membre privées.
■
Ajoutez l’instruction de constructeur, par exemple celui de l’exemple suivant :
public function UserClass(username:String, password:String) {...}
■
Écrivez vos méthodes. Regroupez-les par fonctionnalités et non par accessibilité ou
domaine. En organisant les méthodes de cette manière, vous améliorez la lisibilité et la
clarté de votre code.
■
Ecrivez les méthodes de lecture/définition dans le fichier de classe.
L’exemple suivant examine une simple classe ActionScript nommée User.
254
Classes
Pour créer des fichiers de classe :
1.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK.
2.
Choisissez Fichier > Enregistrer sous et nommez le fichier User.as.
3.
Saisissez le code ActionScript suivant dans la fenêtre de script :
/**
Classe User
auteur : John Doe
version : 0.8
modifié le : 08/21/2005
copyright : Macromedia, Inc.
Ce code définit une classe User personnalisée qui vous permet de créer
de nouveaux utilisateurs et de spécifier leurs informations de
connexion.
*/
class User {
// Variables d’occurrence privées
private var __username:String ;
private var __password:String;
// Instruction de constructeur
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;
}
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;
}
}
Ecriture de fichiers de classe personnalisée
255
4.
Enregistrez les modifications apportées au fichier de classe.
Le code précédent commence par un commentaire de documentation standard, qui indique
le nom de la classe, l’auteur, la version, la date de la dernière modification, les
informations de copyright et une brève description de la fonction de la classe.
L’instruction de constructeur de la classe User demande deux paramètres : p_username et
p_password, copiés dans les variables d’occurrence privés __username et __password de
la classe. Le reste du code de la classe définit les propriétés de lecture et de définition pour
les variables d’occurrence privées. Si vous voulez créer une propriété en lecture seule,
définissez une fonction de lecture, et non de définition. Par exemple, pour être certain
qu’un nom d’utilisateur ne peut plus être modifié après sa définition, supprimez la
fonction de définition username dans le fichier de la classe User.
5.
Choisissez Fichier > Nouveau, puis Document Flash.
6.
Choisissez Fichier > Enregistrer sous et nommez le fichier user_test.fla. Enregistrez le
fichier dans le même répertoire que User.as.
7.
Saisissez le code ActionScript suivant sur l’image 1 du scénario :
Importation utilisateur ;
var user1:User = new User("un1", "pw1");
trace("Before:");
trace("\t username = " + user1.username);
trace("\t password = " + user1.password);
user1.username = "1nu";
user1.password = "1wp";
trace("After:");
trace("\t username = " + user1.username);
trace("\t password = " + user1.password);
// un1
// pw1
// 1nu
// 1wp
La classe User créée précédemment étant très simple, le code ActionScript du document
Flash est également très direct. La première ligne de code importe la classe User
personnalisée dans votre document Flash. L’importation de cette classe User permet
d’utiliser la classe comme un type de données personnalisé.
Une seule occurrence de la classe User est définie et affectée à une variable nommée user1.
Vous affectez une valeur à l’objet User user1 et définissez un nom d’utilisateur un1 et
un mot de passe pw1. Les deux instructions trace suivantes affichent la valeur actuelle
de user1.username et user1.password via les fonctions de lecture de la classe User, qui
retournent toutes les deux des chaînes. Les deux lignes suivantes utilisent les fonctions de
définition de la classe User pour définir de nouvelles valeurs pour les variables username et
password. Enfin, vous envoyez les valeurs des variables username et password au
panneau de sortie. Les instructions trace affichent les valeurs modifiées que vous avez
définies via les fonctions de définition.
256
Classes
8.
Enregistrez le fichier FLA, puis choisissez Contrôle > Tester l’animation pour tester les
fichiers.
Les résultats des instructions trace s’affichent dans le panneau de sortie. Dans les
exemples suivants, vous utilisez ces fichiers dans une application.
Un fichier exemple sur votre disque dur montre comment créer un menu dynamique avec les
données XML et un fichier de classe personnalisée. Cet exemple appelle le constructeur
ActionScript XmlMenu() et lui transmet deux paramètres : Le chemin d’accès au fichier menu
XML et une référence au scénario actuel. Le reste de la fonctionnalité réside dans un fichier de
classe personnalisée, XmlMenu.as.
Vous trouverez l’exemple de fichier source, xmlmenu.fla, dans le dossier Samples de votre
disque dur.
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\
Flash 8\Samples et Tutorials\Samples\ActionScript\XML_Menu.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples et Tutorials/Samples/ActionScript/XML_Menu.
Utilisation des classes personnalisées
dans une application
Dans la section Ecriture de fichiers de classe personnalisée, page 254, vous avez créé un fichier de
classe personnalisée. Dans les sections suivantes, vous utilisez ce fichier de classe dans une
application. Le flux de travail de création de classes implique au minimum les étapes suivantes :
1.
Définition d’une classe dans un fichier de classe ActionScript externe. Pour plus
d’informations sur la définition et l’écriture d’un fichier de classe, consultez la section
Ecriture de fichiers de classe personnalisée, page 254.
2.
Enregistrement du fichier de classe dans un répertoire de chemin de classe spécifique
(emplacement où Flash recherche les classes) ou dans le même répertoire que le fichier FLA
de l’application. Pour plus d’informations sur la définition du chemin de classe, consultez
la section Définition et modification du chemin de classe, page 260. Pour une comparaison et
plus d’informations sur l’importation de classes, consultez la section Importation de fichiers
de classe, page 259.
3.
Création d’une occurrence de la classe dans un autre script, soit dans un document FLA,
soit dans un fichier de script externe, ou création d’une sous-classe basée sur la classe
d’origine. Pour plus d’informations sur la création d’une occurrence de classe, consultez la
section Création d’occurrences de classes dans un exemple, page 303.
Utilisation des classes personnalisées dans une application
257
Les sections suivantes contiennent des exemples de code qui vous permettent de vous
familiariser avec la création de classes dans ActionScript 2.0. Si vous ne maîtrisez pas
ActionScript 2.0, consultez le Chapitre 4, Données et types de données, page 77 et le
Chapitre 5, Eléments fondamentaux du langage et de la syntaxe, page 123.
Pour plus d’informations sur l’utilisation des classes personnalisées, consultez les rubriques
suivantes :
■
Importation de fichiers de classe, page 259
■
Utilisation d’un fichier de classe dans Flash, page 264
■
Utilisation des méthodes et des propriétés d’un fichier de classe, page 265
■
Présentation des membres de classe, page 271
■
Présentation des méthodes de lecture et définition, page 276
■
Résolution des références de classe par le compilateur, page 264
■
Présentation des classes dynamiques, page 280
■
Utilisation de l’encapsulation, page 283
■
Utilisation du mot-clé this dans les classes, page 284
Un fichier exemple sur votre disque dur montre comment créer un menu dynamique avec les
données XML et un fichier de classe personnalisée. Cet exemple appelle le constructeur
ActionScript XmlMenu() et lui transmet deux paramètres : Le chemin d’accès au fichier menu
XML et une référence au scénario actuel. Le reste de la fonctionnalité réside dans un fichier de
classe personnalisée, XmlMenu.as.
Vous trouverez l’exemple de fichier source, xmlmenu.fla, dans le dossier Samples de votre
disque dur.
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples et Tutorials\Samples\ActionScript\XML_Menu.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples et Tutorials/Samples/ActionScript/XML_Menu.
258
Classes
Importation de fichiers de classe
Pour pouvoir utiliser une classe ou une interface que vous avez définie, Flash doit pouvoir
localiser les fichiers ActionScript externes qui contiennent la définition de la classe ou de
l’interface ; il peut ainsi importer le fichier. La liste des répertoires dans lesquels Flash
recherche les définitions de classe, d’interface, de fonction et de variable est appelée chemin de
classe. Flash a deux paramètres de chemin de classe - un chemin de classe global et un chemin
de classe au niveau du document :
■
Le chemin de classe global est un chemin de classe partagé par tous les documents Flash.
Vous le définissez dans la boîte de dialogue Préférences (Edition > Préférences (Windows)
ou Flash > Préférences (Macintosh), cliquez sur ActionScript dans la liste Catégorie, puis
sur Paramètres ActionScript 2.0).
■
Le chemin de classe au niveau du document est un chemin de classe défini de façon
spécifique pour un seul document Flash. Il est défini dans la boîte de dialogue Paramètres
de publication (Fichier > Paramètres de publication, sélectionnez l’onglet Flash, puis
cliquez sur le bouton Paramètres).
Lorsque vous importez des fichiers de classe, les règles suivantes s’appliquent :
■
Les instructions d’importation peuvent se trouver aux emplacements suivants :
■
N’importe où avant la définition de classe des fichiers de classe
■
N’importe où dans les scripts d’image ou d’objet
■
■
N’importe où dans les fichiers ActionScript que vous incluez dans une application (en
utilisant l’instruction #include).
La syntaxe suivante permet d’importer des définitions individuelles mises en package :
importer flash.display.BitmapData ;
■
La syntaxe de caractère générique permet d’importer des packages entiers :
import flash.display.*;
Vous pouvez également inclure le code ActionScript dans un fichier Flash (FLA) à l’aide d’une
instruction include. Les règles suivantes s’appliquent à l’instruction include :
■
Les instructions include sont pour l’essentiel un copier-coller du contenu dans le fichier
ActionScript inclus.
■
Les instructions include utilisées dans les fichiers ActionScript sont liées au sousrépertoire qui contient le fichier.
Utilisation des classes personnalisées dans une application
259
■
Dans un document FLA, une instruction include ne peut apporter que du code valide
dans les fichiers FLA. Cette restriction est également vraie pour les autres emplacements
comprenant des instructions include. Par exemple, si vous avez une instruction include
dans une définition de classe, seules les définitions de propriétés et de méthodes peuvent
être présentes dans le fichier ActionScript inclus :
// Foo.as
classe Foo {
#include "FooDef.as"
}
// FooDef.as:
var fooProp;
fonction fooMethod() {}
trace("Foo"); // Cette instruction est interdite dans une définition de
classe.
Pour plus d’informations sur l’instruction include, consultez #include directive dans le Guide
de référence du langage ActionScript 2.0. Pour plus d’informations sur les chemins de classe,
consultez la section Définition et modification du chemin de classe, page 260.
Définition et modification du chemin de classe
Pour utiliser une classe ou une interface que vous avez définie, Flash doit localiser les fichiers
ActionScript externes qui contiennent sa définition. La liste des répertoires dans lesquels Flash
recherche les définitions de classe et d’interface est appelée chemin de classe.
Lorsque vous créez un fichier de classe ActionScript, vous devez enregistrer le fichier dans l’un
des répertoires spécifiés dans le chemin de classe, ou dans l’un de ses sous-répertoires. (Vous
pouvez modifier le chemin de classe pour inclure le chemin souhaité.) Sinon, Flash ne sera pas
en mesure de résoudre (localiser) la classe ou l’interface spécifiée dans le script. Les sousrépertoires que vous créez dans un répertoire de chemin de classe sont appelés packages. Ils
vous permettent d’organiser vos classes. (Pour plus d’informations sur les packages, consultez
la section Création et mise en package de vos fichiers de classe, page 288.)
Flash dispose de deux paramètres de chemin de classe : un chemin de classe global et un chemin
de classe au niveau du document. Le chemin de classe global est celui que partagent tous vos
documents Flash. Le chemin de classe au niveau du document est celui qui est défini
spécialement pour un seul document Flash.
260
Classes
Le chemin de classe global s’applique aux fichiers ActionScript externes et aux fichiers FLA ;
vous les définissez dans la boîte de dialogue (Windows: Edition > Préférences (Windows) ou
Flash > Préférences (Macintosh), puis sélectionnez ActionScript dans la liste Catégories, puis
cliquez sur les Paramètres ActionScript 2.0). Vous pouvez définir le chemin de classe au niveau
du document dans la boîte de dialogue Paramètres de publication (Fichier > Paramètres de
publication, et sélectionnez l’onglet Flash, puis cliquez sur le bouton Paramètres).
REMARQUE
Lorsque vous cliquez sur le bouton de vérification de la syntaxe situé au-dessus de la
fenêtre de script lors de la modification d’un fichier ActionScript, le compilateur
n’examine que le chemin de classe global. Les fichiers ActionScript ne sont pas associés
aux fichiers FLA en mode édition et ne disposent pas de leur propre chemin de classe.
Utilisation d’un chemin de classe global
Le chemin de classe global est celui que partagent tous vos documents Flash.
Vous pouvez modifier le chemin de classe global à l’aide de la boîte de dialogue Préférences.
Pour modifier le paramètre de chemin de classe au niveau du document, utilisez la boîte de
dialogue Paramètres de publication pour le fichier FLA. Dans les deux cas, vous pouvez
ajouter des chemins de répertoires absolus (par exemple C:/mes_classes) et des chemins de
répertoires relatifs (par exemple, ../mes_classes ou « . »). L’ordre des répertoires dans la
boîte de dialogue correspond à l’ordre de recherche.
Par défaut, le chemin de classe global contient un chemin absolu et un chemin relatif. Le
chemin absolu est indiqué par $(LocalData)/Classes dans la boîte de dialogue Préférences.
L’emplacement du chemin absolu est indiqué ici :
■
Windows : Hard Disk\Documents and Settings\user\Local Settings\Application
Data\Macromedia\Flash 8\language\Configuration\Classes.
■
Macintosh : Hard Disk/Users/user/Library/Application Support/Macromedia/Flash 8/
language/Configuration/Classes.
REMARQUE
Ne supprimez pas le chemin de classe global absolu. Flash l’utilise pour accéder aux
classes intégrées. Si vous supprimez ce chemin de classe par inadvertance,
rétablissez-le en ajoutant $(LocalData)/Classes comme nouveau chemin de classe.
La section chemin relatif du chemin de classe global est identifiée par un point (.) et cette
section pointe vers le répertoire de documents actuel. Notez que les chemins de classe relatifs
peuvent pointer vers des répertoires différents, en fonction de l’emplacement du document
compilé ou publié.
Utilisation des classes personnalisées dans une application
261
La procédure suivante permet d’ajouter un chemin de classe global ou de modifier un chemin
de classe existant.
Pour modifier le chemin de classe global :
1.
Sélectionnez Edition > Préférences (Windows) ou Flash > Préférences (Macintosh) et
cliquez sur la boite de dialogue Préférences.
2.
Dans la colonne de gauche, cliquez sur ActionScript, puis sur le bouton Paramètres
d’ActionScript 2.0.
3.
Cliquez sur le bouton Rechercher le chemin et localisez le dossier que vous souhaitez
ajouter.
4.
Rechercher le chemin que vous souhaitez ajouter, puis cliquez sur OK.
Pour supprimer un répertoire du chemin de classe :
1.
Sélectionnez le chemin dans la liste des chemins de classe.
2.
Cliquez sur le bouton Supprimer du chemin.
REMARQUE
Ne supprimez pas le chemin de classe global absolu. Flash l’utilise pour accéder aux
classes intégrées. Si vous supprimez ce chemin de classe par inadvertance, vous
pouvez le rétablir en ajoutant $(LocalData)/Classes comme nouveau chemin de
classe.
Pour plus d’informations sur l’importation des packages, consultez la section Fonctionnement
des packages, page 248.
Utilisation d’un chemin de classe au niveau du document
Le chemin de classe au niveau du document ne s’applique qu’aux fichiers FLA. Vous définissez
le chemin de classe au niveau du document dans la boîte de dialogue Paramètres de
publication d’un fichier FLA spécifique (Fichier > Paramètres de publication, puis cliquez sur
l’onglet Flash et sur les Paramètres d’ActionScript 2.0). Le chemin de classe au niveau du
document est vide par défaut. Lorsque vous créez et enregistrez un fichier FLA dans un
répertoire, ce dernier devient un répertoire du chemin de classe désigné.
Lorsque vous créez des classes, il peut être nécessaire de les placer dans un répertoire que vous
ajoutez ensuite à la liste de répertoires de chemin de classe globaux dans les situations
suivantes :
■
Si vous avez un ensemble de classes d’utilitaires que tous vos projets utilisent
■
Si vous souhaitez vérifier la syntaxe de votre code (cliquez sur le bouton Vérifier la syntaxe)
dans le fichier ActionScript externe
262
Classes
La création d’un répertoire permet d’empêcher la perte de classes personnalisées si vous devez
désinstaller puis réinstaller Flash ou si le répertoire du chemin de classe global est supprimé ou
remplacé.
Par exemple, vous pouvez créer le répertoire suivant pour vos classes personnalisées :
■
Windows : Hard Disk\Documents et Paramètres\utilisateur\classes personnalisées.
■
Macintosh : Hard Disk\Utilisateurs /utilisateur/classes personnalisées.
Vous devez ensuite ajouter ce chemin à la liste de chemins de classe globaux (consultez la
section Utilisation d’un chemin de classe global, page 261).
Lorsque Flash tente de résoudre les références à des classes dans un script FLA, il recherche en
premier le chemin de classe de niveau document spécifié pour ce fichier FLA. Si la classe ne
figure pas dans ce chemin de classe ou si cette classe est vide, Flash recherche le chemin de
classe global. Si Flash ne trouve pas la classe dans le chemin de classe global, une erreur de
compilation se produit.
Pour modifier le chemin de classe au niveau du document :
1.
Choisissez Fichier > Paramètres de publication pour ouvrir la boîte de dialogue Paramètres
de publication.
2.
Cliquez sur l’onglet Flash.
3.
Cliquez sur le bouton Paramètres en regard du menu déroulant Version d’ActionScript.
4.
Vous pouvez saisir le chemin du fichier manuellement ou cliquer sur le bouton Rechercher
le chemin pour localiser le répertoire à ajouter au chemin de classe.
REMARQUE
Pour modifier un répertoire de chemin de classe existant, sélectionnez le chemin
dans la liste Chemin de classe, cliquez sur le bouton Rechercher le chemin, ouvrez le
répertoire que vous souhaitez ajouter et cliquez sur OK.
REMARQUE
Pour supprimer un répertoire du chemin de classe, sélectionnez le chemin dans la
liste Chemin de classe, puis cliquez sur le bouton Supprimer le chemin sélectionné ().
Pour plus d’informations sur les packages, consultez la section Présentation des packages,
page 246.
Utilisation des classes personnalisées dans une application
263
Résolution des références de classe par le
compilateur
Lorsque Flash tente de résoudre les références de classe dans un script FLA, il recherche en
premier le chemin de classe de niveau document spécifié pour ce fichier FLA. Si la classe ne
figure pas dans ce chemin de classe ou si cette classe est vide, Flash recherche le chemin de
classe global. Si la classe n’est pas trouvée dans le chemin de classe global, une erreur de
compilation se produit.
Dans Flash Professionnel, lorsque vous cliquez sur le bouton Vérifier la Syntaxe pendant la
modification d’un fichier ActionScript, le compilateur consulte uniquement le chemin de
classe global ; les fichiers ActionScript ne sont pas associés à des FLA en mode Edition et ne
disposent pas de leur propre chemin de classe.
Utilisation d’un fichier de classe dans Flash
Pour créer une occurrence de classe ActionScript, utilisez l’opérateur new pour appeler la
fonction constructeur de la classe. La fonction constructeur porte toujours le même nom que
la classe dont elle renvoie une occurrence, que vous affectez généralement à une variable. Par
exemple, si vous utilisez la classe User de la section Ecriture de fichiers de classe personnalisée,
page 254, vous pouvez écrire le code suivant pour créer un nouvel objet User :
var firstUser:User = new User();
REMARQUE
Dans certains cas, il n’est pas nécessaire de créer une occurrence de classe pour
employer ses propriétés et ses méthodes. Pour plus d’informations sur les membres
(statiques) de classe, consultez les sections Présentation des membres (statiques) de
classe, page 325 et Méthodes et propriétés statiques, page 269.
Utilisez l’opérateur point (.) pour accéder à la valeur d’une propriété dans une occurrence.
Entrez le nom de l’occurrence à gauche du point et le nom de la propriété à droite. Par
exemple, dans l’instruction suivante, firstUser représente l’occurrence et username la
propriété :
firstUser.username
Dans un document Flash, vous pouvez également utiliser les classes intégrées ou de niveau
supérieur qui composent le langage ActionScript. Le code suivant crée par exemple un nouvel
objet Array, puis affiche sa propriété length :
var myArray:Array = new Array("apples", "oranges", "bananas");
trace(myArray.length); // 3
264
Classes
Pour plus d’informations sur l’utilisation des classes personnalisées, consultez l’Exemple :
Utilisation de fichiers de classe personnalisée dans Flash, page 301. Pour plus d’informations sur
les fonctions constructeur, consultez la section Ecriture de la fonction constructeur, page 291.
Utilisation des méthodes et des propriétés d’un fichier
de classe
En programmation orientée objet, les membres (propriétés ou méthodes) d’une classe peuvent
être des membres d’occurrence ou de classe. Les membres d’occurrence sont créés pour chaque
occurrence de la classe ; ils sont définis sur le prototype de la classe lorsqu’ils sont initialisés
dans la définition de classe. Par contraste, les membres de classe sont créés une fois par classe
(ils sont également appelés membres statiques).
Les propriétés sont des attributs qui définissent un objet. Par exemple, length est une
propriété qui s’applique à tous les tableaux et spécifie le nombre d’éléments qu’ils contiennent.
Les méthodes sont des fonctions associées à une classe. Pour plus d’informations sur les
fonctions et les méthodes, consultez le Chapitre 6, Fonctions et méthodes, page 217.
L’exemple suivant décrit la création d’une méthode dans un fichier de classe :
exemple de classe {
public function myMethod():Void {
trace("myMethod");
}
}
Vous pourriez ensuite invoquer cette méthode dans votre document. Pour invoquer une
méthode d’occurrence ou accéder à une propriété d’occurrence, faites référence à une
occurrence de la classe. Dans l’exemple suivant, picture01, une occurrence de la classe
personnalisée Picture (disponible dans l’exercice suivant), appelle la méthode showInfo() :
var img1:Picture = new Picture("http://www.helpexamples.com/flash/images/
image1.jpg");
// Invocation de la méthode showInfo().
img1.showInfo();
L’exemple suivant présente l’écriture d’une classe personnalisée Picture qui stocke les divers
éléments d’informations relatifs à une photo.
Utilisation des classes personnalisées dans une application
265
Pour utiliser les classes Picture et PictureClass dans un fichier FLA :
1.
Choisissez Fichier > Nouveau, puis sélectionnez Fichier ActionScript. Enregistrez le
document sous le nom Picture.as puis cliquez sur OK.
Vous écrivez votre classe Picture personnalisée dans ce document.
2.
Saisissez le code ActionScript suivant dans la fenêtre de script :
/**
Classe Picture
auteur : John Doe
version : 0.53
modifié le : 6/24/2005
copyright : Macromedia, Inc.
La classe Picture est utilisée comme conteneur d’une image et de son
URL.
*/
classe 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.
Enregistrez le fichier ActionScript.
4.
Choisissez Fichier > Nouveau, puis Document Flash pour créer un nouveau fichier FLA.
Enregistrez-le sous le nom picture_test.fla dans le même répertoire que le fichier de classe
Picture.
266
Classes
5.
Saisissez le code ActionScript suivant sur l’image 1 du scénario :
var picture1:Picture = new Picture("http://www.helpexamples.com/flash/
images/image1.jpg");
picture1.showInfo();
this.createEmptyMovieClip("img_mc", 9);
img_mc.loadMovie(picture1.src);
6.
Enregistrez le document Flash.
7.
Choisissez Contrôle > Tester l’animation pour tester le document.
Le texte suivant apparait dans le panneau Sortie :
[Picture src=http://www.helpexamples.com/flash/images/image1.jpg]
Un fichier exemple sur votre disque dur montre comment créer un menu dynamique avec les
données XML et un fichier de classe personnalisée. Cet exemple appelle le constructeur
ActionScript XmlMenu() et lui transmet deux paramètres : Le chemin d’accès au fichier menu
XML et une référence au scénario actuel. Le reste de la fonctionnalité réside dans un fichier de
classe personnalisée, XmlMenu.as.
Vous trouverez l’exemple de fichier source, xmlmenu.fla, dans le dossier Samples de votre
disque dur.
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\
Flash 8\Samples et Tutorials\Samples\ActionScript\XML_Menu.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples et Tutorials/Samples/ActionScript/XML_Menu.
Présentation des méthodes et propriétés (membres)
publiques, privées et statiques
Lorsque vous écrivez des fichiers de classe ActionScript dans un fichier de script externe, vous
pouvez créer quatre types de méthodes et propriétés. méthodes et propriétés publiques,
méthodes et propriétés privées, méthodes et propriétés publiques statiques, et propriétés et
méthodes privées et statiques. Ces méthodes et propriétés définissent l’accès de Flash aux
variables et permettent de spécifier les parties du code autorisées à accéder à certaines
méthodes et propriétés.
Utilisation des classes personnalisées dans une application
267
Lorsque vous développez des applications, petites ou grandes, à base de classes, il est
particulièrement important de déterminer si une méthode ou une propriété doit être privée ou
publique. Ces précautions vous permettent de sécuriser votre code autant que possible. Par
exemple, si vous développez une classe User, vous souhaiterez peut-être ne pas autoriser les
utilisateurs qui s’en servent à modifier l’identifiant des utilisateurs. En définissant la propriété
de la classe (parfois appelée membre d’occurrence) comme privée, vous pouvez limiter l’accès à
la propriété au code de la classe ou à des sous-classes de cette classe, et empêcher ainsi tout
autre utilisateur de la modifier directement.
Méthodes et propriétés publiques
Le mot-clé public indique qu’une variable ou une fonction est accessible à tout appelant. Les
variables et les fonctions étant publiques par défaut, le mot-clé this est surtout utilisé pour
des raisons de style et de lisibilité, indiquant que la variable existe dans le domaine actuel.
Vous pouvez par exemple employer le mot-clé this pour des raisons de cohérence dans un
bloc de code qui contient également des variables privées ou statiques. Le mot-clé this peut
être utilisé avec le mot-clé public ou privé.
La classe Sample suivante présente déjà une méthode publique nommée myMethod() :
exemple de classe {
private var ID:Number;
public function myMethod():Void {
this.ID = 15;
trace(this.ID); // 15
trace("myMethod");
}
}
Pour ajouter une propriété publique, utilisez le mot-clé "public" au lieu de "private", comme
dans l’exemple de code suivant :
exemple de classe {
private var ID:Number;
public var email:String;
public function myMethod():Void {
trace("myMethod");
}
}
La propriété email étant publique, vous pouvez la modifier dans la classe Sample, ou
directement dans un fichier FLA.
268
Classes
Méthodes et propriétés privées
Le mot-clé private spécifie qu’une variable ou une fonction est accessible uniquement par la
classe qui la déclare ou la définit, ou par les sous-classes de cette classe. Par défaut, une variable
ou une fonction est publique et accessible par tout appelant. Utilisez le mot-clé this lorsque
vous souhaitez restreindre l’accès à une variable ou une fonction, comme dans l’exemple
suivant :
exemple de classe {
private var ID:Number;
public function myMethod():Void {
this.ID = 15;
trace(this.ID); // 15
trace("myMethod");
}
}
Pour ajouter une propriété privée à la classe précédente, il vous suffit d’utiliser le mot-clé
private avant le mot-clé var.
Si vous tentez d’accéder à la propriété ID privée depuis l’extérieur de la classe Sample, vous
obtenez une erreur de compilation et une erreur de référence dans le panneau de sortie. Le
message indique que le membre est privé et n’est pas accessible.
Méthodes et propriétés statiques
Le mot-clé static spécifie qu’une variable ou une fonction n’est créée qu’une fois par classe et
non pas dans chaque objet basé sur cette classe. Vous pouvez accéder à un membre de classe
statique sans créer une occurrence de sa classe. Les propriétés et méthodes statiques peuvent
être définies dans le domaine public ou privé.
Les membres statiques, également appelés membres de la classe, sont affectés à la classe et non à
n’importe quelle occurrence de la classe. Pour invoquer une méthode de classe ou accéder à
une propriété de classe, faites référence au nom de la classe plutôt qu’à l’une de ses
occurrences, comme indiqué dans le code suivant :
trace(Math.PI / 8); // 0.392699081698724
Si vous saisissez cette seule ligne de code dans la fenêtre de script du panneau Actions, le
résultat s’affiche dans le panneau de sortie.
Utilisation des classes personnalisées dans une application
269
Par exemple, dans la classe Sample précédente, vous auriez pu créer une variable statique pour
garder une trace du nombre d’occurrences créées de cette classe, comme dans le code suivant :
exemple de classe {
public static var count:Number = 0;
private var ID:Number;
public var email:String;
public function Sample() {
Sample.count++;
trace("count updated: " + Sample.count);
}
public function myMethod():Void {
trace("myMethod");
}
}
Chaque fois que vous créez une nouvelle occurrence de la classe Sample, la méthode
constructeur suit le nombre total de classes Sample d’occurrence définies jusque-là.
Certaines classes ActionScript de niveau supérieur disposent de membres de classe (ou
membres statiques), comme vous l’avez vu précédemment dans cette section lorsque vous avez
appelé la propriété Math.PI. Pour invoquer les membres de classe (propriétés et méthodes) ou
y accéder, vous utilisez le nom de la classe, et non l’une de ses occurrences. Il ne faut donc pas
créer une occurrence de la classe pour utiliser ces propriétés et méthodes.
Par exemple, la classe de niveau supérieur Math comprend uniquement des méthodes et des
propriétés statiques. Pour appeler ses méthodes, au lieu de créer une occurrence de la classe
Math, appelez tout simplement les méthodes de la classe Math. Le code suivant appelle la
méthode sqrt() de la classe Math :
var squareRoot:Number = Math.sqrt(4);
trace(squareRoot); // 2
Le code suivant appelle la méthode max() de la classe Math afin de déterminer lequel de deux
nombres est le plus grand :
var plusGrandNombre:Number = Math.max(10, 20);
trace(largerNumber); // 20
Pour plus d’informations sur la création de membres de classe, consultez les sections
Présentation des membres de classe, page 271 et Utilisation de membres de classe, page 275.
Un fichier exemple sur votre disque dur montre comment créer un menu dynamique avec les
données XML et un fichier de classe personnalisée. Cet exemple appelle le constructeur
ActionScript XmlMenu() et lui transmet deux paramètres : Le chemin d’accès au fichier menu
XML et une référence au scénario actuel. Le reste de la fonctionnalité réside dans un fichier de
classe personnalisée, XmlMenu.as.
270
Classes
Vous trouverez l’exemple de fichier source, xmlmenu.fla, dans le dossier Samples de votre
disque dur.
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples et Tutorials\Samples\ActionScript\XML_Menu.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples et Tutorials/Samples/ActionScript/XML_Menu.
Présentation des membres de classe
La plupart des membres (méthodes et propriétés) abordés jusqu’à présent dans ce chapitre font
partie d’un type appelé membre d’occurrence. Pour chaque membre d’occurrence, il existe une
copie unique de ce membre dans chaque occurrence de la classe. Par exemple, la variable du
membre email de la classe Sample a un membre d’occurrence, dans la mesure où chaque
personne a une adresse de messagerie différente.
Vous disposez également d’un autre type de membre, appelé membre de classe. Il ne peut y
avoir qu’une seule copie d’un membre de classe, et vous l’utilisez pour l’ensemble de la classe.
Toute variable déclarée dans une classe, mais en dehors d’une fonction, est une propriété de la
classe. Dans l’exemple suivant, la classe Person a deux propriétés, age et username,
respectivement de type chaîne et nombre.
class Person {
public var age:Number;
public var userName:String ;
}
De la même façon, toute fonction déclarée dans une classe est considérée comme étant une
méthode de cette classe. Dans l’exemple de la classe Person, vous pouvez créer une méthode
unique appelée getInfo() :
class Person {
public var age:Number;
public var userName:String ;
public function getInfo():String {
// définition de la méthode getInfo()
}
}
Dans le code précédent, la méthode getInfo() de la classe Person, ainsi que les propriétés
age et username, sont toutes des membres d’occurrence publics. La propriété age ne
constituerait pas un bon membre de classe, car chaque personne a un âge différent. Seules les
propriétés et les méthodes qui sont partagées par l’ensemble des individus de la classe doivent
être des membres de classe.
Utilisation des classes personnalisées dans une application
271
Supposons que chaque classe doit disposer d’une variable appelée species, afin de donner le
nom latin des espèces représentées par la classe. Pour chaque objet Person, l’espèce est Homo
sapiens. Il serait fastidieux de stocker une copie unique de la chaîne « Homo sapiens » pour
chaque occurrence de la classe, ce qui implique que ce membre soit un membre de classe.
Les membres de classe sont déclarés avec le mot-clé static. Par exemple, vous pouvez déclarer
le membre de classe species avec le code suivant :
class Person {
public static var species:String = "Homo sapiens";
// ...
}
Vous pouvez également déclarer les méthodes d’une classe comme étant statiques, comme
illustré par l’exemple de code suivant :
public static function getSpecies():String {
return Person.species;
}
Les méthodes statiques ne peuvent accéder qu’aux propriétés statiques, pas aux propriétés
d’occurrence. Par exemple, le code suivant génère une erreur de compilation, car la méthode
de classe getAge() fait référence à la variable d’occurrence age :
class Personne {
public var age:Number = 15;
// ...
public static function getAge():Number {
return age; /* **Error**: Il est impossible d’accéder aux variables
d’occurrence dans des fonctions statiques. */
}
}
Pour résoudre ce problème, vous pouvez soit faire de la méthode une méthode d’occurrence,
soit faire de la variable une variable de classe.
Pour plus d’informations sur les membres de classe (ou propriétés statiques), consultez la
section Méthodes et propriétés statiques, page 269.
Un fichier exemple sur votre disque dur montre comment créer un menu dynamique avec les
données XML et un fichier de classe personnalisée. Cet exemple appelle le constructeur
ActionScript XmlMenu() et lui transmet deux paramètres : Le chemin d’accès au fichier menu
XML et une référence au scénario actuel. Le reste de la fonctionnalité réside dans un fichier de
classe personnalisée, XmlMenu.as.
272
Classes
Vous trouverez l’exemple de fichier source, xmlmenu.fla, dans le dossier Samples de votre
disque dur.
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples et Tutorials\Samples\ActionScript\XML_Menu.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples et Tutorials/Samples/ActionScript/XML_Menu.
Utilisation du modèle de conception Singleton
L’un des modes d’utilisation de membres de classe le plus répandu est le modèle de conception
Singleton. Un modèle de conception définit une approche formelle destinée à structurer votre
code. En général, vous concevez un modèle de structure pour résoudre un problème de
programmation courant. Il existe de nombreux modèles de conception, tels que Singleton. Ce
modèle permet de s’assurer que chaque classe ne dispose que d’une seule occurrence et offre
une méthode globale d’accès à l’occurrence. Pour des informations détaillées sur le modèle de
conception Singleton, consultez le site www.macromedia.com/devnet/mx/coldfusion/articles/
design_patterns.html.
Certaines situations nécessitent un objet d’un type spécifique dans un système. Par exemple,
un jeu d’échec implique un échiquier unique et chaque pays n’a qu’une seule capitale. Bien
qu’il n’y ait qu’un seul objet, il est préférable d’encapsuler sa fonctionnalité dans une classe. Il
peut être néanmoins nécessaire de gérer une occurrence de cet objet et d’y accéder.
L’utilisation d’une variable globale est une possibilité, mais les variables globales ne sont pas
souhaitables dans la plupart des projets. La meilleure approche consiste à laisser la classe gérer
l’occurrence unique de l’objet à l’aide de membres de classe. L’exemple suivant montre une
utilisation typique de modèle de conception Singleton, où l’occurrence Singleton est créée une
seule fois.
Utilisation des classes personnalisées dans une application
273
Pour utiliser le modèle de conception Singleton :
1.
Choisissez Fichier > Nouveau, puis sélectionnez Fichier ActionScript. Enregistrez le
document sous le nom Singleton.as.
2.
Saisissez le code ActionScript suivant dans la fenêtre de script :
/**
Classe Singleton
auteur : John Doe
version : 0.53
modifié le : 6/24/2008
copyright : Macromedia, Inc.
*/
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.
Enregistrez le document Singleton.as.
4.
Choisissez Fichier > Nouveau, puis sélectionnez Document Flash pour créer un nouveau
fichier FLA, et enregistrez-le sous le nom singleton_test.fla dans le même répertoire que
celui du fichier de classe singleton.
5.
Saisissez le code ActionScript suivant sur l’image 1 du scénario :
Singleton.getInstance().trackChanges(); // tracking changes.
var s:Singleton = Singleton.getInstance(); // tracking changes.
s.trackChanges();
6.
Enregistrez le document Flash.
7.
Choisissez Contrôle > Tester l’animation pour tester le document.
L’objet Singleton n’est pas créé avant d’être nécessaire, lorsqu’une autre section de code
l’appelle par l’intermédiaire de la méthode getInstance(). Cette formule est généralement
appelée création en dilettante ; elle peut accroître l’efficacité de votre code dans certains cas.
274
Classes
Souvenez-vous de ne pas utiliser trop ou trop peu de fichiers de classes dans votre application,
dans la mesure où ceci peut déboucher sur de nombreux fichiers de classe mal conçus et nuire
aux performances de l’application ou du flux de travail. Vous devriez toujours essayer d’utiliser
des fichiers de classe au lieu de placer du code à d’autres endroits (par exemple des scénarios) ;
cependant, évitez de créer beaucoup de classes avec peu de fonctionnalités, ou peu de classes
gérant de nombreuses fonctionnalités. Ces deux scénarios peuvent indiquer une conception
médiocre.
Utilisation de membres de classe
Vous pouvez notamment utiliser des membres de classe (statiques) pour conserver les
informations d’état sur une classe et ses occurrences. Supposons par exemple que vous
souhaitez consigner le nombre d’occurrences créées à partir d’une classe donnée. Vous pouvez
facilement y parvenir en utilisant une propriété de classe incrémentée à chaque création d’une
nouvelle occurrence.
Dans l’exemple suivant, vous créez une classe nommée Gadget qui définit un compteur
d’occurrences statiques unique nommé widgetCount. A chaque création d’une nouvelle
occurrence de la classe, la valeur de widgetCount est incrémentée de 1 et la valeur actuelle de
widgetCount est affichée dans le panneau de sortie.
Pour créer un compteur d’occurrence en utilisant une variable de classe :
1.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK.
2.
Saisissez le code suivant dans la fenêtre de script :
class Widget {
// Initialisation de la variable de classe
public static var widgetCount:Number = 0;
public function Widget() {
Widget.widgetCount++;
trace("Creating widget #" + Widget.widgetCount);
}
}
La variable widgetCount est déclarée comme statique ; elle est donc initialisée à 0 une
seule fois. Chaque fois que l’instruction constructeur de la classe Widget est appelée, elle
ajoute 1 à la variable widgetCount, puis affiche le numéro de l’occurrence en cours de
création.
3.
Enregistrez votre fichier sous le nom Widget.as.
4.
Choisissez Fichier > Nouveau, puis sélectionnez Document Flash pour créer un nouveau
document FLA, et enregistrez-le sous le nom widget_test.fla dans le même répertoire que
Widget.as.
Utilisation des classes personnalisées dans une application
275
5.
Dans widget_test.fla, saisissez le code suivant sur l’image 1 du scénario :
//Avant de créer une occurrence de
// Widget.widgetCount affiche zéro
trace("Widget count au démarrage :
var widget1:Widget = new Widget();
var widget2:Widget = new Widget();
var widget3:Widget = new Widget();
trace("Widget count à la fermeture
la classe,
(0).
" + Widget.widgetCount); // 0
// 1
// 2
// 3
: " + Widget.widgetCount); // 3
6.
Enregistrez les modifications du fichier widget_test.fla.
7.
Choisissez Contrôle > Tester l’animation pour tester le fichier.
Flash donne les résultats suivants dans le panneau Sortie :
Widget count au démarrage : 0
Creating widget # 1
Création de widget # 2
Création de widget # 3
Widget count à la fermeture : 3
Présentation des méthodes de lecture et définition
Les méthodes de lecture/définition sont des méthodes d’accesseur, c’est-à-dire qu’elles
constituent généralement une interface publique qui permet de changer les membres de classe
privés. Vous utilisez les méthodes de lecture/définition pour définir une propriété. Vous
accédez à ces méthodes comme à des propriétés extérieures à la classe, même si vous les
définissez au sein de la classe en tant que méthodes. Ces propriétés externes à la classe peuvent
porter un nom différent de celui de la propriété dans la classe.
Le choix des méthodes de lecture/définition présente quelques avantages, notamment la
possibilité de créer des membres avec une fonctionnalité complexe auxquels vous pouvez
accéder comme à des propriétés. Elles permettent également de créer des propriétés en lecture
et écriture seules.
Bien que ces méthodes soient très pratiques, il est préférable de ne pas en abuser car, entre
autres problèmes, elles risquent de compliquer la maintenance du code. De même, elles
offrent un accès à l’implémentation de votre classe, comme les membres publics. La
programmation orientée objet décourage l’accès direct aux propriétés à l’intérieur d’une classe.
276
Classes
Lorsque vous écrivez des classes, vous êtes encouragés à rendre autant que possible toutes vos
variables d’occurrence privées et à ajouter des méthodes de définition et de lecture en
conséquence. En effet, il arrive souvent que vous ne souhaitiez pas autoriser les utilisateurs à
modifier certaines variables à l’intérieur de vos classes. Par exemple, lorsqu’une méthode
statique privée surveille le nombre d’occurrences créées pour une classe spécifique, vous ne
souhaitez pas qu’un utilisateur puisse modifier ce compteur à l’aide du code. Seule
l’instruction constructor doit pouvoir incrémenter cette variable à chaque appel. Dans ce cas,
vous pouvez créer une variable d’occurrence privée et n’autoriser qu’une méthode de lecture
pour la variable du compteur. Les utilisateurs peuvent ainsi récupérer la valeur actuelle juste à
l’aide de la méthode de lecture, et non pas définir de nouvelles valeurs via la méthode de
définition. Créer une méthode de lecture sans associer de méthode de définition est un moyen
simple de mettre certaines des variables de votre classe en lecture seule.
Utilisation des méthodes de lecture et définition
La syntaxe des méthodes de lecture et de définition est la suivante :
■
Une méthode de lecture ne réclame aucun paramètre et renvoie toujours une valeur.
■
Une méthode de définition réclame toujours un paramètre et ne renvoie jamais de valeur.
Les classes définissent généralement des méthodes de lecture qui fournissent un accès en
lecture et des méthodes de définition qui fournissent un accès en écriture à une propriété
donnée. Imaginons par exemple une classe contenant une propriété nommée userName :
private var userName:String;
Au lieu de permettre aux occurrences de la classe d’accéder directement à cette propriété
(user.userName = "Buster", par exemple), la classe peut utiliser deux méthodes,
getUserName() et setUserName(), qui seront implémentées dans l’exemple suivant.
Utilisation de méthodes de lecture et définition :
1.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK.
2.
Saisissez le code suivant dans la fenêtre de script :
class Login {
private var __username:String ;
public function Login2(username:String) {
this.__username = username;
}
public function getUserName():String {
return this.__username;
}
public function setUserName(value:String):Void {
this.__username = value;
}
}
Utilisation des classes personnalisées dans une application
277
3.
Enregistrez le document ActionScript sous le nom Login2.as.
Comme vous pouvez le constater, getUserName() renvoie la valeur actuelle de userName
et setUserName() définit le paramètre de chaîne transmis à la méthode en tant que valeur
de userName.
4.
Choisissez Fichier > Nouveau, puis sélectionnez Document Flash pour créer un nouveau
document FLA, et enregistrez-le sous le nom login2_test.fla dans le même répertoire que
Login.as.
5.
Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
var user:Login = new Login("RickyM");
// Appel de la méthode getUserName()
var userName:String = user.getUserName();
trace(userName); // RickyM
// Appel de la méthode setUserName()
user.setUserName("EnriqueI");
trace(user.getUserName()); // EnriqueI
6.
Choisissez Contrôle > Tester l’animation pour tester le fichier.
Flash donne les résultats suivants dans le panneau Sortie :
RickyM
EnriqueI
Si, toutefois, vous préférez une syntaxe plus concise, vous pouvez utiliser des méthodes de
lecture/définition implicites. Celles-ci permettent d’accéder directement aux propriétés de
classe, tout en conservant de bonnes pratiques de programmation orientée objet.
Pour définir ces méthodes, utilisez les attributs de méthodes get et set. Créez des méthodes
qui obtiennent ou définissent la valeur d’une propriété et ajoutez le mot-clé get ou set avant
le nom de méthode, comme dans l’exemple suivant.
REMARQUE
278
Les méthodes de lecture et définition implicites sont des abréviations syntaxiques de la
méthode Object.addProperty() dans ActionScript 1.0.
Classes
Utilisation de méthodes de lecture et définition implicites :
1.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK.
2.
Saisissez le code suivant dans la fenêtre de script :
class Login2 {
private var __username:String ;
public function Login2(username:String) {
this.__username = username;
}
public function get userName():String {
return this.__username;
}
public function set userName(value:String):Void {
this.__username = value;
}
}
3.
Enregistrez le document ActionScript sous le nom Login2.as.
N’oubliez pas que les méthodes de lecture ne réclament aucun paramètre. Une méthode
set (définition) doit prendre exactement un paramètre requis. Une méthode de définition
peut avoir le même nom qu’une méthode de lecture dans le même domaine. Les méthodes
de lecture et définition n’ont pas le même nom que les autres propriétés. Par exemple, dans
le code ci-dessus qui définit des méthodes de lecture et de définition nommées userName,
vous ne pourriez pas avoir de propriété nommée userName dans la même classe.
4.
Choisissez Fichier > Nouveau, puis sélectionnez Document Flash pour créer un nouveau
document FLA, et enregistrez-le sous le nom login2_test.fla dans le même répertoire que
Login2.as.
5.
Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
var user:Login2 = new Login2("RickyM");
// appel de la méthode «get»
var userNameStr:String = user.userName;
trace(userNameStr); // RickyM
// appel de la méthode «set»
user.userName = "EnriqueI";
trace(user.userName); // EnriqueI
Contrairement aux méthodes ordinaires, les méthodes de lecture et de définition sont
appelées sans parenthèses ni arguments. Les méthodes de lecture et de définition sont
appelées de la même manière qu’une propriété.
Utilisation des classes personnalisées dans une application
279
6.
Enregistrez le document Flash, puis choisissez Contrôle > Tester l’animation pour tester le
fichier.
Flash donne les résultats suivants dans le panneau Sortie :
RickyM
EnriqueI
REMARQUE
Vous ne pouvez pas utiliser d’attributs de méthode de lecture/définition dans des
déclarations de méthode d’interface.
Présentation des classes dynamiques
L’ajout du mot-clé dynamic à une définition de la classe spécifie que les objets basés sur la
classe spécifiée peuvent ajouter des propriétés dynamiques et y accéder pendant la période
d’exécution. Il est préférable de ne créer de classes dynamiques que lorsque cette
fonctionnalité est réellement nécessaire.
La vérification du type des classes dynamiques est moins stricte que pour les classes non
dynamiques, dans la mesure où les membres sollicités au sein de la définition de classe et dans
les occurrences de classe ne sont pas comparées à celles qui sont définies dans le domaine de la
classe. Les fonctions des membres de classe, cependant, peuvent toujours faire l’objet d’une
vérification du type de renvoi ou de paramètre.
Pour plus d’informations sur la création de classes dynamiques, consultez la section Création
de classes dynamiques, page 280.
Création de classes dynamiques
Par défaut, les propriétés et méthodes d’une classe sont fixes. C’est-à-dire que l’occurrence
d’une classe ne peut créer ou accéder à des propriétés ou méthodes qui n’étaient pas déclarées
ou définies à l’origine par la classe. Considérons par exemple une classe Person qui définit
deux propriétés, userName et age.
280
Classes
Pour créer une classe non dynamique :
1.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK.
2.
Saisissez le code ActionScript suivant dans la fenêtre de script :
class Personne {
public var userName:String;
public var age:Number;
}
Si, dans un autre script, vous créez une occurrence de la classe Personne et essayez
d’accéder à une propriété de la classe qui n’existe pas, le compilateur génère une erreur.
3.
Enregistrez le fichier dans votre disque dur sous le nom Person.as.
4.
Choisissez Fichier > Nouveau, puis Document Flash pour créer un nouveau fichier FLA,
puis cliquez sur OK.
5.
Choisissez Fichier > Enregistrez sous, nommez le fichier person_test.fla, et enregistrez-le
dans le même répertoire que la classe Person créée précédemment.
6.
Ajoutez le code suivant pour créer une nouvelle occurrence de la classe Person
(firstPerson) et tentez d’affecter une valeur à une propriété nommée hairColor (qui
n’existe pas dans la classe Person).
var firstPerson:Person = new Person();
firstPerson.hairColor = "blue"; // Error. Il n’existe aucune propriété
nommée ’hairColor’.
7.
Enregistrez le document Flash.
8.
Choisissez Contrôle > Tester l’animation pour tester le code.
Ce code crée une erreur de compilation car la classe Person ne déclare pas de propriété
nommée hairColor. Dans la plupart des cas, c’est exactement ce que vous souhaitez qu’il
se passe. Les erreurs de compilation peuvent sembler indésirables, mais se révèlent souvent
bénéfiques pour les programmeurs. Les bons messages d’erreur vous aident à écrire votre
code correctement en mettant les erreurs en évidence de manière précoce dans le processus
de programmation.
Dans certains cas, cependant, il peut être utile d’ajouter et d’accéder à des propriétés ou
méthodes d’une classe à l’exécution qui ne sont pas définies dans la définition de classe
originale. Le modificateur de classe dynamique vous permet de le faire.
Utilisation des classes personnalisées dans une application
281
Pour créer une classe dynamique :
1.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK.
2.
Choisissez Fichier > Enregistrer sous et nommez le fichier Person2.fla. Enregistrez le fichier
sur votre disque dur.
3.
Saisissez le code suivant dans la fenêtre de script:
dynamic class Person2 {
public var userName:String;
public var age:Number;
}
Ce code ActionScript ajoute le mot-clé dynamic à la classe Person de l’exemple précédent.
Les occurrences de la classe Person2 peuvent désormais ajouter et accéder aux propriétés et
méthodes qui ne sont pas définies dans cette classe.
4.
Enregistrez les modifications apportées au fichier ActionScript.
5.
Choisissez Fichier > Nouveau, puis Document Flash pour créer un nouveau fichier FLA,
puis cliquez sur OK.
6.
Choisissez Fichier > Enregistrer sous et nommez le fichier person2_test.fla. Enregistrez le
fichier dans le même répertoire que Person2.as.
7.
Ajoutez le code suivant pour créer une nouvelle occurrence de la classe Person2
(firstPerson) et affecter une valeur à une propriété nommée hairColor (qui n’existe pas
dans la classe Person2).
var firstPerson:Person2 = new Person2();
firstPerson.hairColor = "blue";
trace(firstPerson.hairColor); // blue
8.
Enregistrez les modifications apportées au fichier person2_test.fla.
9.
Choisissez Contrôle > Tester l’animation pour tester le code.
La classe personnalisée Flash étant dynamique, vous pouvez lui ajouter des méthodes et
des propriétés au moment de l’exécution (pendant la lecture du fichier SWF). Lorsque
vous testez le code, le texte blue s’affiche dans le panneau de sortie.
Lorsque vous développez des applications, il est préférable de ne pas rendre les classes
dynamiques si ce n’est pas vraiment nécessaire. L’une des raisons en est que cette vérification
du type des classes dynamiques est moins stricte que celle des classes non dynamiques, dans la
mesure où les membres sollicités au sein de la définition de classe et dans les occurrences de
classe ne sont pas comparées à celles qui sont définies dans le domaine de la classe. Les
fonctions des membres de la classe, cependant, peuvent toujours faire l’objet d’une vérification
du type de renvoi ou de paramètre.
282
Classes
Les sous-classes des classes dynamiques sont également dynamiques, à une exception près. Les
sous-classes de la classe MovieClip ne sont pas dynamiques par défaut, bien que la classe
MovieClip elle-même le soit. Cette implémentation permet de bénéficier de davantage de
contrôle sur les sous-classes de la classe MovieClip, car vous pouvez rendre vos sous-classes
dynamiques si vous le souhaitez.
class A
dynamic
class C
class D
dynamic
extends
class B
extends
extends
class E
MovieClip {}
extends A {}
B {}
A {}
extends MovieClip{}
//
//
//
//
//
A
B
C
D
E
is
is
is
is
is
not dynamic
dynamic
dynamic
not dynamic
dynamic
Pour plus d’informations sur les sous-classes, consultez le Chapitre 8, Héritage, page 329.
Utilisation de l’encapsulation
Dans une conception orientée objet intelligente, les objets sont considérés comme des « boîtes
noires » qui contiennent ou encapsulent des fonctionnalités. Un programmeur doit pouvoir
interagir avec un objet en ne connaissant que ses propriétés, ses méthodes et ses événements
(son interface de programmation), sans connaître les détails de son implémentation. Cette
approche permet aux programmeurs d’atteindre un niveau supérieur d’abstraction et met en
place un cadre de structuration pour la création de systèmes complexes.
L’encapsulation permet à ActionScript 2.0 d’inclure, par exemple, le contrôle de l’accès des
membres, de sorte que les détails de l’implémentation restent privés et invisibles pour tout
codage en dehors d’un objet. Le code situé en dehors d’un objet doit interagir avec l’interface
de programmation de l’objet plutôt qu’avec les détails d’implémentation. Cette approche
présente des avantages importants. Par exemple, elle permet au créateur de l’objet de changer
son implémentation sans modifier le code externe à l’objet, tant que l’interface de
programmation reste inchangée.
L’encapsulation dans Flash consiste par exemple à définir tous vos membres et toutes les
variables de classe comme privés et à forcer les utilisateurs qui implémentent vos classes à
accéder à ces variables via les méthodes de définition et de lecture. Cette méthode
d’encapsulation permet, si vous avez un jour besoin de modifier la structure des variables, de
modifier uniquement le comportement des fonctions de lecture et de définition plutôt que
d’obliger chaque développeur à changer sa méthode d’accès aux variables de la classe.
Utilisation des classes personnalisées dans une application
283
Le code suivant décrit la modification de la classe Person utilisée dans les exemples précédents,
définit ses membres d’occurrence comme privés et des méthodes de lecture et de définition
pour les membres d’occurrence privés :
class Personne {
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;
}
}
Utilisation du mot-clé this dans les classes
Utilisez le mot-clé this en tant que préfixe au sein de vos classes pour les méthodes et les
variables de membre. Bien que non indispensable, ce mot-clé this permet d’indiquer
facilement si une propriété ou une méthode appartient à une classe lorsqu’elle comporte un
préfixe. En l’absence de ce mot-clé, vous ne pouvez pas savoir si la propriété ou la méthode
appartient à la super-classe.
Vous pouvez également utiliser un préfixe de nom de classe pour les variables statiques et les
méthodes, y compris dans une classe. Ceci permet de qualifier vos références et de rendre le
code plus lisible. Selon l’environnement de programmation utilisé, l’ajout de préfixes permet
également de bénéficier de conseils de code.
R E M A R QU E
284
Ces préfixes sont facultatifs et certains développeurs les considèrent superflus. Il est
recommandé d’ajouter le mot clé this en tant que préfixe, dans la mesure où il améliore
la lisibilité et permet d’écrire un code explicite en fournissant le contexte des méthodes
et des variables.
Classes
Exemple : Ecriture de classes
personnalisées
Maintenant que vous connaissez les bases d’un fichier de classe et les types d’éléments qu’il
contient, il est temps de connaître quelques directives générales liées à la création d’un tel
fichier. Le premier exemple de ce chapitre décrit l’écriture des classes et leur mise en package.
Le second exemple présente l’utilisation de ces fichiers de classe avec un fichier FLA.
AT T E NT I O N
Le code ActionScript des fichiers externes est compilé dans un fichier SWF lors de la
publication, de l’exportation, du test ou du débogage d’un fichier FLA. Cela signifie que
si vous apportez des modifications à un fichier externe, vous devez enregistrer le fichier
et recompiler tous les fichiers FLA qui l’utilisent.
Comme nous l’avons vu dans la section Ecriture de fichiers de classe personnalisée, page 254,
une classe comprend deux parties : la déclaration et le corps. La déclaration de la classe
comporte au minimum l’instruction class, suivie de l’identifiant du nom de la classe, puis des
accolades d’ouverture et de fermeture ({}). Tout ce qui figure entre les accolades constitue le
corps de la classe, comme indiqué dans l’exemple suivant :
class className {
// corps de la classe
}
N’oubliez pas que vous pouvez définir des classes uniquement dans des fichiers ActionScript
externes. Par exemple, vous ne pouvez pas définir de classe dans un script d’image d’un fichier
FLA. Vous allez donc créer un nouveau fichier pour cet exemple.
Dans sa forme la plus simple, une déclaration de classe comprend le mot-clé class, suivi du
nom de la classe (Person, dans ce cas), puis des accolades d’ouverture et de fermeture ({}).
Tout ce qui est entre les accolades est appelé corps de la classe et c’est ici que les propriétés et
méthodes de la classe sont définies.
A la fin de cet exemple, l’ordre de base de vos fichiers de classe est le suivant:
■
Commentaires de documentation
■
Déclaration de classe
■
Fonction constructeur
■
Corps de la classe
Nous n’écrivons pas de sous-classes dans ce chapitre. Pour plus d’informations sur les héritages
et les sous-classes, consultez le Chapitre 8, Héritage, page 329.
Exemple : Ecriture de classes personnalisées
285
Cet exemple aborde les sujets suivants :
■
Directives générales sur la création d’une classe, page 286
■
Création et mise en package de vos fichiers de classe, page 288
■
Ecriture de la fonction constructeur, page 291
■
Ajout de méthodes et de propriétés, page 293
■
Contrôle de l’accès des membres dans vos classes, page 297
■
Documentation des classes, page 299
Un fichier exemple sur votre disque dur montre comment créer un menu dynamique avec les
données XML et un fichier de classe personnalisée. Cet exemple appelle le constructeur
ActionScript XmlMenu() et lui transmet deux paramètres : Le chemin d’accès au fichier menu
XML et une référence au scénario actuel. Le reste de la fonctionnalité réside dans un fichier de
classe personnalisée, XmlMenu.as.
Vous trouverez l’exemple de fichier source, xmlmenu.fla, dans le dossier Samples de votre
disque dur.
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\XML_Menu.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/XML_Menu.
Directives générales sur la création d’une classe
Voici quelques conseils à suivre lors de l’écriture de fichiers de classe personnalisés. Ils vous
aideront à écrire des classes correctes et bien constituées. Vous mettez en pratique ces
directives dans les exemples suivants.
■
De manière générale, ne placez qu’une seule déclaration par ligne. Ne placez pas le même
type de déclaration ou des types différents sur une même ligne. Formatez vos déclarations
comme dans l’exemple ci-dessous :
private var SKU:Number; // product SKU (identifying) number
private var quantity:Number; // quantity of product
■
Initialisez les variables locales lorsque vous les déclarez, à moins que cette valeur initiale ne
soit déterminée par un calcul. Pour plus d’informations sur l’initialisation des variables,
consultez la section Ajout de méthodes et de propriétés, page 293.
286
Classes
■
Déclarez les variables avant de les utiliser (y compris dans les boucles). Par exemple, le
code suivant pré déclare la variable d’itérateur de boucle (i) avant de l’utiliser dans la
boucle 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]);
}
■
Evitez d’utiliser des déclarations locales qui masquent des déclarations de niveau
englobant. Par exemple, ne déclarez les variables qu’une seule fois, comme dans l’exemple
ci-dessous :
// Code incorrect
var myNum:Number = 0;
fonction fooMethod() {}
var counter:Number;
for (counter = 0; counter <= 4; counter++) {
// instructions ;
}
}
Ce code déclare la même variable dans un bloc interne.
■
N’affectez pas plusieurs variables à une valeur unique dans une instruction car la lecture
devient alors difficile, comme dans l’exemple de code ActionScript suivant :
// Forme incorrecte
xPos = yPos = 15;
ou
// Forme incorrecte
class User {
private var m_username:String, m_password:String;
}
■
Have a good reason for making public instance variables, or public static, class, or member
variables. Ces variables doivent être déclarées explicitement comme publiques avant d’être
créées de cette façon.
■
Définissez la plupart des variables de membre sur privé à moins qu’il n’y ait une bonne
raison de les rendre publiques. Il est préférable, du point de vue de la conception, de
définir les variables de membre sur privé et de restreindre leur accès par l’intermédiaire
d’un petit groupe de fonctions de lecture et définition.
Exemple : Ecriture de classes personnalisées
287
Appellation des fichiers de classe
Les noms de classes doivent être des identifiants : le premier caractère doit être une lettre, un
soulignement (_) ou le signe dollar ($), et chaque caractère suivant doit être une lettre, un
nombre, un soulignement ou le signe dollar. Il est recommandé de toujours tenter de limiter
les noms de classe à des lettres.
Le nom de classe doit correspondre exactement au nom du fichier ActionScript qui le
contient, majuscules comprises. Dans l’exemple suivant, si vous créez une classe nommée
Rock, le fichier ActionScript qui contient sa définition doit s’appeler Rock.as:
// Dans le fichier Rock.as
class Rock {
// Corps de la classe Rock
}
Dans la section suivante, vous créez et nommez une définition de classe. Pour créer, nommer
et mettre en package les fichiers de classe, consultez la section Création et mise en package de vos
fichiers de classe, page 288. Pour plus d’informations sur l’appellation de fichiers de classe,
consultez la section Appellation des classes et des objets, page 806.
Création et mise en package de vos fichiers de classe
Dans cette section, vous allez créer, nommer et mettre en package vos fichiers de classe pour
cet exemple (Exemple : Ecriture de classes personnalisées, page 285). Les sections suivantes
présentent l’écriture complète (et pourtant simple) de fichiers de classe. Pour des informations
détaillées sur les packages, consultez les sections Présentation des packages, page 246,
Comparaison des classes et des packages, page 247 et Fonctionnement des packages, page 248.
Lorsque vous créez un fichier de classe, choisissez un emplacement de stockage pour le fichier.
Au cours des étapes suivantes, vous allez enregistrer le fichier de classe et le fichier
d’application FLA qui l’utilise dans le même répertoire pour plus de simplicité. Toutefois, si
vous souhaitez vérifier la syntaxe, vous devez également indiquer à Flash comment localiser le
fichier. De façon générale, lorsque vous créez une application, ajoutez le répertoire dans lequel
vous stockez votre application et les fichiers de classe dans le chemin de classe Flash. Pour plus
d’informations sur les chemins de classe, consultez la section Définition et modification du
chemin de classe, page 260.
288
Classes
Les fichiers de classe sont également appelés fichiers ActionScript (AS). Vous créez des fichiers
AS dans l’outil de programmation Flash ou à l’aide d’un éditeur externe. Plusieurs éditeurs
externes, tels que Macromedia Dreamweaver et Macromedia Flex Builder, peuvent créer des
fichiers AS.
REMARQUE
Le nom d’une classe (ClassA) doit correspondre exactement au nom du fichier AS qui la
contient (ClassA.as). Ce point est très important. Si ces deux noms ne correspondent
pas exactement, y compris les majuscules, la compilation de la classe échoue.
Pour créer un fichier de classe et une déclaration de classe :
1.
Choisissez Fichier > Nouveau, puis Document Flash pour créer un nouveau document
FLA, puis cliquez sur OK.
2.
Choisissez Fichier > Enregistrer sous et nommez le nouveau fichier package_test.fla, puis
enregistrez le document Flash dans le répertoire actif.
Ultérieurement, vous ajouterez du contenu dans ce document Flash.
3.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK.
4.
Choisissez Fichier > Enregistrer sous, et créez un nouveau sous-répertoire nommé com,
puis procédez comme suit :
5.
a.
Dans le sous-dossier com, créez un nouveau sous-répertoire appelé macromedia.
b.
Dans le sous-dossier macromedia, créez un nouveau sous-répertoire appelé utils.
c.
Enregistrez le document ActionScript actif dans le répertoire utils et nommez le fichier
ClassA.as.
Saisissez le code suivant dans la fenêtre de script :
class com.macromedia.utils.ClassA {
}
Le code précédant crée une nouvelle classe nommée ClassA dans le package
com.macromedia.utils.
6.
Enregistrez le document ActionScript sous le nom ClassA.as.
7.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK.
8.
Choisissez Fichier > Enregistrez sous, nommez le fichier ClassB.as, et enregistrez-le dans le
même répertoire que le fichier ClassA.as créé précédemment.
Exemple : Ecriture de classes personnalisées
289
9.
Saisissez le code suivant dans la fenêtre de script :
class com.macromedia.utils.ClassB {
}
Le code précédant crée une nouvelle classe nommée ClassB dans le package
com.macromedia.utils.
10. Enregistrez
les modifications apportées aux fichiers de classe ClassA.as et ClassB.as.
Les fichiers de classe que vous utilisez dans un fichier FLA sont importés dans un fichier SWF
lors de sa compilation. Le code que vous écrivez dans un fichier de classe doit respecter une
certaine méthodologie et un certain ordre, tous deux abordés dans les sections suivantes.
Si vous créez plusieurs classes personnalisées, utilisez des packages pour organiser vos fichiers
de classe. Un package est un répertoire qui contient un ou plusieurs fichiers de classe et qui
réside dans un répertoire de chemin de classe désigné. Les noms de classe doivent être
pleinement qualifiés dans le fichier dans lequel ils sont déclarés: ils doivent indiquer le nom du
répertoire (package) dans lequel ils sont enregistrés. Pour plus d’informations sur les chemins
de classe, consultez la section Définition et modification du chemin de classe, page 260.
Par exemple, une classe nommée com.macromedia.docs.YourClass est stockée dans le
répertoire com/macromedia/docs. La déclaration de classe dans le fichier YourClass.as
ressemble à cela :
class com.macromedia.docs.YourClass {
// Votre classe
}
REMARQUE
Vous écrirez la déclaration de classe qui reflète le répertoire de package dans la section
suivante, Exemple : Ecriture de classes personnalisées, page 285.
De ce fait, il est recommandé de planifier votre structure de packages avant de commencer la
création de classes. En effet, si vous décidez de déplacer les fichiers de classe après leur
création, vous devrez modifier les instructions de déclaration de classe pour indiquer leur
nouvel emplacement.
290
Classes
Pour mettre vos fichiers de classe en package :
1.
Choisissez le nom de package que vous désirez utiliser.
Les noms de package doivent être intuitifs et facilement identifiables par les autres
développeurs. N’oubliez pas que le nom du package correspond également à une structure
de répertoires spécifique. Par exemple, les classes du package com.macromedia.utils
doivent être placées dans un dossier com/macromedia/utils sur votre disque dur.
2.
Créez la structure de répertoires requise après avoir choisi un nom de package.
Par exemple, si votre package s’appelle com.macromedia.utils, créez une structure de
répertoires com/macromedia/utils et placez vos classes dans le dossier utils.
3.
Utilisez le préfixe com.macromedia.utils pour toute classe créée dans ce package.
Par exemple, si votre nom de classe était ClassA, son nom complet devrait être
com.macromedia.utils.ClassA au sein du fichier de classe com/macromedia/utils/
ClassA.as.
4.
Si, par la suite, vous modifiez la structure de package, souvenez-vous de modifier non
seulement la structure de répertoires, mais aussi le nom de package dans chaque fichier de
classe, ainsi que dans chaque instruction d’importation ou référence à une classe au sein de
ce package.
Pour poursuivre l’écriture des fichiers de classe, consultez la section Ecriture de la fonction
constructeur, page 291.
Ecriture de la fonction constructeur
Vous avez déjà découvert l’écriture de la déclaration de classe dans la section Création et mise
en package de vos fichiers de classe, page 288. Dans cette partie du chapitre, vous écrivez ce que
l’on appelle la fonction constructeur du fichier de classe.
R E M A R QU E
Vous allez découvrir l’écriture des commentaires, des instructions et des déclarations
dans les sections suivantes.
Les constructeurs sont des fonctions que vous utilisez pour initialiser (définir) les propriétés et
les méthodes d’une classe. Par définition, les constructeurs sont des fonctions au sein d’une
définition de classe qui portent le même nom que la classe. Par exemple, le code suivant
définit une classe Person et implémente une fonction constructeur. En programmation
orientée objet, la fonction constructeur initialise toutes les nouvelles occurrences d’une classe.
Exemple : Ecriture de classes personnalisées
291
Un constructeur de classe est une fonction spéciale appelée automatiquement lorsque vous
créez une occurrence de classe à l’aide de l’opérateur new. La fonction constructeur porte le
même nom que la classe qui la contient. Par exemple, la classe Person créée précédemment
contenait la fonction constructeur suivante :
// Fonction constructeur de la classe Person
public function Person (uname:String, age:Number) {
this.__name = uname;
this.__age = age;
}
Lorsque vous écrivez des fonctions constructeur, gardez à l’esprit les points suivants :
■
Si aucune fonction constructeur n’est explicitement déclarée, c’est-à-dire, si vous ne créez
pas de fonction dont le nom correspond à celui de la classe, le compilateur crée
automatiquement une fonction constructeur vide.
■
Une classe ne peut contenir qu’une seule fonction constructeur ; les fonctions
constructeur étendues ne sont pas autorisées dans ActionScript 2.0.
■
La fonction constructeur ne doit pas avoir de type de renvoi.
Le terme constructeur est généralement utilisé lorsque vous créez (instanciez) un objet en
fonction d’une classe particulière. Les instructions suivantes sont des appels aux fonctions
constructeur pour la classe de niveau supérieur Array et pour la classe Person personnalisée :
var day_array:Array = new Array("Sun", "Mon", "Tue", "Wed", "Thu", "Fri",
"Sat");
var somePerson:Person = new Person("Tom", 30);
Vous allez ensuite ajouter une fonction spéciale appelée constructeur.
REMARQUE
292
L’exercice suivant est associé à l’Exemple : Ecriture de classes personnalisées, page 285.
Si vous ne souhaitez pas suivre l’exemple, il vous est possible de télécharger les fichiers
de classe depuis www.helpexamples.com/flash/learnas/classes/.
Classes
Pour ajouter les fonctions constructeur à vos fichiers de classe :
1.
Ouvrez le fichier de classe ClassA.as dans l’outil de programmation Flash.
2.
Modifiez les fichiers de classe existants de sorte qu’ils correspondent au code suivant (les
modifications à effectuer apparaissent en gras) :
class com.macromedia.utils.ClassA {
function ClassA() {
trace("ClassA constructor");
}
}
Le code précédent définit une méthode constructeur pour la classe ClassA. Ce
constructeur envoie une chaîne simple au panneau de sortie qui vous avertit lorsqu’une
nouvelle occurrence de la classe a été créée.
3.
Ouvrez le fichier de classe ClassB.as dans l’outil de programmation Flash.
4.
Modifiez le fichier de classe de sorte qu’il corresponde au code suivant (les modifications à
effectuer apparaissent en gras) :
class com.macromedia.utils.ClassB {
function ClassB() {
trace("ClassB constructor");
}
}
5.
Enregistrez les deux fichiers ActionScript avant de continuer.
Pour poursuivre l’écriture des fichiers de classe, consultez la section Ajout de méthodes et de
propriétés, page 293.
Ajout de méthodes et de propriétés
Pour créer des propriétés pour les classes ClassA et ClassB, utilisez le mot-clé var qui définit
des variables.
R E M A R QU E
Les trois exercices suivants sont associés à l’Exemple : Ecriture de classes
personnalisées, page 285. Si vous ne souhaitez pas suivre l’exemple, il vous est possible
de télécharger les fichiers de classe depuis www.helpexamples.com/flash/learnas/
classes/.
Exemple : Ecriture de classes personnalisées
293
Pour ajouter des propriétés aux classes ClassA et ClassB :
1.
Ouvrez les fichiers ClassA.as et ClassB.as dans l’outil de programmation Flash.
2.
Modifiez le fichier ClassA.as ActionScript, de sorte qu’il corresponde au code suivant (les
modifications à effectuer apparaissent en gras) :
class com.macromedia.utils.ClassA {
static var _className:String;
function ClassA() {
trace("ClassA constructor");
}
}
Le bloc de code précédent ajoute une seule nouvelle variable statique, _className, qui
contient le nom de la classe active.
3.
Modifiez la classe ClassB et ajoutez la variable statique de sorte qu’elle corresponde au code
précédent.
4.
Enregistrez les deux fichiers ActionScript avant de continuer.
C ON S E I L
Par convention, les propriétés de classe sont définies dans la partie supérieure du
corps de la classe. Procédez ainsi simplifie la lecture du code, mais n’est pas
obligatoire.
Utilisez la syntaxe à deux points (par exemple var username:String et var age:Number)
dans la déclaration des variables. Ceci est un exemple de typage strict des données. Lorsque
vous typez une variable à l’aide du format var variableName:variableType, le compilateur
ActionScript s’assure que toute valeur affectée à cette variable correspond au type spécifié. Si le
type de données correct n’est pas utilisé dans le fichier FLA qui importe cette classe, le
compilateur renvoie une erreur. Pour plus d’informations sur le typage strict des données,
consultez la section Affectation des types de données et typage strict, page 88.
Les membres d’une classe se composent de propriétés (déclarations de variables) et de
méthodes (déclarations de fonctions). Vous devez déclarer et définir toutes les propriétés et
méthodes dans le corps de la classe (entre accolades [{}]), sinon une erreur se produit lors de
la compilation. Pour plus d’informations sur les membres, consultez la section Présentation des
méthodes et propriétés (membres) publiques, privées et statiques, page 267.
294
Classes
Pour ajouter des méthodes aux classes ClassA et ClassB :
1.
Ouvrez les fichiers ClassA.as et ClassB.as dans l’outil de programmation Flash.
2.
Modifiez les fichiers de classe ClassA, de sorte qu’ils correspondent au code suivant (les
modifications à effectuer apparaissent en gras) :
class com.macromedia.utils.ClassA {
static var _className:String;
function ClassA() {
trace("ClassA constructor");
}
function doSomething():Void {
trace("ClassA - doSomething()");
}
}
Le bloc de code en gras crée une nouvelle méthode dans la classe, qui envoie une chaîne au
panneau de sortie.
3.
Dans ClassA.as, choisissez Outils > Vérifier la syntaxe pour vérifier la syntaxe de votre
fichier ActionScript.
Si des erreurs sont signalées dans le panneau de sortie, comparez le code de votre script au
code final de l’étape précédente. Si vous ne parvenez pas à réparer l’erreur, copiez et collez
le code complet dans la fenêtre de script avant de continuer.
4.
Vérifiez la syntaxe de ClassB.as comme vous l’avez fait pour ClassA.as.
Si des erreurs apparaissent dans le panneau de sortie, copiez et collez le code complet dans
la fenêtre de script avant de continuer :
class com.macromedia.utils.ClassB {
static var _className:String;
function ClassB() {
trace("ClassB constructor");
}
function doSomething():Void {
trace("ClassB - doSomething()");
}
}
5.
Enregistrez les deux fichiers ActionScript avant de continuer.
Exemple : Ecriture de classes personnalisées
295
Vous pouvez initialiser des propriétés en ligne, c’est-à-dire lorsque vous les déclarez, avec des
valeurs par défaut, comme dans l’exemple suivant :
class Personne {
var myNum:Number = 50;
var username:String = "John Doe";
}
Lorsque vous initialisez des propriétés alignées, l’expression du côté droit de l’affectation doit
être une constante de compilation. C’est à dire que l’expression ne peut pas faire référence à
un élément paramétré ou défini au moment de l’exécution. Les constantes de compilation
comprennent les chaînes littérales, les nombres, les valeurs booléennes, null et undefined, ainsi
que les fonctions constructeur pour les classes de niveau supérieur suivantes : Array, Boolean,
Number, Object et String.
Pour initialiser des propriétés alignées :
1.
Ouvrez les fichiers ClassA.as et ClassB.as dans l’outil de programmation Flash.
2.
Modifiez les fichiers de classe ClassA, de sorte qu’ils correspondent à l’ActionScript suivant
(les modifications à effectuer apparaissent en gras) :
class com.macromedia.utils.ClassA {
static var _className:String = "ClassA";
function ClassA() {
trace("ClassA constructor");
}
function doSomething():Void {
trace("ClassA - doSomething()");
}
}
La seule différence entre le fichier de classe existant et le bloc de code précédent est qu’une
valeur est à présent définie pour la variable statique _className, "ClassA".
3.
Modifiez le fichier de classe ClassB et ajoutez la propriété alignée, en modifiant la valeur
sur « ClassB ».
4.
Enregistrez les deux fichiers ActionScript avant de continuer.
Cette règle s’applique uniquement aux variables d’occurrence (variables copiées dans chaque
occurrence d’une classe). Elle ne s’applique pas aux variables de classe (variables qui
appartiennent véritablement à la classe).
R E MA R Q U E
296
Lorsque vous initialisez les tableaux alignés, un seul tableau est créé pour toutes les
occurrences de la classe.
Classes
Pour poursuivre l’écriture de votre fichier de classe, consultez la section Contrôle de l’accès des
membres dans vos classes, page 297.
Contrôle de l’accès des membres dans vos classes
Par défaut, toute propriété ou méthode de classe est accessible à toute autre classe : tous les
membres d’une classe sont considérés comme publics par défaut. Toutefois, dans certains cas,
vous pouvez souhaiter que d’autres classes n’aient pas accès aux données ou aux méthodes
d’une classe. Vous devez alors faire en sorte que ces membres deviennent privés, c’est-à-dire
disponibles uniquement pour la classe qui les déclare ou les définit.
Pour spécifier des membres publics ou privés, utilisez l’attribut de membre public ou private.
Par exemple, le code suivant déclare une variable privée (une propriété) et une méthode privée
(une fonction). La classe suivante (LoginClass) définit une propriété privée nommée
userName et une méthode privée nommée getUserName() :
classe LoginClass {
private var nomD’utilisateur:String ;
private function getUserName():String {
return this.userName;
}
// Constructeur :
public function LoginClass(user:String) {
this.userName = user;
}
}
Les membres privés (propriétés et méthodes) sont uniquement accessibles à la classe qui
définit ces membres et aux sous-classes de cette classe d’origine. Les occurrences de la classe
d’origine ou celles des sous-classes de cette classe ne peuvent pas accéder aux propriétés et
méthodes privées ; c’est-à-dire que les membres privés ne sont accessibles qu’au sein des
définitions de classe, et non au niveau des occurrences. Dans l’exemple suivant, vous modifiez
l’accès des membres à vos fichiers de classe.
R EM A R Q U E
Cet exercice est associé à l’Exemple : Ecriture de classes personnalisées, page 285. Si
vous ne souhaitez pas suivre l’exemple, il vous est possible de télécharger les fichiers de
classe depuis www.helpexamples.com/flash/learnas/classes/.
Exemple : Ecriture de classes personnalisées
297
Pour contrôler l’accès des membres :
1.
Ouvrez les fichiers ClassA.as et ClassB.as dans l’outil de programmation Flash.
2.
Modifiez le fichier ClassA.as ActionScript, de sorte que son contenu corresponde au code
ActionScript suivant (les modifications à effectuer apparaissent en gras) :
class com.macromedia.utils.ClassA {
private static var _className:String = "ClassA";
public function
trace("ClassA
}
public function
trace("ClassA
}
ClassA() {
constructor");
doSomething():Void {
- doSomething()");
}
Le code précédent définit les deux méthodes (la constructeur ClassA et la méthode
doSomething()) comme publiques, ce qui signifie que les scripts externes peuvent y
accéder. La variable statique _className est définie comme privée, ce qui signifie qu’elle
n’est accessible qu’au sein de la classe et pas depuis des scripts externes.
3.
Modifiez le fichier ActionScript ClassB.as et ajoutez les mêmes méthode et propriété que
dans le fichier ClassA.
4.
Enregistrez les deux fichiers ActionScript avant de continuer.
Une occurrence de ClassA ou ClassB ne peut pas accéder aux membres privés. Par exemple, le
code suivant, ajouté à l’image 1 du scénario d’un fichier FLA, provoquerait une erreur de
compilation indiquant que la méthode est privée et qu’il est impossible d’y accéder :
import com.macromedia.utils.ClassA;
var a:ClassA = new ClassA();
trace(a._className); // Error. Le membre est privé et n’est pas accessible.
Le contrôle de l’accès des membres est une fonction de compilation uniquement ; à
l’exécution, Flash Player ne fait aucune distinction entre les membres publics et privés.
Pour poursuivre l’écriture de votre fichier de classe, consultez la section Documentation des
classes, page 299.
298
Classes
Documentation des classes
L’insertion de commentaires dans vos classes et interfaces constitue pour les autres utilisateurs
un élément essentiel de leur documentation. Par exemple, vous pouvez distribuer vos fichiers
de classe dans la communauté Flash ou travailler avec une équipe de concepteurs ou de
développeurs amenés à utiliser vos fichiers dans leur travail ou dans le cadre d’un projet en
cours. La documentation permet aux autres utilisateurs de mieux comprendre l’objectif et les
origines de la classe.
Un fichier d’interface ou de classe comporte généralement deux types de commentaire : les
commentaires de documentation et les commentaires d’implémentation. Les commentaires de
documentation décrivent le cahier des charges du code, mais pas son implémentation. Les
commentaires d’implémentation décrivent le code ou l’implémentation de sections
spécifiques du code. Ces deux types de commentaires utilisent des séparateurs légèrement
différents. Les commentaires de documentation sont séparés par /** et */, tandis que les
commentaires d’implémentation sont séparés par /* et */.
REMARQUE
Les commentaires de documentation ne constituent pas un élément de langage dans
ActionScript 2.0. Cependant, ils constituent une manière commune de structurer des
commentaires dans un fichier de classe que vous pouvez utiliser dans vos fichiers AS.
Servez-vous des commentaires de documentation pour décrire les interfaces, les classes, les
méthodes et les constructeurs. Incluez un commentaire de documentation par classe, interface
ou membre, et placez-le directement avant la déclaration.
Si vous vous devez ajouter des informations supplémentaires à vos commentaires de
documentation, utilisez des commentaires d’implémentation (sous la forme de blocs de
commentaires ou de commentaires sur une ligne, décrits dans la section Présentation des
commentaires, page 143). Les commentaires d’implémentation, si vous les ajoutez, suivent
directement la déclaration.
R EM A R Q U E
N’incluez pas les commentaires qui ne se rapportent pas directement à la classe en
cours de lecture. Par exemple, n’incluez pas de commentaires décrivant le package
correspondant.
REMARQUE
L’exercice suivant est associé à l’Exemple : Ecriture de classes personnalisées, page 285.
Si vous ne souhaitez pas suivre l’exemple, il vous est possible de télécharger les fichiers
de classe depuis www.helpexamples.com/flash/learnas/classes/.
Exemple : Ecriture de classes personnalisées
299
Pour documenter vos fichiers de classe :
1.
Ouvrez les fichiers ClassA.as et ClassB.as dans l’outil de programmation Flash.
2.
Modifiez le fichier de classe ClassA et ajoutez le nouveau code (les modifications à effectuer
sont en gras) en haut du fichier de classe :
/**
Classe ClassA
version 1.1
6/21/2005
copyright Macromedia, Inc.
*/
class com.macromedia.utils.ClassA {
private static var _className:String = "ClassA";
public function
trace("ClassA
}
public function
trace("ClassA
}
ClassA() {
constructor");
doSomething():Void {
- doSomething()");
}
Le code ci-dessus a ajouté un commentaire en haut du fichier de classe. Il est toujours
conseillé d’ajouter des commentaires à votre code ActionScript et à vos fichiers Flash afin
d’indiquer des informations très utiles telles que l’auteur de la classe, la date de la dernière
modification, des informations de copyright ou tout problème/bogue éventuel pouvant
être lié au fichier.
3.
Ajoutez un commentaire similaire en haut du fichier ActionScript ClassB.as, en modifiant
le nom de la classe et toute autre information nécessaire.
4.
Enregistrez les deux fichiers ActionScript avant de continuer.
Vous pouvez également ajouter un bloc de commentaires ou des commentaires d’une seule
ligne ou de fin de ligne dans le code de la classe. Pour plus d’informations sur la rédaction de
commentaires pertinents, consultez la section Rédaction de commentaires appropriés, page 810.
Pour plus d’informations sur les commentaires, consultez Commentaires sur une ligne,
page 144, Commentaires sur plusieurs lignes, page 144 et Commentaires en fin de ligne,
page 146.
Pour apprendre à utiliser ces fichiers de classe personnalisée dans un fichier SWF, consultez la
section Exemple : Utilisation de fichiers de classe personnalisée dans Flash, page 301.
300
Classes
Exemple : Utilisation de fichiers de classe
personnalisée dans Flash
Cet exemple utilise des fichiers de classe répertoriés dans l’exemple : Exemple : Ecriture de
classes personnalisées, page 285 ; vous pouvez également les télécharger depuis
www.helpexamples.com/flash/learnas/classes/. Si vous avez complété Exemple : Ecriture de
classes personnalisées, page 285, localisez ClassA.as et ClassB.as sur votre disque dur.
Le package du fichier de la classe ClassA portant le nom com.macromedia.utils.ClassA,
vous devez vous assurer d’avoir enregistré les fichiers de classe dans la structure de répertoires
appropriée. Créez un sous-dossier appelé com dans le répertoire actif. Dans ce dossier com,
créez un dossier nommé macromedia. Enfin, ajoutez un troisième et dernier sous-répertoire
nommé utils dans le dossier macromedia. Enregistrez les deux fichiers de classe ClassA.as et
ClassB.as dans ce dossier utils. Vous êtes maintenant prêt à commencer avec cet exemple.
Vous pouvez utiliser les classes personnalisées écrites dans le cadre de l’Exemple : Ecriture de
classes personnalisées, page 285 avec un fichier FLA. Dans cet exemple, vous utilisez les classes
personnalisées pour créer une petite application dans Flash. Vos classes sont compilées dans le
fichier SWF lorsque vous publiez le document, et l’ensemble fonctionne ensuite de concert.
Dans les exercices suivants, vous allez découvrir les chemins de classe, l’utilisation des fichiers
de classe dans votre application, ainsi que la manière d’importer des classes et des packages.
Pour poursuivre cet exemple, passez à la section Importation de classes et de packages, page 301.
Importation de classes et de packages
Pour faire référence à une classe dans un autre script, vous devez faire précéder le nom de la
classe par son nom de package. La combinaison du nom de la classe et de son chemin de
package correspond au nom pleinement qualifié de la classe. Si une classe réside dans un
répertoire de chemin de classe de premier niveau (et non dans un sous-répertoire du répertoire
de chemin de classe), son nom de classe est également son nom pleinement qualifié.
Pour spécifier des chemins de package, utilisez une notation de type point (.) pour séparer les
noms des répertoires de package. Les chemins de package sont hiérarchiques : chaque point
représente un répertoire imbriqué. Supposons par exemple que vous créiez une classe nommée
ClassName, qui réside dans un package com/macromedia/docs/learnAs2 dans votre chemin
de classe. Pour créer une occurrence de cette classe, vous pouvez spécifier le nom pleinement
qualifié de la classe.
Exemple : Utilisation de fichiers de classe personnalisée dans Flash
301
Vous pouvez également utiliser le nom de classe pleinement qualifié pour taper vos variables,
comme illustré dans l’exemple suivant :
var myInstance:com.macromedia.docs.learnAs2.ClassName = new
com.macromedia.docs.learnAs2.ClassName();
Vous pouvez utiliser l’instruction import pour importer des paquets dans un script, ce qui
vous permet d’utiliser le nom abrégé d’une classe à la place de son nom pleinement qualifié.
Vous pouvez également utiliser le caractère générique * pour importer toutes les classes dans
un package. Dans ce cas, vous n’avez pas besoin d’utiliser le nom de classe pleinement qualifié
à chaque emploi de la classe.
Supposons par exemple que dans un autre script, vous ayez importé la classe ci-dessus avec
l’instruction import, comme dans l’exemple suivant :
import com.macromedia.docs.learnAs2.util.UserClass;
Par la suite, dans le même script, vous pouvez faire référence à cette classe par son nom abrégé,
comme dans l’exemple suivant :
var monUtilisateur:ClasseUtilisateur = new ClasseUtilisateur();
Vous pouvez également utiliser le caractère générique (*) pour importer toutes les classes dans
un package donné. Supposons que vous ayez un package nommé com.macromedia.utils
contenant deux fichiers de classe ActionScript, ClassA.as et ClassB.as. Dans un autre script,
vous pouvez importer les deux classes dans ce package en utilisant le caractère générique,
comme dans l’exemple suivant :
import com.macromedia.utils.*;
L’exemple suivant indique que vous pouvez faire référence aux deux classes directement dans
le même script:
var myA:ClassA = new ClassA();
var myB:ClassB = new ClassB();
L’instruction import s’applique uniquement au script actif (image ou objet) dans lequel elle
est appelée. Si une classe importée n’est pas utilisée dans un script, elle n’est pas incluse dans le
pseudo-code binaire du fichier SWF résultant, et n’est pas disponible dans les fichiers SWF
susceptibles d’être chargés par le fichier FLA contenant l’instruction import.
R E M AR QU E
302
L’exercice suivant est associé à l’Exemple : Utilisation de fichiers de classe personnalisée
dans Flash, page 301 qui succède à l’Exemple : Ecriture de classes personnalisées. Si
vous avez besoin de ClassA et ClassB, il vous est possible de télécharger les fichiers de
classe depuis www.helpexamples.com/flash/learnas/classes/.
Classes
Pour importer une classe ou un package :
1.
Ouvrez le fichier package_test.fla.
2.
Saisissez le code suivant dans la fenêtre de script :
import com.macromedia.utils.*;
var a = new ClassA(); // ClassA constructor
var a = new ClassA(); // ClassA constructor
Le bloc de code précédent commence par importer chacune des classes dans le package
com.macromedia.utils via le caractère générique *. Ensuite, vous créez une nouvelle
occurrence de la classe ClassA, ce qui entraîne l’envoi d’un message dans le panneau de
sortie. Une occurrence de la classe ClassB est également créée, ce qui envoie également des
messages de débogage au panneau de sortie.
3.
Enregistrez les modifications apportées au document Flash avant de continuer.
Pour continuer à utiliser ces fichiers de classe dans un fichier Flash, consultez la section
Création d’occurrences de classes dans un exemple, page 303.
Création d’occurrences de classes dans un exemple
Les occurrences sont des objets qui contiennent toutes les propriétés et les méthodes d’une
classe donnée. Par exemple, les tableaux étant des occurrences de la classe Array, vous pouvez
utiliser n’importe quelle méthode ou propriété de la classe Array avec n’importe quelle
occurrence de tableau. Vous pouvez également créer votre propre classe, par exemple
UserSettings, puis créer une occurrence de la classe UserSettings.
Reprenons l’exemple commencé dans le cadre de l’Exemple : Utilisation de fichiers de classe
personnalisée dans Flash, page 301, lorsque vous avez modifié un fichier FLA pour importer les
classes de manière à ne plus avoir à utiliser leurs noms pleinement qualifiés.
Dans l’Exemple : Utilisation de fichiers de classe personnalisée dans Flash, page 301, l’étape
suivante consiste à créer une occurrence des classes ClassA et ClassB dans un script, telle
qu’un script d’image dans un document Flash package_test.fla, et de l’affecter à une variable.
Pour créer une occurrence d’une classe personnalisée, utilisez l’opérateur new, comme pour
créer une occurrence de classe ActionScript de niveau supérieur (telle que Date ou Array).
Vous faites référence à la classe par son nom de classe pleinement qualifié, ou vous l’importez,
comme dans la section Importation de classes et de packages, page 301.
REMARQUE
L’exercice suivant est associé à l’Exemple : Utilisation de fichiers de classe personnalisée
dans Flash, page 301 qui succède à l’Exemple : Ecriture de classes personnalisées.
Exemple : Utilisation de fichiers de classe personnalisée dans Flash
303
Pour créer une nouvelle occurrence des classes ClassA et ClassB :
1.
Ouvrez le fichier package_test.fla.
2.
Saisissez le code en gras suivant dans la fenêtre de script :
import com.macromedia.utils.*;
var a:ClassA = new ClassA(); // ClassA constructor
a.doSomething(); // call the ClassA’s doSomething() method
var a:ClassA = new ClassA(); // ClassA constructor
b.doSomething(); // call the ClassB’s doSomething() method
Le fait de saisir vos objets dans cet exemple de code permet au compilateur de s’assurer que
vous n’essayez pas d’accéder aux propriétés ou aux méthodes qui ne sont pas définies dans
votre classe personnalisée. Pour plus d’informations sur le typage strict des données,
consultez la section Affectation des types de données et typage strict, page 88. Une exception
au typage strict de vos objets, serait de déclarer que la classe est dynamique à l’aide du mot
clé dynamic. Consultez la section Création de classes dynamiques, page 280.
3.
Enregistrez les modifications apportées au fichier FLA avant de continuer.
A présent, les bases de la création et de l’utilisation des classes dans les documents Flash ne
devraient plus avoir de secrets pour vous. N’oubliez pas que vous pouvez également créer des
occurrences des classes ActionScript de niveau supérieur ou intégrées (consultez la section
Utilisation des classes intégrées, page 322).
Pour continuer à utiliser ces fichiers de classe dans un fichier Flash, consultez la section
Affectation d’une classe à des symboles dans Flash, page 304.
Affectation d’une classe à des symboles
dans Flash
Vous pouvez également affecter une classe aux symboles susceptibles d’être utilisés dans un
fichier Flash, tels qu’un clip sur la scène.
Pour affecter une classe à un symbole de clip :
1.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK.
2.
Choisissez Fichier > Enregistrer sous, et nommez le fichier Animal.as, puis sauvegardez le
fichier sur votre disque dur.
304
Classes
3.
Saisissez le code suivant dans la fenêtre de script:
class Animal {
public function Animal() {
trace("Animal::constructor");
}
}
Ce code ActionScript crée une nouvelle classe appelée Animal qui dispose d’une méthode
constructeur envoyant une chaîne au panneau de sortie.
4.
Enregistrez les modifications apportées au fichier ActionScript.
5.
Choisissez Fichier > Nouveau, puis Document Flash pour créer un nouveau fichier FLA,
puis cliquez sur OK.
6.
Choisissez Fichier > Enregistrez sous et nommez le fichier animal_test.fla; enregistrez le
fichier dans le même dossier que le fichier Animal.as créé à l’étape 2.
7.
Choisissez Insertion > Nouveau Symbole pour ouvrir la boîte de dialogue Créer un
symbole.
8.
Saisissez le nom de symbole d’un animal et sélectionnez l’option Movie Clip.
9.
Cliquez sur le bouton Avancé dans le coin inférieur de la boîte de dialogue Créer un
nouveau symbole, pour activer davantage d’options.
Le bouton Avancé est disponible lorsque vous êtes en mode basique de la boîte de dialogue
Créer un nouveau symbole.
10. Dans
la section Liaison, activez la case à cocher Exporter pour ActionScript.
L’activation de cette option vous permet de joindre dynamiquement des occurrences de ce
symbole à vos documents Flash pendant l’exécution.
11.
Saisissez une valeur pour l’identifiant animal_id et définissez la Classe ActionScript 2.0 sur
Animal (selon le nom de classe spécifié à l’étape 3).
12. Sélectionnez
la case à cocher Exporter dans la première image, puis cliquez sur OK pour
appliquer vos modifications et fermer la boîte de dialogue.
13.
Enregistrez le document Flash et choisissez Contrôle > Tester l’animation.
Le texte provenant de la fonction constructeur de votre classe Animal apparaît dans le
panneau de sortie.
R E MA R Q U E
Si vous devez modifier les propriétés de liaison du clip, cliquez du bouton droit sur le
symbole dans la bibliothèque du document et choisissez Propriétés ou Liaison dans
le menu contextuel.
Affectation d’une classe à des symboles dans Flash
305
Compilation et exportation de classes
Par défaut, les classes utilisées par un fichier SWF sont mises en packages et exportées dans la
première image du fichier SWF. Vous pouvez également spécifier une image différente dans
laquelle vos classes sont mises en package et exportées. Cette option est très pratique, par
exemple lorsqu’un fichier SWF utilise de nombreuses classes dont le téléchargement est long
(telles que des composants). Si les classes sont exportées vers la première image, l’utilisateur
doit attendre que tout le code de classe soit téléchargé avant de voir apparaître cette image. En
spécifiant une image ultérieure dans le scénario, vous pouvez afficher une courte animation de
chargement dans les premières images du scénario, pendant le téléchargement du code de
classe dans l’image ultérieure.
Pour spécifier l’image à exporter pour les classes d’un document Flash :
1.
Choisissez Fichier > Nouveau, puis Document Flash. Enregistrez le nouveau document
sous le nom exportClasses.fla.
2.
Renommez le calque par défaut content, faites glisser un composant ProgressBar du
panneau Composants vers la scène et donnez-lui my_pb comme nom d’occurrence.
3.
Créez un nouveau calque, faites-le glisser sur le calque Contenu, et renommez-le actions.
4.
Ajoutez le code ActionScript suivant à l’image 1 du calque actions du scénario principal :
my_pb.indeterminate = true;
5.
Créez une nouvelle image-clé sur Image 2 du calque actions et ajoutez le code ActionScript
suivant :
var classesFrame:Number = 10;
if (_framesloaded < classesFrame) {
trace(this.getBytesLoaded() + " of " + this.getBytesTotal() + " bytes
loaded");
gotoAndPlay(1);
} else {
gotoAndStop(classesFrame);
}
6.
Créez une nouvelle image-clé sur Image 10 du calque actions et ajoutez le code
ActionScript suivant :
stop();
7.
Créez une nouvelle image-clé sur Image 10 du calque actions et faites glisser plusieurs
composants sur la scène.
8.
Cliquez avec le bouton droit sur chaque composant (masquez ProgressBar) dans le panneau
Bibliothèque et choisissez Liaison dans le menu contextuel pour lancer la boîte de dialogue
Propriétés de liaison.
306
Classes
9.
Dans la boîte de dialogue Propriétés de liaison, assurez-vous que l’option Exporter pour
ActionScript est sélectionnée, désélectionnez la boîte de dialogue Exporter dans la première
image, et cliquez sur OK.
10. Choisissez
11.
Fichier > Paramètres de publication.
Dans la boîte de dialogue Paramètres de publication, cliquez sur l’onglet Flash.
12. Cliquez sur le bouton Paramètres qui se trouve en regard du menu contextuel de la version
ActionScript pour ouvrir la boîte de dialogue Paramètres d’ActionScript.
13.
Dans le champ de texte Exporter l’image pour les classes, saisissez le numéro de l’image
cible (Image 10).
Si l’image spécifiée n’existe pas dans le scénario, un message d’erreur apparaît lors de la
publication du fichier SWF.
14. Cliquez
sur OK pour fermer la boîte de dialogue Paramètres d’ActionScript, puis cliquez
de nouveau sur OK pour fermer la boîte de dialogue Paramètres de publication.
15.
Choisissez Contrôle > Tester l’animation pour tester le document Flash. Si les composants
se chargent trop rapidement, sélectionnez View > Simuler le téléchargement depuis le
fichier SWF. Flash simule le téléchargement du document Flash à une vitesse inférieure,
qui vous permet de voir les composants de la barre de progression s’animer tandis que les
fichiers de classe se téléchargent.
Pour plus d’informations sur les fichiers ASO, consultez la section Utilisation des fichiers ASO,
page 307.
Utilisation des fichiers ASO
Lors de la compilation, Flash crée parfois des fichiers portant l’extension .aso dans le sousrépertoire /aso du répertoire de chemin de classe global par défaut (consultez la section
Définition et modification du chemin de classe, page 260). L’extension .aso signifie objet
ActionScript (ASO). Pour chaque fichier ActionScript 2.0 importé de façon implicite ou
explicite et pour lequel la compilation est réussie, Flash génère un fichier ASO. Ce fichier
contient le pseudo-code binaire issu du fichier ActionScript associé. Ces fichiers contiennent
donc la forme compilée (le pseudo-code binaire) d’un fichier de classe.
Flash ne doit recréer le fichier ASO que dans les cas suivants :
■
Le fichier AS correspondant a été modifié.
■
Les fichiers ActionScript qui contiennent des définitions importées ou utilisées par le
fichier ActionScript correspondant ont été modifiés.
■
Les fichiers ActionScript inclus par le fichier ActionScript correspondant ont été modifiés.
Compilation et exportation de classes
307
Le compilateur crée des fichiers ASO pour faciliter la gestion du cache. La première
compilation est plus lente que les compilations suivantes. Ceci est dû au fait que les fichiers
AS ont changé et sont recompilés en tant que fichiers ASO. Pour les fichiers AS ne
comportant pas de modifications, le compilateur lit le pseudo-code compilé directement dans
le fichier ASO, sans recompiler le fichier AS.
Le format de fichier ASO est un format intermédiaire développé pour l’usage interne. Il n’est
pas documenté et n’a pas été conçu pour la redistribution.
Si Flash semble compiler des versions plus anciennes d’un fichier que vous avez édité,
supprimez les fichiers ASO et compilez-les de nouveau. Si vous prévoyez de supprimer des
fichiers ASO, supprimez-les lorsque Flash n’effectue aucune autre opération, telle que la
vérification de la syntaxe ou l’exportation de SWF.
Pour supprimer des fichiers ASO :
Si vous modifiez un fichier FLA et que vous souhaitez supprimer un fichier ASO, sélectionnez
l’une des actions suivantes dans l’environnement auteur :
■
Sélectionnez Contrôle > Supprimer fichiers ASO pour supprimer des fichiers ASO et
poursuivre la modification.
■
Sélectionnez Contrôle > Supprimer fichiers ASO et Tester l’animation pour supprimer des
fichiers ASO et tester l’application.
Si vous modifiez un document ActionScript dans la fenêtre de script :
■
Sélectionnez Contrôle > Supprimer fichiers ASO pour supprimer des fichiers ASO et
poursuivre la modification.
■
Sélectionnez Contrôle > Supprimer fichiers ASO et Tester le projet pour supprimer des
fichiers ASO et tester l’application.
La quantité de code pouvant être insérée dans un classe n’est pas illimitée : Le pseudo-code
d’une définition de classe dans un fichier SWF exporté ne doit faire plus de 32767octets. Un
message d’avertissement s’affiche s’il dépasse cette limite.
Vous ne pouvez pas prédire la taille du pseudo-code d’une classe donnée, mais les classes
comportant jusqu’à 1 500 lignes dépassent rarement la limite.
Si votre classe dépasse la limite, déplacez une partie du code dans une autre classe. En général,
une programmation orientée objet de qualité consiste à créer des classes aussi concises que
possible.
308
Classes
Distinction entre classes et domaine
Lorsque vous placez du code ActionScript dans des classes, il peut être nécessaire de modifier
le mode d’utilisation du mot-clé this. Par exemple, si une méthode de classe utilise une
fonction de rappel (telle que la méthode onLoad() de la classe LoadVars) dans votre code, il
sera difficile de savoir si le mot-clé this fait référence à la classe ou à l’objet. Dans ce cas, il
peut être nécessaire de créer un pointeur vers la classe actuelle, comme dans l’exemple suivant.
Pour distinguer le domaine et les fichiers de classe externes :
1.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK.
2.
Saisissez ou collez le code suivant dans la fenêtre de script :
/**
Classe Product
Product.as
*/
class Product {
private var productsXml:XML;
// constructeur
// targetXmlStr - chaîne, contient le chemin d’un fichier XML
function Product(targetXmlStr:String) {
/* Crée une référence locale à la classe actuelle.
Même si vous êtes au niveau du gestionnaire d’événement onLoad du
code XML,
vous pouvez faire référence à la classe actuelle et pas seulement
au paquet XML.
*/
var thisObj:Product = this;
// Crée une variable locale, qui permet de charger le fichier XML.
var prodXml:XML = new XML();
prodXml.ignoreWhite = true;
prodXml.onLoad = function(success:Boolean) {
if (success) {
/* Lorsque le code XML est chargé et analysé correctement,
définir la variable productsXml de la classe sur le document
XML analysé et appeler la fonction init.
*/
thisObj.productsXml = this;
thisObj.init();
} else {
/* Une erreur s’est produite pendant le chargement du fichier
XML. */
trace("erreur lors du chargement XML") ;
}
};
// Amorcer le chargement du document XML.
prodXml.load(targetXmlStr) ;
}
Distinction entre classes et domaine
309
public function init():Void {
// Afficher le package XML.
trace(this.productsXml) ;
}
}
Dans la mesure où vous tentez de faire référence à la variable du membre privé dans un
gestionnaire onLoad, le mot-clé this fait référence à l’occurrence prodXml et non pas à la
classe Product. Par conséquent, vous devez créer un pointeur vers le fichier de classe local
de façon à pouvoir référencer directement la classe à partir du gestionnaire onLoad. Vous
pouvez maintenant utiliser cette classe dans un document Flash.
3.
Enregistrez le code ActionScript précédent sous le nom Product.as.
4.
Créez un nouveau document Flash nommé testProduct.fla dans le même répertoire.
5.
Sélectionnez l’image 1 du scénario principal.
6.
Saisissez le code ActionScript suivant dans le panneau Actions :
var myProduct:Product = new Product("http://www.helpexamples.com/
crossdomain.xml");
7.
Choisissez Contrôle > Tester l’animation pour tester ce code dans l’environnement de test.
Le contenu du document XML spécifié s’affiche dans le panneau de sortie.
Les variables et les fonctions statiques sont un autre type de domaine rencontré avec
l’utilisation de ces classes. Le mot-clé static indique qu’une variable ou une fonction n’est
créée qu’une fois par classe et non pas dans chaque occurrence de cette classe. Vous pouvez
accéder à un membre de classe statique sans créer d’occurrence de la classe en utilisant la
syntaxe someClassName.username. Pour plus d’informations sur les variables et les fonctions
statiques, consultez les sections Présentation des méthodes et propriétés (membres) publiques,
privées et statiques, page 267 et Utilisation de membres de classe, page 275.
Un autre avantage des variables statiques est qu’elles ne perdent pas leurs valeurs à la fin de
leur domaine. L’exemple suivant présente l’utilisation du mot-clé static pour créer un
compteur chargé de suivre le nombre d’occurrences de la classe Flash créées. La variable
numInstances étant statique, elle n’est créée qu’une fois pour l’ensemble de la classe, et pas
pour chaque occurrence.
310
Classes
Pour utiliser le mot-clé static :
1.
Choisissez Fichier > Nouveau et sélectionnez Fichier ActionScript, puis cliquez sur OK.
2.
Saisissez le code suivant dans la fenêtre de script :
class User {
private static var numInstances:Number = 0;
public function User() {
User.numInstances++;
}
public static function get instances():Number {
return User.numInstances;
}
}
Le code précédent définit une classe User qui surveille le nombre d’appels au constructeur.
Une variable statique privée (User.numInstances) est incrémentée dans la méthode
constructeur.
3.
Enregistrez le document sous le nom User.as.
4.
Choisissez Fichier > Nouveau puis sélectionnez Document Flash pour créer un nouveau
document FLA, et enregistrez-le dans le même répertoire que User.as.
5.
Saisissez le code ActionScript suivant sur l’image 1 du scénario :
trace(User.instances); // 0
var user1:User = new User();
trace(User.instances); // 1
var user2:User = new User();
trace(User.instances); // 2
La première ligne de code appelle la méthode de lecture statique instances() qui renvoie
la valeur de la variable statique privée numInstances. Le reste du code crée de nouvelles
occurrences de la classe User et affiche la valeur actuelle renvoyée par la méthode de lecture
instances().
6.
Choisissez Contrôle > Tester l’animation pour tester les documents.
Pour plus d’informations sur l’utilisation du mot-clé this dans les classes, consultez la section
Utilisation du mot-clé this dans les classes, page 284.
Distinction entre classes et domaine
311
Présentation des classes de niveau
supérieur et intégrées
Outre les principaux éléments de langage, constructions (boucles for et while, par exemple)
et types de données primitives (nombres, chaînes et valeurs booléennes) décrits précédemment
dans ce manuel (consultez le Chapitre 4, Données et types de données, page 77 et le
Chapitre 5, Eléments fondamentaux du langage et de la syntaxe, page 123), ActionScript fournit
également plusieurs classes intégrées (complexe types de données). Ces classes offrent de
nombreuses options et fonctionnalités à vos scripts. Vous avez utilisé les classes de niveau
supérieur et d’autres classes intégrées du langage ActionScript dans les chapitres précédents et
vous allez encore les exploiter dans les chapitres restants. De nombreuses classes fournies avec
Flash permettent d’ajouter interactivité et fonctionnalité dans vos fichiers SWF ou encore de
développer des applications complexes. Par exemple, vous pouvez utiliser la classe Math pour
calculer des équations dans vos applications. Vous pouvez également utiliser la classe
BitmapData pour créer des animations codées et des pixels.
Les classes de niveau supérieur, énumérées dans la section Classes de niveau supérieur,
page 314, sont écrites dans Flash Player. Dans la boîte à outils Actions, ces classes sont situées
dans le répertoire ActionScript 2.0 Classes. Certaines d’entre elles reposent sur les
spécifications ECMAScript (ECMA-262) edition 3 language specification et sont appelées
classes ActionScript de base. Elles comprennent les classes Array, Boolean, Date et Math. Pour
plus d’informations sur les packages, consultez la section Fonctionnement des packages,
page 248.
Vous pouvez trouver les classes ActionScript installées sur votre disque dur. Vous pouvez
trouver les dossiers classes dans :
■
Windows : Hard Disk\Documents and Settings\user\Local Settings\Application
Data\Macromedia\Flash 8\language\Configuration\Classes.
■
Macintosh : Hard Disk/Users/user/Library/Application Support/Macromedia/Flash 8/
language/Configuration/Classes.
Le document Do note the Read Me placé dans ce répertoire pour plus d’information sur sa
structure.
La distinction entre les classes ActionScript de base et les classes spécifiques à Flash est
similaire à celle qui existe entre les classes JavaScript de base et côté client. Tout comme les
classes JavaScript côté client permettent de contrôler l’environnement du client (le navigateur
Web et le contenu des pages Web), les classes spécifiques à Flash permettent de contrôler
l’apparence et le comportement d’une application Flash à l’exécution.
312
Classes
Les autres classes intégrées ActionScript sont spécifiques à Macromedia Flash et au modèle
d’objet Flash Player. Parmi ces classes, citons Camera, MovieClip et LoadVars. D’autres classes
sont organisées en packages, telles que flash.display. Toutes ces classes sont parfois dites
intégrées (classes prédéfinies pouvant être utilisées pour ajouter des fonctionnalités à vos
applications).
Les sections suivantes présentent les classes ActionScript intégrées, et décrivent les tâches
fondamentales que vous effectuez avec ces classes intégrées. Pour un aperçu de l’utilisation des
classes et des objets en programmation orientée objet, consultez la section Utilisation des classes
intégrées, page 322. Les exemples de code en utilisant ces classes sont inclus dans tout le
manuel Learning ActionScript 2.0 in Flash.
Pour plus d’informations sur les éléments du langage (constantes, opérateurs et instructions),
consultez le Chapitre 5, Eléments fondamentaux du langage et de la syntaxe, page 123.
Pour plus d’informations sur les classes intégrées et de niveau supérieur, consultez les
rubriques suivantes :
■
Classes de niveau supérieur, page 314
■
Le package flash.display, page 318
■
Package flash.external, page 319
■
Le package flash.filters, page 319
■
Package flash.geom, page 320
■
Package flash.net, page 321
■
package flash.text, page 321
■
Le package mx.lang, page 321
■
Les packages System et TextField, page 322
Autres éléments du langage
Il y a d’autres éléments de langage qui constituent ActionScript, en dehors des classes. Ils
incluent des directives, des constantes, des fonctions globales, des propriétés globales, des
opérateurs et des instructions. Pour plus d’informations sur l’utilisation de chacun de ces
éléments de langage, consultez les rubriques suivantes:
■
Chapitre 5, Eléments fondamentaux du langage et de la syntaxe
■
Chapitre 6, Fonctions et méthodes
Présentation des classes de niveau supérieur et intégrées
313
Vous trouverez une liste de ces éléments de language dans les sections suivantes de Guide de
référence du langage ActionScript 2.0:
■
Directives de compilation
■
Constantes
■
Fonctions globales
■
Propriétés globales
■
Opérateurs
■
Instructions
Classes de niveau supérieur
Le niveau supérieur contient les fonctions globales et les classes ActionScript qui, pour la
plupart, fournissent les fonctionnalités de base de vos applications. Les classes de base,
directement empruntées à ECMAScript, comprennent Array, Boolean, Date, Error, Function,
Math, Number, Object, String et System. Pour plus d’informations sur chaque classe,
consultez le tableau suivant.
REMARQUE
Les classes CustomActions et XMLUI sont uniquement disponibles dans
l’environnement de programmation Flash.
Classe
Description
Accessibility
La classe Accessibility gère la communication entre les fichiers SWF et
les applications de lecture d’écran. Conjointement avec la propriété
globale _accProps, les méthodes de cette classe permettent de
contrôler les propriétés accessibles des clips, des boutons et des
champs de texte lors de l’exécution. Consultez la section Accessibilité.
Array
La classe Array représente des tableaux dans ActionScript et tous les
objets de tableau sont des occurrences de cette classe. Elle contient
les méthodes et propriétés réservées aux objets de tableau. Consultez
la section Array.
AsBroadcaster
Cette classe offre des capacités de notification d’événement et de
gestion des écouteurs pouvant être ajoutées à d’autres objets.
Consultez la section AsBroadcaster.
Boolean
La classe Boolean est une enveloppe pour les valeurs booléennes
(true ou false). Consultez la section Booléen.>.
314
Classes
Classe
Description
Button
La classe Button fournit des méthodes, propriétés et gestionnaires
d’événement pour l’utilisation des boutons. Consultez la section
Button. Notez que la classe intégrée Button est différente de la classe
du composant Button, associée au composant Button version 2.
Camera
La classe Camera vous permet d’accéder à la caméra de l’utilisateur,
s’il en a installé une. Utilisé avec Flash Communication Server, votre
fichier SWF peut récupérer, diffuser et enregistrer les images et les
vidéos de la caméra d’un utilisateur. Consultez la section Camera.
Color
La classe Color permet de définir la valeur des couleurs RVB et leur
évolution dans les occurrences de clips, puis de récupérer ces valeurs
après leur définition. La classe Color est abandonnée dans Flash Player
8 en faveur de la classe ColorTransform. Pour plus d’informations sur
ColorTransform, se reporter à ColorTransform
(flash.geom.ColorTransform).
ContextMenu
La classe ContextMenu conditionne le contenu du menu contextuel de
Flash Player à l’exécution. Vous pouvez associer des objets
ContextMenu distincts à des objets MovieClip, Button ou TextField à
l’aide de la propriété menu de ces classes. Vous avez aussi tout loisir
d’utiliser la classe ContextMenuItem pour ajouter des éléments de
menu personnalisés à un objet ContextMenu. Consultez la section
ContextMenu.
ContextMenuItem
La classe ContextMenuItem vous permet de créer des éléments de
menu dans le menu contextuel de Flash Player. Pour ajouter les
éléments de menu que vous créez à l’aide de cette classe au menu
contextuel de Flash Player, vous utilisez la classe ContextMenu.
Consultez la section ContextMenuItem.
CustomActions
La classe CustomActions vous permet de gérer toute action
personnalisée enregistrée avec l’outil de programmation Consultez la
section CustomActions.
Date
La classe Date détermine la représentation des dates et des heures
dans ActionScript et prend en charge leurs opérations de manipulation.
La classe Date permet également de récupérer la date et l’heure
actuelle du système d’exploitation. Consultez la section Date.
Error
La classe Error contient des informations sur les erreurs d’exécution
survenant dans vos scripts. En règle générale, vous utilisez l’instruction
throw pour générer une condition d’erreur, que vous pouvez ensuite
gérer à l’aide d’une instruction try.catch.finally. Consultez la section
Erreur.
Présentation des classes de niveau supérieur et intégrées
315
Classe
Description
Function
La classe Function est la représentation sous forme de classe de toutes
les fonctions ActionScript, y compris celles qui sont natives
d’ActionScript et celles que vous définissez. Consultez la section
Function.
Key
La classe Key fournit des méthodes et propriétés permettant d’obtenir
des informations sur les actions effectuées sur le clavier et les touches
par l’utilisateur. Consultez la section Key.
LoadVars
La classe LoadVars permet de transférer des variables en paires nomvaleur d’un fichier SWF à un serveur. Consultez la section LoadVars.
LocalConnection
La classe LocalConnection permet de développer des fichiers SWF
qui peuvent échanger des instructions entre eux sans utiliser la
méthode fscommand() ni JavaScript. Consultez la section
LocalConnection.
Math
La classe Math fournit un accès pratique aux constantes
mathématiques les plus courantes et offre plusieurs fonctions
mathématiques. Toutes les propriétés et méthodes de la classe Math
sont statiques et doivent être appelées à l’aide de la syntaxe
Math.méthode(paramètre) ou Math.constante. Consultez la section
Math.
Microphone
La classe Microphone vous permet d’accéder au micro de l’utilisateur,
s’il en a installé un. Utilisé avec Flash Communication Server, votre
fichier SWF peut diffuser et enregistrer les sons du microphone d’un
utilisateur. Consultez la section Microphone.
Mouse
La classe Mouse vous permet de contrôler la souris dans un fichier
SWF. Vous pouvez l’utiliser pour masquer ou afficher le pointeur de la
souris, par exemple. Consultez la section Mouse.
MovieClip
Chaque clip d’un fichier SWF est une occurrence de la classe
MovieClip. Utilisez les méthodes et propriétés de cette classe pour
contrôler les objets de clip. Consultez la section MovieClip.
MovieClipLoader
Cette classe permet d’implémenter des rappels d’écouteur qui
fournissent des informations d’état lors du chargement des fichiers
SWF, JPEG, GIF et PNG dans les occurrences de clips. Consultez la
section MovieClipLoader.
NetConnection
La classe NetConnection établit une connexion locale en flux continu
pour la lecture de fichiers Flash Video (FLV) à partir d’une adresse
HTTP ou du système de fichiers local. Consultez la section
NetConnection.
316
Classes
Classe
Description
NetStream
La classe NetStream contrôle la lecture des fichiers FLV à partir d’un
système de fichiers local ou d’une adresse HTTP. Consultez la section
NetStream.
Number
La classe Number est une enveloppe pour le type de données primitif
numérique. Consultez la section Number.
Object
La classe Object est à la racine de la hiérarchie des classes
ActionScript. Toutes les autres classes héritent de ses méthodes et
propriétés. Consultez la section Object.
PrintJob
La classe PrintJob permet d’imprimer du contenu à partir d’un fichier
SWF, y compris le contenu créé de façon dynamique et les documents
à plusieurs pages. Consultez la section PrintJob.
Selection
La classe Selection permet de définir et de contrôler le champ de texte
dans lequel se trouve le point d’insertion (celui qui a le focus).
Consultez la section Selection.
SharedObject
La classe SharedObject crée un stockage de données permanent sur
l’ordinateur client, similaire aux cookies. Cette classe offre le partage
des données en temps réel entre objets de l’ordinateur client.
Consultez la section SharedObject.
Sound
La classe Sound vous permet de contrôler les sons dans un fichier
SWF. Consultez la section Sound.
Stage
La classe Stage fournit des informations sur les dimensions,
l’alignement et le mode d’échelle du fichier SWF. Elle signale
également les événements de redimensionnement Stage. Consultez la
section Stage.
String
La classe String est une enveloppe pour le type de données primitif
chaîne, ce qui vous permet d’utiliser les méthodes et les propriétés de
l’objet String pour manipuler les valeurs primitives de chaîne. Consultez
la section Chaîne.
System
La classe System fournit des informations sur Flash Player et sur le
système sur lequel il s’exécute (la résolution d’affichage et la langue
utilisée, par exemple). Elle vous permet aussi d’afficher ou de masquer
le panneau Paramètres Flash Player et de modifier les paramètres de
sécurité du fichier SWF Consultez la section System.
TextField
La classe TextField permet de contrôler les champs texte de saisie et
dynamiques, notamment pour extraire des informations de formatage,
appeler des gestionnaires d’événement et changer des propriétés
telles que les valeurs alpha et la couleur d’arrière-plan. Consultez la
section TextField.
Présentation des classes de niveau supérieur et intégrées
317
Classe
Description
TextFormat
La classe TextFormat vous permet d’appliquer des styles de formatage
aux caractères et aux paragraphes d’un objet TextField. Consultez la
section TextFormat.
TextSnapshot
L’objet TextSnapshot permet d’accéder au texte statique d’un clip et
de mettre ce texte en forme. Consultez la section TextSnapshot.
Video
La classe Video permet d’afficher des objets vidéo dans un fichier
SWF. Vous pouvez l’utiliser avec Flash Communication Server pour
afficher un contenu vidéo en flux continu dans un fichier SWF ou dans
Flash pour afficher un fichier Flash Video (FLV). Consultez la section
Video.
XML
Cette classe contient les méthodes et propriétés réservées aux objets
XML. Consultez la section XML.
XMLNode
La classe XMLNode représente un nœud unique dans une
arborescence de documents XML. Elle constitue la super-classe de la
classe XML. Consultez la section XMLNode.
XMLSocket
La classe XMLSocket permet de créer une connexion socket durable
entre un serveur et un client exécutant Flash Player. Les sockets du
client autorisent un transfert de données à faible temps d’attente, tel
que celui que requièrent les applications de discussion en ligne en
temps réel (appelées « chat »). Consultez la section XMLSocket.
XMLUI
L’objet XMLUI autorise une communication avec les fichiers SWF
utilisés comme interfaces utilisateur personnalisées pour les fonctions
d’extensibilité de l’outil de programmation Flash (telles que
Comportements, Commandes, Effets et Outils). Consultez la section
XMLUI.
Le package flash.display
Le package flash.display contient la classe BitmapData que vous pouvez utiliser pour
développer des affichages visuels.
Classe
Description
BitmapData
La classe BitmapData permet de créer des images bitmap
transparentes ou opaques de tailles arbitraires ou des images dans le
document et de les manipuler de diverses manières à l’exécution. Voir
BitmapData (flash.display.BitmapData).
318
Classes
Package flash.external
Le package flash.external permet de communiquer avec le conteneur Flash Player à l’aide de
code ActionScript. Par exemple, si vous imbriquez un fichier SWF dans une page HTML,
celle-ci devient le conteneur. Vous pouvez alors communiquer avec la page HTML via la
classe ExternalInterface et JavaScript. Également appelé API externe.
Classe
Description
ExternalInterface
La classe ExternalInterface est l’API External, un sous-système qui
autorise les communications entre ActionScript et le conteneur Flash
Player (par exemple une page HTML utilisant JavaScript) ou une
application de bureau qui utilise Flash Player. Consultez la section
ExternalInterface (flash.external.ExternalInterface).
Le package flash.filters
Le package flash.filters contient des classes liées aux effets de filtres bitmap disponibles dans
Flash Player 8. Les filtres permettent d’appliquer de riches effets visuels, tels que le flou, les
biseaux, le rayonnement et les ombres portées, aux occurrences d’image et de clip. Pour plus
d’informations sur chaque classe, consultez les références fournies dans le tableau suivant.
Classe
Description
BevelFilter
La classe BevelFilter permet d’ajouter un effet biseauté à une
occurrence de clip. Consultez la section BevelFilter
(flash.filters.BevelFilter).
BitmapFilter
La classe BitmapFilter est une classe de base pour tous les effets de
filtres. Consultez la section BitmapFilter (flash.filters.BitmapFilter).
BlurFilter
La classe BlurFilter permet d’appliquer un effet flou à des occurrences
de clip. Consultez la section BlurFilter (flash.filters.BlurFilter).
ColorMatrixFilter
La classe ColorMatrixFilter permet d’appliquer une transformation
matricielle 4x5 aux valeurs de couleur RGBA et alpha de chaque
pixel d’une image d’entrée. Après l’application de cette
transformation, le résultat peut être produit avec un nouveau jeu de
couleurs RGBA et de valeurs alpha. Consultez la section
ColorMatrixFilter (flash.filters.ColorMatrixFilter).
ConvolutionFilter
La classe ConvolutionFilter permet d’appliquer un filtre de
convolution de matrice. Consultez la section ConvolutionFilter
(flash.filters.ConvolutionFilter).
Présentation des classes de niveau supérieur et intégrées
319
Classe
Description
DisplacementMapFilter La classe DisplacementMapFilter permet d’utiliser les valeurs des
pixels d’une image spécifiée (remplacement d’une image) pour
remplacer dans l’espace l’occurrence d’origine (un clip) auquel le
filtre est appliqué. Consultez la section DisplacementMapFilter
(flash.filters.DisplacementMapFilter).
DropShadowFilter
La classe DropShadowFilter permet d’ajouter un effet d’ombre
portée à un clip. Consultez la section DropShadowFilter
(flash.filters.DropShadowFilter).
GlowFilter
La classe GlowFilter permet d’ajouter un effet de rayonnement à un
clip. Consultez la section GlowFilter (flash.filters.GlowFilter).
GradientBevelFilter
La classe GradientBevelFilter permet d’appliquer un effet dégradé à
un clip. Consultez la section GradientBevelFilter
(flash.filters.GradientBevelFilter).
GradientGlowFilter
La classe GradientGlowFilter permet d’appliquer un effet de
rayonnement dégradé à un clip. Consultez la section
GradientGlowFilter (flash.filters.GradientGlowFilter).
Package flash.geom
Le package flash.geom contient des classes de géométrie, telles que des points, des rectangles et
des matrices de transformation. Ces classes prennent en charge la classe BitmapData et la
fonctionnalité de mise en cache des bitmap. Pour plus d’informations sur chaque classe,
consultez les références fournies dans le tableau suivant.
Classe
Description
ColorTransform
La classe ColorTransform permet de définir mathématiquement la
valeur des couleurs RVB et de transformation de couleur d’une
occurrence. Vous pouvez récupérer ces valeurs après leur définition.
Consultez la section ColorTransform (flash.geom.ColorTransform).
Matrix
Représente une matrice de transformation qui détermine la façon de
mapper des points d’un espace de coordonnées à l’autre. Consultez la
section Matrix (flash.geom.Matrix).
Point
L’objet Point représente un emplacement dans un système de
coordonnées à deux dimensions, dans lequel x est l’axe horizontal et y
l’axe vertical. Consultez la section Point (flash.geom.Point).
320
Classes
Classe
Description
Rectangle
La classe Rectangle permet de créer et de modifier les objets
Rectangle. Consultez la section Rectangle (flash.geom.Rectangle).
Transform
Rassemble des données sur les transformations de couleurs et les
manipulations de coordonnées qui s’appliquent à un objet occurrence.
Consultez la section Transform (flash.geom.Transform).
Package flash.net
Le package flash.net contient des classes qui vous permettent de charger et télécharger un ou
plusieurs fichiers entre l’ordinateur d’un utilisateur et le serveur. Pour plus d’informations sur
chaque classe, consultez les références fournies dans le tableau suivant.
Classe
Description
FileReference
La classe FileReference vous permet de charger et télécharger un ou
plusieurs fichiers entre l’ordinateur d’un utilisateur et le serveur.
Consultez la section FileReference (flash.net.FileReference).
FileReferenceList
La classe FileReferenceList permet de charger un ou plusieurs fichiers
entre l’ordinateur d’un utilisateur et le serveur. Consultez la section
FileReferenceList (flash.net.FileReferenceList).
package flash.text
Le package flash.text comporte la classe TextRenderer permettant de travailler avec une
fonctionnalité d’anti-crénelage avancée dans Flash Player8.
Classe
Description
TextRenderer
Cette classe fournit une fonctionnalité d’anti-crénelage avancé dans
Flash Player8. Voir TextRenderer (flash.text.TextRenderer)..
Le package mx.lang
Le package mx.lang comporte la classe Locale pour travailler avec un texte multilingue.
Classe
Description
Locale
Cette classe vous permet de contrôler la façon dont le texte multilingue
s’affiche dans un fichier SWF. Consultez la section Locale
(mx.lang.Locale).
Présentation des classes de niveau supérieur et intégrées
321
Les packages System et TextField
Le package System contient les capacités d’IME et des classes de sécurité. Ces classes traitent
les paramètres du client susceptibles d’affecter le fonctionnement de votre application dans
Flash Player. Pour plus d’informations sur chaque classe, consultez les références fournies dans
le tableau suivant.
Classe
Description
capabilities
La classe Capabilities détermine les capacités du système et du Flash
Player qui héberge le fichier SWF. Elle vous permet de personnaliser le
contenu pour des formats différents. Consultez la section capabilities
(System.capabilities).
IME
La classe IME permet de manipuler directement l’IME (Input Method
Editor) du système d’exploitation sous lequel l’application Flash Player
s’exécute sur l’ordinateur client. Consultez la section IME
(System.IME).
security
La classe security contient des méthodes spécifiant la façon dont les
fichiers SWF peuvent communiquer entre eux dans différents
domaines. Consultez la section security (System.security).
Le package TextField contient la classe StyleSheet qui vous permet d’appliquer des styles CSS
au texte.
Classe
Description
StyleSheet
La classe StyleSheet permet de créer un objet feuille de style
contenant les règles de formatage du texte, comme la taille et la
couleur de la police et d’autres styles de formatage. Consultez la
section StyleSheet (TextField.StyleSheet).
Utilisation des classes intégrées
En programmation orientée objet (OOP), une classe définit une catégorie d’objets. Une classe
décrit les propriétés (données) et le comportement (méthodes) d’un objet, comme un plan
d’architecte décrit les caractéristiques d’un immeuble. Pour plus de détails sur les classes et
autres concepts de programmation orientée objet, consultez les sections suivantes :
■
Bases de la programmation orientée objet., page 250
■
Ecriture de fichiers de classe personnalisée, page 254
322
Classes
Flash 8 comporte de nombreuses classes intégrées que vous pouvez utiliser dans votre code
(consultez la section Présentation des classes de niveau supérieur et intégrées, page 312), ce qui
vous aide à rajouter facilement de l’interactivité à vos applications. Pour utiliser les propriétés
et méthodes définies par une classe, vous devez tout d’abord créer une occurrence de cette
classe (sauf pour les classes comportant des membres statiques). La relation entre une
occurrence et sa classe est similaire à la relation entre une maison et le plan d’architecte
correspondant, comme évoqué dans la section Présentation des classes de niveau supérieur et
intégrées, page 312.
Pour plus d’informations sur l’utilisation des classes qui sont intégrées à Flash 8, consultez les
rubriques suivantes:
■
Création d’une nouvelle occurrence d’une classe intégrée, page 323
■
Accès aux propriétés intégrées des objets, page 324
■
Appel de méthodes d’objet intégré, page 325
■
Présentation des membres (statiques) de classe, page 325
■
Préchargement de fichiers de classe, page 326
■
Exclusion de classes, page 325
Création d’une nouvelle occurrence d’une classe
intégrée
Pour créer une occurrence de classe ActionScript, utilisez l’opérateur new pour appeler la
fonction constructeur de la classe. La fonction constructeur porte toujours le même nom que
la classe dont elle renvoie une occurrence, que vous attribuez généralement à une variable.
Le code suivant crée par exemple un nouvel objet Sound :
var song_sound:Sound = new Sound();
Dans certains cas, il n’est pas nécessaire de créer une occurrence de classe pour employer ses
propriétés et ses méthodes. Pour plus d’informations, consultez la section Présentation des
membres (statiques) de classe, page 325.
Utilisation des classes intégrées
323
Accès aux propriétés intégrées des objets
Utilisez l’opérateur point (.) pour accéder à la valeur d’une propriété d’objet. Entrez le nom
de l’objet à gauche du point et le nom de la propriété à droite. Par exemple, dans l’instruction
suivante, my_obj représente l’objet et firstName la propriété :
my_obj.firstName
L’exemple de code suivant crée un nouvel objet Array puis affiche sa propriété length :
var my_array:Array = new Array("apples", "oranges", "bananas");
trace(my_array.length); // 3
Vous pouvez également utiliser l’opérateur d’accès tableau ([]) pour accéder aux propriétés
d’un objet, notamment au cours des processus de débogage. L’exemple suivant passe en boucle
sur un objet pour afficher toutes ses propriétés:
Pour passer en boucle les contenus d’un objet :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom forin.fla.
2.
Ajoutez le code ActionScript suivant à l’image 1 du scénario 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]);
}
Le code précédent définit un nouvel Objet appelé résultats et définit des valeurs pour
firstName, lastName, age, avg, b, et t. Un for..in en boucle suit chaque propriété
dans l’objet résultat et suit sa valeur au panneau de sortie.
3.
Choisissez Contrôle > Tester l’animation pour tester le document Flash.
Pour plus d’informations sur la création de tableaux et leurs opérateurs d’accès, consultez la
section Présentation des opérateurs, page 191. Pour plus d’informations sur les méthodes et les
propriétés, consultez le Chapitre 6, Fonctions et méthodes, page 217. Pour des exemples de
l’utilisation des propriétés de la classe intégrée MovieClip, consultez le
Chapitre 11, Utilisation des clips, page 381, pour des exemples de l’utilisation des propriétés
des classes TextField, String, TextRenderer et TextFormat, consultez le
Chapitre 12, Utilisation du texte et des chaînes, page 415.
324
Classes
Appel de méthodes d’objet intégré
Pour appeler la méthode d’un objet, utilisez l’opérateur point (.), suivi de la méthode. Par
exemple, le code suivant crée un nouvel objet Sound et appelle sa méthode setVolume() :
var my_sound:Sound = new Sound(this);
my_sound.setVolume(50);
Pour des exemples de l’utilisation des méthodes de la classe intégrée MovieClip, consultez le
Chapitre 11, Utilisation des clips, page 381. Pour des exemples de l’utilisation des méthodes de
la classe intégrée TextField, String, TextRenderer, et TextFormat, consultez le
Chapitre 12, Utilisation du texte et des chaînes, page 415.
Présentation des membres (statiques) de classe
Certaines classes ActionScript intégrées possèdent des membres de classe ( membres statiques).
Pour invoquer les membres de classe (propriétés et méthodes) ou y accéder, vous utilisez le
nom de la classe, et non son occurrence. Vous ne devez donc pas créer d’occurrence de la classe
pour utiliser ces propriétés et méthodes.
Par exemple, toutes les propriétés de la classe Math sont statiques. Le code suivant appelle la
méthode max() de la classe Math pour déterminer lequel de deux nombres est le plus grand.
var largerNumber:Number = Math.max(10, 20);
trace(largerNumber); // 20
Pour plus d’informations sur les méthodes statiques de la classe Math, et des exemples
d’utilisation, Consultez la section Math dans le Guide de référence du langage ActionScript 2.0.
Exclusion de classes
Pour réduire la taille d’un fichier SWF, il peut être nécessaire d’exclure des classes de la
compilation tout en restant capable d’y accéder et de les utiliser pour la vérification du type.
Par exemple, procédez de cette façon lorsque vous développez une application qui utilise
plusieurs fichiers SWF ou des bibliothèques partagées, en particulier celles qui accèdent
souvent aux mêmes classes. Cette exclusion de classes vous aide à éviter la duplication de
classes dans ces fichiers.
Pour plus d’informations sur l’utilisation des classes, consultez les rubriques suivantes :
■
Préchargement de fichiers de classe, page 326
Utilisation des classes intégrées
325
Pour exclure des classes de la compilation :
1.
Créez un nouveau fichier XML.
2.
Nommez le fichier XML FLA_filename_exclude.xml, où FLA_filename correspond au
nom du fichier FLA sans son extension.
Par exemple, si le fichier FLA s’appelle sellStocks.fla, le nom de fichier XML doit être
sellStocks_exclude.xml.
3.
Enregistrez le fichier dans le même répertoire que le fichier FLA.
4.
Placez les balises suivantes dans le fichier XML :
<excludeAssets>
<asset name="className1" />
<asset name="className2" />
</excludeAssets>
Les valeurs spécifiées pour les attributs de nom dans les balises <asset> désignent les
noms des classes à exclure du fichier SWF. Ajoutez-en autant que nécessaire pour votre
application. Par exemple, le fichier XML suivant exclut les classes mx.core.UIObject et
mx.screens.Slide du fichier SWF :
<excludeAssets>
<asset name="mx.core.UIObject" />
<asset name="mx.screens.Slide" />
</excludeAssets>
Pour plus d’informations sur les classes de préchargement, consultez la section Préchargement
de fichiers de classe, page 326.
Préchargement de fichiers de classe
Cette section décrit certaines méthodologies de préchargement et d’exportation des classes
dans Flash 8 (y compris les classes qu’utilisent les composants dans la version 2 de
Macromedia Component Architecture). Le préchargement implique le chargement de certaines
des données sur un fichier SWF avant que l’utilisateur ne commence à interagir. Flash importe
les classes dans la première image d’un fichier SWF lorsque vous utilisez des classes externes.
Ces données constituent le premier élément à charger dans un fichier SWF. Il est similaire aux
classes de composant, dans la mesure où la structure des composants se charge également dans
la première image d’un fichier SWF. Lorsque vous créez de grandes applications, le temps de
chargement peut être considérable lorsque vous devez importer des données. Vous devez donc
traiter ces données de façon plus technique, comme indiqué dans les procédures suivantes.
326
Classes
Dans la mesure où les classes constituent les premières données à charger, vous risquez d’avoir
à créer des difficultés à créer une barre de progression ou à charger une animation lorsque les
classes se chargent avant la barre de progression, car la barre de progression doit rendre compte
de l’ensemble du processus de chargement, classes incluses. Par conséquent, il est recommandé
de charger les classes après les autres parties du fichier SWF, mais avant d’utiliser les
composants.
La procédure suivante indique comment modifier l’image dans laquelle les classes se chargent
dans un fichier SWF.
Pour sélectionner une autre image pour les classes à charger dans le fichier
SWF :
1.
Choisissez Fichier > Paramètres de publication.
2.
Sélectionnez l’onglet Flash, puis cliquez sur le bouton Paramètres.
3.
Dans la zone de texte Exporter l’Image pour les Classes, tapez le numéro d’une nouvelle
image, ce qui va déterminer quand charger les classes.
4.
Cliquez sur OK.
Vous ne pouvez pas utiliser n’importe quelle classe tant que la tête de lecture n’a pas atteint
l’image cible du chargement. Par exemple, les composants de la version 2 nécessitent des
classes pour leur fonctionnalité ; vous devez donc charger des composants après l’image
exportée pour les classes ActionScript 2.0. Si vous procédez à l’exportation pour l’image 3,
vous ne pouvez pas exploiter ces classes tant que la tête de lecture n’a pas atteint l’image 3 et
n’a pas chargé les données.
Si vous devez précharger un fichier utilisant des composants, par exemple les classes de
composants de la version 2, vous devez les précharger dans le fichier SWF. Pour ce faire, vous
devez définir vos composants de façon à les exporter pour une autre image dans le fichier
SWF. Par défaut, les composants UI s’exportent vers l’image 1 du fichier SWF ; assurez-vous
donc que vous avez désélectionné Export dans First Frame de la boîte de dialogue de liaison
du composant.
Lorsque les composants ne se chargent pas sur la première image, vous pouvez créer une barre
de progression personnalisée pour la première image du fichier SWF. Ne référencez aucun
composant dans votre code ActionScript ou n’incluez aucun composant sur la scène pendant
le chargement des classes destinées à l’image spécifiée dans le champ Export Frame for Classes.
A T T EN T I ON
Vous devez exporter les composants après les classes ActionsScript qu’ils utilisent.
Utilisation des classes intégrées
327
328
Classes
8
CHAPITRE 8
Héritage
Dans le Chapitre 7, Classes, vous avez appris à écrire des fichiers de classe et à utiliser les classes
pour organiser le code dans des fichiers externes. Ce chapitre décrivait également
l’organisation des fichiers de classe dans des packages associés. L’objectif de ce chapitre est de
vous apprendre à écrire des classes plus complexes, qui étendent les fonctionnalités d’une
classe existante. Ce sujet est intéressant car vous serez probablement amené à étendre vos
propres classes personnalisées ou les classes existantes pour pouvoir ajouter des nouvelles
méthodes et des propriétés.
Pour plus d’informations sur les héritages, consultez la section Présentation de l’héritage,
page 329. Pour plus d’informations sur les méthodes et les propriétés, consultez le
Chapitre 6, Fonctions et méthodes, page 217.
Pour plus d’informations sur l’héritage, consultez les sections suivantes :
Présentation de l’héritage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .329
Ecriture de sous-classes dans Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
Utilisation du polymorphisme dans une application . . . . . . . . . . . . . . . . . . . . . . . . . .338
Présentation de l’héritage
Vous avez découvert dans le Chapitre 7, Classes comment créer un fichier de classe pour créer
vos propres types de données personnalisés. A travers ces fichiers de classe personnalisée, vous
avez également appris à extraire le code du scénario pour le placer dans des fichiers externes.
Ce déplacement vers des fichiers externes simplifie l’édition de votre code. Maintenant que les
bases de la création de classes personnalisées n’ont plus de secrets pour vous, vous allez
découvrir une technique de programmation orientée objet appelée sous-classement ou extension
de classe, qui vous permet de créer de nouvelles classes à partir d’une classe existante.
329
L’un des avantages de la programmation orientée objet réside dans la possibilité de créer des
sous-classes d’une classe. Ces sous-classes héritent alors de toutes les propriétés et méthodes de
la super-classe. Par exemple, si vous étendez (ou sous-classez) la classe MovieClip, vous créez une
classe personnalisée qui étend la classe MovieClip. Votre sous-classe hérite donc de toutes les
propriétés et méthodes de la classe MovieClip. Vous pouvez également créer un ensemble de
classes étendant une super-classe personnalisée. La classe Laitue, par exemple, peut être une
extension de la super-classe Légume.
Votre sous-classe définit généralement d’autres méthodes et propriétés utilisables dans votre
application et, en cela, étend la super-classe. Les sous-classes peuvent également supplanter
(apporter leurs propres définitions) les méthodes héritées d’une super-classe. Lorsqu’une sousclasse remplace une méthode héritée de sa super-classe, la définition de la superclasse n’est plus
accessible depuis la sous-classe. La seule exception à cette règle est la suivante : si vous êtes
dans la fonction constructeur d’une sous-classe, vous pouvez appeler la fonction de
constructeur de la superclasse à l’aide de l’instruction super. Pour plus d’informations sur le
remplacement de méthodes et de propriétés, consultez la section Remplacement des méthodes et
des propriétés, page 335.
Par exemple, vous créez une classe Mammifère qui définit certaines propriétés et certains
comportements communs à tous les mammifères. Vous pouvez alors créer une sous-classe
Chat qui permet d’étendre la classe Mammifère. L’utilisation de sous-classes permet de
recycler le code de sorte que, au lieu de recréer le code commun à deux classes, il vous suffit
d’étendre une classe existante. Une autre sous-classe peut étendre la classe Chat (la classe
Siamois par exemple), et ainsi de suite. Dans une application complexe, la définition de la
structure hiérarchique des classes représente une grande partie du processus de création.
L’héritage et le sous-classement se révèlent très utiles dans les grandes applications car ils vous
permettent de créer une série de classes associées partageant les mêmes fonctionnalités. Par
exemple, vous pouvez créer une classe Employé définissant les méthodes et les propriétés de
base d’un employé typique dans une société. Vous pouvez ensuite créer une nouvelle classe
appelée Fournisseur qui étend la classe Employé et hérite de toutes ses méthodes et propriétés.
La classe Fournisseur pourrait également ajouter ses propres méthodes et propriétés ou
supplanter celles de la super-classe Employé. Vous pouvez même créer une classe Dirigeant
étendant également la classe Employé et définissant d’autres méthodes et propriétés telles que
recrutement(), licenciement(), augmentation() et promotion(). Vous pouvez encore
étendre une sous-classe, par exemple la classe Dirigeant, et créer une nouvelle classe appelée
Directeur, ajoutant à son tour de nouvelles méthodes ou remplaçant les méthodes existantes.
330
Héritage
Chaque fois que vous étendez une classe existante, la nouvelle classe hérite de toutes les
méthodes et propriétés de la sous-classe. Si aucune des classes n’était associée, il vous faudrait
réécrire chaque méthode et propriété dans chaque fichier de classe, même lorsque la
fonctionnalité ne change pas. Vous perdriez alors du temps, non seulement dans l’écriture du
code, mais également dans le débogage de votre application et la maintenance du projet
lorsque le même code doit être modifié dans plusieurs fichiers.
Dans ActionScript, utilisez le mot-clé extends pour établir une relation d’héritage entre une
classe et sa super-classe, ou pour étendre une interface. Pour plus d’informations sur
l’utilisation du mot-clé extends, consultez les sections Ecriture de sous-classes dans Flash,
page 331 et Ecriture d’une sous-classe, page 332. Pour plus d’informations sur le mot-clé
extends, consultez l’instruction extends dans le Guide de référence du langage ActionScript 2.0.
Ecriture de sous-classes dans Flash
En programmation orientée objet, une sous-classe peut hériter des propriétés et méthodes
d’une autre classe, appelée super-classe. Vous pouvez étendre vos propres classes personnalisées
et la plupart des classes de base et des classes ActionScript de Flash Player. Vous ne pouvez pas
étendre la classe TextField ou les classes statiques, telles que les classes Math, Key et Mouse.
Pour créer ce type de relation entre deux classes, utilisez la clause extends de l’instruction
class. Pour spécifier une super-classe, utilisez la syntaxe suivante :
class SubClass extends SuperClasse {}
La classe spécifiée dans SubClass hérite de toutes les propriétés et méthodes définies dans la
super-classe.
Par exemple, vous créez une classe Mammifère qui définit des propriétés et méthodes
communes à tous les mammifères. Pour créer une variante de cette classe Mammifère
(Mammal), telle que la classe Marsupial, étendez la classe Mammal, c’est-à-dire créez une
sous-classe de la classe Mammal, comme suit :
class Marsupial extends Mammifère {}
La sous-classe hérite de toutes les propriétés et méthodes de la superclasse, y compris des
propriétés ou des méthodes que vous avez déclarées comme étant privées en utilisant le motclé private.
Pour plus d’informations sur l’extension des classes, consultez les rubriques suivantes :
■
Ecriture d’une sous-classe, page 332
■
Remplacement des méthodes et des propriétés, page 335
Ecriture de sous-classes dans Flash
331
Pour plus d’informations sur les membres privés, consultez la section Présentation des méthodes
et propriétés (membres) publiques, privées et statiques, page 267. Pour un exemple de création de
sous-classe, consultez la section Exemple : Extension de la classe Widget, page 333.
Ecriture d’une sous-classe
Le code suivant définit la classe personnalisée JukeBox, qui étend la classe Sound (Son). Il
définit un tableau appelé song_arr et une méthode appelée playSong() qui permet de lire
une chanson et d’invoquer la méthode loadSound(), dont il hérite de la classe Sound.
class JukeBox extends Son {
public var song_arr:Array = new Array("beethoven.mp3", "bach.mp3",
"mozart.mp3");
public function litChanson(songID:Number):Void {
super.loadSound(song_arr[songID], true);
}
}
Si vous ne placez pas un appel à super() dans la fonction constructeur d’une sous-classe, le
compilateur génère automatiquement un appel au constructeur de sa superclasse immédiate,
sans paramètre, en tant que première instruction de la fonction. Si la super-classe n’a pas de
constructeur, le compilateur crée une fonction constructeur vide, puis génère un appel à cette
fonction à partir de la sous-classe. Cependant, si une super-classe prend des paramètres dans sa
définition, vous devez créer un constructeur dans la sous-classe et appeler la super-classe avec
les paramètres requis.
L’héritage multiple, ou héritage à partir de plusieurs classes, n’est pas autorisé dans
ActionScript 2.0. Toutefois, les classes peuvent effectivement hériter de plusieurs classes, si
vous utilisez des instructions extends individuelles, comme dans l’exemple suivant :
// non autorisé
class C extends A, B {} // **Error: Une classe ne peut pas étendre plusieurs
classes.
// autorisé
class B extends A {}
class C extends A, B {}
Vous pouvez également utiliser des interfaces pour mettre en oeuvre une forme limitée
d’héritage multiple. Pour plus d’informations sur les interfaces, consultez le
Chapitre 9, Interfaces, page 343. Pour un exemple de création de sous-classe, consultez la
section Exemple : Extension de la classe Widget, page 333. Pour plus d’informations sur super,
consultez l’instruction super dans le Guide de référence du langage ActionScript 2.0.
332
Héritage
Exemple : Extension de la classe Widget
Les membres de classe se propagent dans les sous-classes de la super-classe qui définit ces
membres. L’exemple suivant décrit la création d’une classe Widget, que vous étendez
(sous-classe) via l’écriture d’une sous-classe SubWidget.
Pour créer la classe Widget et la sous-classe SubWidget :
1.
Créez un nouveau fichier ActionScript et enregistrez-le sous le nom Widget.as.
2.
Ajoutez le code suivant dans le nouveau document :
class Widget {
public static var widgetCount:Number = 0;
public function Widget() {
Widget.widgetCount++;
}
}
3.
Enregistrez les modifications apportées au fichier ActionScript.
4.
Créez un nouveau fichier et enregistrez-le sous le nom SubWidget.as dans le même
répertoire que la classe Widget.
5.
Dans SubWidget.as, saisissez le code suivant dans la fenêtre de script :
class SubWidget extends Widget {
public function SubWidget() {
trace("Creating subwidget #" + Widget.widgetCount);
}
}
6.
Enregistrez les modifications apportées à SubWidget.as.
7.
Créez un nouveau fichier FLA et enregistrez-le en tant que subWidgetTest.fla dans le
même répertoire que les fichiers de classe ActionScript précédents.
Ecriture de sous-classes dans Flash
333
8.
Dans le fichier subWidgetTest.fla, saisissez le code suivant dans l’image 1 du scénario
principal :
var sw1:SubWidget = new SubWidget();
var sw2:SubWidget = new SubWidget();
trace("Widget.widgetCount = " + Widget.widgetCount);
trace("SubWidget.widgetCount = " + SubWidget.widgetCount);
Le code précédent crée deux occurrences de la classe SubWidget: sw1 et sw2. Chaque
appel au constructeur du SubWidget affiche la valeur actuelle de la propriété statique de
Widget.widgetCount. Comme la classe SubWidget est une sous classe de la classe
Widget, vous pouvez accéder à la propriété widgetCount par l’intermédiaire de la classe
SubWidget, et le compilateur écrit de nouveau la référence (dans le pseudo-code binaire,
pas dans votre fichier ActionScript) sous la forme Widget.widgetCount. Si vous tentez
d’accéder à la propété statique widgetCount par des occurrences de la classe Widget ou
SubWidget, comme sw1 ou sw2, le compilateur émet une erreur.
9.
Enregistrez les modifications apportées au document.
10. Choisissez
Contrôle > Tester l’animation pour tester le document Flash.
Le panneau de sortie affiche les données de sortie suivantes :
Creating subwidget #1
Creating subwidget #2
Widget.widgetCount = 2
SubWidget.widgetCount = 2
Ce résultat est dû au fait que, bien que le constructeur de la classe Widget ne soit jamais
appelé explicitement, le constructeur de la classe SubWidget l’appelle à votre place. Le
constructeur de la classe Widget incrémente donc la variable statique widgetCount de la
classe Widget.
Le compilateur d’ActionScript 2.0 peut résoudre des références à des membres statiques au
sein des définitions de classe.
Si vous ne spécifiez pas le nom de classe de la propriété Widget.widgetCount et la
référencez simplement avec widgetCount, le compilateur d’ActionScript 2.0 la résout en
Widget.widgetCount et exporte correctement cette propriété. De même, si vous faites
référence à la propriété en tant que SubWidget.widgetCount, le compilateur écrit de
nouveau la référence (dans le pseudo-code binaire, pas dans votre fichier ActionScript)
sous la forme Widget.widgetCount car SubWidget est une sous-classe de la classe
Widget.
A TT E N TI O N
334
Si vous tentez d’accéder à la variable statique widgetCount à partir de la classe
Widget à l’aide des occurrences sw1 ou sw2, Flash génère une erreur qui vous
indique que les membres statiques ne peuvent être accédés que via les classes.
Héritage
Pour améliorer la lisibilité du code, Macromedia recommande de toujours employer des
références explicites aux variables de membres statiques, comme dans l’exemple précédent.
Ces références explicites facilitent la localisation des définitions des membres statiques.
Remplacement des méthodes et des propriétés
Lorsqu’une sous-classe étend une super-classe, la sous-classe hérite de toutes les méthodes et
propriétés de cette super-classe. L’un des avantages de l’utilisation et de l’extension des classes
réside non seulement dans la possibilité d’apporter une nouvelle fonctionnalité à une classe
existante, mais également de modifier la fonctionnalité existante. Prenons par exemple la
classe Widget créée à la section Exemple : Extension de la classe Widget, page 333. Vous pouvez
maintenant créer une nouvelle méthode dans votre super-classe (Widget), puis supplanter la
méthode de votre sous-classe (SubWidget), ou simplement utiliser la méthode héritée de la
classe Widget. L’exemple suivant montre comment supplanter les méthodes existantes dans
vos classes.
Pour supplanter les méthodes d’une sous-classe :
1.
Créez un nouveau document ActionScript, puis enregistrez-le sous le nom Widget.as.
2.
Dans Widget.as, saisissez le code ActionScript suivant dans la fenêtre de script :
REMARQUE
Si vous avez créé la classe Widget dans un exemple précédent, modifiez le code
existant en ajoutant la méthode doSomething(), comme suit :
class Widget {
public static var widgetCount:Number = 0;
public function Widget() {
Widget.widgetCount++;
}
public function doSomething():Void {
trace("Widget::doSomething()");
}
}
3.
Enregistrez les modifications apportées au document ActionScript.
La classe Widget définit maintenant un constructeur et une méthode publique appelée
doSomething().
Ecriture de sous-classes dans Flash
335
4.
Créez un nouveau fichier ActionScript nommé SubWidget.as et enregistrez-le dans le
même répertoire que Widget.as.
R E M A R QU E
5.
Si vous avez créé la classe SubWidget à la section Exemple : Extension de la classe
Widget, page 333, vous pouvez utiliser ce fichier à la place.
Dans SubWidget.as, saisissez le code ActionScript suivant dans la fenêtre de script :
class SubWidget extends Widget {
public function SubWidget() {
trace("Creating subwidget # " + Widget.widgetCount);
doSomething();
}
}
6.
Enregistrez les modifications apportées à SubWidget.as.
Notez que le constructeur de la classe SubWidget appelle la méthode doSomething() que
vous avez définie dans la super-classe.
7.
Créez un nouveau document Flash et enregistrez-le sous subWidgetTest.fla dans le même
répertoire que les documents ActionScript.
8.
Dans subWidgetTest.fla, saisissez le code ActionScript suivant sur l’image 1 du scénario
principal :
var sw1:SubWidget = new SubWidget();
var sw2:SubWidget = new SubWidget();
9.
Enregistrez les modifications apportées au document Flash.
10. Choisissez
Contrôle > Tester l’animation pour tester le document Flash. Les données de
sortie suivantes doivent s’afficher dans le panneau de sortie:
Creating subwidget # 1
Widget::doSomething()
Creating subwidget # 2
Widget::doSomething()
Ce résultat indique que le constructeur de la classe SubWidget appelle le constructeur de
sa super-classe (Widget), qui incrémente la propriété statique widgetCount. Le
constructeur de SubWidget suit la propriété statique de la super-classe et appelle la
méthode doSomething(), qui hérite de la super-classe.
336
Héritage
11.
Ouvrez la classe SubWidget et ajoutez une nouvelle méthode appelée doSomething().
Modifiez votre classe de sorte qu’elle corresponde au code suivant (ajoutez le code présenté
en gras) :
class SubWidget extends Widget {
public function SubWidget() {
trace("Creating subwidget # " + Widget.widgetCount);
doSomething();
}
public function doSomething():Void {
trace("SubWidget::doSomething()");
}
}
12. Enregistrez
les modifications apportées au fichier de classe, puis ouvrez de nouveau
subwidgetTest.fla.
13.
Choisissez Contrôle > Tester l’animation pour tester le fichier. Les données de sortie
suivantes doivent s’afficher dans le panneau de sortie :
Creating subwidget # 1
SubWidget::doSomething()
Creating subwidget # 2
SubWidget::doSomething()
Le résultat précédent montre que la méthode doSomething() du constructeur de la classe
SubWidget appelle la méthode doSomething() de la classe active et non celle de la superclasse.
Ouvrez de nouveau la classe SubWidget, et modifiez le constructeur de la classe
SubWidget pour appeler la méthode doSomething() de la super-classe (ajoutez le code
présenté en gras) :
public function SubWidget() {
trace("Creating subwidget # " + Widget.widgetCount);
super.doSomething();
}
Comme nous l’avons démontré, vous pouvez ajouter le mot-clé super pour appeler la
méthode doSomething() de la super-classe plutôt que la méthode doSomething() de la
classe active. Pour plus d’informations sur le mot-clé super, consultez la section
correspondante dans le Guide de référence du langage ActionScript 2.0.
14. Enregistrez
le fichier de la classe SubWidget et le constructeur modifié, puis choisissez
Contrôle > Tester l’animation pour republier le document Flash.
Le panneau de sortie affiche le contenu de la méthode doSomething() de la classe
Widget.
Ecriture de sous-classes dans Flash
337
Utilisation du polymorphisme dans une
application
La programmation orientée objet permet d’exprimer les différences entre les classes
individuelles par une technique appelée polymorphisme. Cette technique permet aux classes
de supplanter les méthodes de leurs super-classes et de définir des implémentations spécialisées
de ces méthodes.
Par exemple, vous pouvez commencer par une classe appelée Mammal qui comporte les
méthodes play() et sleep(). Vous créez ensuite les sous-classes Chat, Singe et Chien pour
étendre la classe Mammifère. Les sous-classes supplantent la méthode play() de la classe
Mammal, de façon à représenter de façon plus réaliste ces types d’animaux. La classe Monkey
implémente la méthode play() pour se balancer aux arbres ; la classe Cat implémente la
méthode play() pour courir après une pelote ; la classe Dog implémente la méthode play()
pour rapporter une balle. Dans la mesure où la fonctionnalité sleep() reste similaire quel que
soit l’animal, vous utiliseriez l’implémentation de super-classe. La procédure suivante montre
cet exemple dans Flash.
Pour utiliser le polymorphisme dans une application :
1.
Créez un nouveau document ActionScript et enregistrez-le sous le nom Mammal.as.
Ce document est la classe de base des quelques classes d’animaux différentes que vous allez
créer dans les étapes suivantes.
2.
Dans Mammal.as, saisissez le code ActionScript suivant dans la fenêtre de script :
class Mammal {
private var _gender:String;
private var _name:String = "Mammal";
// Constructeur
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 {
338
Héritage
return this._gender;
}
public function get speciesName():String {
return this._gender;
}
public function set speciesName(value:String):Void {
this._name = value;
}
}
La classe précédente définit deux variables privées, __gender et _name, servant à stocker le
type de mammifère et le sexe de l’animal. Le constructeur de Mammal est ensuite défini. Ce
constructeur prend un seul paramètre, gender, utilisé pour définir la variable privée
_gender définie précédemment. Trois méthodes publiques supplémentaires sont
également spécifiées : toString(), play(), et sleep(), chacune renvoyant des objets de
chaîne. Les trois méthodes finales sont des méthodes de lecture et de définition pour les
propriétés _gender et _name de Mammal.
3.
Enregistrez le document ActionScript.
Cette classe sert de super-classe pour les classes Cat, Dog et Monkey, que vous créerez par
la suite. Vous pouvez utiliser la méthode toString() de la classe Mammal pour afficher
une représentation de chaîne de n’importe quelle occurrence de Mammal (ou toute
occurrence qui étendait la classe Mammal).
4.
Créez un nouveau fichier ActionScript et enregistrez-le sous le nom Cat.as dans le même
répertoire que le fichier de la classe Mammal.as créé à l’étape 1.
5.
Dans Cat.as, saisissez le code ActionScript suivant dans la fenêtre de script :
class Cat extends Mammal {
// Constructeur
public function Cat(gender:String) {
super(gender);
speciesName = "Cat";
}
public function play():String {
return "Pounce a ball of yarn.";
}
}
Notez que vous supplantez la méthode play() de la super-classe Mammal. La classe Cat
ne définit que deux méthodes : une méthode constructeur et une méthode play().
Comme la classe Cat étend la classe Mammal, elle hérite de ses méthodes et de ses
propriétés. Pour plus d’informations sur le remplacement de méthodes et de propriétés,
consultez la section Remplacement des méthodes et des propriétés, page 335.
6.
Enregistrez les modifications apportées au document ActionScript.
Utilisation du polymorphisme dans une application
339
7.
Créez un nouveau document et enregistrez-le sous le nom Dog.as dans le même répertoire
que les deux fichiers de classe précédents.
8.
Dans Dog.as, saisissez le code ActionScript suivant dans la fenêtre de script :
class Dog extends Mammal {
// Constructeur
public function Dog(gender:String) {
super(gender);
speciesName = "Dog";
}
public function play():String {
return "Fetch a stick.";
}
}
Remarquez que la structure de la classe Dog est très similaire à celle de la classe Cat, seules
quelques valeurs changent. Là encore, la classe Dog étend la classe Mammal et hérite de
ses méthodes et propriétés. Le constructeur Dog prend une seule propriété, gender, qu’il
transmet à la classe parent de la classe Dog, Mammal. La variable speciesName est
également remplacée et définie sur la chaîne Dog. La méthode play() de la classe parent
est également supplantée.
9.
Enregistrez les modifications apportées au document ActionScript.
10. Créez un autre document ActionScript dans le même répertoire que vos autres fichiers, puis
enregistrez-le sous le nom Monkey.as.
11.
Dans Monkey.as, saisissez le code ActionScript suivant dans la fenêtre de script :
class Monkey extends Mammal {
// Constructeur
public function Monkey(gender:String) {
super(gender);
speciesName = "Monkey";
}
public function play():String {
return "Swing from a tree.";
}
}
Comme les deux classes précédentes, Cat et Dog, la classe Monkey étend la classe
Mammal. Le constructeur de cette classe appelle le constructeur de la classe Mammal, en
transmettant le genre au constructeur de Mammal, et en définissant speciesName sur la
chaîne Monkey. La classe Monkey supplante également le comportement de la méthode
play().
12. Enregistrez
340
Héritage
les modifications apportées au document ActionScript.
13.
Maintenant que vous avez créé trois sous-classes de la classe Mammal, créez un nouveau
document Flash appelé mammalTest.fla.
14. Dans
mammalTest.fla, saisissez le code ActionScript suivant dans l’image 1 du scénario
principal :
var mammals_arr:Array = new Array();
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;
// Affichage des infos relatives à Mammal en 4 colonnes de texte HTML
et arrêts de tabulation.
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>";
// L’instruction trace appelle la méthode Mammal.toString().
trace(mammals_arr[i]);
}
info_txt.htmlText += "</textformat>";
}
Le code de mammalTest.fla est un peu plus complexe que celui des classes précédentes. Il
commence par importer trois classes d’animaux.
Utilisation du polymorphisme dans une application
341
15.
Enregistrez le document Flash, puis choisissez Contrôle > Tester l’animation pour tester le
document.
Les informations relatives à la classe Mammal s’affichent dans un champ de texte sur la
scène, et le texte suivant apparaît dans le panneau de sortie :
[object
[object
[object
[object
342
Dog]
Cat]
Monkey]
Mammal]
Héritage
9
CHAPITRE 9
Interfaces
En programmation orientée objet, une interface est un document qui vous permet de déclarer
(mais pas de définir) les méthodes devant apparaître au sein d’une classe. Si vous faites partie
d’une équipe de développeurs, ou si vous développez de grandes applications dans Flash, les
interfaces vous seront certainement très utiles. Grâce à elles, les développeurs peuvent
facilement identifier les méthodes de base dans les classes ActionScript. Ces méthodes doivent
être implémentées lorsque les développeurs utilisent chaque interface.
Ce chapitre présente quelques exemples d’interfaces et, à la fin de sa lecture, vous serez à
même de développer vos propres fichiers d’interface. Si vous ne maîtrisez pas le
développement des classes, commencez par lire le Chapitre 7, Classes avant d’effectuer les
didacticiels et d’examiner les exemples de ce chapitre.
Pour plus d’informations sur l’utilisation des interfaces, consultez les rubriques suivantes :
Présentation des interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .343
Création d’interfaces comme types de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
Fonctionnement des héritages et des interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351
Exemple : Utilisation des interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .353
Exemple : Création d’une interface complexe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .355
Présentation des interfaces
En programmation orientée objet, les interfaces sont comme des classes dont les méthodes ne
sont pas implémentées (définies), c’est-à-dire que, mis à part cela, elles ne « font » rien. Une
interface se compose donc de méthodes « vides ». Une autre classe peut ensuite implémenter
les méthodes déclarées par l’interface. Dans ActionScript, la distinction entre interface et objet
porte sur la détection des erreurs lors de la compilation et l’application des règles du langage.
343
Une interface n’est pas une classe. Cependant, ceci n’est pas tout à fait vrai dans ActionScript
lors de l’exécution du code car une interface est une abstraction. Il est possible d’utiliser des
interfaces ActionScript pendant l’exécution pour effectuer une attributionde type (attribuer
un autre type de données à des données existantes). Le modèle d’objet ActionScript 2.0 ne
prend pas en charge l’héritage multiple. Par conséquent, une classe ne peut hériter que d’une
classe parent. Cette classe parent peut être soit de base, soit une classe Flash Player, soit une
classe définie par l’utilisateur (personnalisée). Vous pouvez utiliser les interfaces pour
appliquer une forme limitée d’héritage multiple, dans laquelle la classe hérite de plusieurs
classes.
Par exemple, en C++, la classe Chat peut étendre la classe Mammal, ainsi que la classe Playful,
qui a les méthodes chaseTail() et eatCatNip(). Comme Java, ActionScript 2.0 ne permet
pas d’étendre directement plusieurs classes, mais permet d’étendre une classe unique et
d’implémenter plusieurs interfaces. Par conséquent, vous pouvez créer une interface Playful
qui déclare les méthodes chaseTail() et eatCatNip(). Une classe Chat ou toute autre classe
peut alors implémenter cette interface et fournir des définitions pour ces méthodes.
Une interface peut également être considérée comme un « contrat de programmation »
destiné à imposer des relations entre des classes non connexes. Par exemple, supposons que
vous travailliez avec une équipe de programmeurs et que chacun de vous travaille sur une
classe différente de la même application. Lors de la réalisation de l’application, vous vous
mettez d’accord sur un ensemble de méthodes que les différentes classes utiliseront pour
communiquer. Ainsi, vous créez une interface qui déclare ces méthodes, leurs paramètres et
leurs types de renvoi. Toute classe qui implémente cette interface doit fournir des définitions
pour ces méthodes; dans le cas contraire, une erreur du compilateur se produit. L’interface se
comporte comme un protocole de communication auquel toutes les classes doivent adhérer.
Pour ce faire, vous pouvez créer une classe qui définit toutes ces méthodes, puis faire en sorte
que chaque classe étende cette super-classe, ou en hérite. Cependant, l’application étant
composée de classes n’ayant aucun rapport entre elles, il est inutile de toutes les placer dans
une hiérarchie de classes communes. Il est préférable de créer une interface qui déclare les
méthodes que ces classes utilisent pour communiquer, puis que chaque classe implémente ces
méthodes (en fournissant ses propres définitions).
Vous pouvez généralement programmer de façon efficace sans utiliser les interfaces.
Lorsqu’elles sont utilisées de façon appropriée, cependant, les interfaces peuvent rendre la
conception de vos applications plus élégante, évolutive et stable.
344
Interfaces
Les interfaces d’ActionScript existent pendant l’exécution pour autoriser l’attribution de type.
Consultez le Chapitre 4, Attribution des objets, page 121. Une interface n’est ni objet ni une
classe, mais son flux de travail est le même que celui des classes. Pour plus d’informations sur
le flux de travail des classes, consultez la section Ecriture de fichiers de classe personnalisée,
page 254. Un didacticiel sur la création d’une application avec interfaces est à votre
disposition à la section Exemple : Utilisation des interfaces, page 353.
Pour plus d’informations sur l’utilisation des interfaces, consultez les sections suivantes :
■
Présentation du mot-clé interface, page 345
■
Affectation des noms d’interfaces, page 346
■
Définition et implémentation des interfaces, page 346
Présentation du mot-clé interface
Le mot-clé interface définit une interface. Une interface est similaire à une classe. Les
différences fondamentales sont regroupées ci-dessous :
■
Les interfaces contiennent uniquement les déclarations des méthodes, pas leur
implémentation. Ainsi, toute classe qui implémente une interface doit fournir une
implémentation pour chaque méthode déclarée dans l’interface.
■
Seuls les membres publics sont autorisés dans la définition d’une interface. Les membres
statiques et les membres de classe ne sont pas permis.
■
Les instructions get et set ne sont pas autorisées dans les définitions d’interface.
■
Pour utiliser le mot-clé interface, vous devez spécifier ActionScript 2.0 et Flash Player 6
ou une version plus récente dans l’onglet Flash de la boîte de dialogue Paramètres de
publication de votre fichier FLA.
Le mot-clé interface n’est pris en charge que lorsqu’il est utilisé dans des fichiers de script
externes, et non dans les scripts écrits dans le panneau Actions.
Présentation des interfaces
345
Affectation des noms d’interfaces
Les noms d’interface doivent commencer par une majuscule, comme les noms de classe. Les
noms d’interface sont généralement des adjectifs, tels que Imprimable. Le nom d’interface
suivant, IEmployeeRecords, commence par une majuscule et le mot concaténé commence
par une majuscule suivie de minuscules :
interface IEmployeeRecords {}
REMARQUE
Certains développeurs font débuter les noms d’interface par un I majuscule pour les
distinguer des classes. Cette méthode est judicieuse car elle permet de distinguer
rapidement les interfaces et les classes ordinaires.
Pour plus d’informations sur les conventions d’appellation, consultez le
Chapitre 19, Recommandations et conventions de programmation pour ActionScript 2.0,
page 797.
Définition et implémentation des interfaces
Le processus de création d’une interface est identique au processus de création d’une classe.
Comme pour les classes, vous pouvez définir des interfaces uniquement dans des fichiers
ActionScript externes. Le flux de travail de création d’une interface implique au minimum les
étapes suivantes :
■
Définition d’une interface dans un fichier ActionScript externe.
■
Enregistrement du fichier d’interface dans un répertoire de chemin de classe spécifique
(emplacement où Flash recherche les classes) ou dans le même répertoire que le fichier
FLA de l’application
■
Création d’une occurrence de la classe dans un autre script, soit dans un document Flash
(FLA), soit dans un fichier de script externe, soit dans des sous-interfaces basées sur
l’interface d’origine.
■
Création d’une classe qui implémente l’interface dans un fichier de script externe
Déclarez une interface à l’aide du mot-clé interface, suivi du nom de l’interface et
d’accolades gauche et droite ({}), qui définissent le corps de l’interface, comme dans l’exemple
suivant :
interface IEmployeeRecords {
// déclarations de méthodes d’interface
}
Une interface ne peut contenir que des déclarations de méthodes (fonction), y compris des
paramètres, des types de paramètres et des types de renvoi de fonction.
346
Interfaces
Pour plus d’informations sur les conventions de structuration des classes et interfaces,
consultez le Chapitre 19, Recommandations et conventions de programmation pour ActionScript
2.0, page 797. Un didacticiel sur la création d’une application utilisant une interface est à
votre disposition à la section Exemple : Utilisation des interfaces, page 353.
Par exemple, le code suivant déclare une interface nommée IMyInterface qui contient deux
méthodes, method1() et method2(). La première méthode, method_1(), ne comporte pas de
paramètre et spécifie le type Void (ce qui signifie qu’aucune valeur n’est renvoyée). La
deuxième méthode, method2(), ne prend qu’un seul paramètre de type String et spécifie un
renvoi de type booléen.
Pour créer une interface simple :
1.
Créez un nouveau fichier ActionScript et enregistrez-le sous le nom IMyInterface.as.
2.
Saisissez le code ActionScript suivant dans la fenêtre de script :
interface IMyInterface {
public function method1():Void;
public function method2(param:String):Boolean;
}
3.
Enregistrez les modifications apportées au fichier ActionScript.
Pour utiliser la nouvelle interface dans une application, vous devez d’abord créer une classe
qui l’implémente.
4.
Créez un nouveau fichier ActionScript et enregistrez-le sous le nom MyClass.as dans le
même répertoire que IMyInterface.as.
5.
Dans le fichier de classe MyClass, saisissez le code ActionScript suivant dans la fenêtre de
script :
class MyClass {
}
Pour demander à la classe personnalisée (MyClass) d’utiliser votre interface
(IMyInterface), utilisez le mot-clé implements qui spécifie qu’une classe doit définir
toutes les méthodes déclarées dans l’interface (ou les interfaces) que vous implémentez.
6.
Modifiez le code ActionScript dans le fichier MyClass.as (ajoutez le code présenté en gras)
de sorte qu’il corresponde au code suivant :
class MyClass implements IMyInterface {
}
Placez le mot-clé implements après le nom de la classe.
Présentation des interfaces
347
7.
Cliquez sur le bouton Vérifier la syntaxe.
Flash affiche une erreur dans le panneau de sortie pour signaler que MyClass doit
implémenter la méthode X de l’interface IMyInterface. Ce message d’erreur apparaît car
toute classe qui étend une interface doit définir chaque méthode énumérée dans le
document de l’interface.
8.
Modifiez de nouveau le document MyClass (ajoutez le code présenté en gras) et écrivez le
code ActionScript pour les méthodes method1() et method2(), comme dans l’exemple
suivant :
class MyClass implements IMyInterface {
public function method1():Void {
// ...
};
public function method2(param:String):Boolean {
// ...
return true;
}
}
9.
Enregistrez le document MyClass.as et cliquez sur Vérifier la syntaxe.
Le panneau de sortie n’affiche plus de message d’erreur ou d’avertissement car les deux
méthodes sont à présent définies.
Le fichier de classe que vous avez créé n’est pas limité aux méthodes publiques définies dans le
fichier d’interface. Le fichier d’interface ne présente que les méthodes devant être
implémentées au minimum, avec leurs propriétés et leurs types de retour. Les classes qui
implémentent une interface particulière incluent presque toujours d’autres méthodes,
variables et méthodes de lecture et de définition.
Les fichiers d’interfaces ne peuvent contenir aucune déclaration ni affectation de variable. Les
fonctions déclarées dans une interface ne doivent pas contenir d’accolades. Par exemple,
l’interface suivante ne sera pas compilée :
interface IBadInterface {
// Erreur de compilation. Les déclarations de variables ne sont pas
autorisées dans les interfaces.
public var illegalVar:String;
// Erreur de compilation. Les corps de fonctions ne sont pas autorisés
dans les interfaces.
public function illegalMethod():Void {
}
// Erreur de compilation. Les méthodes privées sont interdites dans les
interfaces.
private function illegalPrivateMethod():Void;
348
Interfaces
// Erreur de compilation. Les méthodes de lecture/définition sont
interdites dans les interfaces.
public function get illegalGetter():String;
}
Un didacticiel sur la création d’une interface complexe est à votre disposition à la section
Exemple : Utilisation des interfaces, page 353.
Les règles d’affectation de nom et de stockage des interfaces dans les paquets sont les mêmes
que celles des classes ; consultez la section Appellation des fichiers de classe, page 288.
Création d’interfaces comme types de
données
Tout comme une classe, une interface définit un nouveau type de données. Toute classe qui
implémente une interface peut être considérée comme relevant du type défini par l’interface.
Ceci est utile pour déterminer si un objet donné implémente une interface donnée. Prenons
par exemple l’interface IMovable que vous allez créer dans l’exemple suivant.
Pour créer une interface en tant que type de données :
1.
Créez un nouveau document ActionScript et enregistrez-le sur votre disque dur sous le nom
IMovable.as.
2.
Dans IMovable.as, saisissez le code ActionScript suivant dans la fenêtre de script :
interface IMovable {
public function moveUp():Void;
public function moveDown():Void;
}
3.
Enregistrez les modifications apportées au fichier ActionScript.
4.
Créez un document ActionScript et enregistrez-le sous le nom Box.as dans le même
répertoire que IMovable.as.
Dans ce document, vous créez une classe Box implémentant l’interface IMovable créée
précédemment.
Création d’interfaces comme types de données
349
5.
Dans Box.as, tapez le code ActionScript suivant dans la fenêtre de script :
class Box implements IMovable {
public var xPos:Number;
public var yPos:Number;
public function Box() {
}
public function
trace("moving
// définition
}
public function
trace("moving
// définition
}
moveUp():Void {
up");
de méthode
moveDown():Void {
down");
de méthode
}
6.
Enregistrez les modifications apportées au document ActionScript.
7.
Créez un nouveau document Flash nommé boxTest.fla, et enregistrez-le dans le même
répertoire que les documents ActionScript précédents.
8.
Sélectionnez l’image 1 du scénario, ouvrez l’éditeur ActionScript, puis tapez le code suivant
dans le panneau Actions :
var newBox:Box = new Box();
Ce code ActionScript crée une occurrence de la classe Box, que vous allez déclarer en tant
que variable du type Box.
9.
Enregistrez les modifications apportées au document Flash, puis choisissez Contrôle >
Tester l’animation pour tester le fichier SWF.
A l’exécution, dans Flash Player7 et ses versions ultérieures, vous pouvez attribuer une
expression à un type d’interface ou à un autre type de données lors de l’exécution.
Contrairement aux interfaces Java, des interfaces ActionScript existent lors de l’exécution
du script, ce qui autorise l’attribution de type. Si l’expression est un objet qui implémente
l’interface, ou si elle possède une super-classe qui implémente l’interface, l’objet est
renvoyé. Dans le cas contraire, null est renvoyé. Cela est particulièrement utile si vous
souhaitez vous assurer qu’un objet particulier implémente une interface particulière. Pour
plus d’informations sur l’attribution de type, consultez le Chapitre 4, Attribution des
objets, page 121.
350
Interfaces
10. Dans
boxTest.fla, ajoutez le code suivant à la fin du code ActionScript :
if (IMovable(newBox) != null) {
newBox.moveUp();
} else {
trace("box instance is not movable");
}
Ce code ActionScript contrôle si l’occurrence newBox implémente l’interface IMovable
avant l’appel de la méthode moveUp() sur l’objet.
11.
Enregistrez le document Flash, puis sélectionnez Contrôle > Tester l’animation pour tester
le fichier SWF.
Comme l’occurrence Box implémente l’interface IMovable, la méthode Box.moveUp() est
appelée et le texte « moving up » s’affiche dans le panneau de sortie.
Pour plus d’informations sur l’attribution, consultez le Chapitre 4, Attribution des objets,
page 121.
Fonctionnement des héritages et des
interfaces
Le mot-clé extends vous permet de créer des sous-classes d’une interface. Cela peut se révéler
très utile pour les vastes projets dans lesquels vous souhaitez étendre (ou sous-classer) une
interface existante et ajouter d’autres méthodes. Ces méthodes doivent être définies pour
toutes les classes qui implémentent cette interface.
Lorsque vous étendez des interfaces, vous devez savoir que vous recevez des messages d’erreur
dans Flash si plusieurs fichiers d’interface déclarent des fonctions portant le même nom mais
ayant des paramètres ou des types de retour différents.
L’exemple suivant présente le sous-classement d’un fichier d’interface à l’aide du mot-clé
extends.
Pour étendre une interface :
1.
Créez un nouveau fichier ActionScript et enregistrez-le sous le nom Ia.as.
2.
Dans Ia.as, saisissez le code ActionScript suivant dans la fenêtre de script :
interface Ia {
public function f1():Void;
public function f2():Void;
}
3.
Enregistrez les modifications apportées au fichier ActionScript.
Fonctionnement des héritages et des interfaces
351
4.
Créez un nouveau fichier ActionScript et enregistrez-le sous le nom Ib.as, dans le même
répertoire que le fichier Ia.as créé à l’étape 1.
5.
Dans Ib.as, saisissez le code ActionScript suivant dans la fenêtre de script :
interface Ib extends Ia {
public function f8():Void;
public function f9():Void;
}
6.
Enregistrez les modifications apportées au fichier ActionScript.
7.
Créez un nouveau fichier ActionScript et enregistrez-le sous le nom ClassA.as dans le
même répertoire que les deux fichiers précédents.
8.
Dans ClassA.as, saisissez le code ActionScript suivant dans la fenêtre de script :
class ClassA implements Ib {
// f1() et f2() sont définies dans l’interface Ia.
public function f1():Void {
}
public function f2():Void {
}
// f8() et f9() sont définies dans l’interface lb qui étend Ia.
public function f8():Void {
}
public function f9():Void {
}
}
9.
Enregistrez votre fichier de classe, puis cliquez sur le bouton Vérifier la syntaxe sous la la
fenêtre de script.
Flash ne génère pas de message d’erreur tant que les quatre méthodes sont définies et
correspondent aux définitions provenant de leurs fichiers d’interface respectifs.
REMARQUE
Dans ActionScript2.0, chaque classe ne peut étendre qu’une classe, même si vous
pouvez utiliser les classes pour implémenter autant d’interfaces que nécessaire.
Pour que votre classe ClassA implémente plusieurs interfaces dans l’exemple précédent, il vous
suffit de séparer les interfaces par des virgules. Ou, si l’une de vos classes étend une superclasse et implémente plusieurs interfaces, servez-vous d’un code semblable au suivant :
class ClassA extends ClassB implements Ib, Ic, Id {...}.
352
Interfaces
Exemple : Utilisation des interfaces
Dans cet exemple, vous allez créer une interface simple que vous pourrez ensuite réutiliser
entre plusieurs classes différentes.
Pour créer une interface :
1.
Créez un nouveau fichier ActionScript et enregistrez-le sous le nom IDocumentation.as.
2.
Dans IDocumentation.as, saisissez le code ActionScript suivant dans la fenêtre de script :
interface IDocumentation {
public function downloadUpdates():Void;
public function checkForUpdates():Boolean;
public function searchHelp(keyword:String):Array;
}
3.
Enregistrez les modifications apportées au fichier d’interface ActionScript.
4.
Créez un nouveau fichier ActionScript dans le même répertoire que IDocumentation.as,
puis enregistrez-le sous le nom FlashPaper.as.
5.
Dans FlashPaper.as, saisissez le code ActionScript suivant dans la fenêtre de script :
class FlashPaper implements IDocumentation {
}
6.
Enregistrez les modifications apportées au fichier ActionScript.
7.
Cliquez sur le bouton Vérifier la syntaxe pour votre classe ActionScript.
Un message semblable au suivant apparaît :
**Error** path\FlashPaper.as: Line 1: La classe doit implémenter la
méthode ’checkForUpdates’ depuis l’interface ’IDocumentation’.
class FlashPaper implements IDocumentation {
Total ActionScript Errors: 1
Reported Errors: 1
Cette erreur est due au fait que la classe FlashPaper active ne définit aucune des méthodes
publiques que vous avez définies dans l’interface IDocumentation.
8.
Ouvrez de nouveau le fichier de classe FlashPaper.as et modifiez le code ActionScript
existant de sorte qu’il corresponde au suivant :
class FlashPaper implements IDocumentation {
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 []
};
}
Exemple : Utilisation des interfaces
353
9.
Enregistrez les modifications apportées au fichier ActionScript et cliquez de nouveau sur le
bouton Vérifier la syntaxe.
Aucun message ne s’affiche plus dans le panneau de sortie.
R E M A R QU E
Vous pouvez ajouter autant de méthodes ou variables statiques, publiques ou
privées supplémentaires que nécessaire dans le fichier de classe FlashPaper. Le
fichier d’interface ne définit qu’un ensemble minimum de méthodes devant
apparaître au sein des classes qui implémentent cette interface.
10. Ouvrez de nouveau le document d’interface IDocumentation et ajoutez la ligne de code en
gras suivante (au-dessous de la méthode 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.
Enregistrez les modifications apportées au fichier d’interface et ouvrez de nouveau le
document FlashPaper.as.
12. Cliquez
sur le bouton Vérifier la syntaxe et un nouveau message d’erreur apparaît dans le
panneau de sortie :
**Error** path\FlashPaper.as: Line 1: La classe doit implémenter la
méthode ’addComment’ depuis l’interface ’IDocumentation’.
class FlashPaper implements IDocumentation {
Total ActionScript Errors: 1
Reported Errors: 1
L’erreur précédente est due au fait que le fichier de classe FlashPaper.as ne définit plus
toutes les classes décrites dans le fichier d’interface. Pour corriger l’erreur, vous devez soit
ajouter la méthode addComment() à la classe FlashPaper, soit supprimer la définition de la
méthode du fichier d’interface IDocumentation.
13.
Ajoutez la méthode suivante dans la classe FlashPaper :
public function addComment(username:String, comment:String):Void {
/* Envoi de paramètres à la page côté serveur, qui insère un
commentaire dans la base de données. */
}
14. Enregistrez les modifications apportées à FlashPaper.as, puis cliquez sur le bouton Vérifier
la syntaxe. Aucune erreur ne devrait plus apparaître.
Dans la section précédente, vous avez créé une classe basée sur le fichier d’interface
IDocumentation. Dans cette section, vous allez créer une nouvelle classe qui implémente
également l’interface IDocumentation, tout en ajoutant d’autres méthodes et propriétés.
354
Interfaces
Ce didacticiel démontre l’utilité des interfaces car si vous souhaitez créer une autre classe
étendant l’interface IDocumentation, vous pouvez aisément identifier les méthodes
nécessaires au sein de la nouvelle classe.
Exemple : Création d’une interface
complexe
L’exemple suivant présente plusieurs façons de définir et d’implémenter des interfaces. Dans
ce didacticiel, vous allez apprendre à créer un fichier d’interface simple, à écrire une classe qui
implémente plusieurs interfaces et à utiliser des interfaces qui étendent d’autres interfaces
pour créer des structures de données plus complexes.
Pour créer une interface complexe :
1.
Créez un nouveau document ActionScript, puis enregistrez-le sous le nom InterfaceA.as.
2.
Créez un nouveau dossier appelé complexInterface et enregistrez InterfaceA.as dans ce
répertoire.
Vous enregistrerez ensuite tous les fichiers créés pour ce didacticiel dans ce répertoire.
3.
Dans Interface.as, saisissez le code ActionScript suivant dans la fenêtre de script :
// Nom de fichier : InterfaceA.as
interface InterfaceA {
public function k():Number;
public function n(z:Number):Number;
}
4.
Enregistrez le document ActionScript, puis créez-en un autre appelé ClassB.as et
enregistrez-le dans le répertoire complexInterface.
ClassB.as implémente l’interface InterfaceA créée précédemment.
5.
Dans ClassB.as, saisissez le code ActionScript suivant dans la fenêtre de script :
// Nom de fichier : ClassB.as
class ClassB implements InterfaceA {
public function k():Number {
return 25;
}
public function n(z:Number):Number {
return (z + 5);
}
}
6.
Enregistrez les modifications apportées au document ClassB.as, puis créez un autre
document Flash nommé classbTest.fla dans le répertoire complexInterface.
Ce fichier de classe teste la classe ClassB créée précédemment.
Exemple : Création d’une interface complexe
355
7.
Dans classbTest.fla, saisissez le code ActionScript suivant dans l’image 1 du scénario :
// Nom de fichier : classbTest.fla
import ClassB;
var myB:ClassB = new ClassB();
trace(myB.k()); // 25
trace(myB.n(7)); // 12
8.
Enregistrez les modifications apportées au document Flash, puis choisissez Contrôle >
Tester l’animation pour tester le document Flash.
Le panneau de sortie affiche deux nombres, 25 et 12, résultats des méthodes k() et n() de
la classe ClassB.
9.
Créez un nouveau fichier ActionScript et enregistrez-le sous ClassC.as dans le répertoire
complexInterface.
Ce fichier de classe implémente l’interface InterfaceA créée à l’étape 1.
10. Dans
ClassC.as, saisissez le code ActionScript suivant dans la fenêtre de script :
// Nom de fichier : ClassC.as
class ClassC implements InterfaceA {
public function k():Number {
return 25;
}
// **Erreur** La classe doit implémenter la méthode ’n’ depuis
l’interface ’InterfaceA’.
}
Si vous cliquez sur le bouton Vérifier la syntaxe pour le fichier de classe ClassC, Flash
affiche un message d’erreur dans le panneau de sortie signalant que la classe active doit
implémenter la méthode n() définie dans l’interface InterfaceA. Lorsque vous créez des
classes qui implémentent une interface, il est important de définir des méthodes pour
chaque entrée de l’interface.
11.
Créez un nouveau document ActionScript et enregistrez-le sous le nomInterfaceB.as dans
le répertoire complexInterface.
12. Dans
InterfaceB.as, saisissez le code ActionScript suivant dans la fenêtre de script :
// Nom de fichier : InterfaceB.as
interface InterfaceB {
public function o():Void;
}
13.
Enregistrez les modifications apportées au document InterfaceB.as, puis créez un autre
document ActionScript sous le nom ClassD.as dans le répertoire complexInterface.
Cette classe implémente les interfaces InterfaceA et InterfaceB créées précédemment. La
classe ClassD doit inclure des implémentations de méthode pour chaque méthode
énumérée dans chaque fichier d’interface.
356
Interfaces
14. Dans
ClassD.as, saisissez le code ActionScript suivant dans la fenêtre de script :
// Nom de fichier : ClassD.as
class ClassD implements InterfaceA, InterfaceB {
public function k():Number {
return 15;
}
public function n(z:Number):Number {
return (z * z);
}
public function o():Void {
trace("o");
}
}
15.
Enregistrez les modifications apportées au fichier ClassD.as, puis créez un nouveau
document Flash et enregistrez-le sous le nom classdTest.fla.
Ce document Flash teste la classe ClassD créée précédemment.
16.
Dans classdTest.fla, saisissez le code ActionScript suivant dans l’image 1 du scénario :
// Nom de fichier : classdTest.fla
import ClassD;
var myD:ClassD = new ClassD();
trace(myD.k()); // 15
trace(myD.n(7)); // 49
myD.o(); // o
17.
Enregistrez les modifications apportées au fichier classdTest.fla, puis choisissez Contrôle >
Tester l’animation pour tester le fichier.
Les valeurs 15 et 49 et la lettre o doivent apparaître dans le panneau de sortie. Ces valeurs
sont les résultats respectifs des méthodes ClassD.k(), ClassD.n() et ClassD.o().
18.
Créez un nouveau document ActionScript, puis enregistrez-le sous le nom InterfaceC.as.
Cette interface étend l’interface InterfaceA créée précédemment, puis ajoute une nouvelle
définition de méthode.
19. Dans
InterfaceC.as, saisissez le code ActionScript suivant dans la fenêtre de script :
// Nom de fichier : InterfaceC.as
interface InterfaceC extends InterfaceA {
public function p():Void;
}
20.Enregistrez
les modifications apportées au fichier ActionScript, puis créez-en un autre et
enregistrez-le sous le nom ClassE.as dans le répertoire complexInterface.
Cette classe implémente deux interfaces, InterfaceB et InterfaceC.
Exemple : Création d’une interface complexe
357
21. Dans
ClassE.as, saisissez le code ActionScript suivant dans la fenêtre de script :
// Nom de fichier : ClassE.as
class ClassE implements InterfaceB, InterfaceC {
public function k():Number {
return 15;
}
public function n(z:Number):Number {
return (z + 5);
}
public function o():Void {
trace("o");
}
public function p():Void {
trace("p");
}
}
22.Enregistrez les modifications apportées au document
ActionScript, puis créez un nouveau
document Flash et enregistrez-le sous le nom classeTest.fla dans le répertoire
complexInterface.
23.Dans
classeTest.fla, saisissez le code ActionScript suivant dans l’image 1 du scénario :
// Nom de fichier : 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.Enregistrez le document Flash, puis sélectionnez Contrôle > Tester l’animation pour tester
le fichier SWF.
Les valeurs 15, 12, o et p apparaissent dans le panneau de sortie. Ces valeurs sont
renvoyées par les méthodes ClassE.k(), ClassE.n(), ClassE.o() et ClassE.p(). La
classe ClassE implémentant les interfaces InterfaceB et InterfaceC, chaque méthode issue
des deux fichiers d’interface doit être définie. Bien que les interfaces InterfaceB et
InterfaceC ne définissent que les méthodes o() et p(), InterfaceC étend InterfaceA. Cela
signifie que chacune des méthodes définies, k() et n(), doit également être implémentée.
358
Interfaces
10
CHAPITRE 10
Gestion d’événements
Les événements sont des actions qui se produisent lors de la lecture d’un fichier SWF. Un
événement tel qu’un clic de souris ou une pression sur une touche est appelé événement
utilisateur puisqu’il résulte d’une interaction directe avec l’utilisateur. Un événement généré
automatiquement par Flash Player, tel que l’apparence initiale d’un clip sur la scène, est appelé
événement système car il n’est pas généré directement par l’utilisateur.
Pour que votre application réagisse à des événements, vous devez utiliser des gestionnaires
d’événement (code ActionScript associé à un objet et à un événement particuliers). Par
exemple, lorsqu’un utilisateur clique sur un bouton sur la scène, la tête de lecture peut passer à
l’image suivante. De même, à l’issue du chargement d’un fichier XML sur le réseau, le
contenu du fichier peut s’afficher dans un champ de texte.
Vous pouvez gérer les événements avec ActionScript de plusieurs façons :
■
Utilisation de méthodes de gestionnaire d’événement, page 360
■
Utilisation des écouteurs d’événement, page 363
■
Association de gestionnaires d’événement à des boutons et des clips, page 368, plus
précisément, gestionnaire on et gestionnaire onClipEvent.
■
Diffusion d’événements à partir d’occurrences de composant, page 373
L’utilisation de gestionnaires d’événement avec loadMovie (méthode MovieClip.loadMovie)
peut donner des résultats imprévisibles. Si vous liez un gestionnaire d’événement à un bouton
avec on() ou si vous créez un gestionnaire dynamique avec une méthode telle que onPress
(gestionnaire MovieClip.onPress),, puis que vous appelez loadMovie(), le gestionnaire
d’événement ne sera plus disponible après le chargement du nouveau contenu. Cependant, si
vous utilisez gestionnaire onClipEvent ou gestionnaire on pour lier un gestionnaire
d’événement à un clip, puis que vous appelez loadMovie() pour ce clip, le gestionnaire
d’événement restera disponible après le chargement du nouveau contenu.
359
Pour plus d’informations sur la gestion des événements, consultez les sections suivantes :
Utilisation de méthodes de gestionnaire d’événement . . . . . . . . . . . . . . . . . . . . . . 360
Utilisation des écouteurs d’événement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .363
Utilisation d’écouteurs d’événement avec des composants. . . . . . . . . . . . . . . . . . .366
Association de gestionnaires d’événement à des boutons et des clips . . . . . . . . .368
Diffusion d’événements à partir d’occurrences de composant . . . . . . . . . . . . . . . . 373
Création de clips avec des états de bouton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373
Domaine du gestionnaire d’événement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374
Domaine du mot-clé this. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
Utilisation de la classe Delegate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
Utilisation de méthodes de gestionnaire
d’événement
Une méthode de gestionnaire d’événement est une méthode de classe invoquée lorsqu’un
événement se produit sur une occurrence de cette classe. Par exemple, la classe MovieClip
définit un gestionnaire d’événement onPress, invoqué lorsque l’utilisateur clique avec le
bouton de la souris sur un objet clip. Contrairement aux autres méthodes de classe, vous
n’invoquez pas directement un gestionnaire d’événement ; Flash Player le fait lui-même
lorsque l’événement concerné se produit.
Les classes ActionScript suivantes sont des exemples de classes qui définissent des gestionnaires
d’événement : Button, ContextMenu, ContextMenuItem, Key, LoadVars, LocalConnection,
Mouse, MovieClip, MovieClipLoader, Selection, SharedObject, Sound, Stage, TextField,
XML et XMLSocket. Pour plus d’informations sur les gestionnaires d’événement qu’elles
proposent, consultez les entrées correspondantes dans le Guide de référence du langage
ActionScript 2.0. Le terme gestionnaire est ajouté au titre de chaque gestionnaire d’événement.
Par défaut, les méthodes de gestionnaire d’événement ne sont pas définies : lorsqu’un
événement particulier se produit, son gestionnaire associé est invoqué, mais votre application
ne répond pas davantage à l’événement. Pour qu’elle réponde à l’événement, définissez une
fonction au moyen de l’instruction function et affectez-la au gestionnaire d’événement
approprié. La fonction que vous avez affectée au gestionnaire d’événement est ensuite
invoquée automatiquement lorsque l’événement se produit.
360
Gestion d’événements
Un gestionnaire d’événement se compose de trois éléments : l’objet auquel l’événement
s’applique, le nom de la méthode du gestionnaire d’événement de l’objet et la fonction que
vous avez affectée au gestionnaire d’événement. L’exemple suivant illustre la structure de base
d’un gestionnaire d’événement :
object.eventMethod = function () {
// Votre code, répondant à l’événement.
}
Par exemple, supposons que vous ayez un bouton next_btn sur la scène. Le code suivant
affecte au gestionnaire d’événement onPress du bouton une fonction qui fait avancer la tête
de lecture jusqu’à l’image suivante dans le scénario actuel :
next_btn.onPress = function () {
nextFrame();
}
Affectation d’une référence de fonction Dans le code précédent, la fonction nextFrame()
a été affectée à un gestionnaire d’événement pour onPress. Vous pouvez également affecter
une référence de fonction (nom) à une méthode de gestionnaire d’événement et définir la
fonction ultérieurement, comme illustré par l’exemple suivant.
// Affecte une référence de fonction au gestionnaire d’événement onPress du
bouton.
next_btn.onPress = goNextFrame;
// Définit la fonction goNextFrame().
function goNextFrame() {
nextFrame();
}
Notez que, dans l’exemple suivant, vous affectez la référence de fonction, et non la valeur
renvoyée, au gestionnaire d’événement onPress :
// Incorrect !
next_btn.onPress = goNextFrame();
// Correct.
next_btn.onPress = goNextFrame;
Réception des paramètres transmis
Certains gestionnaires d’événement reçoivent des
paramètres qui fournissent des informations sur l’événement qui s’est produit. Par exemple, le
gestionnaire d’événement TextField.onSetFocus est invoqué lorsqu’une occurrence de
champ de texte parvient au focus clavier. Ce gestionnaire d’événement reçoit une référence à
l’objet de champ de texte qui avait précédemment le focus clavier.
Utilisation de méthodes de gestionnaire d’événement
361
Par exemple, le code suivant insère du texte dans le champ de texte qui vient juste de perdre le
focus clavier :
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";
};
Gestionnaires d’événement pour les objets d’exécution
Vous pouvez également affecter
des fonctions aux gestionnaires d’événement pour les objets créés lors de l’exécution. Le code
suivant, par exemple, crée une nouvelle occurrence de clip (newclip_mc) et affecte une
fonction au gestionnaire d’événement onPress du clip :
this.attachMovie("symbolID", "newclip_mc", 10);
newclip_mc.onPress = function () {
trace("You pressed me");
}
Pour plus d’informations, consultez la section Création de clips à l’exécution, page 391.
Contournement des méthodes de gestionnaire d’événement En créant une classe qui
étend une classe ActionScript, vous pouvez supplanter les méthodes du gestionnaire
d’événement avec les fonctions que vous avez écrites. Vous pouvez définir un gestionnaire
d’événement dans une nouvelle sous-classe que vous pouvez utiliser de nouveau pour
différents objets en liant les symboles de la bibliothèque de la classe étendue à la nouvelle sousclasse. Le code suivant contourne le gestionnaire d’événement onPress de la classe MovieClip
par l’intermédiaire d’une fonction qui réduit la transparence du clip :
// Classe FadeAlpha – définit la transparence lorsque vous cliquez sur le
clip.
class FadeAlpha extends MovieClip {
function onPress() {
this._alpha -= 10;
}
}
Pour plus d’informations sur l’extension d’une classe ActionScript et sur la liaison avec les
symboles de la bibliothèque, consultez les exemples de la section Affectation d’une classe à des
symboles dans Flash, page 304. Pour plus d’informations sur l’écriture et l’utilisation de classes
personnalisées, consultez le Chapitre 7, Classes.
362
Gestion d’événements
Utilisation des écouteurs d’événement
Les écouteurs d’événement permettent à un objet, appelé objet écouteur, de recevoir des
événements diffusés par un autre objet, appelé objet diffuseur. L’objet diffuseur enregistre
l’objet écouteur afin de recevoir des événements générés par le diffuseur. Par exemple, vous
enregistrez un objet de clip pour recevoir des notifications onResize de la scène, ou une
occurrence de bouton peut recevoir des notifications onChanged d’un objet de champ de
texte. Vous pouvez enregistrer plusieurs objets écouteurs pour recevoir des événements d’un
seul diffuseur et vous pouvez enregistrer un seul objet écouteur pour recevoir des événements
de plusieurs diffuseurs.
Contrairement aux méthodes de gestion d’erreurs, le modèle écouteur-diffuseur applicable
aux événements permet d’utiliser plusieurs éléments de code pour écouter un même
événement sans créer de conflits. Les modèles d’événement qui n’appliquent pas ce modèle,
tels que XML.onLoad, peuvent devenir une source de problèmes lorsque plusieurs blocs de
code écoutent un même événement. Ces différents blocs entrent en conflit pour contrôler la
seule référence de la fonction de rappel XML.onLoad. Avec le modèle écouteur/diffuseur, vous
pouvez ajouter facilement des écouteurs à un même événement sans avoir à vous soucier des
blocages.
Les classes ActionScript suivantes permettent de diffuser des événements : Key, Mouse,
MovieClipLoader, Selection, TextField et Stage. Pour identifier les écouteurs disponibles pour
une classe, consultez chaque entrée de classe dans le Guide de référence du langage ActionScript
2.0.
Pour plus d’informations sur les écouteurs d’événement, consultez les rubriques suivantes :
■
Modèle d’écouteur d’événement, page 364
■
Exemple d’écouteur d’événement, page 365
La classe Stage permet de diffuser des événements. Vous trouverez un exemple de fichier
source, stagesize.fla, dans le dossier Samples de votre disque dur. Cet exemple montre les effets
de la propriété Stage.scaleMode sur les valeurs de Stage.width et Stage.height lorsque la
fenêtre du navigateur est redimensionnée.
■
Sous Windows, accédez à lecteur d’amorçage\Program Files\Macromedia\Flash 8\Samples
and Tutorials\Samples\ActionScript\StageSize.
■
Sur Macintosh, accédez à disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/StageSize.
Utilisation des écouteurs d’événement
363
Modèle d’écouteur d’événement
Le modèle des écouteurs d’événement est similaire à celui des gestionnaires d’événement (voir
la section Utilisation de méthodes de gestionnaire d’événement, page 360), à deux différences
près :
■
Vous affectez le gestionnaire d’événement à l’objet écouteur et non pas à l’objet qui diffuse
l’événement.
■
Vous appelez une méthode spéciale de l’objet diffuseur, addListener(), qui enregistre
l’objet écouteur pour recevoir ses événements.
Le code suivant présente le modèle d’écouteur d’événement :
var listenerObject:Object = new Object();
listenerObject.eventName = function(eventObj:Object) {
// Votre code ici.
};
broadcasterObject.addListener(listenerObject);
Le code commence par un objet, listenerObject, avec une propriété eventName. L’objet
écouteur spécifié peut être un objet, tel qu’un objet existant, une occurrence de bouton ou de
clip sur la scène ou une occurrence de n’importe quelle classe ActionScript. Par exemple, un
clip personnalisé peut implémenter les méthodes d’écoute pour les écouteurs de la scène. Vous
pouvez également avoir un objet qui écoute plusieurs types d’écouteurs.
La propriété eventName est un événement qui se produit sur broadcasterObject, qui
ensuite diffuse l’événement à listenerObject. Vous pouvez enregistrer plusieurs écouteurs
sur un diffuseur d’événement.
Affectez ensuite une fonction à l’écouteur d’événement qui répond en quelque sorte à
l’événement.
Enfin, appelez la méthode addListener() sur l’objet qui diffuse l’événement, en lui
transmettant le nom de l’objet écouteur.
Pour désenregistrer un objet écouteur de sorte qu’il ne reçoive plus d’événements, appelez la
méthode removeEventListener() de l’objet diffuseur, en lui transmettant le nom de
l’événement à supprimer et l’objet écouteur.
broadcasterObject.removeListener(listenerObject);
364
Gestion d’événements
Exemple d’écouteur d’événement
L’exemple suivant illustre comment utiliser l’écouteur d’événement onSetFocus dans la classe
Selection pour créer un gestionnaire de focus simple pour un groupe de champs de saisie de
texte. Dans ce cas, la bordure du champ de texte qui reçoit le focus clavier est activée (affichée)
et la bordure du champ de texte qui a perdu le focus est désactivée.
Pour créer un gestionnaire de focus simple avec des gestionnaires
d’événement :
1.
En utilisant l’outil Texte, créez un champ de texte sur la scène.
2.
Sélectionnez le champ de texte et, dans l’inspecteur des propriétés, choisissez Entrée dans
le menu contextuel Type de texte, puis choisissez l’option Afficher la bordure autour du
texte.
3.
Créez un autre champ de saisie de texte, sous le premier.
Assurez-vous que l’option Afficher la bordure autour du texte n’est pas activée pour ce
champ de texte. Vous pouvez poursuivre la création de champs texte.
4.
Sélectionnez l’image 1 dans le scénario et ouvrez le panneau Actions (Fenêtre > Actions).
5.
Pour créer un objet qui écoute les notifications de focus d’une classe Selection, entrez le
code suivant dans le panneau Actions :
// Crée un objet écouteur, focusListener.
var focusListener:Object = new Object();
// Définit la fonction pour l’objet écouteur.
focusListener.onSetFocus = function(oldFocus_txt:TextField,
newFocus_txt:TextField) {
oldFocus_txt.border = false;
newFocus_txt.border = true;
}
Ce code crée un objet nommé focusListener qui définit une propriété onSetFocus et
lui affecte une fonction. La fonction prend en compte deux paramètres : une référence au
champ de texte qui a perdu le focus et une référence au champ de texte qui a reçu le focus.
La fonction définit la propriété border du champ de texte qui a perdu le focus sur false
et la propriété border du champ de texte qui a reçu le focus sur true.
6.
Pour enregistrer l’objet focusListener pour recevoir des événements de l’objet Selection,
ajoutez le code suivant au panneau Actions :
// Enregistre focusListener auprès du diffuseur.
Selection.addListener(focusListener);
7.
Testez l’application (Contrôle > Tester l’animation), cliquez dans le premier champ de
texte, puis appuyez sur la touche Tab pour passer d’un champ à l’autre.
Utilisation des écouteurs d’événement
365
Utilisation d’écouteurs d’événement avec
des composants
La syntaxe d’un écouteur d’événement change légèrement lorsque l’on utilise des composants.
Les composants génèrent des événements, qui doivent être écoutés de façon spécifique par un
objet écouteur ou par une fonction personnalisée.
L’exemple suivant présente l’utilisation d’écouteurs d’événement pour surveiller la progression
du téléchargement dynamique d’une image.
Pour écouter les événements du composant Loader :
1.
Faites glisser une occurrence du composant Loader du panneau Composants jusqu’à la
scène.
2.
Sélectionnez la nouvelle occurrence et saisissez my_ldr dans le champ Nom de l’occurrence
de l’inspecteur des propriétés.
3.
Ajoutez le code suivant à l’image 1 du scénario 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");
Ce code ActionScript définit un objet écouteur nommé loaderListener, qui écoute
deux événements : progress et complete. Lorsque chacun de ces événements est diffusé,
son code est exécuté et le texte de débogage s’affiche dans le panneau de sortie si vous
testez le fichier SWF dans l’outil de programmation.
Vous indiquez ensuite à l’occurrence my_ldr d’écouter chacun des deux événements
spécifiés (progress et complete) et vous désignez l’objet écouteur ou la fonction à
exécuter lorsque l’événement est diffusé. Enfin, la méthode Loader.load() est appelée, ce
qui déclenche le téléchargement de l’image.
366
Gestion d’événements
4.
Choisissez Contrôle > Tester l’animation pour tester le fichier SWF.
L’image est téléchargée dans l’occurrence Loader de la scène, puis plusieurs messages
s’affichent dans le panneau de sortie. Selon la taille de l’image téléchargée, et si l’image a
été mise en cache sur l’ordinateur local de l’utilisateur, l’événement progress peut être
diffusé plusieurs fois, alors que l’événement complete n’est diffusé qu’une fois à la fin du
téléchargement de l’image.
Lorsque vous utilisez des composants et diffusez des événements, la syntaxe diffère
légèrement de celle des écouteurs d’événement des exemples précédents. En particulier,
vous devez utiliser la méthode addEventListener() au lieu d’appeler addListener().
Deuxièmement, vous devez désigner l’événement spécifique que vous souhaitez écouter,
ainsi que l’objet écouteur ou la fonction.
Au lieu d’utiliser un objet écouteur, comme à la section Utilisation d’écouteurs d’événement avec
des composants, page 366, vous pouvez également utiliser une fonction personnalisée. Le code
de l’exemple précédent pourrait être réécrit de la manière suivante :
System.security.allowDomain("http://www.helpexamples.com");
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
}
REMARQUE
Remarquez que, dans les exemples précédents, les écouteurs d’événement sont
toujours ajoutés avant l’appel de la méthode Loader.load(). Si vous appelez la
méthode Loader.load() avant de spécifier les écouteurs d’événement, il est possible
que le téléchargement se termine avant que les écouteurs d’événement soient
entièrement définis. Cela signifie que le contenu peut s’afficher et que l’événement
complete peut ne pas être intercepté.
Utilisation d’écouteurs d’événement avec des composants
367
Association de gestionnaires
d’événement à des boutons et des clips
Vous pouvez associer des gestionnaires d’événement directement à une occurrence de bouton
ou de clip sur la scène au moyen des gestionnaires d’événement onClipEvent() et on(). Le
gestionnaire d’événement onClipEvent() diffuse les événements de clip alors que le
gestionnaire d’événement on() traite les événements de bouton.
Pour lier un gestionnaire d’événement à une occurrence de bouton ou de clip, cliquez sur cette
occurrence sur la scène pour lui donner le focus, puis entrez du code dans le panneau Actions.
Le titre du panneau Actions indique que du code va être lié au bouton ou au clip : panneau
Actions - panneau Bouton ou Actions - Clip. Pour consulter les recommandations liées à
l’exploitation de code avec des occurrences de bouton ou de clip, consultez la section
Association de code à des objets, page 814.
REMARQUE
Ne confondez pas les gestionnaires d’événement de boutons et de clips et les
événements de composant, tels que SimpleButton.click, UIObject.hide et
UIObject.reveal, qui doivent être liés aux occurrences de composants et sont abordés
dans le guide Utilisation des composants.
Vous pouvez associer onClipEvent() et on() uniquement à des occurrences de clips qui ont
été placées sur la scène au cours de la programmation. Il est impossible d’associer
onClipEvent() ou on() à des occurrences de clips créées à l’exécution (avec la méthode
attachMovie, par exemple). Pour associer des gestionnaires d’événement à des objets créés à
l’exécution, utilisez des méthodes de gestionnaire d’événement ou des écouteurs d’événement.
(Consultez les sections Utilisation de méthodes de gestionnaire d’événement, page 360 et
Utilisation des écouteurs d’événement, page 363.)
REMARQUE
Il n’est pas conseillé de lier les gestionnaires d’événement onClipEvent() et on(). Il est
préférable d’intégrer votre code à des scripts d’image ou à un fichier de classe, comme
décrit tout au long de ce manuel. Pour plus d’informations, consultez les sections
Utilisation de méthodes de gestionnaire d’événement, page 360 et Association de code à
des objets, page 814.
Pour plus d’informations sur les gestionnaires d’événement de boutons et de clips, consultez
les rubriques suivantes :
■
Utilisation de on et onClipEvent avec des méthodes de gestionnaires d’événement, page 369
■
Spécification d’événements pour les méthodes on ou onClipEvent, page 370
■
Ajout ou affectation de plusieurs gestionnaires à un même objet, page 371
368
Gestion d’événements
Utilisation de on et onClipEvent avec des méthodes
de gestionnaires d’événement
Vous pouvez, dans certains cas, appliquer différentes techniques pour gérer les événements
sans provoquer de conflits. L’utilisation des méthodes on() et onClipEvent() ne provoque
pas de conflit avec les méthodes de gestionnaire d’événement que vous définissez.
Imaginons par exemple que votre fichier SWF comporte un bouton associé à un gestionnaire
on(press) qui déclenche la lecture du fichier SWF. Ce même bouton possède également une
méthode onPress(), pour laquelle vous définissez une fonction qui fait pivoter un objet sur
la scène. Lorsque l’utilisateur clique sur le bouton, la lecture du fichier SWF commence et
l’objet tourne sur lui-même. Selon les types d’événement à appeler et le moment auquel ces
derniers doivent être appelés, vous pouvez utiliser les méthodes on() et onClipEvent(), des
méthodes de gestionnaire d’événement ou ces deux types de gestion d’événement.
Toutefois, le domaine des variables et des objets dans les gestionnaires on() et
n’est pas le même que celui du gestionnaire d’événement et des écouteurs
d’événement. Voir Domaine du gestionnaire d’événement, page 374.
onClipEvent()
Vous pouvez également utiliser on() avec des clips pour créer des clips qui reçoivent des
événements de bouton. Pour plus d’informations, consultez la section Création de clips avec des
états de bouton, page 373. Pour plus d’informations sur la spécification d’événements pour
on() et onClipEvent(), consultez la section Spécification d’événements pour les méthodes on ou
onClipEvent, page 370.
Pour utiliser un gestionnaire on et le gestionnaire d’événements onPress :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom handlers.fla.
2.
A l’aide de l’outil Rectangle, dessinez un grand carré sur la scène.
3.
A l’aide de l’outil Sélection, double-cliquez sur le carré sur la scène, puis appuyez sur F8
pour ouvrir la boîte de dialogue Convertir en symbole.
4.
Entrez un nom de symbole pour la zone, définissez le type clip et cliquez sur OK.
5.
Donnez au clip sur la scène le nom d’occurrence box_mc .
6.
Ajoutez le code ActionScript suivant directement au symbole du clip sur la scène :
on (press) {
trace("on (press) {...}");
}
7.
Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
box_mc.onPress = function() {
trace("box_mc.onPress = function() {...};");
};
Association de gestionnaires d’événement à des boutons et des clips
369
8.
Choisissez Contrôle > Tester l’animation pour tester le document Flash.
Lorsque vous cliquez sur le symbole du clip sur la scène, les informations suivantes
s’affichent dans le panneau de sortie :
on (press) {...}
box_mc.onPress = function() {...};
REMARQUE
Il n’est pas conseillé de lier les gestionnaires d’événement onClipEvent() et on(). Il
est préférable d’intégrer votre code à des scripts d’image ou à un fichier de classe,
comme décrit tout au long de ce manuel. Pour plus d’informations, consultez les
sections Utilisation de méthodes de gestionnaire d’événement, page 360 et
Association de code à des objets, page 814.
Spécification d’événements pour les méthodes on ou
onClipEvent
Pour utiliser le gestionnaire on() ou onClipEvent(), associez-le directement à une
occurrence d’un bouton ou d’un clip sur la scène et spécifiez l’événement que vous souhaitez
gérer pour cette occurrence. Pour obtenir la liste complète des événements pris en charge par
les gestionnaires d’événement on() et onClipEvent(), consultez les entrées gestionnaire on
et gestionnaire onClipEvent dans le Guide de référence du langage ActionScript 2.0.
Par exemple, le gestionnaire d’événement on() suivant est exécuté lorsque l’utilisateur clique
sur le bouton auquel il est associé :
on (press) {
trace("Thanks for pressing me.");
}
Vous pouvez spécifier plusieurs événements pour chaque gestionnaire on() en les séparant par
des virgules. Le code ActionScript d’un gestionnaire est exécuté lorsque l’un des événements
spécifiés par le gestionnaire se produit. Par exemple, le gestionnaire on() suivant, associé à un
bouton, est exécuté lorsque le pointeur de la souris passe au-dessus du bouton, puis s’en
écarte :
on (rollOver, rollOut) {
trace("You rolled over, or rolled out");
}
370
Gestion d’événements
Vous pouvez également ajouter des événements de touche enfoncée à l’aide de gestionnaires
on(). Par exemple, le code suivant trace une chaîne lorsque vous appuyez sur la touche 3 du
clavier. Sélectionnez une occurrence de bouton ou de clip, puis ajoutez le code suivant dans le
panneau Actions :
on (keyPress "3") {
trace("Vous avez appuyé sur 3")
}
Ou, pour tracer la chaîne lorsque la touche Entrée est enfoncée par l’utilisateur, vous pouvez
utiliser le format de code suivant. Sélectionnez une occurrence de bouton ou de clip, puis
ajoutez le code suivant dans le panneau Actions :
on (keyPress "<Entrée>") {
trace("Entrée enfoncé");
}
Choisissez Contrôle > Tester l’animation, puis appuyez sur la touche Entrée pour visualiser le
tracé de la chaîne dans le panneau de sortie. Si le tracé n’apparaît pas, sélectionnez Contrôle >
Désactiver les raccourcis clavier, puis réessayez. Pour plus d’informations sur l’ajout d’une
interactivité relative à la pression des touches à vos applications, consultez l’entrée Key.
REMARQUE
Il n’est pas conseillé de lier les gestionnaires d’événement onClipEvent() et on(). Il est
préférable d’intégrer votre code à des scripts d’image ou à un fichier de classe, comme
décrit tout au long de ce manuel. Pour plus d’informations, consultez les sections
Utilisation de méthodes de gestionnaire d’événement, page 360 et Association de code à
des objets, page 814.
Ajout ou affectation de plusieurs gestionnaires à un
même objet
Vous pouvez associer plusieurs gestionnaires à un objet si vous souhaitez exécuter différents
scripts lorsque différents événements se produisent. Par exemple, vous pouvez associer les
gestionnaires onClipEvent() suivants à la même occurrence de clip. Le premier est exécuté
au premier chargement du clip (ou lorsque celui-ci apparaît sur la scène), le second est exécuté
lorsque le clip est purgé de la scène.
on (press) {
this.unloadMovie()
}
onClipEvent (load) {
trace("I've loaded");
}
onClipEvent (unload) {
trace("I've unloaded");
}
Association de gestionnaires d’événement à des boutons et des clips
371
R E MA R Q U E
Il n’est pas conseillé de lier les gestionnaires d’événement onClipEvent() et on(). Il est
préférable d’intégrer votre code à des scripts d’image ou à un fichier de classe, comme
décrit tout au long de ce manuel. Pour plus d’informations, consultez les sections
Utilisation de méthodes de gestionnaire d’événement, page 360 et Association de code à
des objets, page 814.
Pour lier plusieurs gestionnaires à un objet à l’aide du code placé dans le scénario, consultez
l’exemple suivant. Le code associe les gestionnaires onPress et onRelease à une occurrence
de clip.
Pour affecter plusieurs gestionnaires à un même objet :
1.
Créez un nouveau document Flash et nommez-le assignMulti.fla.
2.
Sélectionnez l’image 1 du scénario, puis ajoutez le code suivant dans le panneau Actions :
this.createEmptyMovieClip("img_mc", 10);
var mclListener:Object = new Object();
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("erreur de téléchargement d’image");
}
var img_mcl:MovieClipLoader = new MovieClipLoader();
img_mcl.addListener(mclListener);
img_mcl.loadClip("http://www.helpexamples.com/flash/images/image1.jpg",
img_mc);
3.
Sélectionnez Contrôle > Tester l’animation pour tester le document.
L’image se charge dans l’occurrence de img_mc et les gestionnaires d’événement
onPress() et onRelease() vous permettent de faire glisser l’image sur la scène.
372
Gestion d’événements
Diffusion d’événements à partir
d’occurrences de composant
Quelle que soit l’occurrence de composant, vous pouvez spécifier le mode de gestion d’un
événement. Les événements de composant sont traités différemment par rapport aux
diffusions d’événements en provenance d’objets ActionScript natifs.
Pour plus d’informations, consultez la section Gestion des événements des composants du guide
Utilisation des composants.
Création de clips avec des états de
bouton
Lorsque vous associez un gestionnaire on() à un clip ou que vous affectez une fonction à l’un
des gestionnaires d’événement souris MovieClip pour une occurrence de clip, le clip répond à
des événements souris de la même façon qu’un bouton. Vous pouvez également créer des états
de bouton automatiques (Haut, Dessus et Abaissé) dans un clip, en ajoutant les étiquettes
d’image _up, _over et _down au scénario du clip.
Lorsque l’utilisateur déplace la souris au-dessus d’un clip ou qu’il clique sur ce dernier, la tête
de lecture passe à l’image comportant l’étiquette d’image appropriée. La propriété hitArea
(propriété MovieClip.hitArea) permet de désigner la zone active d’un clip.
Pour créer des états de bouton dans un clip :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom mcbutton.fla.
2.
A l’aide de l’outil Rectangle, tracez un petit rectangle (d’environ 100 pixels de large et
20 pixels de haut) sur la scène.
3.
A l’aide de l’outil Sélection, double-cliquez sur la forme, puis appuyez sur F8 pour ouvrir
la boîte de dialogue Convertir en symbole.
4.
Entrez le nom de symbole mcbutton, définissez le type de symbole de clip et cliquez sur
OK.
5.
Double-cliquez sur le symbole de clip sur la scène pour activer le mode d’édition de
symbole.
6.
Créez un nouveau calque dans le scénario du clip, et nommez-le labels.
7.
Entrez l’étiquette d’image _up dans l’inspecteur des propriétés.
8.
Créez un nouveau calque sur le calque par défaut et le calque labels.
Création de clips avec des états de bouton
373
9.
Renommez le nouveau calque actions et ajoutez le code ActionScript suivant à l’image 1
du scénario du clip :
stop();
10. Sélectionnez
l’image 10, les trois calques, puis sélectionnez Insertion > Scénario > Image-
clé.
11.
Ajoutez une action stop() à l’image 10 du calque actions, puis ajoutez l’étiquette d’image
_over à l’image 10 du calque labels.
12. Sélectionnez
le rectangle dans l’image 10 et sélectionnez une nouvelle couleur de
remplissage à l’aide de l’inspecteur des propriétés.
13.
Créez de nouvelles images-clés dans l’image 20 de chacun des trois calques, puis ajoutez
l’étiquette d’image _down dans l’inspecteur des propriétés.
14. Modifiez la couleur du rectangle dans l’image
20 afin que chacun des trois états de bouton
apparaisse dans une couleur différente.
15.
Revenez au scénario principal.
16.
Pour que votre clip réponde aux événements souris, effectuez l’une des opérations
suivantes :
■
■
17.
Ajoutez un gestionnaire d’événement on() à l’occurrence de clip, comme indiqué dans
la section Association de gestionnaires d’événement à des boutons et des clips, page 368.
Affectez une fonction à l’un des gestionnaires d’événement souris de l’objet du clip
(onPress, onRelease, etc.), comme indiqué dans la section Utilisation de méthodes de
gestionnaire d’événement, page 360.
Choisissez Contrôle > Tester l’animation pour tester le document Flash.
Lorsque vous passez le pointeur de la souris sur une occurrence de clip sur la scène, le clip
passe automatiquement à l’état _over. Cliquez sur l’occurrence de clip pour que la tête de
lecture passe automatiquement à l’état _down du clip.
Domaine du gestionnaire d’événement
Le domaine, ou contexte, des variables et commandes que vous déclarez et exécutez dans un
gestionnaire d’événement varie selon le type de gestionnaire d’événement que vous utilisez :
gestionnaires d’événement ou écouteurs d’événement, gestionnaires on() et onClipEvent().
Si vous définissez un gestionnaire d’événement dans une nouvelle classe ActionScript 2.0, le
domaine dépend également du mode de définition du gestionnaire d’événement. Cette
section regroupe des exemples relatifs à ActionScript 1.0 et à ActionScript 2.0.
374
Gestion d’événements
Exemples ActionScript 1.0 Les fonctions affectées aux méthodes de gestionnaire
d’événement et aux écouteurs d’événement (comme toutes les fonctions ActionScript que
vous rédigez) définissent un domaine de variable locale, contrairement aux gestionnaires on()
et onClipEvent().
Par exemple, soit les deux gestionnaires d’événement suivants : le premier est un gestionnaire
d’événement onPress associé à un clip appelé clip_mc, le second est un gestionnaire on()
associé à la même occurrence de clip.
// Ajouté au scénario de clip parent de clip_mc :
clip_mc.onPress = function () {
var shoeColor; // Variable de la fonction locale
shoeColor = "blue";
}
// Gestionnaire on() ajouté au clip_mc :
on (press) {
var shoeColor; // aucun domaine de variable locale
shoeColor = "blue";
}
Bien que les deux gestionnaires d’événement contiennent le même code, leurs résultats sont
différents. Dans le premier cas, la variable color est locale par rapport à la fonction définie
pour onPress. Dans le second, le gestionnaire on() ne définissant pas de domaine de variable
locale, la variable est définie dans le domaine du scénario du clip clip_mc.
Dans le cas des gestionnaires d’événement on() associés à des boutons, plutôt qu’à des clips, le
domaine des variables (à l’instar des appels de fonction et de méthode) est limité au scénario
qui contient l’occurrence de bouton.
Le gestionnaire d’événement on() suivant, par exemple, génère différents résultats selon qu’il
est ajouté à un clip ou à un bouton. Dans le premier exemple, l’appel de la fonction play()
lance la tête de lecture du scénario qui contient le bouton ; dans le second, l’appel de la
fonction play() démarre le scénario du clip auquel le gestionnaire est associé.
// Associé à
on (press) {
play(); //
}
// Associé à
on (press) {
play(); //
}
un bouton.
Exécute le scénario parent.
un clip.
Exécute le scénario du clip.
Domaine du gestionnaire d’événement
375
Autrement dit, lorsqu’elle est associée à un objet bouton, la fonction play() s’applique au
scénario qui contient le bouton, c’est-à-dire au scénario parent du bouton. En revanche,
lorsque le gestionnaire on(press) est associé à un objet de clip, la fonction play() s’applique
au clip qui contient le gestionnaire. Si vous associez le code suivant à un clip, le scénario
parent est joué :
// Associé à un clip.
on (press) {
_parent.play(); // Exécute le scénario parent.
}
Dans la définition d’un gestionnaire d’événement ou d’écouteur d’événement, la fonction
play() s’applique au scénario contenant la définition. Imaginons, par exemple, que vous
déclariez la méthode de gestionnaire d’événement my_mc.onPress suivante dans le scénario
contenant l’occurrence de clip my_mc.
// Fonction définie dans le scénario.
my_mc.onPress = function () {
play(); // Lit le scénario ayant servi à la définition.
};
Pour exécuter le clip qui définit le gestionnaire d’événement onPress, vous devez faire
explicitement référence à ce clip à l’aide du mot-clé this, comme suit :
// Fonction définie dans le scénario racine.
my_mc.onPress = function () {
this.play(); // Loue le scénario de my_mc clip.
};
Toutefois, le même code placé sur le scénario racine d’une occurrence de bouton lirait le
scénario racine :
my_btn.onPress = function () {
this.play(); // Exécute le scénario racine.
};
Pour plus d’informations sur le domaine du mot-clé this dans les gestionnaires d’événement,
consultez la section Domaine du mot-clé this, page 378.
Exemple ActionScript 2.0
La classe TextLoader suivante permet de charger un fichier texte
et d’afficher un texte après avoir chargé le fichier.
// 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 {
376
Gestion d’événements
_level0.createTextField("my_txt", 999, 0, 0, 100, 20);
_level0.my_txt.autoSize = "left";
_level0.my_txt.text = params_lv.monthNames; // undefined
}
}
Ce code ne peut pas fonctionner correctement car il y a un problème de domaine avec les
gestionnaires d’événement. Par ailleurs la référence this prête à confusion entre le
gestionnaire d’événement onLoad et la classe. Le comportement attendu dans cet exemple est
que la méthode onLoadVarsDone() soit appelée dans le domaine de l’objet TextLoader, alors
qu’elle est appelée dans le domaine de l’objet LoadVars. En effet, la méthode a été extraite à
partir de l’objet TextLoader et greffée sur l’objet LoadVars. L’objet LoadVars appelle alors le
gestionnaire d’événement this.onLoad lorsque le fichier texte a été chargé avec succès et
lorsque la fonction onLoadVarsDone() appelée par this est définie sur LoadVars et non sur
TextLoader. L’objet params_lv réside dans le domaine this lorsqu’il est appelé, bien que la
fonction onLoadVarsDone() repose sur l’objet params_lv par référence. Par conséquent, la
fonction onLoadVarsDone() attend une occurrence params_lv.params_lv qui n’existe pas.
Pour appeler correctement la méthode onLoadVarsDone() dans le domaine de l’objet
TextLoader, appliquez la stratégie suivante : utilisez une fonction littérale pour créer une
fonction anonyme qui appelle la fonction voulue. L’objet owner reste visible dans le domaine
de la fonction anonyme, ce qui permet de rechercher l’objet TextLoader ayant procédé à
l’appel.
// 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; // Janvier, février,
mars...
}
}
Domaine du gestionnaire d’événement
377
Domaine du mot-clé this
Le mot-clé this fait référence à l’objet dans le domaine en cours d’exécution. Selon le type de
technique de gestionnaire d’événement que vous utilisez, this renvoie à différents objets.
Dans une fonction de gestionnaire d’événement ou d’écouteur d’événement, this
fait
référence à l’objet qui définit la méthode du gestionnaire d’événement ou de l’écouteur
d’événement. Dans le code suivant, par exemple, this renvoie à my_mc :
// Gestionnaire d’événement onPress() associé au scénario principal :
my_mc.onPress = function () {
trace(this); // _level0.my_mc
}
Dans un gestionnaire on() associé à un clip, this
renvoie au clip auquel le gestionnaire
on() est associé, comme indiqué dans le code suivant :
// Associé à un clip appelé my_mc sur le scénario principal.
on (press) {
trace(this); // _level0.my_mc
}
Dans un gestionnaire on() associé à un bouton, this
renvoie au scénario qui contient le
bouton, comme dans le code suivant :
// Associé à un bouton du scénario principal.
on (press) {
trace(this); // _level0
}
Utilisation de la classe Delegate
La classe Delegate permet d’exécuter une fonction dans un domaine spécifique. Elle est
fournie pour que vous puissiez distribuer le même événement à deux fonctions différentes
(consultez la section Délégation d’événements aux fonctions du guide Utilisation des composants)
et appeler des fonctions au sein du domaine de la classe qui les contient.
Lorsque vous transmettez une fonction sous forme de paramètre à la méthode
la fonction est invoquée dans le domaine de
l’occurrence de composant diffuseur, pas de l’objet dans lequel elle est déclarée (consultez la
section Délégation du domaine d’une fonction du guide Utilisation des composants). Pour appeler
la fonction dans le domaine de l’objet dans lequel elle est déclarée, vous pouvez utiliser
Delegate.create().
EventDispatcher.addEventListener(),
L’exemple suivant présente trois méthodes d’écoute d’événements pour une occurrence de
composant Button. Chaque méthode d’ajout d’écouteurs d’événement à une occurrence de
composant Button distribue l’événement vers un domaine différent.
378
Gestion d’événements
Pour utiliser la classe Delegate pour écouter des événements :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom delegate.fla.
2.
Faites glisser un composant Button du dossier Interface utilisateur du panneau
Composants à la bibliothèque.
Vous pourrez ajouter et positionner l’occurrence de bouton sur la scène ultérieurement à
l’aide du code ActionScript.
3.
Ajoutez le code ActionScript suivant à l’image 1 du scénario 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));
Le code qui précède est divisé en six sections (séparées par une ligne vide). La première
section importe la classe Button (pour le composant Button) ainsi que la classe Delegate.
La deuxième section du code définit la fonction qui est appelée lorsque l’utilisateur clique
sur certains boutons. La troisième section de code crée un objet que vous utilisez comme
un écouteur d’événement ; il écoute un seul événement, click.
Utilisation de la classe Delegate
379
Les trois dernières sections de code créent chacune une nouvelle occurrence du composant
Button sur la scène, repositionnent l’occurrence et ajoutent un écouteur d’événement pour
l’événement click. Le premier bouton ajoute un écouteur pour l’événement click et
transmet directement une référence à une fonction de gestionnaire click. Le deuxième
bouton ajoute un écouteur pour l’événement click et transmet une référence à un objet
écouteur qui contient un gestionnaire pour l’événement click. Enfin, la troisième
fonction ajoute un écouteur pour l’événement click, utilise la classe Delegate pour
distribuer l’événement click dans le domaine this (où this équivaut à _level0) et
transmet une référence à la fonction de gestionnaire click.
4.
Choisissez Contrôle > Tester l’animation pour tester le document Flash.
5.
Cliquez sur chaque occurrence de bouton sur la scène pour visualiser le domaine dans
lequel l’événement est pris en charge.
a.
Cliquez sur le premier bouton sur la scène pour suivre le texte suivant dans le panneau
de sortie :
[click] event on _level0.one_button instance.
this -> _level0.one_button
Lorsque vous cliquez sur l’occurrence bouton_un, le domaine this fait directement
référence à l’occurrence du bouton.
b.
Cliquez sur le deuxième bouton sur la scène pour suivre le texte suivant dans le
panneau de sortie :
[click] event on _level0.two_button instance.
this -> [object Object]
Lorsque vous cliquez sur l’occurrence bouton_deux, le domaine this fait référence à
l’objet buttonListener.
c.
Cliquez sur le troisième bouton sur la scène pour suivre le texte suivant dans le
panneau de sortie :
[click] event on _level0.three_button instance.
this -> _level0
Lorsque vous cliquez sur l’occurrence bouton_trois, le domaine this fait référence
au domaine spécifié dans l’appel de la méthode Delegate.create() soit, dans ce cas,
_level0.
380
Gestion d’événements
11
CHAPITRE 11
Utilisation des clips
Les clips sont comme des fichiers SWF autonomes exécutés indépendamment les uns des
autres et du scénario qui les contient. Par exemple, si le scénario principal contient une seule
image et qu’un clip contenu dans cette image comporte dix images, chaque image du clip est
lue lorsque vous lisez le fichier SWF principal. Un clip peut lui-même contenir d’autres clips,
ou clips imbriqués. Les clips imbriqués de cette manière sont organisés hiérarchiquement : le
clip parent contient un ou plusieurs clips enfants.
Vous pouvez nommer des occurrences de clip pour les identifier en tant qu’objets contrôlables
avec du code ActionScript. Lorsque vous donnez un nom d’occurrence à une occurrence de
clip, ce nom l’identifie en tant qu’objet du type de classe MovieClip. Utilisez les propriétés et
méthodes de la classe MovieClip pour contrôler l’apparence et le comportement des clips à
l’exécution.
Vous pouvez considérer les clips comme des objets autonomes qui répondent à des
événements, envoient des messages à d’autres objets de clip, conservent leur état et gèrent leurs
clips enfants. De cette amnière, les clips constituent la base de l’architecture basée sur les
composants de Macromedia Flash Basic 8 et Macromedia Flash Professionnel 8. Les
composants disponibles dans le panneau Composants (Fenêtre > Composants) sont en réalité
des clips sophistiqués qui ont été conçus et programmés pour adopter une apparence donnée
et certains comportements.
Pour plus d’informations sur l’utilisation de l’API de dessin (méthodes de dessin de la classe
MovieClip), les filtres, les mélanges, les animations scriptées, etc., consultez le Chapitre 13,
Animation, filtres et dessins.
Pour plus d’informations sur les clips, consultez les rubriques suivantes :
A propos du contrôle des clips à l’aide d’ActionScript. . . . . . . . . . . . . . . . . . . . . . . .382
Appel de plusieurs méthodes sur un seul clip. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .384
Chargement et déchargement des fichiers SWF . . . . . . . . . . . . . . . . . . . . . . . . . . . .384
Modification de la position et de l’apparence d’un clip . . . . . . . . . . . . . . . . . . . . . . .388
Déplacement des clips . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .389
Création de clips à l’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
381
Ajout de paramètres aux clips créés dynamiquement . . . . . . . . . . . . . . . . . . . . . . . 395
Gestion des profondeurs de clip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .397
Mise en cache et parcours de clips à l’aide d’ActionScript . . . . . . . . . . . . . . . . . . . . 401
Utilisation des clips en tant que masques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
Gestion des événements clip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .411
Affectation d’une classe à un symbole de clip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
Initialisation des propriétés de classe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
A propos du contrôle des clips à l’aide
d’ActionScript
Vous pouvez utiliser les fonctions ActionScript globales ou les méthodes de la classe
MovieClip pour accomplir des tâches sur les clips. Certaines méthodes de la classe MovieClip
accomplissent les mêmes tâches que les fonctions du même nom, alors que d’autres méthodes
MovieClip, comme hitTest() et swapDepths(), ne possèdent pas de noms de fonction
correspondants.
L’exemple suivant illustre la différence entre l’emploi d’une méthode et d’une fonction. Les
deux instructions copient l’occurrence my_mc, nomment le nouveau clip new_mc et le placent
à une profondeur de 5.
my_mc.duplicateMovieClip("new_mc", 5);
duplicateMovieClip(my_mc, "new_mc", 5);
Lorsqu’une fonction et une méthode présentent des comportements similaires, vous pouvez
choisir l’une ou l’autre pour contrôler des clips. Le choix dépend de vos préférences et de votre
familiarité avec la rédaction de scripts dans ActionScript. Que vous utilisiez une fonction ou
une méthode, le scénario cible doit être chargé dans Flash Player lorsque la fonction ou la
méthode est appelée.
Pour utiliser une méthode, vous l’invoquez en utilisant le chemin cible du nom d’occurrence,
suivi d’un point (.), puis du nom et des paramètres de la méthode, comme dans l’exemple
suivant :
myMovieClip.play();
parentClip.childClip.gotoAndPlay(3);
Dans la première instruction, la méthode play() lance la tête de lecture dans l’occurrence
myMovieClip. Dans la deuxième instruction, la méthode gotoAndPlay() place la tête de
lecture sur childClip (qui est un enfant de l’occurrence parentClip) à l’image 3 et continue
la lecture.
382
Utilisation des clips
Les fonctions globales qui contrôlent un scénario possèdent un paramètre cible qui permet
de définir le chemin cible de l’occurrence que vous voulez contrôler. Par exemple, dans le
script suivant, startDrag() cible l’occurrence recevant le code et la rend déplaçable :
my_mc.onPress = function() {
startDrag(this);
};
my_mc.onRelease = function() {
stopDrag();
};
Les fonctions suivantes ciblent des clips : loadMovie(), unloadMovie(), loadVariables(),
setProperty(), startDrag(), duplicateMovieClip() et removeMovieClip(). Pour
utiliser ces fonctions, vous devez entrer un chemin cible dans leur paramètre target pour
indiquer la cible de la fonction.
Les méthodes MovieClip suivantes peuvent contrôler des clips ou des niveaux chargés et n’ont
pas de fonctions équivalentes : Clip.attacherFilm(), Clip.créerClipVide(),
Clip.créerChampTexte(), MovieClip.getBounds(), MovieClip.getBytesLoaded(),
MovieClip.getBytesTotal(), MovieClip.getDepth(), Clip.ExempleProfondeur(),
Clip.ProfondeurMax.Suivante(), Clip.globalVersLocal(),
Clip.localVersGlobal(), Clip.Test(), Clip.réglerMasque(),
Clip.changerProfondeurs().
Pour plus d’informations sur ces fonctions et ces méthodes, consultez les entrées
correspondantes dans le Guide de référence du langage ActionScript 2.0.
Pour avoir un aperçu d’animation scriptée dans Flash, vous pouvez consulter l’exemple de
fichier source, animation.fla, dans le dossier Samples de votre disque dur.
■
Sous Windows, ouvrez le répertoire lecteur d’initialisation\Program
Files\Macromedia\Flash 8\Samples and Tutorials\Samples\ActionScript\Animation.
■
Sur Macintosh, ouvrez le dossier Disque dur MacintoshApplications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Animation.
Vous trouverez des exemples d’applications de galeries photos sur votre disque dur. Ces
fichiers vous montrent comment utiliser ActionScript pour contrôler dynamiquement des
clips tout en chargeant des fichiers image dans un fichier SWF, avec des animations scriptées.
Vous trouverez des exemples de fichiers sources, gallery_tree.fla et gallery_tween.fla, dans le
dossier Samples de votre disque dur.
■
Sous Windows, ouvrez le répertoire lecteur d’initialisation\Program
Files\Macromedia\Flash 8\Samples and Tutorials\Samples\ActionScript\Galleries.
■
Sur Macintosh, accédez à disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Galleries.
A propos du contrôle des clips à l’aide d’ActionScript
383
Appel de plusieurs méthodes sur un seul
clip
Vous pouvez utiliser l’instruction with pour appeler un clip une seule fois, puis exécuter une
série de méthodes sur ce clip. L’instruction with fonctionne sur tous les objets ActionScript
(tels que Array, Color et Sound), et pas uniquement sur les clips.
L’instruction with prend un clip comme paramètre. L’objet que vous spécifiez est ajouté à la
fin du chemin cible courant. Toutes les actions imbriquées dans une instruction with sont
exécutées à l’intérieur du nouveau chemin cible. Par exemple, dans le script suivant, l’objet
donut.hole passe au avec l’instruction pour changer les propriétés de hole :
with (donut.hole) {
_alpha = 20;
_xscale = 150;
_yscale = 150;
}
Le script se comporte comme si les instructions imbriquées dans l’instruction with étaient
appelées depuis le scénario de l’occurrence hole. Le code ci-dessus est équivalent à l’exemple
suivant :
donut.hole._alpha = 20;
donut.hole._xscale = 150;
donut.hole._yscale = 150;
Le code ci-dessus est également équivalent à l’exemple suivant :
with (donut) {
hole._alpha = 20;
hole._xscale = 150;
hole._yscale = 150;
}
Chargement et déchargement des
fichiers SWF
Pour lire des fichiers SWF supplémentaires sans fermer Flash Player, ou pour faire permuter
des fichiers SWF sans charger une autre page HTML, utilisez l’une des options suivantes :
■
la fonction globale loadMovie() ou la méthode loadMovie() de la classe MovieClip.
■
la méthode de la classe loadClip() MovieClipLoader. Pour plus d’informations sur la
classe MovieClipLoader, consultez MovieClipLoader dans le Guide de référence du langage
ActionScript 2.0.
384
Utilisation des clips
Vous pouvez également utiliser la méthode loadMovie() pour envoyer des variables à un
script CGI, ce qui génère un fichier SWF en tant que sortie CGI. Par exemple, elle permet
de charger des fichiers dynamiques SWF ou des images en fonction des variables spécifiées
dans un clip. Lorsque vous chargez un fichier SWF, vous pouvez spécifier comme cible un
niveau ou un clip, dans lequel il sera chargé. Si vous chargez un fichier SWF dans une cible, il
hérite des propriétés du clip ciblé. Une fois l’animation chargée, vous pouvez modifier ces
propriétés.
La méthode unloadMovie() supprime un fichier SWF précédemment chargé avec la
méthode loadMovie(). En purgeant explicitement les fichiers SWF avec unloadMovie(),
vous assurez une transition fluide entre les fichiers SWF et vous allégez la quantité de mémoire
requise par Flash Player. Il peut être plus efficace dans certains cas de définir la propriété
_visible du clip sur false au lieu de le décharger. Si vous avez à réutiliser le clip par la suite,
définissez la propriété _visible sur false, puis sur true en fonction des besoins.
Utilisez loadMovie() pour effectuer les opérations suivantes :
■
Jouez une séquence de bannières publicitaires, correspondant à des fichiers SWF, en
plaçant une fonction loadMovie() dans un fichier SWF conteneur qui charge et décharge
de façon séquentielle les fichiers SWF de bannières.
■
Développez une interface arborescente avec des liens qui permettent à l’utilisateur de
sélectionner plusieurs fichiers SWF servant à afficher le contenu d’un site.
■
Créez une interface de navigation, avec des contrôles de navigation au niveau 0, qui charge
du contenu dans d’autres niveaux. Le chargement de contenu dans des niveaux permet de
bénéficier de transitions plus souples entre les pages de contenu que le chargement de
nouvelles pages HTML dans un navigateur.
Pour plus d’informations sur le chargement de fichiers SWF, consultez Chargement de fichiers
SWF et de fichiers d’images externes, page 647.
Pour plus d’informations, se reporter aux sections suivantes :
■
Spécification d’un scénario racine pour les fichiers SWF chargés, page 386
■
Chargement de fichiers image dans des clips, page 387
Chargement et déchargement des fichiers SWF
385
Spécification d’un scénario racine pour les fichiers
SWF chargés
La propriété ActionScript _root spécifie ou contient une référence au scénario racine d’un
fichier SWF. Si un fichier SWF possède plusieurs niveaux, le scénario racine se situe dans le
niveau contenant le script en cours d’exécution. Par exemple, si un script de niveau 1 est
évalué comme _root, _level1 est renvoyé. Cependant, le scénario spécifié par _root peut
changer si le fichier SWF est exécuté de façon indépendante (à son propre niveau) ou s’il a été
chargé dans une occurrence de clip par un appel loadMovie() .
Dans l’exemple suivant, prenez un fichier nommé container.swf qui possède une occurrence
de clip nommée target_mc dans son scénario principal. Le fichier container.swf déclare une
variable nommée userName dans son scénario principal; le même script charge ensuite un
autre fichier nommé contents.swf dans l’occurrence de clip target_mc :
// Dans container.swf:
_root.userName = "Tim";
target_mc.loadMovie("contents.swf");
my_btn.onRelease = function():Void {
trace(_root.userName);
};
Dans l’exemple suivant, le fichier SWF chargé contents.swf déclare également une variable
nommée userName dans son scénario racine :
// Dans contents.swf :
_root.userName = "Mary";
Lorsque contents.swf est chargé dans le clip de container.swf, la valeur de userName associée
au scénario racine du fichier SWF hôte (container.swf ) prend la valeur "Mary" qui remplace
"Tim". Ceci peut entraîner le mauvais fonctionnement du code dans container.swf (ainsi que
dans contents.swf ).
Pour obliger _root à évaluer systématiquement le scénario du fichier SWF chargé, et non le
scénario racine réel, utilisez la propriété _lockroot. Cette propriété peut être définie par le
fichier SWF en cours de chargement ou par le fichier SWF chargé. Lorsque _lockroot est
défini sur true pour une occurrence de clip, le clip agira comme _root pour tout fichier SWF
qui y sera chargé. Lorsque _lockroot est défini sur true au sein d’un fichier SWF, le fichier
SWF en question agira comme sa propre racine, quel que soit l’autre fichier SWF effectuant le
chargement. N’importe quel clip, et n’importe quel nombre de clips, peut définir _lockroot
sur true. Cette propriété est false par défaut.
386
Utilisation des clips
Par exemple, le créateur de container.swf peut entrer le code suivant sur l’image 1 du scénario
principal :
// Ajouté à l’image 1 dans container.swf :
target_mc._lockroot = true;
Cette étape permet de s’assurer que toute référence à _root dans contents.swf, ou tout autre
fichier SWF chargé dans target_mc, se rapporte à son propre scénario et non pas au scénario
racine de container.swf. Désormais, "Tim" s’affiche lorsque vous cliquez sur le bouton.
L’auteur de contents.swf peut également ajouter le code suivant à son scénario principal :
// Ajouté à l’image 1 dans contents.swf :
this._lockroot = true;
Ceci garantit que, quel que soit l’endroit où contents.swf est chargé, toute référence à _root
fera référence à son propre scénario principal et non à celui du fichier SWF hôte.
Pour plus d’informations, consultez _lockroot (MovieClip._lockroot property).
Chargement de fichiers image dans des clips
Vous pouvez utiliser la fonction loadMovie() ou la méthode MovieClip sur un même nom
pour charger des fichiers image dans une occurrence de clip. Vous pouvez également utiliser la
fonction loadMovieNum() pour charger un fichier image dans un niveau.
Lorsque vous chargez une image dans un clip, son coin supérieur gauche est placé au niveau
du point de réglage du clip. Ce point se trouvant souvent au centre du clip, il se peut que
l’image chargée ne soit pas centrée. De même, lorsque vous chargez une image dans un
scénario principal, son coin supérieur gauche est placé dans le coin supérieur gauche de la
scène. L’image chargée hérite des paramètres de rotation et de l’échelle du clip, mais le
contenu initial du clip est supprimé.
Pour plus d’informations, consultez loadMovie function ,
loadMovie(MovieClip;.loadMovie method) et loadMovieNum functiondans le Guide de
référence du langage ActionScript 2.0 et Chargement de fichiers SWF et de fichiers d’images
externes, page 647.
Chargement et déchargement des fichiers SWF
387
Modification de la position et de
l’apparence d’un clip
Pour modifier les propriétés d’un clip pendant sa lecture, vous pouvez rédiger une instruction
affectant une valeur à une propriété ou utiliser la fonction setProperty(). Par exemple, le
code suivant fixe la rotation de l’occurrence my_mc à 45 :
my_mc._rotation = 45;
Cela équivaut au code suivant, qui utilise la fonction setProperty() :
setProperty("my_mc", _rotation, 45);
Certaines propriétés, appelées propriétés en lecture seule, ont des valeurs que vous pouvez lire
mais pas définir. (Ces propriétés sont identifiées comme telles dans le Guide de référence du
langage ActionScript 2.0). Les propriétés suivantes sont en lecture seule : _currentframe,
_droptarget, _framesloaded, _parent, _target, _totalframes, _url, _xmouse et
_ymouse.
Vous pouvez rédiger des instructions pour définir des propriétés qui ne sont pas en lecture
seule. L’instruction suivante définit la propriété _alpha de l’occurrence de clip wheel_mc, qui
est un enfant de l’occurrence car_mc :
car_mc.wheel_mc._alpha = 50;
En outre, vous pouvez rédiger des instructions qui récupèrent la valeur d’une propriété de clip.
Par exemple, l’instruction suivante récupère la valeur de la propriété _xmouse dans le
scénario du niveau actuel et définit la propriété _x de l’occurrence my_mcà cette valeur :
this.onEnterFrame = function() {
my_mc._x = _root._xmouse;
};
Cela équivaut au code suivant, qui utilise la fonction getProperty():
this.onEnterFrame = function() {
my_mc._x = getProperty(_root, _xmouse);
};
Les propriétés _x, _y, _rotation, _xscale, _yscale, _height, _width, _alpha et _visible
sont affectées par les transformations effectuées sur le parent du clip et transforment le clip et
tous ses enfants. Les propriétés _focusrect, _highquality, _quality et _soundbuftime
sont globales; elles appartiennent uniquement au scénario principal de niveau 0. Toutes les
autres propriétés appartiennent à chaque clip ou niveau chargé.
Pour consulter la liste des propriétés de clip, consultez le récapitulatif de propriété pour la
classe MovieClip dans la section Guide de référence du langage ActionScript 2.0.
388
Utilisation des clips
Pour avoir un aperçu d’animation scriptée dans Flash, vous pouvez consulter l’exemple de
fichier source, animation.fla, dans le dossier Samples de votre disque dur.
■
Sous Windows, ouvrez le répertoire lecteur d’initialisation\Program
Files\Macromedia\Flash 8\Samples and Tutorials\Samples\ActionScript\Animation.
■
Sur Macintosh, ouvrez le dossier Disque dur MacintoshApplications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Animation.
Vous trouverez des exemples d’applications de galeries photos sur votre disque dur. Ces
fichiers vous montrent comment utiliser ActionScript pour contrôler dynamiquement des
clips tout en chargeant des fichiers image dans un fichier SWF, avec des animations scriptées.
Vous trouverez des exemples de fichiers sources, gallery_tree.fla et gallery_tween.fla, dans le
dossier Samples de votre disque dur.
■
Sous Windows, ouvrez le répertoire lecteur d’initialisation\Program
Files\Macromedia\Flash 8\Samples and Tutorials\Samples\ActionScript\Galleries.
■
Sur Macintosh, accédez à disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Galleries.
Déplacement des clips
Vous pouvez utiliser la fonction globale startDrag() ou la méthode
MovieClip.startDrag() pour rendre un clip déplaçable. Par exemple, vous pouvez créer un
clip pouvant être déplacé pour les jeux, les fonctions glisser-déposer, les interfaces
personnalisables, les barres de défilement et les curseurs de défilement.
Un clip reste déplaçable jusqu’à son arrêt explicite par stopDrag() ou jusqu’à ce qu’un autre
clip soit ciblé avec startDrag(). Vous ne pouvez déplacer qu’un seul clip à la fois dans un
fichier SWF.
Déplacement des clips
389
Pour créer des comportements plus complexes avec les opérations glisser-déposer, vous pouvez
évaluer la propriété _droptarget du clip en cours de déplacement. Par exemple, vous pouvez
examiner la propriété _droptarget pour voir si le clip a été déplacé vers un clip spécifique (tel
qu’un clip « poubelle »), puis déclencher une autre action, comme dans l’exemple suivant :
// Faire glisser un élément vers la corbeille
garbage_mc.onPress = function() {
this.startDrag(false);
};
// Lorsque cet élément arrive sur la corbeille, le rendre invisible
garbage_mc.onRelease = function() {
this.stopDrag();
// Convertit la notation à barre oblique en notation à point avec eval
if (eval(this._droptarget) == trashcan_mc) {
garbage_mc._visible = false;
}
};
Pour plus d’informations, consultez startDrag function ou
startDrag(MovieClip.startDrag method) dans le Guide de référence du langage ActionScript
2.0.
Vous trouverez un exemple d’application de galerie photo sur votre disque dur. Ce fichier
fournit un exemple d’utilisation d’ActionScript pour contrôler dynamiquement des clips tout
en chargeant des fichiers images dans un fichier SWF, qui inclue la méthode de déplacement
de chacun des clips. Vous trouverez le fichier source d’exemple gallery_tween.fla dans le
dossier Samples sur votre disque dur.
■
Sous Windows, ouvrez le répertoire lecteur d’initialisation\Program
Files\Macromedia\Flash 8\Samples and Tutorials\Samples\ActionScript\Galleries.
■
Sur Macintosh, accédez à disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Galleries.
390
Utilisation des clips
Création de clips à l’exécution
En plus de créer des occurrences de clip dans l’environnement de programmation Flash, vous
pouvez également créer des occurrences de clip lors de l’exécution de l’une des façons
suivantes :
■
Création d’un clip vide, page 392
■
Duplication ou suppression d’un clip, page 393
■
Attacher un symbole de clip à la scène, page 394
Chaque occurrence de clip créée à l’exécution doit avoir un nom d’occurrence et une valeur de
profondeur (ordre d’empilement ou ordre z). La profondeur que vous spécifiez détermine la
façon dont le nouveau clip recouvre les autres clips sur le même scénario. Elle permet
également d’écraser les clips qui résident à la même profondeur. (Consultez la section Gestion
des profondeurs de clip, page 397.)
Vous trouverez un exemple d’application de galerie photo sur votre disque dur. Ce fichier
fournit un exemple d’utilisation d’ActionScript pour contrôler dynamiquement des clips tout
en chargeant des fichiers images dans un fichier SWF, qui inclue la création de clips lors de
l’exécution. Vous trouverez le fichier source d’exemple gallery_tween.fla dans le dossier
Samples sur votre disque dur.
■
Sous Windows, ouvrez le répertoire lecteur d’initialisation\Program
Files\Macromedia\Flash 8\Samples and Tutorials\Samples\ActionScript\Galleries.
■
Sur Macintosh, accédez à disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Galleries.
Pour obtenir un exemple de fichier source qui crée et retire plusieurs clips lors de l’exécution,
vous trouverez un exemple de fichier source animation.fla dans le répertoire Samples sur votre
disque dur.
■
Sous Windows, ouvrez le répertoire lecteur d’initialisation\Program
Files\Macromedia\Flash 8\Samples and Tutorials\Samples\ActionScript\Animation.
■
Sur Macintosh, ouvrez le dossier Disque dur MacintoshApplications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Animation.
Pour plus d’informations, se reporter aux sections suivantes :
■
Création d’un clip vide, page 392
■
Duplication ou suppression d’un clip, page 393
■
Attacher un symbole de clip à la scène, page 394
Création de clips à l’exécution
391
Création d’un clip vide
Pour créer une occurrence de clip vide sur la scène, utilisez la méthode
createEmptyMovieClip() de la classe MovieClip. Cette méthode crée un clip en tant
qu’enfant du clip qui l’a appelée. Le point d’enregistrement d’un clip vide nouvellement créé
se situe dans le coin supérieur gauche.
Par exemple, le code suivant permet de créer un nouveau clip enfant nommé new_mc à une
profondeur de 10 dans le clip nommé parent_mc :
parent_mc.createEmptyMovieClip("new_mc", 10);
Le code suivant permet de créer un nouveau clip nommé canvas_mc sur le scénario racine du
fichier SWF dans lequel le script est exécuté, puis d’activer loadMovie() pour y charger un
fichier JPEG externe
this.createEmptyMovieClip("canvas_mc", 10);
canvas_mc.loadMovie("http://www.helpexamples.com/flash/images/image1.jpg");
Comme le montre l’exemple suivant, vous pouvez charger l’image image2.jpg dans un clip et
utiliser la méthode MovieClip.onPress() pour que l’image se comporte comme un bouton.
Le chargement d’une image avec loadMovie() remplace le clip par l’image, mais ne permet
pas d’accéder aux méthodes du clip. Pour accéder aux méthodes du clip, vous devez créer un
clip parent vide et un clip conteneur enfant. Chargez l’image dans ce conteneur et placez le
gestionnaire d’événement dans le clip parent.
// Crée un clip parent pour stocker le conteneur.
this.createEmptyMovieClip("my_mc", 0);
// Crée un clip enfant dans "my_mc".
// Clip devant être remplacé par l’image.
my_mc.createEmptyMovieClip("container_mc",99);
// Utiliser MovieClipLoader pour charger l’image.
var my_mcl:MovieClipLoader = new MovieClipLoader();
my_mcl.loadClip("http://www.helpexamples.com/flash/images/image2.jpg",
my_mc.container_mc);
// Placer le gestionnaire d’événement sur le clip parent my_mc.
my_mc.onPress = function():Void {
trace("It works");
};
Pour plus d’informations, consultez lcreateEmptyMovieClip
(MovieClip.createEmptyMovieClip method) dans le Guide de référence du langage
ActionScript 2.0.
392
Utilisation des clips
Pour obtenir un exemple de fichier source qui crée et retire plusieurs clips lors de l’exécution,
vous trouverez un exemple de fichier source animation.fla dans le répertoire Samples sur votre
disque dur.
■
Sous Windows, ouvrez le répertoire lecteur d’initialisation\Program
Files\Macromedia\Flash 8\Samples and Tutorials\Samples\ActionScript\Animation.
■
Sur Macintosh, ouvrez le dossier Disque dur MacintoshApplications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Animation.
Duplication ou suppression d’un clip
Pour dupliquer ou supprimer des occurrences de clip, utilisez les fonctions globales
duplicateMovieClip() ou removeMovieClip(), ou encore les méthodes de la classe
MovieClip du même nom. La méthode duplicateMovieClip() crée une nouvelle
occurrence d’une occurrence de clip existante, lui affecte un nouveau nom d’occurrence et lui
donne une profondeur, ou ordre z. Un clip dupliqué commence toujours à l’image 1 même si
le clip initial se trouvait dans une autre image lors de la duplication, et il se situe toujours
devant tous les clips prédéfinis placés dans le scénario.
Pour supprimer un clip que vous avez créé avec duplicateMovieClip(), utilisez
removeMovieClip(). Un clip dupliqué est également supprimé si le clip parent est supprimé.
Pour plus d’informations, consultez duplicateMovieClip function et removeMovieClip
function dans le Guide de référence du langage ActionScript 2.0.
Pour obtenir un exemple de fichier source qui crée et retire plusieurs clips lors de l’exécution,
vous trouverez un exemple de fichier source animation.fla dans le répertoire Samples sur votre
disque dur.
■
Sous Windows, ouvrez le répertoire lecteur d’initialisation\Program
Files\Macromedia\Flash 8\Samples and Tutorials\Samples\ActionScript\Animation.
■
Sur Macintosh, ouvrez le dossier Disque dur MacintoshApplications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Animation.
Création de clips à l’exécution
393
Attacher un symbole de clip à la scène
La dernière manière de créer des occurrences de clip à l’exécution est d’utiliser la méthode
attachMovie(). La méthode attachMovie() associe à la scène une occurrence de symbole
de clip incluse dans la bibliothèque du fichier SWF. Le nouveau clip devient un clip enfant du
clip l’ayant associé.
Pour associer un symbole de clip à partir de la bibliothèque avec du code ActionScript, vous
devez exporter le symbole pour ActionScript et lui affecter un identifiant de liaison unique.
Pour ce faire, utilisez la boîte de dialogue Propriétés de liaison.
Par défaut, tous les clips exportés pour être utilisés avec ActionScript sont chargés avant la
première image du fichier SWF les contenant. Ce chargement peut entraîner un retard avant
la lecture de la première image. Lorsque vous affectez un identifiant de liaison à un élément,
vous pouvez également spécifier si cet élément doit être ajouté avant la première image. S’il
n’est pas ajouté à la première image, vous devez en inclure une occurrence sur une autre image
du fichier SWF; sinon, l’élément ne sera pas exporté dans le fichier SWF.
Pour affecter un identifiant de liaison à un clip :
1.
Choisissez Fenêtre > Bibliothèque pour ouvrir le panneau Bibliothèque.
2.
Sélectionnez un clip dans le panneau Bibliothèque.
3.
Dans le panneau Bibliothèque, choisissez Liaison dans le menu déroulant.
La boîte de dialogue Propriétés de liaison apparaît.
4.
Pour Liaison, activez l’option Exporter pour ActionScript.
5.
Pour Identifiant, entrez l’identifiant du clip.
Par défaut, l’identifiant est identique au nom du symbole.
Vous pouvez également affecter une classe ActionScript au symbole de clip. Ceci permet
au clip d’hériter des méthodes et des propriétés de la classe spécifiée. (Se reporter à la
section Affectation d’une classe à un symbole de clip, page 412.)
6.
Si vous ne souhaitez pas que le clip soit chargé avant la première image, désactivez l’option
Exporter dans la première image.
Si vous désactivez cette option, placez une occurrence du clip sur l’image du scénario où
vous souhaitez qu’elle soit disponible. Par exemple, si le script que vous écrivez ne fait pas
référence au clip avant l’image 10, placez une occurrence du symbole au niveau de l’image
10 ou juste avant celle-ci dans le scénario.
7.
Cliquez sur OK.
Une fois que vous avez affecté un identifiant de liaison à un clip, vous pouvez associer une
occurrence du symbole à la scène lors de l’exécution à l’aide de la méthode attachMovie().
394
Utilisation des clips
Pour associer un clip à un autre clip :
1.
Affectez un identifiant de liaison à un symbole de bibliothèque de clip comme décrit dans
l’exemple précédent.
2.
Le panneau Actions étant ouvert (Fenêtre > Actions), sélectionnez une image dans
le scénario.
3.
Dans la fenêtre de script du panneau Actions, tapez le nom du clip ou du niveau auquel
vous souhaitez associer le nouveau clip.
Par exemple, pour associer le clip au scénario racine, tapez ceci.
4.
Dans la boîte à outils Actions (à gauche du panneau Actions), cliquez sur les méthodes
ActionScript 2.0 Classes > Movie > MovieClip > et sélectionnez attachMovie().
5.
A l’aide des conseils de code, entrez les valeurs des paramètres suivants :
■
■
■
Pour idName, spécifiez l’identifiant que vous avez saisi dans la boîte de dialogue
Propriétés de liaison.
Pour newName, entrez un nom d’occurrence pour le clip associé afin de pouvoir le
cibler.
Pour depth, entrez le niveau dans lequel l’animation dupliquée sera associée au clip.
Chaque animation associée suit un ordre d’empilement qui lui est propre, le niveau 0
étant le niveau de l’animation d’origine. Les clips associés sont toujours au-dessus du
clip d’origine, comme indiqué dans l’exemple suivant :
this.attachMovie("calif_id", "california_mc", 10);
Pour plus d’informations, consultez attachMovie (MovieClip.attachMovie method) dans
le Guide de référence du langage ActionScript 2.0.
Ajout de paramètres aux clips créés
dynamiquement
Lorsque vous créez ou dupliquez dynamiquement un clip à l’aide de
MovieClip.attachMovie() et MovieClip.duplicateMovie(), vous pouvez remplir le clip
avec des paramètres provenant d’un autre objet. Le paramètre objetInit de attachMovie()
et duplicateMovie() permet aux clips créés dynamiquement de recevoir des paramètres de
clip.
Pour plus d’informations, consultez attachMovie (MovieClip.attachMovie method) et
duplicaterMovieClip(MovieClip.duplicateMovieClip method)dans le Guide de
référence du langage ActionScript 2.0.
Ajout de paramètres aux clips créés dynamiquement
395
Pour remplir un clip créé de façon dynamique avec des paramètres provenant
d’un objet spécifié :
Effectuez l’une des opérations suivantes :
■
Utilisez la syntaxe suivante avec attachMovie() :
myMovieClip.attachMovie(idName, newName, depth [, initObject]);
■
Utilisez la syntaxe suivante avec duplicateMovie():
myMovieClip.duplicateMovie(idName, newName, depth [, initObject]);
Le paramètre objetInit spécifie le nom de l’objet dont vous souhaitez utiliser les paramètres
pour remplir le clip créé dynamiquement.
Pour remplir un clip avec des paramètres en utilisant attachMovie() :
1.
Dans un nouveau document Flash, créez un symbole de clip en choisissant Insertion >
Nouveau symbole.
2.
Tapez dynamic_mc dans la zone de texte Nom du symbole et sélectionnez le
comportement de clip.
3.
A l’intérieur du symbole, créez une zone de texte dynamique sur la scène avec nom_txt
comme nom d’occurrence .
Assurez-vous que ce champ texte est en dessous et à droite du point d’alignement.
4.
Sélectionnez la première image du scénario du clip et ouvrez le panneau Actions (Fenêtre
> Actions).
5.
Créez une nouvelle variable nommée nom_str et affectez sa valeur à la propriété du texte
de nom_txt, comme dans l’exemple suivant :
var name_str:String;
name_txt.text = name_str;
6.
Choisissez Edition > Modifier le document pour revenir au scénario principal.
7.
Sélectionnez le symbole de clip dans la bibliothèque et choisissez Liaison dans le menu
déroulant Bibliothèque.
La boîte de dialogue Propriétés de liaison apparaît.
8.
Choisissez l’option Exporter pour ActionScript , puis Exporter dans la première image.
9.
Entrez dynamic_iddans la zone de texte de l’identifiant, puis cliquez sur OK.
10. Sélectionnez
la première image du scénario principal et ajoutez le code suivant dans la
fenêtre de script du panneau Actions :
/* Joint un nouveau clip et le déplace aux coordonnées x et y de 50 */
this.attachMovie("dynamic_id", "newClip_mc", 99, {name_str:"Erick",
_x:50, _y:50});
396
Utilisation des clips
11.
Testez le document Flash (Contrôle > Tester animation).
Le nom que vous avez spécifié dans l’appel attachMovie() apparaît dans le champ de
texte du nouveau clip.
Vous trouverez un exemple d’application de galerie photo sur votre disque dur. Ce fichier
fournit un exemple d’utilisation d’ActionScript pour contrôler dynamiquement des clips tout
en chargeant des fichiers images dans un fichier SWF, qui inclue la création de clips lors de
l’exécution. Vous trouverez le fichier source d’exemple gallery_tween.fla dans le dossier
Samples sur votre disque dur.
■
Sous Windows, ouvrez le répertoire lecteur d’initialisation\Program
Files\Macromedia\Flash 8\Samples and Tutorials\Samples\ActionScript\Galleries.
■
Sur Macintosh, accédez à disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Galleries.
Pour obtenir un exemple de fichier source qui crée et retire plusieurs clips lors de l’exécution,
vous trouverez un exemple de fichier source animation.fla dans le répertoire Samples sur votre
disque dur.
■
Sous Windows, ouvrez le répertoire lecteur d’initialisation\Program
Files\Macromedia\Flash 8\Samples and Tutorials\Samples\ActionScript\Animation.
■
Sur Macintosh, ouvrez le dossier Disque dur MacintoshApplications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Animation.
Gestion des profondeurs de clip
Chaque clip possède son propre ordre z qui détermine la façon dont les objets se chevauchent
à l’intérieur du fichier SWF parent ou du clip. Chaque clip est associé à une valeur de
profondeur qui détermine s’il sera rendu devant ou derrière les autres clips dans le même
scénario de clip. Lorsque vous créez un clip lors de l’exécution à l’aide de attachMovie
(MovieClip.attachMovie methode)), duplicateMovieClip
(MovieClip.duplicateMovie method) ou createEmptyMovieClip
(MovieClip.createEmptyMovieClip method), vous pouvez toujours spécifier une
profondeur pour le nouveau clip en tant que paramètre de méthode. Par exemple, le code
suivant associe un nouveau clip au scénario d’un clip nommé conteneur_mc avec une valeur
de profondeur de10.
container_mc.attachMovie("symbolID", "clip1_mc", 10);
Cet exemple crée un nouveau clip avec une profondeur de 10 dans l’espace d’ordre z de
container_mc.
Gestion des profondeurs de clip
397
Le code suivant associe deux nouveaux clips à container_mc. Le premier clip, nommé
clip1_mc, sera rendu derrière clip2_mc, car une valeur de profondeur inférieure lui a été
attribuée.
container_mc.attachMovie("symbolID", "clip1_mc", 10);
container_mc.attachMovie("symbolID", "clip2_mc", 15);
Les valeurs de profondeur pour les clips peuvent aller de -16384 à 1048575. Si vous créez ou
associez un nouveau clip à une profondeur déjà associée à un autre clip, le nouveau clip ou clip
associé remplace le contenu existant. Pour éviter ce problème, utilisez la méthode
MovieClip.getNextHighestDepth(); toutefois, n’employez pas cette méthode avec des
composants qui utilisent un système différent de gestion de profondeur. Utilisez plutôt Classe
DepthManager avec des occurrences de composant.
La classe MovieClip offre plusieurs méthodes de gestion de la profondeur des clips. Pour plus
d’informations, consultez les sections getNextHighestDepth
(MovieClip.getNextHighestDepth method), getInstanceAtDepth
(MovieClip.getInstanceAtDepth method), getDepth (MovieClip.getDepth method)
et swapDepths (MovieClip.swapDepths method) dans leGude de référence du langage
ActionScript 2.0.
Pour plus d’informations sur les profondeurs de clip, consultez les sections suivantes :
■
Définition de la profondeur maximale disponible suivante, page 398
■
Définition de l’occurrence à une profondeur spécifique, page 399
■
Définition de la profondeur d’une occurrence, page 399
■
Permutation de profondeurs de clips, page 400
Définition de la profondeur maximale disponible
suivante
Pour déterminer quelle est la profondeur maximale disponible suivante dans un clip, utilisez
MovieClip.getNextHighestDepth(). La valeur entière renvoyée par cette méthode indique
la prochaine profondeur disponible qui sera rendue devant tous les autres objets dans le clip.
Le code suivant associe un nouveau clip, avec une valeur de profondeur de 10, sur le scénario
racine nommé file_mc. Il détermine ensuite la prochaine profondeur maximale disponible
dans le même clip, puis crée un nouveau clip, edit_mc, à cette profondeur.
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
398
Utilisation des clips
Dans ce cas, la variable nommée nextDepth contient la valeur 11 puisqu’il s’agit de la
prochaine profondeur maximale disponible pour le clip edit_mc.
N’utilisez pas MovieClip.getNextHighestDepth() avec des composants; préférez-lui le
gestionnaire de profondeur. Pour plus d’informations, consultez la section Classe
DepthManager dans Référence du langage des composants. Pour plus d’informations sur
MovieClip.getNextHighestDepth(), consultez la rubrique getNextHighestDepth
(MovieClip.getNextHighestDepth method)..
Pour obtenir la profondeur maximale actuellement occupée, soustrayez 1 à la valeur renvoyée
par getNextHighestDepth(), comme illustré dans la section suivante.
Définition de l’occurrence à une profondeur
spécifique
Pour définir l’occurrence à une profondeur spécifique, utilisez
MovieClip.getInstanceAtDepth(). Cette méthode renvoie une référence à l’occurrence de
MovieClip se trouvant à la profondeur indiquée.
Le code suivant combine getNextHighestDepth() et getInstanceAtDepth() pour
déterminer le clip se trouvant à la plus grande profondeur (actuellement) occupée du scénario
racine.
var highestOccupiedDepth:Number = this.getNextHighestDepth() - 1;
var instanceAtHighestDepth:MovieClip =
this.getInstanceAtDepth(highestOccupiedDepth);
Pour plus d’informations, consultez getInstanceAtDepth
(MovieClip.getInstanceAtDepth method) dans le Guide de référence du langage
ActionScript 2.0.
Définition de la profondeur d’une occurrence
Pour déterminer la profondeur d’une occurrence de clip, utilisez MovieClip.getDepth().
Le code suivant itère sur tous les clips du scénario principal d’un fichier SWF et affiche le nom
d’occurrence et la valeur de profondeur de chaque clip dans le panneau de sortie :
for (var item:String in _root) {
var obj:Object = _root[item];
if (obj instanceof MovieClip) {
var objDepth:Number = obj.getDepth();
trace(obj._name + ":" + objDepth)
}
}
Gestion des profondeurs de clip
399
Pour plus d’informations, consultez getDepth (MovieClip.getDepth method) dans le
Guide de référence du langage ActionScript 2.0.
Permutation de profondeurs de clips
Pour permuter les profondeurs de deux clips sur un même scénario, utilisez
MovieClip.swapDepths(). Les exemples suivants montrent comment deux occurrences de
clips peuvent permuter leurs profondeurs en cours d’exécution.
Pour permuter des profondeurs de clips :
1.
Créez un nouveau document Flash appelé swap.fla.
2.
Dessinez un cercle bleu sur la scène.
3.
Sélectionnez le cercle bleu, puis Modifier > Convertir en symbole.
4.
Sélectionnez l’option clip et cliquez sur "OK".
5.
Sélectionnez l’occurrence sur la scène, puis tapez first_mc dans la zone de texte Nom de
l’occurrence dans l’inspecteur de propriétés.
6.
Dessinez un cercle rouge sur la scène, puis choisissez Modifier > Convertir en symbole.
7.
Sélectionnez l’option clip et cliquez sur "OK".
8.
Sélectionnez l’occurrence sur la scène, puis tapez second_mc dans la zone de texte Nom de
l’occurrence dans l’inspecteur de propriétés.
9.
Faites glisser les deux occurrences de manière à ce qu’elles chevauchent légèrement la scène.
10. Sélectionnez
la première image du scénario, puis ajoutez le code suivant au panneau
Actions :
first_mc.onRelease = function() {
this.swapDepths(second_mc);
};
second_mc.onRelease = function() {
this.swapDepths(first_mc);
};
11.
Sélectionnez Contrôle > Tester l’animation pour tester le document.
Lorsque vous sélectionnez les occurrences sur la scène, elles permutent leurs profondeurs.
Vous verrez que les deux occurrences changent la position des clips l’un au-dessus de
l’autre.
Pour plus d’informations, consultez swapDepths (MovieClip.swapDepths method) dans le
Guide de référence du langage ActionScript 2.0.
400
Utilisation des clips
Mise en cache et parcours de clips à
l’aide d’ActionScript
Que vous créiez une application ou des animations scriptées complexes, vous devez considérer
la performance et l’optimisation, à mesure que la taille de vos conceptions Flash augmente.
Lorsque votre contenu demeure statique (par exemple un clip rectangle), Flash ne l’optimise
pas. Toutefois, lorsque vous modifiez la position du clip rectangle, Flash redessine la totalité
du rectangle dans Flash Player 7 et les versions antérieures.
Dans Flash Player 8, vous pouvez mettre certains clips et boutons en cache pour améliorer les
performances de votre fichier SWF. Le clip ou bouton est une surface, c’est-à-dire la version
bitmap des données vectorielles de l’occurrence, données non destinées à être énormément
modifiées tout au long de la vie de votre fichier SWF. Ainsi, les occurrences pour lesquelles la
mise en cache est activée ne sont pas continuellement redessinées pendant la lecture du fichier
SWF, et le rendu de ce dernier est rapide.
REMARQUE
Vous pouvez mettre à jour les données vectorielles au moment de la recréation de la
surface. Ainsi, les données vectorielles mises en cache dans la surface ne doivent pas
nécessairement être les mêmes pour l’ensemble du fichier SWF.
Vous pouvez utiliser ActionScript pour activer la mise en cache, le parcours et le contrôle des
arrière-plans. Vous pouvez activer la mise en cache pour une occurrence de clip dans
l’inspecteur des propriétés. Pour mettre en cache des clips ou des boutons sans l’aide
d’ActionScript, vous pouvez en revanche sélectionner l’option d’utilisation de la mise en cache
bitmap en cours d’exécution dans l’inspecteur de propriétés.
Mise en cache et parcours de clips à l’aide d’ActionScript
401
Le tableau suivant contient une brève description des nouvelles propriétés d’occurrences de
clips :
Propriété
Description
cacheAsBitmap
L’occurrence de clip met en cache une représentation bitmap d’ellemême. Flash crée un objet de surface pour l’occurrence,
correspondant à une image bitmap mise en cache et non à des
données vectorielles. Si vous modifiez les limites du clip, la surface est
recréée et non redimensionnée. Pour plus d’informations et un
exemple, consultez la section Mise en cache d’un clip, page 406.
opaqueBackground L’occurrence de clip est opaque et vous pouvez définir la couleur
d’arrière-plan. Si vous définissez cette propriété sur une valeur
numérique, la surface de l’occurrence de clip est opaque (non
transparente). Une image bitmap opaque n’a pas de canal alpha
(transparence) et son rendu est plus rapide. Pour plus d’informations et
un exemple, consultez la section Réglage de l’arrière-plan d’un clip,
page 408.
scrollRect
Cette propriété permet de parcourir rapidement le contenu du clip et
d’ouvrir une fenêtre capable d’afficher davantage de contenu. Le
contenu du clip est recadré et l’occurrence défile avec une largeur, une
longueur et des décalages de défilement spécifiés. L’utilisateur peut
ainsi parcourir rapidement le contenu du clip et ouvrir une fenêtre plus
grande que la scène. Les champs de texte et le contenu complexe
affichés dans l’occurrence peuvent défiler plus rapidement car Flash ne
regénère pas l’ensemble des données vectorielle du clip. Pour plus
d’informations et un exemple, consultez la section scrollRect
(MovieClip.scrollRect property).
Ces trois propriétés sont indépendantes les unes des autres, toutefois les propriétés
opaqueBackground et scrollRect fonctionnent mieux quand un objet est caché en tant que
bitmap. Vous ne constaterez les bénéfices en performance pour les propriétés
opaqueBackground et scrollRect que lorsque vous réglerez cacheAsBitmap sur true.
Pour créer une surface qui puisse défiler, vous devez définir les propriétés cacheAsBitmap et
scrollRect pour l’occurrence de clip. Les surfaces peuvent s’imbriquer dans d’autres surfaces.
La surface copiera l’image bitmap sur sa surface parent.
402
Utilisation des clips
Pour des informations sur le masquage de canal alpha, qui exige que vous définissiez la
propriété du cacheAsBitmapsur true, consultez la section Masquage de canal alpha,
page 411.
REMARQUE
Vous ne pouvez pas appliquer la mise en cache directement aux champs de texte. Pour
profiter de cette fonctionnalité, vous devez placer le texte dans un clip. Pour obtenir un
exemple, consultez le fichier dans le Répertoire d’installation de Flash 8\Samples and
Tutorials\Samples\ActionScript\FlashType.
Vous trouverez un exemple de fichier source vous expliquant comment appliquer la mise en
cache bitmap à une occurrence. Ce fichier est dénommé cacheBitmap.fla et se trouve dans le
dossier Samples de votre disque dur.
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\CacheBitmap.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash
8/Samples and Tutorials/Samples/ActionScript/CacheBitmap.
Vous trouverez un exemple de fichier source vous expliquant comment appliquer la mise en
cache bitmap à un texte défilant. Ce fichier est dénommé flashtype.fla et se trouve dans le
dossier Samples de votre disque dur.
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\FlashType.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash
8/Samples and Tutorials/Samples/ActionScript/FlashType.
Quand activer la mise en cache
L’activation de la mise en cache pour un clip crée une surface dont les avantages sont
multiples, par exemple pour accélérer le rendu des animations vectorielles complexes. Lorsque
vous souhaitez activer la mise en cache, plusieurs scénarios sont disponibles. Il pourrait
sembler avantageux de toujours activer la mise en cache pour améliorer les performances de
votre fichier SWF. Cependant, dans certains cas, cette opération ne les améliore pas, voire
même les diminue. Cette section présente des scénarios où la mise en cache s’avère bénéfique
et d’autres où il est préférable d’utiliser des clips ordinaires.
Les performances générales des données mises en cache dépendront de la complexité des
données vectorielles de vos occurrences, de la quantité de modifications et de la définition, ou
non, de la propriété opaqueBackground. Si vous modifiez de petites zones, la différence entre
l’utilisation d’une surface et celle de données vectorielles sera négligeable. Vous pouvez dans ce
cas tester les deux scénarios avant de déployer votre application.
Mise en cache et parcours de clips à l’aide d’ActionScript
403
Pour des informations sur le masquage de canal alpha, qui exige que vous définissiez la
propriété du cacheAsBitmapsur true, consultez la section Masquage de canal alpha,
page 411.
Quand utiliser le cache bitmap
Ce qui suit est une série de scénarios dans lesquels vous pouvez voir les bénéfices significatifs
qui résultent de la mise en cache bitmap.
Image de fond complexe Une application qui contient une image de fond complexe de
données vectorielles (peut-être une image à laquelle vous avez appliqué la commande de
traçage de bitmap ou une création artistique créée dans Adobe Illustrator). Vous pouvez
animer les caractères sur l’arrière-plan, ce qui ralentit l’animation parce que l’arrière-plan a
besoin de continuellement régénérer les données vectorielles. Pour améliorer les
performances, vous pouvez sélectionner le contenu, le stocker dans un clip et définir la
propriété opaqueBackground sur true. L’arrière-plan est rendu en tant que bitmap et peut
être redessiné rapidement pour que l’animation se joue beaucoup plus vite.
Zone de texte déroulant Application qui affiche une grande quantité de texte dans une
zone de texte déroulant. Vous pouvez placer la zone de texte dans un clip que vous définissez
comme déroulant à l’aide de bornes de déroulement (propriété scrollRect). Ceci permet un
déroulement de pixels rapide pour l’occurrence donnée. Quand un utilisateur déroule
l’occurrence de clip, Flash fait défiler les pixels déroulés vers le haut et génère la zone
nouvellement exposée au lieu de régénérer toute la zone de texte.
Système de chevauchement de fenêtres
Application comportant un système complexe
de chevauchement de fenêtres. Chaque fenêtre peut être ouverte ou fermée (par exemple, les
fenêtres de navigateur Web). Si vous marquez chaque fenêtre en tant que surface (définissez la
propriété cacheAsBitmap sur true), chaque fenêtre sera isolée et cachée. Les utilisateurs
peuvent faire glisser les fenêtres de manière à ce qu’elles se chevauchent. Chaque fenêtre n’a
pas besoin de regénérer le contenu vectoriel.
Tous ces scénarios améliorent la réactivité et l’interactivité de l’application en optimisant les
graphiques vectoriels.
Vous trouverez un exemple de fichier source vous expliquant comment appliquer la mise en
cache bitmap à une occurrence. Ce fichier est dénommé cacheBitmap.fla et se trouve dans le
dossier Samples de votre disque dur.
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\CacheBitmap.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash
8/Samples and Tutorials/Samples/ActionScript/CacheBitmap.
404
Utilisation des clips
Vous trouverez un exemple de fichier source vous expliquant comment appliquer la mise en
cache bitmap à un texte défilant. Ce fichier est dénommé flashtype.fla et se trouve dans le
dossier Samples de votre disque dur.
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\FlashType.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash
8/Samples and Tutorials/Samples/ActionScript/FlashType.
Quand éviter d’utiliser la mise en cache bitmap
Un mauvais usage de cette fonctionnalité peut avoir un effet négatif sur votre fichier SWF.
Lorsque vous créez un fichier FLA qui utilise des surfaces, gardez à l’esprit les points suivants :
■
N’abusez pas des surfaces (clips avec mise en cache activée). Chaque surface utilise plus de
mémoire qu’un clip courant, ce qui signifie que vous ne devez activer les surfaces que
quand vous devez améliorer les performances de rendu.
Un bitmap caché utilise beaucoup plus de mémoire qu’une occurrence de clip courant.
Par exemple, si le clip sur la scène a une taille de 250 pixels sur 250 pixels, il peut occuper
250 KO s’il est caché, contre 1 KO s’il est courant (non caché).
■
Évitez de zoomer dans les surfaces cachées. Si vous abusez de la mise en cache bitmap, une
grande quantité de mémoire sera occupée (voir la puce précédente), surtout si vous
zoomer sur le contenu.
■
Utilisez des surfaces pour les occurrences de clip qui sont grandement statiques (nonanimées). Vous pouvez faire glisser ou déplacer l’occurrence, mais son contenu ne doit pas
être animé ni subir de nombreuses modifications. Par exemple, si vous faites pivoter ou si
vous transformez une occurrence, celle-ci change entre la surface et les données
vectorielles, ce qui rend le traitement difficile et endommage votre fichier SWF.
■
Si vous mélangez des surfaces avec des données vectorielles, cela augmente la quantité de
traitement que Flash Player (et parfois l’ordinateur) doit accomplir. Rassembler les
surfaces autant que possible; par exemple, quand vous créez des applications de fenêtrage.
Mise en cache et parcours de clips à l’aide d’ActionScript
405
Mise en cache d’un clip
Pour cacher une occurrence de clip, il faut définir la propriété cacheAsBitmap sur true.
Après avoir défini la propriété cacheAsBitmap sur true, vous remarquerez que l’occurrence
de clip accroche les pixels sur toutes les coordonnées. Lorsque vous testez le fichier SWF, vous
devriez remarquer que le rendu des animations vectorielles complexes est bien plus rapide.
Une surface (bitmap caché) n’est pas créée même quand cacheAsBitmap est défini sur true,
si l’un ou l’autre des événements suivants survient :
■
Le bitmap fait plus de 2 880 pixels en hauteur ou en largeur.
■
Le bitmap ne peut être alloué en mémoire (erreur de manque de mémoire).
Mise en cache d’un clip
1.
Créez un nouveau document Flash, puis nommez le fichier cachebitmap.fla.
2.
Tapez 24 dans la boîte de texte fps dans l’inspecteur de propriétés (Fenêtre > Propriétés >
Propriétés).
3.
Créez ou importez un graphique vectoriel complexe dans le fichier FLA.
Vous pouvez obtenir un graphique vectoriel complexe dans le fichier source fini pour cet
exemple dans le répertoire suivant :
■
■
Sous Windows, ouvrez le répertoire lecteur d’initialisation\Program
Files\Macromedia\Flash 8\Samples and Tutorials\Samples\ActionScript\CacheBitmap.
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia
Flash 8/Samples and Tutorials/Samples/ActionScript/CacheBitmap.
4.
Sélectionnez le graphique vectoriel, puis Modifier > Concertir en symbole.
5.
Tapez star dans la boîte de texte Nom, puis cliquez sur Avancé (si la boîte de dialogue n’est
pas déjà élargie).
6.
Sélectionnez Exporter pour ActionScript (ce qui sélectionne également Exporter dans la
première image).
7.
Tapez star_id dans la boîte de texte de l’identifiant.
8.
Cliquez sur "OK" pour créer le symbole du clip, avec la liaison identifiante de Star.
406
Utilisation des clips
9.
Sélectionnez la première image du scénario, puis ajoutez l’ActionScript suivant au panneau
Actions :
import mx.transitions.Tween;
var my_xml:XML = new XML();
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(mouseListener);
10. Sélectionnez
11.
Contrôle > Tester l’animation pour tester le document.
Cliquez n’importe où sur la scène pour activer la mise en cache bitmap.
Vous remarquerez que l’animation apparaît puis s’anime à une image par seconde et passe
à une animation fluide où les occurrences s’animent de long en large à travers la scène.
Quand vous cliquez sur la scène, cela fait basculer les réglages cacheAsBitmap entre true
et false.
Si vous activez et désactivez la mémoire cache comme illustré dans l’exemple précédent, cela
libère les données cachées. Vous pouvez également appliquer ce code pour une occurrence de
bouton. Consultez cacheAsBitmap(Button.cacheAsBitmap property) dans le Guide de
référence du langage ActionScript 2.0.
Mise en cache et parcours de clips à l’aide d’ActionScript
407
Pour plus d’informations sur les clips déroulants, consultez
scrollRect(MovieClip.scrollRect property) dans le Guide de référence du langage
ActionScript 2.0. Pour des informations sur le masquage de canal alpha, qui demande que vous
définissiez la propriété cacheAsBitmap sur true, consultez la section Masquage de canal
alpha, page 411.
Vous trouverez un exemple de fichier source vous expliquant comment appliquer la mise en
cache bitmap à une occurrence. Ce fichier est dénommé cacheBitmap.fla et se trouve dans le
dossier Samples de votre disque dur.
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\CacheBitmap.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash
8/Samples and Tutorials/Samples/ActionScript/CacheBitmap.
Vous trouverez un exemple de fichier source vous expliquant comment appliquer la mise en
cache bitmap à un texte défilant. Ce fichier est dénommé flashtype.fla et se trouve dans le
dossier Samples de votre disque dur.
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\FlashType.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash
8/Samples and Tutorials/Samples/ActionScript/FlashType.
Réglage de l’arrière-plan d’un clip
Vous pouvez définir un arrière-plan opaque pour un clip. Par exemple, quand vous avez un
arrière-plan qui contient un art vectoriel complexe, vous pouvez définir la propriété
opaqueBackground sur une couleur donnée (en général la même couleur que la scène).
L’arrière-plan est alors considéré comme un bitmap, ce qui permet d’optimiser les
performances.
Quand vous définissez cacheAsBitmap sur true et la propriété opaqueBackground sur une
couleur donnée, la propriété d’arrière-plan opaque permet que le bitmap interne soit opaque
et rendu plus rapidement. Si vous ne définissez pas cacheAsBitmapsur true, la propriété
opaqueBackgroundajoute une forme carrée vectorielle opaque à l’arrière-plan de l’occurrence
de clip. Cela ne crée par un bitmap automatiquement.
L’exemple suivant décrit comment définir l’arrière-plan d’un clip pour optimiser les
performances.
408
Utilisation des clips
Pour définir l’arrière-plan d’un clip :
1.
Créez un nouveau document Flash et enregistrez-le sous le nom background.fla.
2.
Dessinez un cercle bleu sur la scène.
3.
Sélectionnez le cercle bleu, puis Modifier > Convertir en symbole.
4.
Sélectionnez l’option clip et cliquez sur "OK".
5.
Sélectionnez l’occurrence sur la scène, puis tapez my_mc dans la boîte de texte Nom de
l’occurence dans l’inspecteur de propriétés.
6.
Sélectionnez la première image du scénario, puis ajoutez le code suivant au panneau
Actions :
/* When you set cacheAsBitmap, the internal bitmap is opaque and renders
faster. */
my_mc.cacheAsBitmap = true;
my_mc.opaqueBackground = 0xFF0000;
7.
Sélectionnez Contrôle > Tester l’animation pour tester le document.
Le clip apparaît sur la scène avec la couleur de l’arrière-plan spécifiée.
Pour plus d’informations sur cette propriété, consultez
opaqueBackground(MovieClip.opaqueBackground property)
dans le Guide de référence
du langage ActionScript 2.0 .
Utilisation des clips en tant que masques
Vous pouvez utiliser un clip comme masque pour créer un trou qui laisse apparaître le
contenu d’un autre clip. Le clip masque joue toutes les images dans son scénario comme dans
un clip courant. Vous pouvez rendre le clip déplaçable, l’animer le long d’un guide de
mouvement, utiliser des formes distinctes dans un même masque, ou redimensionner un
masque de façon dynamique. Vous pouvez également utiliser ActionScript pour activer ou
désactiver un masque.
Il est impossible d’utiliser un masque pour en masquer un autre. Il est impossible de définir la
propriété _alpha d’un clip utilisé comme masque. Seuls les remplissages sont utilisés dans un
clip employé comme un masque ; les traits sont ignorés.
Utilisation des clips en tant que masques
409
Pour créer un masque :
1.
Créez un carré sur la scène à l’aide de l’outil Rectangle.
2.
Sélectionnez le carré et appuyez sur F8 pour le convertir en clip.
Cette occurrence est votre masque.
3.
Dans l’inspecteur de propriétés, tapez mask_mc dans la boîte de texte Nom de
l’occurrence.
Le clip masqué se joue sous toutes les zones opaques (non transparentes) du clip agissant
comme le masque.
4.
Sélectionnez l’image 1 dans le scénario.
5.
Ouvrez le panneau Actions (Fenêtre > Actions) si ce n’est pas déjà fait.
6.
Dans le panneau Actions, entrez le code suivant :
System.security.allowDomain("http://www.helpexamples.com");
this.createEmptyMovieClip("img_mc", 10);
var mclListener:Object = new Object();
mclListener.onLoadInit = function(target_mc:MovieClip):Void {
target_mc.setMask(mask_mc);
}
var my_mcl:MovieClipLoader = new MovieClipLoader();
my_mcl.addListener(mclListener);
my_mcl.loadClip("http://www.helpexamples.com/flash/images/image1.jpg",
img_mc);
7.
Sélectionnez Contrôle > Tester l’animation pour tester le document.
Une image JPEG externe se charge dans le fichier SWF en cours d’exécution et sera
masquée par la forme précédemment dessinée sur la scène.
Pour plus d’informations, consultez setMask (MovieClip.setMask method) dans le Guide de
référence du langage ActionScript 2.0.
Les polices de périphérique des masques
Vous pouvez utiliser un clip pour masquer le texte défini dans une police de périphérique.
Pour qu’un masque clip fonctionne correctement sur une police de périphérique, l’utilisateur
doit posséder Flash Player 6 (6.0.40.0) ou une version ultérieure.
Lorsque vous utilisez un clip pour masquer le texte défini dans une police de périphérique, le
cadre de délimitation rectangulaire du masque est utilisé comme forme de masque. Ainsi, si
vous créez un masque clip non rectangulaire pour un texte de police de périphérique dans
l’environnement autorisant Flash, le masque qui apparaît dans le fichier SWF est la forme de
la boîte de délimitation rectangulaire du masque, et non celle du masque en lui-même.
410
Utilisation des clips
Vous pouvez uniquement masquer des polices de périphérique en utilisant un clip comme
masque. Vous ne pouvez pas masquer des polices de périphérique en utilisant un calque de
masque sur la scène.
Masquage de canal alpha
Le masquage de canal alpha est pris en charge si le masque et les clips masques utilisent la mise
en cache bitmap. Cette prise en charge permet également d’utiliser un filtre sur le masque
indépendamment du filtre qui est appliqué sur le clip masque lui-même.
Pour obtenir un exemple de masquage alpha, téléchargez le fichier exemple de masquage alpha
depuis le site www.macromedia.com/go/flash_samples_fr.
Dans ce fichier exemple, le masque est oval (oval_mask) qui possède un alpha de 50% et un
filtre de flou lui est appliqué. Le clip masque (flower_maskee) possède un alpha de 100% et
aucun filtre ne lui est appliqué. Les deux clips possèdent une mise en cache bitmap en cours
appliquée dans l’inspecteur de propriétés.
Dans le panneau Actions, le code suivant est placé sur l’image 1 du scénario :
flower_maskee.setMask(oval_mask);
Quand vous testez le document (Contrôle > Tester l’animation), le clip masque est mêlé
d’alpha en raison de l’emploi du masque.
REMARQUE
Les couches de masques ne prennent pas en charge le masquage de canal alpha. Vous
devez utiliser le code ActionScript pour applicquer un masque et utiliser la mise en cache
bitmap pour le temps d’exécution.
Gestion des événements clip
Les clips peuvent répondre à des événements utilisateur, tels que des clics de souris ou des
pressions sur des touches, ainsi qu’à des événements de niveau système, tel que le chargement
initial d’un clip sur la scène. ActionScript fournit deux façons de gérer les événements de clip :
à travers les méthodes de gestion d’événements et les gestionnaires d’événements
onClipEvent() et on(). Pour plus d’informations sur la gestion d’événements clip, consultez
le Chapitre 10, Gestion d’événements.
Gestion des événements clip
411
Affectation d’une classe à un symbole de
clip
En utilisant ActionScript 2.0, vous pouvez créer une classe qui élargit le comportement de la
classe de clip incorporée, puis utiliser la boîte de dialogue des propriétés de liaison pour
affecter cette classe à un symbole de bibliothèque d’un clip. Lorsque vous créez une
occurrence du clip auquel la classe est affectée, elle assume les propriétés et comportements
définis par la classe qui lui est affectée. (Pour plus d’informations sur ActionScript 2.0,
consultez la section Exemple : Ecriture de classes personnalisées, page 285).
Dans une sous-classe de la classe MovieClip, vous pouvez fournir les définitions des méthodes
et gestionnaires d’événement intégrés MovieClip, tels que onEnterFrame et onRelease. Dans
la procédure suivante, vous créez une classe intitulée MoveRight qui étend la classe MovieClip
et définit un gestionnaire onPress qui déplace le clip de 20 pixels vers la droite chaque fois
que l’utilisateur clique sur le clip. Dans la seconde procédure, vous créerez un symbole de clip
dans un nouveau document Flash (FLA) et affecterez la classe MoveRight à ce symbole.
Pour créer une sous-classe de clip :
1.
Créez un nouveau rpertoire et enregistrez-le sous le nom BallTest.
2.
Choisissez Fichier > Nouveau, puis sélectionnez un fichier ActionScript dans la liste des
types de document pour créer un nouveau fichier ActionScript.
3.
Entrez le code suivant dans votre fichier de script :
// Classe MoveRight -- déplace le clip de 20 pixels vers la droite suite
à un clic
class MoveRight extends MovieClip {
public function onPress() {
this._x += 20;
}
}
4.
Enregistrez le document en tant que MoveRight.as dans le répertoire BallTest.
Pour affecter la classe à un symbole de clip :
1.
Dans Flash, choisissez Fichier > Nouveau, sélectionnez Document Flash dans la liste des
types de fichiers et cliquez sur OK.
2.
A l’aide de l’outil Ovale, dessinez un cercle sur la scène.
3.
Sélectionnez le cercle puis choisissez Modification > Convertir en symbole.
4.
Dans la boîte de dialogue de conversion en symbole, sélectionnez Clip comme le
comportement du symbole et saisissez ball_mc dans la boîte de texte Nom.
5.
Sélectionnez Avancé pour afficher les options de Liaison, si elles ne sont pas visibles.
412
Utilisation des clips
6.
Slectionnez l’option d’exportation pour ActionScript et tapez mask_mc dans la boîte de
texte de la classe. Cliquez sur OK.
7.
Enregistrez le fichier sous ball.fla dans le répertoire BallTest (le répertoire contenant le
fichier MoveRight.as).
8.
Testez le document Flash (Contrôle > Tester l’animation).
Chaque fois que vous cliquez sur le clip ball, il se déplace de 20 pixels sur la droite.
Si vous créez des propriétés de composante pour une classe et si vous souhaitez qu’un clip
hérite de ces propriétés de composante, il faut passer à l’étape suivante : Après avoir
sélectionné le symbole de clip dans le panneau Bibliothèque, sélectionnez Définition de
composante depuis le menu déroulant de la Bibliothèque et entrez le nouveau nom de classe
dans la boîte Classe.
Initialisation des propriétés de classe
Dans l’exemple présenté lors de la seconde procédure sous Affectation d’une classe à un symbole
de clip, vous avez ajouté l’occurrence du symbole de la Balle sur la scène pendant la
programmation. Comme présenté dans la section Ajout de paramètres aux clips créés
dynamiquement, page 395, vous pouvez affecter des paramètres à des clips que vous créez pour
le temps d’exécution en utilisant le paramètre initObject de attachMovie() et
duplicateMovie(). Vous pouvez utiliser cette fonctionnalité pour initialiser des propriétés de
la classe que vous affectez à un clip.
Par exemple, la classe suivante nommée MoveRightDistance est une variante de la classe
MoveRight (consultez la section Affectation d’une classe à un symbole de clip, page 412). La
différence est une nouvelle propriété nommée distance, dont la valeur détermine le nombre
de pixels dont un clip se déplace chaque fois que vous cliquez dessus.
Pour transmettre des arguments à une classe personnalisée :
1.
Créez un nouveau document ActionScript, puis enregistrez-le sous le nom
MoveRightDistance.as.
2.
Tapez l’ActionScript suivant dans la fenêtre Script :
// MoveRightDistance class -- déplace le clip vers la droite, à raison de
5 pixels par image.
class MoveRightDistance extends MovieClip {
// La propriété Distance détermine de combien de
// pixels déplacer le clip à chaque clic de la souris.
var distance:Number;
function onPress() {
this._x += this.distance;
}
}
Initialisation des propriétés de classe
413
3.
Enregistrez vos progrès.
4.
Créez un nouveau document Flash, puis enregistrez-le sous le nom MoveRightDistance.fla
dans le même répertoire que le fichier de classe.
5.
Créez un symbole de clip qui contient une forme vectorielle, telle qu’une forme ovale, puis
supprimez tout le contenu de la scène.
Il vous suffit d’un symbole de clip dans la bibliothèque pour cet exemple.
6.
Dans le panneau Bibliothèque, cliquez-droit (Windows) ou tapez Contrôle-clic
(Macintosh) sur le symbole et choisissez Liaison dans le menu contextuel.
7.
Affectez l’identifiant de liaison Ball au symbole.
8.
Tapez MoveRightDistance dans la boîte de texte de la classe AS 2.0.
9.
Ajoutez le code suivant à l’image 1 du scénario :
this.attachMovie("Ball", "ball50_mc", 10, {distance:50});
this.attachMovie("Ball", "ball125_mc", 20, {distance:125});
Ce code crée deux nouvelles occurrences du symbole sur le scénario racine du fichier SWF.
La première occurrence, nommée ball50_mc, se déplace de 50 pixels à chaque fois qu’on
clique dessus ; la seconde, nommée ball125_mc, se déplace de 125 pixels à chaque fois
qu’on clique dessus.
10. Choisissez
414
Contrôle > Tester l’animation pour tester le fichier SWF.
Utilisation des clips
CHAPITRE 12
12
Utilisation du texte et des
chaînes
Un grand nombre des applications, présentations et graphiques que vous créez à l’aide de
Macromedia Flash Professionnel 8 ou de Macromedia Flash Basic 8 contiennent du texte.
Vous pouvez utiliser toutes sortes de textes. Vous pouvez utiliser un texte statique dans vos
présentations et un texte dynamique pour les passages plus longs. Vous pouvez également
utiliser la saisie de texte pour capturer la saisie de l’utilisateur, et du texte dans une image pour
votre motif d’arrière-plan. Il est possible de créer des champs de texte à l’aide de l’outil de
programmation Flash ou d’utiliser ActionScript.
Pour afficher un texte, une solution consiste à utiliser un code pour manipuler l’aspect des
chaînes avant qu’elles ne soient chargées et affichées sur la scène au moment de l’exécution. Il
existe plusieurs moyens de manipuler les chaînes dans une application : on peut par exemple
les envoyer vers un serveur et récupérer une réponse, analyser les chaînes dans un tableau ou
valider les chaînes que l’utilisateur saisit dans un champ de texte.
Ce chapitre décrit plusieurs manières d’utiliser le texte et les chaînes dans vos applications, en
mettant l’accent sur l’utilisation du code pour manipuler le texte.
La liste suivante décrit la terminologie utilisée dans ce chapitre.
Alias
Le texte en alias n’utilise pas de variations de couleur pour que ses bordures découpées
semblent plus lisses, contrairement au texte anti-aliasé (voir la définition suivante).
Anti-alias
Vous utiliserez l’anti-alias pour lisser le texte afin que les bords des caractères
apparaissant à l’écran semblent moins accentués. L’option Anti-Alias de Flash rend le texte
plus lisible en alignant le contour du texte le long des limites de pixels et est particulièrement
efficace pour rendre nettement les petites polices.
Caractères
Les caractères sont des lettres, des chiffres et des signes de ponctuation que vous
combinez pour former des chaînes.
415
Polices de périphérique Les polices de périphérique sont des polices spéciales de Flash qui
ne sont pas incorporées à un fichier SWF. Flash Player utilise en fait la police présente sur
l’ordinateur local qui ressemble le plus à la police de périphérique. Dans la mesure où le
contour des polices n’est pas incorporé, la taille d’un fichier SWF est inférieure que si le
contour des polices est incorporé. Toutefois, dans la mesure où le contour des polices n’est pas
incorporé, le texte que vous créez avec ces polices semble différent de ce que vous pouvez
attendre sur les systèmes informatiques ne disposant pas d’une police installée correspondant à
la police de périphérique. Flash intègre trois polices de périphérique : _sans (similaire à
Helvetica ou Arial), _serif (similaire à Times Roman) et _typewriter (similaire à Courier).
Polices
Jeux de caractères présentant un aspect, un style et une taille similaires.
Chaîne
Séquence de caractères.
Texte
Série d’une ou plusieurs chaînes pouvant être affichées dans un champ de texte ou au
sein d’un composant d’interface utilisateur.
Champs de texte
Elément visuel de la scène qui vous permet d’afficher du texte pour un
utilisateur. Comme le contrôle des formes d’un champ de saisie de texte ou d’une zone de
texte en HTML, Flash vous permet de définir les champs de texte comme modifiables (lecture
seule), d’autoriser le formatage HTML, d’activer la prise en charge multiligne, le masquage de
mot de passe, ou d’appliquer une feuille de style CSS à votre texte au format HTML.
Formatage de texte
Vous pouvez appliquer le formatage à un champ de texte ou à certains
caractères d’un champ de texte. Voici certains exemples d’options de formatage de texte
pouvant être appliquées à du texte : alignement, retrait, gras, couleur, taille de la police,
largeur des marges, italiques et espacement des lettres.
Pour plus d’informations sur le texte, consultez les rubriques suivantes :
A propos des champs de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
Utilisation de la classe TextField . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418
A propos du chargement de texte et de variables dans des champs de texte . . .428
Utilisation des polices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434
Présentation du rendu d’un texte anti-alias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444
Présentation de la mise en forme et du formatage du texte . . . . . . . . . . . . . . . . . . .453
Formatage de texte avec les feuilles de style CSS . . . . . . . . . . . . . . . . . . . . . . . . . . .462
Création d’un objet feuille de style . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .465
Utilisation de texte au format HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477
Exemple : Création de texte défilant. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492
416
Utilisation du texte et des chaînes
A propos des champs de texte
Un champ de texte dynamique ou de saisie est un objet TextField (occurrence de la classe
TextField). Lorsque vous créez un champ de texte dans l’environnement de programmation,
vous pouvez lui affecter un nom d’occurrence dans l’inspecteur des propriétés. Utilisez ce nom
d’occurrence dans les instructions ActionScript pour définir, modifier et formater le champ de
texte et son contenu à l’aide des classes TextField et TextFormat.
Vous pouvez utiliser l’interface utilisateur pour créer différents champs de texte, ou utiliser
ActionScript pour créer des champs de texte. Vous pouvez créer les types de champs de texte
suivants dans Flash :
Texte statique
Utilisez le texte statique pour afficher les caractères n’ayant pas à être
modifiés, afficher de petites quantités de texte ou des polices spéciales non disponibles sur la
plupart des ordinateurs. Vous pouvez également afficher les polices rares en incorporant les
caractères destinés à des champs de texte dynamiques.
Texte dynamique
Utilisez les champs de texte dynamique pour afficher des caractères mis à
jour ou modifiés au moment de l’exécution. Vous pouvez également charger du texte dans des
champs de texte dynamiques.
Texte de saisie
Les champs de texte de saisie permettent de récupérer les entrées des
utilisateurs. Ces derniers peuvent saisir du texte dans ces champs.
Composants de texte
Les composants TextArea ou TextInput permettent d’afficher ou de
récupérer du texte dans vos applications. Le composant TextArea est semblable à un champ de
texte dynamique avec barres de défilement intégrées. Le composant TextInput est similaire à
un champ de texte de saisie. Les deux composants présentent des fonctionnalités
supplémentaires par rapport aux champs de texte équivalents ; toutefois, ils augmentent la
taille des fichiers dans votre application. .
R E M A R QU E
Tous les champs de texte prennent en charge le codage Unicode. Pour plus
d’informations sur l’Unicode, consultez la rubrique Présentation des chaînes et de la
classe String, page 493.
Les méthodes de la classe TextField vous permettent de définir, sélectionner et manipuler du
texte dans un champ de texte dynamique ou de saisie que vous créez en cours de
programmation ou à l’exécution. Pour plus d’informations, consultez Utilisation de la classe
TextField, page 418. Pour plus d’informations sur les champs de texte de débogage lors de
l’exécution, reportez-vous à la section Affichage des propriétés de champ de texte pour le débogage,
page 794.
A propos des champs de texte
417
ActionScript propose également différentes manières de formater vos textes à l’exécution. La
classe TextFormat vous permet de définir le formatage des caractères et des paragraphes pour
les objets TextField (consultez Utilisation de la classe TextFormat, page 459). Flash Player prend
également en charge un sous-ensemble de balises HTML à utiliser pour formater le texte
(consultez Utilisation de texte au format HTML, page 477). Flash Player 7 et les versions
ultérieures prennent en charge la balise HTML img, qui permet non seulement d’intégrer des
images externes, mais également des fichiers SWF externes, ainsi que les clips qui résident
dans la bibliothèque (consultez Balise Image, page 481).
A partir de Flash Player7, vous pouvez appliquer des styles CSS (feuilles de style en cascade)
aux champs de texte à l’aide de la classe TextField.StyleSheet. Vous pouvez utiliser le style CSS
pour l’appliquer aux balises HTML intégrées, définir de nouvelles balises de format ou
appliquer des styles. Pour plus d’informations sur l’utilisation de CSS, consultez Formatage de
texte avec les feuilles de style CSS, page 462.
Vous pouvez également directement affecter du texte au format HTML, pouvant
éventuellement utiliser des styles CSS, à un champ de texte. Dans Flash Player 7 et les versions
ultérieures, le texte HTML que vous assignez à un champ de texte peut contenir des supports
intégrés (clips vidéo, fichiers SWF et fichiers JPEG). Flash Player 8 permet également de
charger dynamiquement des images PNG, GIF et JPEG progressives (Flash Player 7 ne prend
pas en charge les images JPEG progressives). Le texte entoure le média intégré comme le fait
un navigateur Web dans un document HTML. Pour plus d’informations, consultez Balise
Image, page 481.
Pour plus d’informations sur la terminologie comparant le texte, les chaînes, etc., reportezvous à l’introduction de ce chapitre, Utilisation du texte et des chaînes, page 415.
Utilisation de la classe TextField
La classe TextField représente les champs de texte dynamiques ou de saisie (modifiables) que
vous créez à l’aide de l’outil Texte dans Flash. Utilisez les méthodes et les propriétés de cette
classe pour contrôler les champs de texte à l’exécution. Les objets TextField prennent en
charge les mêmes propriétés que les objets MovieClip à l’exception des propriétés
_currentframe, _droptarget, _framesloaded et _totalframes. Vous pouvez obtenir et
définir des propriétés et invoquer des méthodes pour les champs de texte de façon dynamique.
Pour contrôler un champ de texte dynamique ou de saisie en utilisant ActionScript, vous
devez affecter au champ de texte un nom d’occurrence dans l’inspecteur des propriétés. Vous
pouvez ensuite faire référence au champ de texte avec le nom de l’occurrence et utiliser les
méthodes et les propriétés de la classe TextField pour contrôler le contenu ou l’aspect général
du champ de texte.
418
Utilisation du texte et des chaînes
Vous pouvez également créer des objets TextField à l’exécution et leur affecter des noms
d’occurrence à l’aide de la méthode MovieClip.createTextField(). Pour plus
d’informations, consultez Création de champs de texte à l’exécution, page 422.
Pour plus d’informations sur l’utilisation de la classe TextField, consultez les rubriques
suivantes :
■
Affectation de texte à un champ de texte à l’exécution, page 419
■
A propos des noms d’occurrence et de variable de champ de texte, page 421
Vous pouvez trouver des exemples de fichiers source indiquant comment intervenir sur les
champs de texte à l’aide d’ActionScript. Les fichiers sources sont nommés textfieldsA.fla et
textfieldsB.fla ; vous les trouverez dans le dossier Samples sur votre disque dur :
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\TextFields.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/TextFields.
Affectation de texte à un champ de texte à l’exécution
Lorsque vous créez des applications à l’aide de Flash, vous pouvez souhaiter charger du texte
provenant d’une source externe, telle qu’un fichier texte, un fichier XML ou même un service
Web distant. Flash vous permet de contrôler parfaitement la création et l’affichage de texte sur
scène, par exemple le texte de support au format HTML, texte brut ou XML ainsi que les
feuilles de style externes. Vous pouvez également utiliser ActionScript pour définir une feuille
de style.
Pour affecter du texte à un champ, vous pouvez utiliser la propriété TextField.text ou
TextField.htmlText. Si vous avez saisi une valeur dans le champ de texte de variable de
l’inspecteur des propriétés, vous pouvez affecter une valeur au champ de texte en créant une
variable du nom spécifié. Si vous utilisez la version 2 de l’architecture des composants
Macromedia dans votre document Flash, vous pouvez aussi attribuer des valeurs en créant des
liaisons entre composants.
L’exercice suivant permet d’affecter du texte à un champ de texte à l’exécution :
A propos des champs de texte
419
Pour affecter du texte à un champ de texte à l’exécution :
1.
En utilisant l’outil Texte, créez un champ de texte sur la scène.
2.
Après avoir sélectionné le champ de texte, dans l’inspecteur des propriétés (Fenêtre >
Propriétés > Propriétés), sélectionnez Texte de saisie dans le menu contextuel Type de
texte, puis saisissez headline_txt dans le champ Nom de l’Occurrence.
Les noms d’occurrence peuvent uniquement comporter des lettres, des chiffres, des traits
de soulignement (_) et des dollars ($).
3.
Sélectionnez l’image 1 dans le scénario et ouvrez le panneau Actions (Fenêtre > Actions).
4.
Tapez le code suivant dans le panneau Actions :
headline_txt.text = "New articles available on Developer Center";
5.
Choisissez Contrôle > Tester l’animation pour tester le document Flash.
Vous pouvez également créer un champ de texte à l’aide d’ActionScript, puis lui affecter du
texte. Saisissez le code ActionScript suivant sur l’image 1 du scénario :
this.createTextField("headline_txt", this.getNextHighestDepth(), 100, 100,
300, 20);
headline_txt.text = "New articles available on Developer Center";
Ce code crée un nouveau champ de texte portant le nom d’occurrence headline_txt. Le
champ de texte est créé à la profondeur maximale suivante, aux coordonnées x et y de 100,
100, avec une largeur de champ de texte de 200 pixels et une hauteur de 20 pixels. Lorsque
vous testez le fichier SWF (Contrôle > Tester l’animation), le texte "Nouveaux articles
disponibles sur Developer Center” apparaît sur la scène.
Pour créer un champ de texte au format HTML, procédez comme suit :
Utilisez l’une des deux étapes suivantes pour activer le formatage HTML pour le champ de
texte :
■
Sélectionnez un champ de texte et cliquez sur Rendre le texte au format HTML dans
l’inspecteur des propriétés.
■
Définissez la propriété de champ de texte html sur true à l’aide d’ActionScript (voir
l’exemple de code suivant).
Pour appliquer le formatage HTML à un champ de texte à l’aide d’ActionScript, saisissez
l’ActionScript suivant dans l’Image 1 du scénario :
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>.";
420
Utilisation du texte et des chaînes
Le code précédent crée de manière dynamique un nouveau champ de texte, active le
formatage HTML et affiche le texte “Nouveaux articles disponibles sur Developer Center” sur
la scène, le terme “Developer Center” apparaissant en italiques.
AT T E NT I O N
Lorsque vous utilisez du texte formaté HTML avec un champ de texte (pas des
composants) sur la scène, vous devez affecter le texte à la propriété htmlText du champ
de texte et non de la propriété de texte.
Vous pouvez trouver des exemples de fichiers source indiquant comment intervenir sur les
champs de texte à l’aide d’ActionScript. Les fichiers sources sont nommés textfieldsA.fla et
textfieldsB.fla ; vous les trouverez dans le dossier Samples sur votre disque dur :
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\TextFields.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/TextFields.
A propos des noms d’occurrence et de variable de
champ de texte
Dans le champ Nom de l’occurrence de l’inspecteur des propriétés, vous devez affecter un
nom d’occurrence à un champ de texte pour invoquer des méthodes, puis obtenir et définir
des propriétés dans ce champ de texte.
Dans la zone de texte Var de l’inspecteur de propriétés, attribuez un nom de variable à un
champ texte dynamique ou de saisie. Vous pouvez alors attribuer des valeurs à la variable. Il
s’agit d’une fonctionnalité déconseillée, que vous pouvez néanmoins utiliser lors de la création
d’applications pour des versions antérieures de Flash Player (telles que Flash Player 4).
Lorsque vous ciblez des lecteurs plus récents, ciblez le texte d’un champ de texte en utilisant
son nom d’occurrence et ActionScript.
Veillez cependant à ne pas confondre le nom d’occurrence d’un champ texte avec son nom de
variable. Le nom de variable d’un champ de texte est une référence de variable au texte
contenu dans ce champ de texte, il ne s’agit pas d’une référence à un objet.
Par exemple, si vous affectez à un champ de texte le nom de variable myTextVar, vous pouvez
ensuite utiliser le code suivant pour définir le contenu du champ de texte :
var myTextVar:String = "This is what will appear in the text field";
A propos des champs de texte
421
Toutefois, vous ne pouvez pas utiliser le nom de variable myTextVar pour définir la propriété
text du champ de texte. Vous devez utiliser le nom d’occurrence, comme indiqué dans le
code suivant :
// Cela ne fonctionnera pas.
myTextVar.text = "A text field variable is not an object reference";
// Pour un champ de texte de saisie avec le nom d’occurrence "myField", cela
fonctionnera.
myField.text = "This sets the text property of the myField object";
Utilisez la propriété TextField.text pour contrôler le contenu d’un champ de texte, sauf si
vous ciblez une version de Flash Player qui ne prend pas en charge la classe TextField. Ceci
réduit l’éventualité d’un conflit de noms de variables, qui pourrait engendrer un
comportement inattendu à l’exécution.
Vous pouvez trouver des exemples de fichiers source indiquant comment intervenir sur les
champs de texte à l’aide d’ActionScript. Les fichiers sources sont nommés textfieldsA.fla et
textfieldsB.fla ; vous les trouverez dans le dossier Samples sur votre disque dur :
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\TextFields.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/TextFields.
Création de champs de texte à l’exécution
Vous pouvez utiliser la méthode createTextField() de la classe MovieClip pour créer un
champ de texte vide sur la scène à l’exécution. Ce nouveau champ est associé au scénario du
clip qui appelle la méthode.
Pour créer dynamiquement un champ de texte à l’aide d’ActionScript :
1.
Sélectionnez Fichier > Nouveau, puis sélectionnez Document Flash pour créer un nouveau
fichier FLA.
2.
Saisissez le code ActionScript suivant sur l’image 1 du scénario :
this.createTextField("test_txt", 10, 0, 0, 300, 100);
Ce code crée un champ de texte de 300 x 100 pixels nommé test_txt à l’emplacement
(0, 0) et d’une profondeur de (ordre-z) de 10.
422
Utilisation du texte et des chaînes
3.
Pour accéder aux méthodes et propriétés du nouveau champ de texte, utilisez le nom
d’occurrence spécifié dans le premier paramètre de la méthode createTextField().
Par exemple, le code suivant crée un nouveau champ de texte nommé test_txt, puis
modifie ses propriétés pour en faire un champ de texte multiligne avec retour automatique
à la ligne, qui se développe pour s’ajuster à la taille du texte inséré. Il affecte ensuite du
texte à la propriété text du champ de texte :
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.
Choisissez Contrôle > Tester l’animation pour visualiser le champ de texte.
Le texte est créé au moment de l’exécution et apparaît sur la scène.
Vous pouvez utiliser la méthode TextField.removeTextField() pour supprimer un champ
de texte créé avec createTextField(). La méthode removeTextField() ne fonctionne pas
pour les champs de texte placés par le scénario au cours de la programmation.
Pour plus d’informations, voir createTextField (MovieClip.createTextField method) et
removeTextField (TextField.removeTextField method) dans le Guide de référence du langage
ActionScript 2.0.
REMARQUE
Certaines propriétés TextField telles que _rotation ne sont pas disponibles lorsque vous
créez des champs de texte à l’exécution. Vous ne pouvez faire pivoter un champ de texte
que s’il utilise des polices incorporées. Voir Pour intégrer un symbole de police :,
page 437.
Vous pouvez trouver des exemples de fichiers source indiquant comment intervenir sur les
champs de texte à l’aide d’ActionScript. Les fichiers sources sont nommés textfieldsA.fla et
textfieldsB.fla ; vous les trouverez dans le dossier Samples sur votre disque dur :
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\TextFields.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/TextFields.
A propos des champs de texte
423
A propos de la manipulation des champs de texte
Vous pouvez manipuler de différentes manières les champs de texte que vous créez dans un
fichier FLA. Vous pouvez manipuler un champ de texte à condition de lui affecter un nom
d’occurrence dans l’inspecteur des propriétés, ou en affecter un à l’aide d’un code si vous
utilisez du code pour créer le champ. L’exemple suivant est simple, il crée un champ de texte,
lui affecte du texte, puis modifie sa propriété de bordure :
this.createTextField("pigeon_txt", this.getNextHighestDepth(), 100, 100,
200, 20);
pigeon_txt.text = "I like seeds";
pigeon_txt.border = true;
Pour obtenir une liste complète des propriétés de la classe TextField, consultez le Guide de
référence du langage ActionScript 2.0 .
Pour examiner des exemples de manipulation de champs de texte, consultez les sections
suivantes :
■
Modification de la position d’un champ de texte, page 425
■
Modification des dimensions d’un champ de texte à l’exécution, page 425
Vous pouvez trouver des exemples de fichiers source indiquant comment intervenir sur les
champs de texte à l’aide d’ActionScript. Les fichiers sources sont nommés textfieldsA.fla et
textfieldsB.fla ; vous les trouverez dans le dossier Samples sur votre disque dur :
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\TextFields.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/TextFields.
424
Utilisation du texte et des chaînes
Modification de la position d’un champ de texte
Vous pouvez modifier la position d’un champ de texte sur la scène au moment de l’exécution.
Pour ce faire, vous devez définir les nouvelles valeurs des propriétés _x et _y du champ de
texte, comme dans l’exemple suivant.
Pour repositionner un champ de texte à l’aide d’ActionScript, procédez
comme suit :
1.
Créez un nouveau fichier FLA, puis enregistrez-le sous le nom positionText.fla.
2.
Ajoutez le code ActionScript suivant à l’image 1 du scénario :
this.createTextField("my_txt", 10, 0, 0, 300, 200);
my_txt.border = true;
my_txt.text = "Hello world";
my_txt._x = (Stage.width - my_txt._width) / 2;
my_txt._y = (Stage.height - my_txt._height) / 2;
3.
Enregistrez le document Flash et sélectionnez Contrôle > Tester l’animation pour voir le
champ de texte centré sur la scène.
Vous pouvez trouver des exemples de fichiers source indiquant comment intervenir sur les
champs de texte à l’aide d’ActionScript. Les fichiers sources sont nommés textfieldsA.fla et
textfieldsB.fla ; vous les trouverez dans le dossier Samples sur votre disque dur :
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\TextFields.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/TextFields.
Modification des dimensions d’un champ de texte à l’exécution
Vous devrez peut-être obtenir ou définir les dimensions d’un champ de texte de manière
dynamique à l’exécution, au lieu de le faire dans l’environnement auteur. L’exemple suivant
crée un champ de texte dans un scénario et définir ses dimensions initiales sur 100 pixels de
large par 21 pixels de haut. Par la suite, le champ de texte est redimensionné à 300 pixels de
large sur 200 pixels de haut, et repositionné au centre de la scène.
A propos des champs de texte
425
Pour redimensionner un champ de texte à l’aide d’ActionScript :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom resizeText.fla.
2.
Ajoutez le code ActionScript suivant à l’image 1 du scénario :
this.createTextField("my_txt", 10, 0, 0, 100, 21);
my_txt.border = true;
my_txt.multiline = true;
my_txt.text = "Hello world";
my_txt.wordWrap = true;
my_txt._width = 300;
my_txt._height = 200;
my_txt._x = (Stage.width - my_txt._width) / 2;
my_txt._y = (Stage.height - my_txt._height) / 2;
3.
Enregistrez le document Flash et sélectionnez Contrôle > Tester l’animation pour visualiser
les résultats dans l’environnement auteur.
L’exemple précédent a permis de redimensionner un champ de texte créé de manière
dymanique à 300 pixels sur 200 pixels à l’exécution, mais lorsque vous chargez un contenu à
partir d’un site Web externe et que vous n’êtes pas certain de la quantité de contenu qui sera
retournée, cette technique n’est peut-être pas adaptée à vos besoins. Heureusement, Flash
comprend une propriété TextField.autoSize que vous pouvez utiliser pour redimensionner
automatiquement un champ de texte en fonction de son contenu. L’exemple suivant
démontre la manière dont vous pouvez utiliser la propriété TextField.autoSize pour
redimensionner le champ de texte après y avoir ajouté du texte.
426
Utilisation du texte et des chaînes
Pour redimensionner automatiquement des champs de texte en fonction du
contenu :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom resizeTextAuto.fla.
2.
Ajoutez le code suivant à l’image 1 du scénario principal :
this.createTextField("my_txt", 10, 10, 10, 160, 120);
my_txt.autoSize = "left";
my_txt.border = true;
my_txt.multiline = true;
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.";
my_txt.wordWrap = true;
REMARQUE
3.
Si vous collez ce code directement dans le panneau Actions à partir de certaines
versions de l’aide de Flash, vous pouvez rencontrer des sauts de ligne dans la chaîne
de texte longue. Dans ce cas, le code ne sera pas compilé. Si vous vous trouvez dans
cette situation, activez les Caractères masqués dans le menu contextuel du panneau
Actions, puis supprimez les caractères de saut de ligne dans la chaîne de texte
longue.
Enregistrez le document Flash et sélectionnez Contrôle > Tester l’animation pour visualiser
le document Flash dans l’environnement auteur.
Flash redimensionne le champ de texte verticalement de manière à afficher l’ensemble du
contenu sans le réduire aux limites du champ. Si vous définissez la propriété
my_txt.wordWrap sur false, le champ de texte est redimensionné horizontalement en
fonction du texte.
Pour appliquer une hauteur maximale au champ de texte redimensionné
automatiquement (afin que la hauteur du champ de texte ne dépasse pas les limites de la
scène), utilisez le code suivant.
if (my_txt._height > 160) {
my_txt.autoSize = "none";
my_txt._height = 160;
}
Vous devez ajouter une fonctionnalité de défilement, par exemple une barre de défilement,
afin de permettre aux utilisateurs de visualiser le reste du texte. Vous pouvez aussi faire passer
le pointeur de la souris sur le texte ; cette méthode est souvent adéquate pour tester ce code.
A propos des champs de texte
427
Vous pouvez trouver des exemples de fichiers source indiquant comment intervenir sur les
champs de texte à l’aide d’ActionScript. Les fichiers sources sont nommés textfieldsA.fla et
textfieldsB.fla ; vous les trouverez dans le dossier Samples sur votre disque dur :
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\TextFields.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/TextFields.
A propos du chargement de texte et de
variables dans des champs de texte
Vous pouvez charger du texte dans un document Flash de différentes manières, y compris
(mais pas seulement) à l’aide de FlashVars, LoadVars, XML ou de services Web. La méthode la
plus simple pour intégrer du texte dans un document Flash consiste peut-être à utiliser la
propriété FlashVars, qui fait passer des chaînes de texte courtes dans un document Flash au
moyen des balises object et embed dans le code HTML que vous utilisez pour incorporer le
fichier SWF dans une page HTML. Un autre moyen facile de charger du texte ou des
variables dans un document Flash consiste à utiliser la classe LoadVars, qui permet de charger
de gros blocs de texte ou de charger une série de variables porteuses d’URL à partir d’un
fichier texte.
Comme vous l’avez vu dans les exemples précédents de cette section, certaines méthodes de
chargement de texte dans un fichier SWF sont plus simples que d’autres. Toutefois, si vous
diffusez des données provenant de sites externes, vous risquez de ne pas avoir le choix quant au
format des données que vous devez charger.
Chaque manière de charger et/ou d’envoyer des données vers et en provenance d’un fichier
SWF possède ses avantages et ses inconvénients. Le XML, les services Web et le Flash
Remoting sont les outils les plus polyvalents pour charger des données externes, mais ils sont
également les plus difficiles à apprendre. Pour plus d’informations sur le Flash Remoting,
consultez le site www.macromedia.com/support/flashremoting.
428
Utilisation du texte et des chaînes
Les solutions FlashVars et LoadVars sont beaucoup plus simples, comme vous pouvez le
constater aux rubriques Utilisation de FlashVars pour charger et afficher du texte, page 430 et
Utilisation de LoadVars pour charger et afficher du texte, page 431, mais ces méthodes peuvent
être plus limitées en termes de types et de formats des données que vous pouvez charger. Vous
devez également respecter les restrictions de sécurité lorsque vous envoyez et chargez des
données. Pour plus d’informations sur la sécurité, reportez-vous au Chapitre 17,
Fonctionnement de la sécurité. Pour plus d’informations sur le chargement de données externes,
reportez-vous au Chapitre 16, Utilisation de données externes.
Les sections suivantes présentent divers moyens de charger du texte et des variables dans vos
documents :
■
Utilisation de FlashVars pour charger et afficher du texte, page 430
■
Utilisation de LoadVars pour charger et afficher du texte, page 431
■
Chargement de variables à l’aide de LoadVars, page 432
■
Chargement et affichage de texte à partir d’un document XML, page 433
Vous pouvez trouver des exemples de fichiers source indiquant comment intervenir sur les
champs de texte à l’aide d’ActionScript. Les fichiers sources sont nommés loadText.fla et
formattedText.fla ; vous les trouverez dans le dossier Samples sur votre disque dur :
■
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples et Tutorials\Samples\ActionScript\LoadText.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/LoadText.
Vous pouvez également trouver un fichier source qui charge du texte et applique le formatage
anti-alias en plus de la mise en cache des bitmaps. L’exemple de fichier source est nommé
flashtype.fla dans le dossier Samples de votre disque dur :
■
Sous Windows, ouvrez le répertoire lecteur d’initialisation\Program
Files\Macromedia\Flash 8\Samples and Tutorials\Samples\ActionScript\FlashType.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/FlashType.
A propos du chargement de texte et de variables dans des champs de texte
429
Utilisation de FlashVars pour charger et afficher du
texte
L’utilisation de FlashVars est simple, mais requiert la publication de vos fichiers SWF en plus
des documents HTML. Vous modifiez le code HTML généré et incluez les propriétés
FlashVars dans les balises object et embed. Vous pouvez tester le document Flash en
visualisant le document HTML modifié dans votre navigateur Web.
Pour utiliser FlashVars pour transmettre des variables de HTML vers votre
document Flash :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom flashvars.fla.
2.
Ajoutez le code ActionScript suivant à l’image 1 du scénario :
this.createTextField("my_txt", 10, 10, 10, 100, 21);
my_txt.text = _level0.username;
3.
Enregistrez le document Flash et sélectionnez Fichier > Publier pour générer les fichiers
HTML et SWF.
REMARQUE
Par défaut, un document HTML est publié dans le même répertoire que votre fichier
FLA. Si un document HTML n’est pas publié, sélectionnez Fichier > Paramètres de
publication, puis choisissez l’onglet Formats. Veillez à sélectionner l’option HTML.
4.
Ouvrez le document flashvars.html dans un éditeur de texte ou HTML.
5.
Dans le document HTML, modifiez le code dans la balise object selon ce qui suit.
Le code que vous devez ajouter apparaît en gras.
<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="flashvars"
align="middle">
<param name="allowScriptAccess" value="sameDomain" />
<param name="movie" value="flashvars.swf" />
<param name="FlashVars" value="username=Thomas" />
<param name="quality" value="high" />
<param name="bgcolor" value="#ffffff" />
<embed src="flashvars.swf" FlashVars="username=Thomas" quality="high"
bgcolor="#ffffff" width="550" height="400" name="flashvars"
align="middle" allowScriptAccess="sameDomain" type="application/xshockwave-flash" pluginspage="http://www.macromedia.com/go/
getflashplayer" />
</object>
6.
Enregistrez vos modifications dans le document HTML.
430
Utilisation du texte et des chaînes
7.
Ouvrez le document HTML modifié dans un navigateur Web.
Le fichier SWF affiche le nom "Thomas" dans le champ de texte créé de manière
dynamique sur la scène.
Pour plus d’informations sur la sécurité, voir Chapitre 17, Fonctionnement de la sécurité.
Utilisation de LoadVars pour charger et afficher du
texte
Vous pouvez également utiliser la classe LoadVars pour charger du contenu dans un fichier
SWF qui charge du texte ou des variables depuis un fichier externe du même serveur ou
encore du contenu provenant d’un autre serveur. L’exemple suivant démontre la procédure à
suivre pour créer un champ de texte de manière dynamique et le peupler à l’aide du contenu
d’un fichier texte distant.
Pour utiliser LoadVars pour peupler un champ de texte avec du texte externe :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom loadvarsText.fla.
2.
Ajoutez le code ActionScript suivant à l’image 1 du scénario :
this.createTextField("my_txt", 10, 10, 10, 320, 100);
my_txt.autoSize = "left";
my_txt.border = true;
my_txt.multiline = true;
my_txt.wordWrap = true;
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");
Le premier bloc de code de la section précédente crée un nouveau champ de texte sur la
scène et active l’affichage multiligne et le retour à la ligne. Le deuxième bloc de code
définit un nouvel objet LoadVars qui est utilisé pour charger un fichier texte (lorem.txt) à
partir d’un serveur Web distant et afficher son contenu dans le champ de texte my_txt créé
antérieurement.
A propos du chargement de texte et de variables dans des champs de texte
431
3.
Enregistrez le document Flash, puis choisissez Contrôle > Tester l’animation pour tester le
fichier SWF.
Après un court délai, Flash affiche le contenu du fichier distant dans le champ de texte sur
la scène.
Pour plus d’informations sur la sécurité, voir Chapitre 17, Fonctionnement de la sécurité.
Chargement de variables à l’aide de LoadVars
La classe LoadVars vous permet également de charger des variables au format encodé par
URL, une opération similaire au transfert de variables dans la chaîne de requête d’un
navigateur Web. L’exemple suivant présente le chargement d’un fichier texte distant dans un
fichier SWF et l’affichage de ses variables, monthNames et dayNames.
Pour charger des variables à partir d’un fichier texte à l’aide de LoadVars :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom loadvarsVariables.fla.
2.
Ajoutez le code suivant à l’image 1 du scénario :
this.createTextField("my_txt", 10, 10, 10, 320, 100);
my_txt.autoSize = "left";
my_txt.border = true;
my_txt.multiline = true;
my_txt.wordWrap = true;
var lorem_lv:LoadVars = new LoadVars();
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 {
my_txt.text = "Unable to load external file.";
}
}
/* contents of params.txt:
&monthNames=January,February,...&dayNames=Sunday,Monday,...
*/
lorem_lv.load("http://www.helpexamples.com/flash/params.txt");
3.
Enregistrez le document Flash et sélectionnez Contrôle > Tester l’animation dans le menu
principal.
Comme vous utilisez la méthode LoadVars.onLoad() au lieu de LoadVars.onData(),
Flash analyse les variables et crée des variables dans l’occurrence d’objet LoadVars. Le
fichier texte externe contient deux variables, monthNames et dayNames, qui contiennent
toutes les deux des chaînes de caractères.
Pour plus d’informations sur la sécurité, voir Chapitre 17, Fonctionnement de la sécurité.
432
Utilisation du texte et des chaînes
Chargement et affichage de texte à partir d’un
document XML
XML est une technique très couramment employée pour distribuer du contenu sur Internet,
en partie parce que ce standard est largement accepté pour l’organisation et l’analyse des
données. En tant que tel, le XML constitue un excellent choix pour envoyer et recevoir des
données de Flash ; toutefois, le XML est légèrement plus difficile à apprendre que l’utilisation
de LoadVars et FlashVars pour charger des données et afficher du texte.
Pour charger du texte dans Flash depuis un document XML externe :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom xmlReviews.fla.
2.
Ajoutez le code suivant à l’image 1 du scénario :
this.createTextField("my_txt", 10, 10, 10, 320, 100);
my_txt.autoSize = "left";
my_txt.border = true;
my_txt.multiline = true;
my_txt.wordWrap = true;
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 {
my_txt.text = "Unable to load external file.";
}
}
reviews_xml.load("http://www.helpexamples.com/flash/xml/reviews.xml");
Le premier bloc de code de la section précédente crée un nouveau champ de texte sur la
scène. Ce champ de texte est utilisé pour afficher différentes parties du document XML
qui est chargé par la suite. Le deuxième bloc de code gère la création d’un objet XML qui
sera utilisé pour charger le contenu XML. Une fois les données entièrement chargées et
analysées par Flash, le gestionnaire d’événement XML.onLoad() est invoqué et affiche le
contenu du paquet XML dans le champ de texte.
A propos du chargement de texte et de variables dans des champs de texte
433
3.
Enregistrez le document Flash, puis choisissez Contrôle > Tester l’animation pour tester le
fichier SWF.
Flash affiche le résultat suivant dans le champ de texte sur la scène :
Item 1
Item 2
...
Item 8
Pour plus d’informations sur la sécurité, voir Chapitre 17, Fonctionnement de la sécurité.
Utilisation des polices
Les polices sont des jeux de caractères présentant un aspect, un style et une taille similaires.
Quels que soient les objets que vous créez à l’aide de Flash Basic 8 ou de Flash Professionnel 8,
vous utiliserez probablement du texte avec au moins une ou deux polices dans vos applications
Flash. Si vous créez des animations et que vous ne savez pas au juste si vos utilisateurs finaux
disposent d’une police spécifique sur leur système, vous devez comprendre les éléments de
base de l’incorporation de polices.
Les sections suivantes présentent l’intégration de caractères, de polices complètes, de polices
partagées et d’autres techniques d’utilisation des polices dans Flash 8.
Pour plus d’informations sur les polices, reportez-vous aux sections suivantes:
■
Intégration de caractères, page 435
■
Intégration de polices, page 437
■
Création de jeux de caractères personnalisés, page 439
■
Utilisation des méthodes TextField avec les polices intégrées, page 442
■
A propos du partage des polices, page 444
L’exemple suivant présente la manière d’ajouter et de supprimer des caractères et des jeux de
caractères incorporés dans un document Flash.
434
Utilisation du texte et des chaînes
Pour ajouter et supprimer des caractères et des jeux de caractères
incorporés :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom embedding.fla.
2.
Créez un champ de texte dynamique sur la scène à l’aide de l’outil Text.
3.
Cliquez sur Intégrer pour ouvrir la boîte de dialogue Caractères incorporés.
4.
Sélectionnez un jeu de caractères spécifique à intégrer en cliquant dessus à l’aide du
pointeur de la souris.
Pour sélectionner plusieurs jeux de caractères, vous pouvez utiliser la touche Maj ou Ctrl
tout en sélectionnant des éléments à l’aide du pointeur de la souris. Pour sélectionner un
bloc de jeux de caractères, sélectionnez un jeu à l’aide du pointeur de la souris, appuyez sur
la touche Maj et maintenez-la enfoncée, puis cliquez sur un nouveau jeu de caractères.
L’utilisation de la touche Maj sélectionne tous les jeux de caractères situés entre les deux
jeux sélectionnés. Pour sélectionner plusieurs jeux de caractères non consécutifs, appuyez
sur la touche Ctrl et maintenez-la enfoncée pendant que vous sélectionnez les jeux de
caractères. Vous pouvez également sélectionner rapidement plusieurs jeux de caractères en
sélectionnant le premier à l’aide de la souris et, tout en maintenant le bouton de la souris
enfoncé, en faisant glisser celle-ci sur plusieurs jeux de caractères.
5.
Pour supprimer un jeu de caractères spécifique que vous avez ajouté antérieurement,
appuyez sur la touche Ctrl et maintenez-la enfoncée, puis désélectionnez le jeu de caractères
en cliquant dessus à l’aide du pointeur de la souris.
6.
Pour supprimer tous les jeux de caractères et les éventuels caractères spécifiés dans le champ
de saisie de texte Inclure ces caractères, cliquez sur Ne pas intégrer.
L’option Ne pas intégrer efface les éventuels caractères individuels ou jeux de caractères
sélectionnés précédemment.
A T TE N T I ON
Si vous cliquez sur Ne pas intégrer dans la boîte de dialogue Caractères incorporés,
vous supprimez les éventuels caractères et jeux de caractères intégrés spécifiés qui
ont été sélectionnés précédemment sans vous demander de confirmation.
Intégration de caractères
Si vous travaillez avec des polices intégrées et savez exactement de quels caractères vous avez
besoin, vous pouvez réduire la taille du fichier en intégrant uniquement les caractères dont
vous avez besoin au lieu d’ajouter d’autres contours de polices qui ne vous seront pas utiles.
Pour intégrer certains caractères dans un champ de texte, mais ne pas intégrer un jeu complet
de caractères, utilisez la boîte de dialogue Caractères incorporés pour spécifier les caractères
que vous souhaitez intégrer.
Utilisation des polices
435
Pour intégrer des caractères spécifiques à utiliser dans un champ de texte :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom charembed.fla.
2.
A l’aide du toucher Text, créez un champ de texte sur la scène et définissez le type de texte
du champ de texte comme dynamique ou saisie.
3.
Alors que le champ de texte est toujours sélectionné sur la scène, cliquez sur Intégrer dans
l’inspecteur des propriétés afin d’ouvrir la boîte de dialogue Caractères incorporés.
La boîte de dialogue Caractères incorporés vous permet de définir les jeux de caractères
qui seront intégrés dans le document Flash (ainsi que le nombre de glyphes par jeu de
caractères), de spécifier quels caractères intégrer et vous indique le nombre total de glyphes
qui sont intégrés dans ce champ de texte.
4.
Saisissez la chaîne hello world dans le champ Inclure ces caractères.
La boîte de dialogue vous indique que 8 glyphes au total seront incorporés pour ce champ
de texte. Bien que la chaîne "hello world" contienne 11 caractères, Flash intègre seulement
les glyphes uniques, de sorte que les lettres l et o sont intégrés une seule fois.
5.
Cliquez sur OK pour appliquer les modifications et revenir à votre document.
6.
En utilisant l’outil Texte, créez un nouveau champ de texte sur la scène.
7.
Définissez le type de texte de ce champ sur dynamique dans l’inspecteur des propriétés.
8.
Saisissez la chaîne hello world dans le champ de texte sur la scène.
9.
Cliquez sur Intégrer dans l’inspecteur des propriétés pour ouvrir de nouveau la boîte de
dialogue Caractères incorporés.
10. Cliquez sur Remplissage automatique pour peupler automatiquement le champ Inclure ces
caractères.
Vous verrez apparaître la chaîne "helo wrd". Au lieu d’avoir à indiquer à Flash quels
caractères vous souhaitez inclure, Flash peut déterminer pour vous tous les caractères
uniques du champ de texte spécifié.
C ON S E I L
11.
Flash peut déterminer les caractères à intégrer automatiquement uniquement si le
champ de texte contient du texte sur la scène. Si le champ de texte est peuplé à
l’aide d’ActionScript, vous devez spécifier quels caractères vous souhaitez intégrer
dans ce champ.
Cliquez sur OK.
436
Utilisation du texte et des chaînes
Intégration de polices
Lorsque vous intégrez des polices, Flash stocke l’ensemble des informations relatives à la police
dans le fichier SWF, de sorte que la police s’affiche correctement, même si elle n’est pas
installée sur l’ordinateur de l’utilisateur. Si vous utilisez dans votre fichier FLA une police qui
est absente sur le système de l’utilisateur sans l’intégrer dans le fichier SWF, Flash Player
sélectionnera automatiquement une police de remplacement.
REMARQUE
Vous devez intégrer une police uniquement si vous utilisez des champs de texte
dynamiques ou de saisie. Si vous utilisez un champ de texte statique, vous n’avez pas à
intégrer la police.
Pour intégrer un symbole de police :
1.
Choisissez Fenêtre > Bibliothèque pour ouvrir la bibliothèque du fichier FLA.
Ouvrez la bibliothèque à laquelle vous souhaitez ajouter le symbole de police.
2.
Sélectionnez Nouvelle police dans le menu contextuel de la bibliothèque (coin supérieur
droit du panneau Bibliothèque).
3.
Dans la boîte de dialogue Propriétés des symboles de police, entrez un nom pour le symbole
de police dans le champ Nom.
4.
Sélectionnez une police dans le menu Police ou saisissez un nom de police dans le champ
Police.
5.
Pour appliquer un style à la police, sélectionnez Gras, Italique ou Texte aliasé.
6.
Saisissez la taille de police à intégrer, puis cliquez sur OK pour appliquer les modifications
et revenir à votre document.
Votre police apparaît maintenant dans la bibliothèque du document actif.
Après avoir intégré une police dans votre bibliothèque, vous pouvez l’utiliser avec un champ
de texte sur la scène.
Utilisation des polices
437
Pour utiliser un symbole de police intégré dans votre document Flash :
1.
Suivez les étapes de la procédure décrite à la section Intégration de polices, page 437 pour
intégrer une police dans votre bibliothèque.
2.
Utilisez l’outil Texte pour créer un champ de texte sur la scène.
3.
Entrez du texte dans ce champ.
4.
Sélectionnez le champ de texte et ouvrez l’inspecteur des propriétés.
a.
Définissez-le en tant que champ de texte à une seule ligne.
b.
Sélectionnez le nom de la police intégrée en utilisant le menu déroulant Police.
Le nom des polices intégrées est suivi d’un astérisque (*).
5.
Cliquez sur Intégrer dans l’inspecteur des propriétés pour ouvrir la boîte de dialogue
Caractères incorporés.
La boîte de dialogue Intégration de caractères vous permet de sélectionner les caractères
individuels ou les jeux de caractères que vous souhaitez intégrer pour le champ de texte
sélectionné. Pour spécifier quels caractères incorporer, saisissez les caractères dans le champ
de la boîte de dialogue, ou cliquez sur Remplissage automatique pour peupler
automatiquement le champ de texte à l’aide des caractères uniques figurant actuellement
dans le champ de texte. Si vous n’êtes pas certain des caractères dont vous avez besoin (par
exemple, si votre texte est chargé à partir d’un fichier externe ou d’un service Web), vous
pouvez sélectionner des jeux de caractères entiers à intégrer, tels que les Majuscules [A..Z],
les minuscules [a..z], les chiffres [0..9], les signes de ponctuation [!@#%...] et les jeux de
caractères correspondant à différentes langues.
REMARQUE
Chaque jeu de caractères que vous sélectionnez augmente la taille finale du fichier
SWF car Flash doit stocker toutes les informations relatives à la police pour chaque
jeu de caractères que vous utilisez.
6.
Sélectionnez les caractères individuels ou les jeux de caractères que vous souhaitez intégrer,
puis cliquez sur OK pour appliquer les modifications et revenir à votre document.
7.
Choisissez Contrôle > Tester l’animation pour tester le document Flash dans
l’environnement de programmation.
La police intégrée s’affiche dans le champ de texte sur la scène. Pour vérifier correctement
que la police est intégrée, vous devrez peut-être effectuer un test sur un autre ordinateur ne
disposant pas de cette police.
Vous pouvez aussi définir les propriétés TextField._alpha ou TextField._rotation
du champ de texte avec les polices intégrées, car ces propriétés ne fonctionnent sur sur les
polices intégrées (voir les étapes suivantes).
438
Utilisation du texte et des chaînes
8.
Fermez le fichier SWF pour revenir dans l’environnement de programmation.
9.
Sélectionnez le champ de texte sur la scène et ouvrez l’inspecteur des propriétés.
a.
Définissez le type du champ de texte sur Texte dynamique.
b.
Saisissez font_txt dans le champ Nom de l’occurrence.
10. Ajoutez
le code suivant à l’image 1 du scénario :
font_txt._rotation = 45;
11.
Choisissez de nouveau Contrôle > Tester l’animation pour visualiser les modifications dans
l’environnement auteur.
La police sélectionnée pivote de 45 ° dans le sens des aiguilles d’une montre et vous pouvez
toujours voir le texte car il est intégré au fichier SWF.
A TT E N TI O N
Si vous n’intégrez pas une police dans votre document Flash et que Flash Player
choisit automatiquement une police de substitution sur l’ordinateur de l’utilisateur, la
propriété TextField.font utilise la police d’origine employée dans le fichier FLA, et
non la police de substitution.
REMARQUE
Si vous utilisez des polices intégrées avec différents styles dans vos champs de
texte, vous devez intégrer le style à utiliser. Par exemple, si vous utilisez une police
intégrée appelée Times, puis que vous souhaitez qu’un mot apparaisse en italiques,
vous devez intégrer à la fois les contours de police normal et italiques. Dans le cas
contraire, le texte n’apparaîtra pas dans le champ.
Création de jeux de caractères personnalisés
Outre l’utilisation des jeux de caractères par défaut de Flash, vous pouvez également créer vos
propres jeux de caractères et les ajouter à la boîte de dialogue Caractères incorporés. Par
exemple, vous devrez peut-être permettre à certains champs d’intégrer la police Extended
Latin pour prendre en charge différents caractères accentués. Toutefois, il est possible que vous
n’ayez pas besoin des chiffres ni de la ponctuation, ou que vous ayez uniquement besoin de
caractères en majuscules. Au lieu d’intégrer des jeux de caractères entiers, vous pouvez créer un
jeu de caractères personnalisé contenant uniquement les caractères dont vous avez besoin.
Cela vous permettra de limiter la taille de votre fichier SWF autant que possible, car vous ne
stockerez pas d’informations supplémentaires sur les polices pour les caractères dont vous
n’avez pas besoin.
Pour créer un jeu de caractères personnalisé, vous devez modifier le fichier UnicodeTable.xml
situé dans le répertoire C:\Program Files\Macromedia\Flash 8\<language>\First
Run\FontEmbedding\ . Ce fichier définit les jeux de caractères par défaut et les plages de
caractères ainsi que les caractères qu’elles contiennent.
Utilisation des polices
439
Avant de créer un jeu de caractères personnalisé, vous devez comprendre la structure XML
nécessaire. Les nœuds XML suivants définissent le jeu de caractères Majuscules [A..Z] :
<glyphRange name="Uppercase [A..Z] " id="1" >
<range min="0x0020" max ="0x0020" />
<range min="0x0041" max ="0x005A" />
</glyphRange>
Vous pouvez remarquer que le nœud glyphRange comprend name, Uppercase [A..Z], et
id. Un nœud glyphRange peut comporter autant de nœuds enfants range que nécessaire. Une
plage peut se composer d’un seul caractère, par exemple 0x0020 (le caractère d’espacement),
figurant dans l’extrait précédent, ou une série de caractères, telle que la deuxième plage
constituant le nœud enfant. Pour intégrer un seul caractère, définissez les valeurs min et max
sur la même valeur de caractère unicode.
Un autre exemple de nœud XML glyphRange est celui des chiffres Numerals [0..9] :
<glyphRange name="Numerals [0..9] " id="3" >
<range min="0x0030" max ="0x0039" />
<range min="0x002E" max ="0x002E" />
</glyphRange>
Cette plage de caractères comprend les valeurs Unicode 0x0030 (zéro) à 0x0039 (9), ainsi que
la valeur 0x002E (.).
Avant de créer un jeu de caractères personnalisé, vous devez connaître les caractères et leurs
valeurs Unicode correspondantes. Pour obtenir les valeurs Unicode, consultez le site Web des
normes Unicode, www.unicode.org, qui contient le tableau des codes de caractères Unicode
correspondant à des dizaines de langues.
A TT E N TI O N
Pour ajouter des jeux de caractères personnalisés, vous devez modifier un fichier XML
dans le dossier d’installation de Flash. Avant de modifier ce fichier, vous devriez
effectuer une copie de sauvegarde au cas où vous souhaiteriez revenir au tableau
Unicode d’origine.
A T T E NT I ON
Macromedia vous recommande de ne pas modifier les jeux de caractères existants qui
sont installés à l’aide de Flash, et de créer plutôt vos propres jeux de caractères
personnalisés comprenant les caractères et les signes de ponctuation dont vous avez
besoin.
440
Utilisation du texte et des chaînes
Pour créer et utiliser un jeu de caractères personnalisé :
1.
Ouvrez le document UnicodeTable.xml, situé dans le répertoire <Flash install
directory>\<language>\First Run\FontEmbedding\ à l’aide d’un éditeur XML ou d’un
éditeur de texte tel que Notepad ou TextEdit.
REMARQUE
2.
N’oubliez pas de conserver une sauvegarde de ce document, au cas où vous
souhaiteriez revenir au fichier d’origine installé avec Flash.
Défilez jusqu’au bas du document XML et ajoutez le code XML suivant juste avant le
nœud final </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.
Enregistrez vos modifications dans UnicodeTable.xml.
Si Flash est ouvert, vous devez redémarrer l’application avant d’utiliser le nouveau jeu de
caractères.
4.
Ouvrez ou redémarrez Flash, puis créez un nouveau document Flash.
5.
Ajoutez une nouvelle occurrence de TextField sur la scène à l’aide de l’outil Text.
6.
Définissez le type Text de TextField sur dynamique dans l’inspecteur des propriétés, puis
cliquez sur Options de caractères incorporés pour ouvrir la boîte de dialogue Caractères
incorporés.
7.
Défilez jusqu’au bas de la boîte de dialogue Caractères incorporés et sélectionnez votre
nouveau jeu de caractères personnalisé, Majuscules (Uppercase) et Chiffres (Numerals)
[A..Z,0..9] (38 glyphes).
Utilisation des polices
441
8.
Sélectionnez les autres jeux de caractères éventuels, puis cliquez sur OK.
Si vous sélectionnez votre jeu de caractères personnalisé, Uppercase et Numerals
[A..Z,0..9], ainsi que le jeu de caractères par défaut Uppercase [A..Z] ou Numerals [0..9],
remarquez que le nombre de glyphes incorporés ne change pas. C’est dû au fait que tous
les caractères en majuscules sont inclus dans votre jeu de caractères personnalisé, et que
Flash n’intègre pas de caractères e ndouble, ce qui permet de réduire autant que possible la
taille du fichier. Si vous sélectionnez le jeu de caractères Ponctuation (Punctuation), qui
comprend 52 glyphes, ainsi que votre jeu de caractères personnalisé, comprenant 38
glyphes, Flash stocke des informations relatives à 88 glyphes seulement au lieu de 90. En
effet, deux caractères se recouvrent dans ces jeux : l’espacement et le point se trouvent déjà
dans votre jeu de caractères personnalisé.
C ON S E I L
La position d’un caractère définie dans la boîte de dialogue Caractères incorporés
est déterminée par son emplacement dans le document XML. Vous pouvez modifier
l’ordre des jeux de caractères, y compris de vos jeux de caractères personnalisés, en
déplaçant les paquets <glyphRange> dans le fichier XML.
Utilisation des méthodes TextField avec les polices
intégrées
Les méthodes de la classe TextField fournissent des fonctionnalités utiles à vos applications.
Vous pouvez par exemple contrôler l’épaisseur d’un champ de texte à l’aide d’ActionScript,
comme le démontre l’exemple suivant.
Pour définir l’épaisseur d’un champ de texte à l’aide d’ActionScript :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom textfieldThickness.fla.
2.
Ouvrez le panneau Bibliothèque et sélectionnez Nouvelle police dans le menu contextuel
(dans le coin supérieur droit du panneau Bibliothèque).
La boîte de dialogue Propriétés des symboles de police s’ouvre. Cette boîte de dialogue
vous invite à sélectionner une police à intégrer dans le fichier SWF (ainsi qu’un style et
une taille de police). Vous pouvez également affecter un nom de police affiché dans la
bibliothèque du document et le menu déroulant Police de l’inspecteur des propriétés (si
un champ de texte est sélectionné sur la scène).
a.
Sélectionnez le nom de police Times New Roman dans le menu déroulant Police.
b.
Assurez-vous de désactiver les options Gras et Italique.
c.
Définissez la taille sur 30 pixels.
d.
Saisissez le nom de police Times (intégrée)
e.
Cliquez sur OK.
442
Utilisation du texte et des chaînes
3.
Dans la bibliothèque, cliquez avec le bouton droit de la souris sur le symbole de la police et
sélectionnez Liaison dans le menu contextuel.
Flash affiche la boîte de dialogue Propriétés de liaison.
4.
Sélectionnez Exporter pour ActionScript, puis Exporter dans la première image et cliquez
sur OK.
5.
Ajoutez l’ActionScript suivant à l’Image 1 du scénario :
// 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
var mouseListener:Object = new Object();
mouseListener.onMouseMove = function():Void {
// Les valeurs de TextField.thickness peuvent varier de -200 à +200.
lorem_txt.thickness = Math.round(_xmouse * (400 / Stage.width) - 200);
thickness_txt.text = "TextField.thickness = " + lorem_txt.thickness;
};
Mouse.addListener(mouseListener);
Le premier bloc de code crée deux champs de texte, thickness_txt et lorem_txt, puis
les place sur la scène. Le champ de texte lorem_txt définit sa propriété embedFonts sur
true et peuple le champ de texte à l’aide d’un bloc de texte.
Le deuxième bloc de code définit un format de texte avec la police Times New Roman,
définit la taille de la police sur 30 pixels et applique le format de texte au champ
lorem_txt.
Le troisième et dernier bloc de code définit un écouteur de souris et l’affecte à l’événement
Lorsque le pointeur de la souris se déplace horizontalement sur la scène, la
propriété TextField.thickness varie de -200 à +200, selon la valeur actuelle de
_xmouse.
onMouseMove.
Utilisation des polices
443
6.
Enregistrez vos modifications dans le fichier FLA.
7.
Choisissez Contrôle > Tester l’animation pour tester votre document Flash.
Lorsque vous déplacez le pointeur de la souris vers la moitié gauche de la scène, l’épaisseur
de la police diminue. Lorsque vous déplacez le pointeur de la souris vers la moitié droite
de la scène, l’épaisseur de la police augmente.
A propos du partage des polices
Pour utiliser une police en tant qu’élément de bibliothèque partagé, vous pouvez créer un
symbole de police dans le panneau Bibliothèque, puis affecter les attributs suivants au symbole
de police :
■
Une chaîne d’identifiant
■
Une URL sur laquelle le document contenant le symbole de police sera placé
Ainsi, vous pouvez effectuer une liaison avec la police et l’utiliser dans une application Flash
sans que la police ne soit stockée dans un fichier FLA.
Présentation du rendu d’un texte
anti-alias
Le rendu des polices dans Flash contrôle l’apparence de votre texte dans un fichier SWF ;
c’est-à-dire la manière dont il est rendu (ou tracé) à l’exécution. La technologie de rendu
avancé des polices utilisée dans Flash Player 8, appelée FlashType. FlashType utilise la
technologie de rendu avancé pour contribuer à rendre le texte lisible et clair même avec les
polices de taille réduite ou moyenne, par exemple lorsque vous appliquez l’anti-alias avancé à
vos champs de texte. Cette technologie est présentée plus en détails ci-après dans cette section.
L’anti-aliasing vous permet de lisser le texte de sorte que les contours des caractères affichés à
l’écran soient plus réguliers. Cette fonctionnalité est très utile pour afficher du texte de petite
taille. L’option anti-alias pour le texte rend les caractères plus lisibles en alignant le contour du
texte le long des limites de pixels ; elle est particulièrement efficace pour obtenir un rendu plus
clair des polices de petite taille. Vous pouvez appliquer l’anti-alias à chaque champ de texte de
votre application, plutôt qu’à des caractères individuels.
L’anti-aliasing est pris en charge pour le texte statique, dynamique et de saisie, lorsque
l’utilisateur est équipé de Flash Player 7 ou d’une version ultérieure. Avec une version
antérieure de Flash Player, elle ne fonctionne que pour le texte statique. Les options d’antialias avancées sont disponibles pour Flash Player 8.
444
Utilisation du texte et des chaînes
Flash Basic 8 et Flash Professionnel 8 intègrent une technologie de rastérisation et de rendu
des polices nettement améliorée appelée FlashType, qui permet de travailler avec des polices
anti-aliasées. Flash 8 comprend cinq méthodes de rendu des polices, lesquelles ne sont
disponibles que lorsque vous publiez des fichiers SWF pour Flash Player 8. Si vous publiez des
fichiers à utiliser avec Flash Player 7 ou des versions antérieures, seule l’option Anti-Alias pour
l’animation est disponible pour vos champs de texte.
FlashType est une technologie de rendu des polices de haute qualité que vous pouvez activer
en utilisant l’outil auteur de Flash 8 ou ActionScript. La technologie FlashType vous permet
de bénéficier d’un rendu des polices de haute qualité même pour les polices de petite taille, en
disposant d’un meilleur contrôle. Vous pouvez appliquer FlashType au rendu des polices
intégrées pour les champs de texte statiques, dynamiques et de saisie. Les capacités améliorées
signifient que le texte intégré apparaît au même niveau de qualité que le texte de périphérique
et que les polices présentent le même aspect sur différentes plates-formes.
Les méthodes de rendu des polices disponibles pour Flash Player 8 sont Polices de
périphérique, Texte bitmap (sans anti-alias), Anti-alias pour l’animation, Anti-alias pour la
lisibilité et Anti-alias personnalisé, qui vous permet de définir une valeur personnalisée pour
l’épaisseur et la netteté. Pour plus d’informations sur ces options, consultez Options de rendu
des polices dans Flash, page 446.
REMARQUE
Lorsque vous ouvrez des fichiers FLA existants dans Flash 8, votre texte n’est pas
automatiquement mis à jour vers l’otion Anti-alias pour la lisibilité ; vous devez
sélectionner des champs de texte individuels et modifier manuellement les paramètres
d’anti-alias afin de bénéficier de la technologie de rendu FlashType.
Les fonctionnalités d’anti-alias avancées et personnalisées prennent en charge les éléments
suivants :
■
Mise à l’échelle et rotation de texte
■
Toutes les polices (normal, gras ou italiques) jusqu’à la taille de 255 pt
■
L’exportation de fichiers vers la plupart des formats (tels que les fichiers JPEG ou GIF)
Présentation du rendu d’un texte anti-alias
445
Les fonctionnalités d’anti-alias avancées et personnalisées ne prennent pas en charge les
éléments suivants :
■
Flash Player 7 ou versions antérieures
■
Texte incliné ou renversé
■
Impression
■
Exportation de fichiers vers le format PNG
REMARQUE
Lorsque le texte est animé, le lecteur désactive l’anti-alias avancé afin d’améliorer
l’apparence de votre texte pendant son déplacement. Une fois l’animation terminée,
l’anti-alias est réactivé.
Un exemple de fichier sur votre disque dur vous présente l’application et la manipulation de
texte anti-aliasé dans une application. Vous utilisez la technologie de rendu FlashType pour
créer un petit texte néanmoins très lisible. Cet exemple présente également le défilement
rapide et fluide des champs de texte à l’aide de la propriété cacheAsBitmap.
Vous trouverez un exemple de fichier source, flashtype.fla, dans le dossier Samples de votre
disque dur.
Sous Windows, ouvrez le répertoire lecteur d’initialisation\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\FlashType.
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/FlashType.
Options de rendu des polices dans Flash
Cins options différentes de rendu des polices sont disponibles dans Flash 8. Pour sélectionner
une option, choisissez le champ de texte et ouvrez l’inspecteur des propriétés. Sélectionnez
une option dans le menu contextuel des Méthode de rendu des polices.
Polices de périphérique
Produit un fichier SWF de plus petite taille. Cette option assure
le rendu en utilisant les polices actuellement installées sur l’ordinateur de l’utilisateur final.
Texte Bitmap (sans anti-alias) Produit un texte aux bords nets, sans anti-alias. Cette
option génère un fichier SWF plus volumineux, car le contour des polices est inclus dans le
fichier SWF.
446
Utilisation du texte et des chaînes
Anti-Alias pour l’animation
Produit un texte anti-alias à l’animation fluide. L’animation du
texte est également plus rapide dans certains cas, car l’alignement et l’anti-aliasing ne sont pas
appliqués pendant l’animation. Vous ne constatez pas d’amélioration des performances
lorsque vous utilisez des polices de grande taille comprenant beaucoup de lettres ou des polices
mises à l’échelle. Cette option génère un fichier SWF plus volumineux, car le contour des
polices est inclus dans le fichier SWF.
Anti-Alias pour la lisibilité
Le moteur d’anti-alias avancé est utilisé pour cette option. Elle
offre le plus haut niveau de qualité de texte et la meilleure lisibilité. Elle donne aussi le plus
gros fichier SWF car ce dernier inclut les contours des polices et des informations spéciales sur
l’anti-aliasing.
Anti-alias personnalisé Identique à l’anti-alias pour la lisibilité, si ce n’est que vous pouvez
manipuler visuellement les paramètres d’anti-alias pour obtenir un aspect spécifique. Cette
option est utile pour donner la meilleure apparence possible aux polices nouvelles ou rares.
Pour obtenir un exemple d’utilisation de l’anti-alias avec ActionScript, consultez Définition de
l’anti-alias avec ActionScript, page 447.
A propos de la modulation continue des traits
La technologie de rendu des polices FlashType exploite les propriétés inhérentes aux champs
de distance afin d’offrir une modulation continue des traits (CSM) ; par exemple, la
modulation continue du poids des traits et de la netteté des contours du texte. CSM utilise
deux paramètres de rendu pour contrôler le mappage des distances des champs de distance
échantillonnées de manière adaptative (ADF) par rapport aux vaneurs de densité des glyphes.
Les valeurs optimales de ces paramètres sont extrêmement subjectives ; elles peuvent dépendre
des préférences de l’utilisateur, des conditions d’éclairage, des propriétés de l’affichage, de la
police, des couleurs d’avant-plan et d’arrière-plan et de la taille des points. La fonction qui
mappe les distances ADF par rapport aux valeurs de densité présente une limite extérieure
sous laquelle les valeurs sont définies sur 0, et une limite intérieure, au-dessus de laquelle les
valeurs sont réglées sur une valeur de densité maximale, telle que 255.
Définition de l’anti-alias avec ActionScript
Flash 8 offre deux types d’anti-alias : normal et avancé. L’anti-alias avancé est disponible
uniquement dans Flash Player 8 et les versions ultérieures et peut uniquement être utilisé si
vous intégrez la police dans la bibliothèque et si la propriété embedFonts du champ de texte
est définie sur true. Pour Flash Player 8, le paramètre par défaut des champs de texte créés à
l’aide d’ActionScript est normal.
Présentation du rendu d’un texte anti-alias
447
Pour définir les valeurs de la propriété TextField.antiAliasType, utilisez les valeurs de
chaîne suivantes :
normal
Applique l’anti-alias de texte normal. Cela correspond au type d’anti-alias utilisé par
Flash Player dans la version 7 et les versions antérieures.
avancé Applique l’anti-alias avancé pour améliorer la lisibilité du texte, qui est disponible
dans Flash Player 8. L’anti-alias avancé permet un rendu de grande qualité des polices de petite
taille. Il est préférable de l’utiliser avec les applications comprenant une grande quantité de
texte de petite taille.
CONSEIL
Macromedia ne recommande pas l’anti-alias avancé pour les polices de plus de 48
points.
Pour utiliser ActionScript afin de définir le texte d’anti-alias, consultez l’exemple suivant.
Pour utiliser l’anti-alias avancé :
1.
Créez un nouveau document Flash et enregistrez-le sous le nom antialiastype.fla.
2.
Créez deux clips sur la scène et attribuez-leur les noms d’occurrences normal_mc et
advanced_mc.
Vous utiliserez ces clips pour alterner entre les deux types d’anti-alias : normal et avancé.
3.
Ouvrez le panneau Bibliothèque et sélectionnez Nouvelle police dans le menu contextuel
dans le coin supérieur droit du panneau Bibliothèque.
La boîte de dialogue Propriétés des symboles de police s’ouvre et vous permet de
sélectionner une police à intégrer dans le fichier SWF (y compris le style et la taille de la
police). Vous pouvez également attribuer un nom de police qui apparaît dans la
bibliothèque du document et dans le menu déroulant Polices de l’inspecteur des propriétés
(si un champ de texte est sélectionné sur la scène).
4.
a.
Sélectionnez la police Arial dans le menu déroulant Polices.
b.
Assurez-vous que les options Gras et Italique ne sont pas sélectionnées.
c.
Définissez la taille sur 10 pixels.
d.
Entrez le nom Arial-10 (embedded).
e.
Cliquez sur OK.
Dans la bibliothèque, cliquez avec le bouton droit de la souris sur le symbole de la police et
sélectionnez Liaison dans le menu contextuel.
La boîte de dialogue Propriétés de liaison apparaît.
5.
Sélectionnez les options Exporter pour ActionScript et Exporter dans la première image,
entrez l’identifiant de liaison Arial-10 et cliquez sur OK.
448
Utilisation du texte et des chaînes
6.
Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
var text_fmt:TextFormat = new TextFormat();
text_fmt.font = "Arial-10";
text_fmt.size = 10;
this.createTextField("my_txt", 10, 20, 20, 320, 240);
my_txt.autoSize = "left";
my_txt.embedFonts = true;
my_txt.selectable = false;
my_txt.setNewTextFormat(text_fmt);
my_txt.multiline = true;
my_txt.wordWrap = true;
var lorem_lv:LoadVars = new LoadVars();
lorem_lv.onData = function(src:String) {
if (src != undefined) {
my_txt.text = src;
} else {
my_txt.text = "unable to load text file.";
}
};
lorem_lv.load("http://www.helpexamples.com/flash/lorem.txt");
normal_mc.onRelease = function() {
my_txt.antiAliasType = "normal";
};
advanced_mc.onRelease = function() {
my_txt.antiAliasType = "advanced";
};
Le code précédent est divisé en quatre zones clés. Le premier bloc de code crée un nouvel
objet TextFormat, qui spécifie une police et une taille de police à utiliser pour un champ
de texte qui sera créé prochainement. La police spécifiée, Arial-10, est l’identifiant de
liaison pour le symbole de police que vous avez intégré lors d’une étape précédente.
Le deuxième bloc de code crée un nouveau champ de texte portant le nom d’occurrence
my_txt. Pour que la police soit correctement intégrée, vous devez définir embedFonts sur
true pour l’occurrence du champ de texte. Le code définit également le formatage du
texte pour le nouveau champ de texte en fonction de l’objet TextFormat créé
antérieurement.
Le troisième bloc de code définit une occurrence de LoadVars qui peuple le champ de
texte de la scène avec le contenu d’un fichier de texte externe. Une fois le document
entièrement chargé (mais pas analysé), tout le contenu du fichier est copié dans la
propriété my_txt.text, de sorte qu’il apparaît sur la scène.
Le quatrième et dernier bloc de code définit les gestionnaires d’événements onRelease pour
le clip normal_mc et le clip advanced_mc. Lorsque l’utilisateur clique et libère l’une de ces
options, le type d’anti-alias correspondant au champ de texte de la scène est modifié.
Présentation du rendu d’un texte anti-alias
449
7.
Enregistrez vos modifications dans le fichier FLA.
8.
Choisissez Contrôle > Tester l’animation pour tester votre document Flash.
9.
Cliquez sur le clip advanced_mc sur la scène.
Un clic sur le clip fait basculer le type d’anti-alias de normal (la valeur par défaut) à
avancé. Lorsque vous traitez des champs de texte contenant une taille de police plus petite,
la définition de l’anti-alias sur avancé peut améliorer considérablement la lisibilité du
texte.
C O N S E IL
L’anti-alias avancé offre un rendu de haute qualité pour les polices de petite taille. Il
est préférable de l’utiliser avec les applications comprenant une grande quantité de
texte de petite taille. Macromedia ne recommande pas l’anti-alias avancé pour les
polices de plus de 48 points.
Pour plus d’informations sur le formatage de texte anti-alias, consultez Utilisation d’un type
d’insertion dans la grille, page 457 et Présentation du formatage du texte anti-alias, page 454.
Un exemple de fichier sur votre disque dur vous présente l’application et la manipulation de
texte anti-aliasé dans une application. Vous utilisez la technologie de rendu FlashType pour
créer un petit texte néanmoins très lisible. Cet exemple présente également le défilement
rapide et fluide des champs de texte à l’aide de la propriété cacheAsBitmap.
Vous trouverez un exemple de fichier source, flashtype.fla, dans le dossier Samples de votre
disque dur.
Sous Windows, ouvrez le répertoire lecteur d’initialisation\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\FlashType.
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/FlashType.
Définition des tableaux pour les polices
Si vous créez des polices à utiliser dans les fichiers SWF ou à distribuer aux développeurs
Flash, vous devrez peut-être définir des tableaux de polices afin de contrôler leur rendu sur la
scène.
L’anti-alias avancé utilise des champs de distance échantillonnés de manière adaptative (ADF)
pour représenter lescontours déterminant un glyphe (un caractère). Flash utilise deux valeurs :
■
Une valeur de limite extérieure, sous laquelle les densités sont définies sur 0.
■
Une valeur de limite intérieure, au-dessus de laquelle les densités sont définies sur une
densité maximale, telle que 255.
Entre ces deux valeurs limites, la fonction de mappage est une courbe linéaire qui varie entre 0
à la limite extérieure et la densité maximale à la limite intérieure.
450
Utilisation du texte et des chaînes
L’ajustement des valeurs limites extérieure et intérieure affecte le poids des traits et la netteté
des bords. L’espacement entre ces deux paramètres est comparable à deux fois le rayon de filtre
des méthodes d’anti-alias classiques ; un espacement étroit fournit un bord plus net, alors
qu’un espacement plus important offre des bords plus doux et plus filtrés. Lorsque
l’espacement est de 0, l’image de densité produite est un bitmap à deux niveaux. Lorsque
l’espacement est très large, l’image de densité produite présente des bords évoquant une
aquarelle.
Généralement, les utilisateurs préfèrent les bords nets et très contrastés pour les polices de
petite taille et des bords plus doux pour les textes animés et les polices plus grandes.
La limite extérieure possède généralement une valeur négative, la limite intérieure présentant
une valeur positive et le point intermédiaire est proche de 0. L’ajustement de ces paramètres
pour déplacer le point intermédiaire vers l’infini négatif augmente le poids du trait ; son
déplacement vers l’infini négatif réduit le poids du trait.
REMARQUE
La limite extérieure devrait toujours être inférieure ou égale à la limite intérieure.
Flash Player comprend des paramètres d’anti-alias avancés pour dix polices de base ; pour ces
dernières, les paramètres d’anti-alias avancé sont uniquement fournis pour les tailles de police
de 6 à 20. Pour ces polices, toutes les tailles inférieures à 6 utilisent les paramètres liés à la taille
6, alors que les tailles supérieures à 20 utilisent les paramètres liés à la taille 20. Les autres
polices sont mappées vers les données des polices fournies. La méthode
setAdvancedAntialiasingTable() vous permet de définir des données d’anti-alias
personnaliisées pour d’autres polices et d’autres tailles de polices, ou de remplacer les
paramètres par défaut des polices fournies. Pour plus d’informations sur la création d’un
tableau d’anti-alias, reportez-vous à l’exemple suivant :
Pour créer un tableau d’anti-alias avancé pour une police intégrée :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom advancedaatable.fla.
2.
Sélectionnez Nouvelle police dans le menu contextuel Bibliothèque.
3.
Sélectionnez Arial dans le menu contextuel Police, puis définissez la taille de la police sur
32 points.
4.
Sélectionnez les options Gras et Italique.
5.
Entrez le nom de police Arial (embedded) dans le champ Nom et cliquez sur OK.
6.
Cliquez avec le bouton droit de la souris (Windows) ou appuyez sur la touche Contrôle
(Macintosh) dans la Bibliothèque, et choisissez Liaison.
Présentation du rendu d’un texte anti-alias
451
7.
8.
Dans la boîte de dialogue Propriétés de liaison :
a.
Tapez Arial-embedded dans le champ Identifiant.
b.
Sélectionnez Exporter pour ActionScript et Exporter dans la première image.
c.
Cliquez sur OK.
Sélectionnez Image 1 pour le scénario principal, puis ajoutez l’ActionScript suivant dans le
panneau Actions :
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.multiline = true;
my_txt.setNewTextFormat(my_fmt);
my_txt.sharpness = 0;
my_txt.thickness = 0;
my_txt.wordWrap = true;
var lorem_lv:LoadVars = new LoadVars();
lorem_lv.onData = function(src:String):Void {
if (src != undefined) {
my_txt.text = src + "\n\n" + src;
} else {
trace("erreur lors du téléchargement du fichier texte");
}
};
lorem_lv.load("http://www.helpexamples.com/flash/lorem.txt");
452
Utilisation du texte et des chaînes
Le code précédent est divisé en quatre sections. La première section de code importe la
classe TextRenderer et définit un nouveau tableau d’anti-alias pour deux tailles différentes
de la police Arial. La deuxième section de code définit un nouvel objet TextFormat, que
vous utiliserez pour appliquer le formatage de texte au champ de texte (que vous créez
dans la section de code suivante). La section de code suivante crée un nouveau champ de
texte portant le nom d’occurrence my_txt, active l’anti-alias avancé, applique l’objet de
format de texte (créé antérieurement) et active le texte multiligne et le retour à la ligne. Le
dernier bloc de code définit un objet LoadVars que vous utilisez pour charger du texte à
partir d’un fichier de texte externe et peupler le champ de texte sur la scène.
9.
Choisissez Contrôle > Tester l’animation pour tester le document Flash.
Une fois le texte chargé à partir du serveur distant, Flash affiche du texte dans le champ de
texte, ce qui vous permet d’observer l’effet des propriétés du tableau d’anti-alias avancé sur
votre champ de texte. La police intégrée sur la scène devrait apparaître légèrement floue en
raison des valeurs actuelles de insideCutoff et outsideCutoff.
Présentation de la mise en forme et du
formatage du texte
Vous pouvez contrôler la mise en forme et le formatage du texte à l’aide d’ActionScript. La
classe TextFormat permet de contrôler l’apparence du texte à l’exécution, en plus des autres
formes de formatage telles que les feuilles de style (consultez Formatage de texte avec les feuilles
de style CSS, page 462) et le texte HTML (consultez Utilisation de texte au format HTML,
page 477).
Vous pouvez également contrôler l’insertion des caractères dans la grille à l’aide d’ActionScript
lorsque vous utilisez le texte anti-alias dans un fichier SWF. Cela vous permet de contrôler
l’apparence des caractères à l’exécution. Pour obtenir un exemple de l’utilisation d’un type
d’insertion dans la grille de vos applications, consultez Utilisation d’un type d’insertion dans la
grille, page 457.
Pour plus d’informations sur les champs de texte, consultez A propos des champs de texte,
page 417. Pour plus d’informations sur le formatage du texte, consultez Présentation du
formatage du texte anti-alias, page 454. Pour plus d’informations sur la classe TextFormat,
consultez Utilisation de la classe TextFormat, page 459 et TextFormat dans le Guide de
référence du langage ActionScript.
Présentation de la mise en forme et du formatage du texte
453
Pour plus d’informations sur la mise en forme et le formatage du texte à l’aide de la classe
TextFormat, consultez les sections suivantes :
■
Présentation du formatage du texte anti-alias, page 454
■
Utilisation d’un type d’insertion dans la grille, page 457
■
Utilisation de la classe TextFormat, page 459
■
Propriétés par défaut des nouveaux champs de texte, page 461
Présentation du formatage du texte anti-alias
Flash 8 présente deux nouvelles propriétés que vous pourrez utiliser pour formater des champs
de texte alors que l’anti-alias avancé est activé : sharpness et thickness. Sharpness fait
référence à la quantité d’alias appliquée à l’occurrence du champ de texte. Une valeur de
netteté élevée donne aux bords de la police intégrée un aspect découpé et net. La définition de
la netteté sur une valeur inférieure donne à la police un aspect plus doux, un peu plus flou. La
définition de l’épaisseur d’une police est similaire à l’activation du formatage gras pour un
champ de texte. Plus l’épaisseur est importante, plus la police prend un aspect gras.
L’exemple suivant charge dynamiquement un fichier de texte et affiche le texte sur la scène. Le
déplacement du pointeur de la souris le long de l’axe des x définit la netteté entre - 400 et 400.
Le déplacement du pointeur de la souris le long de l’axe des y définit l’épaisseur entre - 200 et
200.
Pour modifier la netteté et l’épaisseur d’un champ de texte :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom sharpness.fla.
2.
Sélectionnez Nouvelle police dans le menu contextuel dans le coin supérieur droit du
panneau Bibliothèque.
3.
Sélectionnez Arial dans le menu déroulant Police, puis définissez la taille de la police sur
24 points.
4.
Entrez le nom de police Arial-24 (embedded) dans le champ Nom et cliquez sur OK.
5.
Cliquez avec le bouton droit de la souris sur le symbole de la police dans la bibliothèque et
sélectionnez Liaison pour ouvrir la boîte de dialogue Propriétés de liaison.
6.
Définissez l’identifiant de liaison sur Arial-4, cochez les cases Exporter pour ActionScript
et Exporter dans la première image, puis cliquez sur OK.
454
Utilisation du texte et des chaînes
7.
Ajoutez le code suivant à l’image 1 du scénario principal :
var my_fmt:TextFormat = new TextFormat();
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;
var lorem_lv:LoadVars = new LoadVars();
lorem_lv.onData = function(src:String) {
lorem_txt.text = src;
}
lorem_lv.load("http://www.helpexamples.com/flash/lorem.txt");
var mouseListener:Object = new Object();
mouseListener.onMouseMove = function():Void {
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);
};
Mouse.addListener(mouseListener);
Présentation de la mise en forme et du formatage du texte
455
Ce code ActionScript peut être divisé en cinq sections clés. La première section de code
définit une nouvelle occurrence de TextFormat qui sera appliquée à un champ de texte
créé dynamiquement. Les deux sections suivantes créent deux nouveaux champs de texte
sur la scène. La premier champ de texte, lorem_txt, applique l’objet de formatage de
texte personnalisé créé antérieurement, active les polices intégrées et définit la propriété
antiAliasType sur true. Le deuxième champ de texte, debug_txt, affiche les valeurs
actuelles de netteté et d’épaisseur de la police pour le champ de texte lorem_txt. La
quatrième section de code crée un objet LoadVars, responsable du chargement du fichier
de texte externe et de peupler le champ de texte lorem_txt. La cinquième et dernière
section de code définit un écouteur de souris qui est appelé chaque fois que le pointeur de
la souris se déplace sur la scène. Les valeurs actuelles de netteté et d’épaisseur sont
calculées en fonction de la position actuelle du pointeur de la souris sur la scène. Les
propriétés netteté et épaisseur sont définies pour le champ de texte lorem_txt et les
valeurs actuelles s’affichent dans le champ de texte debug_txt.
8.
Sélectionnez Contrôle > Tester l’animation pour tester le document.
Déplacez le pointeur de la souris le long de l’axe des x afin de modifier la netteté du champ
de texte. Déplacez le pointeur de la souris de gauche à droite pour augmenter la netteté et
donner au texte un aspect plus découpé. Déplacez le pointeur de la souris le long de l’axe
des y afin de modifier l’épaisseur du champ de texte.
Pour plus d’informations sur l’utilisation de texte anti-alias dans un fichier SWF, consultez les
rubriques Définition de l’anti-alias avec ActionScript, page 447, Options de rendu des polices
dans Flash, page 446 et Utilisation d’un type d’insertion dans la grille, page 457.
Un exemple de fichier sur votre disque dur vous présente l’application et la manipulation de
texte anti-aliasé dans une application. Vous utilisez la technologie de rendu FlashType pour
créer un petit texte néanmoins très lisible. Cet exemple présente également le défilement
rapide et fluide des champs de texte à l’aide de la propriété cacheAsBitmap.
Vous trouverez un exemple de fichier source, flashtype.fla, dans le dossier Samples de votre
disque dur.
Sous Windows, ouvrez le répertoire lecteur d’initialisation\Program Files\Macromedia\Flash
8\Samples and Tutorials\Samples\ActionScript\FlashType.
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/FlashType.
456
Utilisation du texte et des chaînes
Utilisation d’un type d’insertion dans la grille
Lorsque vous utilisez l’anti-alias avancé sur un champ de texte, trois types d’insertion dans une
grille sont disponibles :
aucune
L’insertion dans une grille n’est pas utilisée. Les lignes horizontales et verticales des
glyphes ne sont pas forcées dans la grille des pixels. Ce paramètre est généralement utile pour
l’animation et pour les polices de grande taille.
pixel Spécifie que les lignes horizontales et verticales fortes sont insérées dans la grille des
pixels. Ce paramètre fonctionne uniquement avec les champs de texte alignés à gauche. Il offre
généralement la meilleure lisibilité pour le texte aligné à gauche.
sous-pixel Spécifie que les lignes horizontales et verticales fortes sont insérées dans la grille
des sous-pixels sur un écran à cristaux liquides. Le paramètre sous-pixel est généralement utile
pour le texte dynamique aligné à droite ou centré, et permet souvent de trouver un bonne
équilibre entre animation et qualité du texte.
L’exemple suivant présente la procédure à suivre pour définir un type d’insertion dans une
grille dans un champ de texte à l’aide d’ActionScript.
Pour définir un type d’insertion dans une grille dans un champ de texte :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom gridfittype.fla.
2.
Sélectionnez Nouvelle police dans le menu contextuel dans le coin supérieur droit du
panneau Bibliothèque.
3.
Sélectionnez Arial dans le menu déroulant Police, puis définissez la taille de la police sur 10
points.
4.
Entrez le nom de police Arial-10 (embedded) dans le champ Nom et cliquez sur OK.
5.
Cliquez avec le bouton droit de la souris sur le symbole de la police dans la bibliothèque et
sélectionnez Liaison pour ouvrir la boîte de dialogue Propriétés de liaison.
6.
Définissez l’identifiant de liaison sur Arial-10, puis cochez les cases Exporter pour
ActionScript et Exporter dans la première image.
7.
Cliquez sur OK.
8.
Ajoutez le code suivant à l’image 1 du scénario principal :
var my_fmt:TextFormat = new TextFormat();
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;
Présentation de la mise en forme et du formatage du texte
457
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;
var lorem_lv:LoadVars = new LoadVars();
lorem_lv.onData = function(src:String):Void {
if (src != undefined) {
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");
}
};
lorem_lv.load("http://www.helpexamples.com/flash/lorem.txt");
458
Utilisation du texte et des chaînes
Le code ActionScript précédent peut être divisé en cinq sections. La première section
définit un nouvel objet de format de texte spécifiant deux propriétés, size et font. La
propriété font fait référence à l’identifiant de liaison du symbole de police figurant
actuellement dans la bibliothèque du document. Les deuxième, troisième et quatrième
sections de code créent chacune un nouveau champ de texte dynamique sur la scène et
définissent certaines propriétés communes : antiAliasType (qui doit être défini sur
avancé), embedFonts (défini sur true), multiline et wordWrap. Chaque section
applique également l’objet de format de texte créé dans une section précédente et définit le
type d’insertion dans une grille sur normal, pixel ou sous-pixel. La cinquième et
dernière section crée une occurrence de LoadVars, qui charge le contenu d’un fichier de
texte externe dans chacun des champs de texte que vous créez avec du code.
9.
Enregistrez le document et choisissez Contrôle > Tester l’animation pour tester le fichier
SWF.
Chaque champ de texte doit être initialisé avec la valeur “chargement...”. Une fois le
fichier de texte externe chargé avec succès, chaque champ de texte affiche un exemple de
texte formaté utilisant un type différent d’insertion dans une grille.
CONSEIL
La technologie de rendu FlashType utilise l’insertion dans une grille uniquement si la
rotation est de 0°.
Utilisation de la classe TextFormat
Vous pouvez utiliser la classe TextFormat pour définir les propriétés de formatage d’un champ
de texte. Cette classe intègre des informations sur le formatage des caractères et des
paragraphes. Les informations sur le formatage des caractères décrivent l’apparence des
différents caractères : nom de police, taille, couleur et URL associée. Les informations sur le
formatage des paragraphes décrivent l’apparence d’un paragraphe : marge de gauche, marge de
droite, indentation de la première ligne, ainsi qu’alignement à gauche, droite ou au centre.
Pour utiliser la classe TextFormat, vous devez d’abord créer un objet TextFormat et définir ses
styles de formatage de caractères et de paragraphes. Appliquez ensuite l’objet TextFormat à un
champ de texte à l’aide des méthodes TextField.setTextFormat() ou
TextField.setNewTextFormat().
Présentation de la mise en forme et du formatage du texte
459
La méthode setTextFormat() modifie le format de texte appliqué à chaque caractère, à des
groupes de caractères ou à tout le texte d’un champ de texte. Cependant, le texte
nouvellement inséré (saisi par l’utilisateur ou inséré par du code ActionScript) n’adopte pas le
formatage spécifié par un appel de la méthode setTextFormat(). Pour spécifier le formatage
par défaut d’un texte nouvellement inséré, utilisez TextField.setNewTextFormat(). Pour
plus d’informations, voir setTextFormat (TextField.setTextFormat method) and
setNewTextFormat (TextField.setNewTextFormat method) dans le Guide de référence du
langage ActionScript 2.0.
Pour formater un champ de texte avec la classe TextFormat :
1.
Dans un nouveau document Flash, créez un champ de texte sur la scène à l’aide de l’outil
Texte.
Tapez du texte dans le champ de texte sur la scène; par exemple «Texte gras, italique, 24
points».
2.
Dans l’inspecteur des propriétés, tapez myText_txt dans la zone de texte Nom de
l’occurrence, sélectionnez Dynamique dans le menu contextuel Type de texte et
sélectionnez Multiligne dans le menu contextuel Type de ligne.
3.
Sélectionnez l’image 1 dans le scénario et ouvrez le panneau Actions (Fenêtre>Actions).
4.
Entrez le code suivant dans le panneau Actions pour créer un objet TextFormat et
définissez ses propriétés bold et italic sur la valeur true et sa propriété size sur 24.
// Créez un objet TextFormat.
var txt_fmt:TextFormat = new TextFormat();
// Spécifiez le formatage des paragraphes et des caractères.
txt_fmt.bold = true;
txt_fmt.italic = true;
txt_fmt.size = 24;
5.
Appliquez l’objet TextFormat au champ de texte que vous avez créé à l’étape 1 en utilisant
TextField.setTextFormat().
myText_txt.setTextFormat(txt_fmt);
Cette version de setTextFormat() applique le formatage spécifié à l’intégralité du champ
de texte. Deux autres versions de cette méthode vous permettent d’appliquer le formatage
à des caractères individuels ou à des groupes de caractères. Par exemple, le code suivant
applique le formatage gras, italique, 24 points aux trois premiers caractères que vous avez
entrés dans le champ texte :
myText_txt.setTextFormat(0, 3, txt_fmt);
Pour plus d’informations, voir setTextFormat (TextField.setTextFormat method) and
setNewTextFormat (TextField.setNewTextFormat method) dans le Guide de référence du
langage ActionScript 2.0.
460
Utilisation du texte et des chaînes
6.
Choisissez Contrôle > Tester l’animation pour tester l’application.
Pour plus d’informations sur l’utilisation de la classe TextFormat, consultez les rubriques
suivantes :
■
Propriétés par défaut des nouveaux champs de texte, page 461
■
Formatage de texte avec les feuilles de style CSS, page 462
Propriétés par défaut des nouveaux champs de texte
Les champs de texte créés à l’exécution avec createTextField() reçoivent un objet
TextFormat par défaut avec les propriétés suivantes :
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 = ""
REMARQUE
La propriété de police par défaut sur Mac OS X est Times.
Pour obtenir une liste complète des méthodes TextFormat et leur description, consultez
TextFormat dans le Guide de référence du langage ActionScript.
Présentation de la mise en forme et du formatage du texte
461
Formatage de texte avec les feuilles de
style CSS
Les styles CSS (feuilles de style en cascade) permettent de travailler avec des styles de texte
pouvant être appliqués à des documents HTML ou XML. Une feuille de style est un ensemble
de règles de formatage qui spécifie comment formater des éléments HTML ou XML. Chaque
règle associe un nom de style, ou sélecteur, à une ou plusieurs propriétés de style ainsi qu’à leurs
valeurs. Par exemple, le style suivant définit un sélecteur nommé bodyText.
.bodyText {
text-align: left
}
Vous pouvez créer des styles définissant les balises de formatage HTML intégrées que Flash
Player utilise (telles que <p> et <li>). Vous pouvez également créer des classes de style qui
peuvent être appliquées à des éléments HTML spécifiques à l’aide de l’attribut <p> ou <span>
des classes de balises, ou définir de nouvelles balises.
Utilisez la classe TextField.StyleSheet pour utiliser les feuilles de style de texte. Bien que la
classe TextField puisse être utilisée avec Flash Player 6, la classe TextField.StyleSheet nécessite
des fichiers SWF conçus pour Flash Player 7 ou une version plus récente. Vous pouvez charger
des styles à partir d’un fichier CSS externe ou les créer de façon native en utilisant
ActionScript. Pour appliquer une feuille de style à un champ de texte contenant du texte au
format HTML ou XML, utilisez la propriété TextField.styleSheet. Les styles définis dans
la feuille de style sont automatiquement mis en correspondance avec les balises définies dans le
document HTML ou XML.
Pour utiliser des feuilles de style, vous devez suivre trois étapes essentielles :
■
Créez un objet de feuille de style à partir de la classe TextField.StyleSheet (pour plus
d’informations, consultez StyleSheet (TextField.StyleSheet) dans le Guide de référence du
langage ActionScript 2.0).
■
Ajoutez des styles à l’objet feuille de style, soit en les chargeant à partir d’un fichier CSS
externe, soit en créant de nouveaux styles avec ActionScript.
■
Affecter la feuille de style à un objet TextField contenant du texte au format XML ou
HTML.
462
Utilisation du texte et des chaînes
Pour plus d’informations, se reporter aux sections suivantes :
■
Propriétés CSS prises en charge, page 463
■
Création d’un objet feuille de style, page 465
■
Chargement de fichiers CSS externes, page 465
■
Création de nouveaux styles avec ActionScript, page 467
■
Application de styles à un objet TextField, page 467
■
Application d’une feuille de style à un composant TextArea, page 468
■
Association de styles, page 469
■
Utilisation des classes de style, page 470
■
Définition du style de balises HTML intégrées, page 470
■
Exemple d’utilisation de styles avec HTML, page 471
■
Utilisation de styles pour définir de nouvelles balises, page 474
■
Exemple d’utilisation de styles avec XML, page 474
Vous pouvez trouver un exemple de fichier source, formattedText.fla, dans le dossier Sample
sur votre disque dur, qui vous présente l’application du formatage CSS au texte que vous
chargez dans un fichier SWF à l’exécution.
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples et Tutorials\Samples\ActionScript\LoadText.
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/LoadText.
Propriétés CSS prises en charge
Flash Player prend en charge un sous-ensemble de propriétés dans la spécification CSS1
d’origine (www.w3.org/TR/REC-CSS1). Le tableau suivant présente les propriétés et les
valeurs CSS prises en charge et les noms de propriétés ActionScript correspondants. (Chaque
nom de propriété ActionScript est tiré du nom de propriété CSS correspondant. Le trait
d’union est omis et le caractère suivant est une majuscule.)
Propriété
CSS
Propriété
ActionScript
text-align
textAlign
Utilisation et valeurs prises en charge
Les valeurs reconnues sont left, center, right et
justify.
font-size
fontSize
Seule la partie numérique de la valeur est utilisée.
Les unités (px, pt) ne sont pas analysées ; les
pixels et les points sont équivalents.
Formatage de texte avec les feuilles de style CSS
463
Propriété
CSS
Propriété
ActionScript
Utilisation et valeurs prises en charge
text-decoration
textDecoration
Les valeurs reconnues sont none et underline.
margin-left
marginLeft
Seule la partie numérique de la valeur est utilisée.
Les unités (px, pt) ne sont pas analysées ; les
pixels et les points sont équivalents.
margin-right
marginRight
Seule la partie numérique de la valeur est utilisée.
Les unités (px, pt) ne sont pas analysées ; les
pixels et les points sont équivalents.
font-weight
fontWeight
Les valeurs reconnues sont normal et bold.
kerning
kerning
Les valeurs reconnues sont true et false.
font-style
fontStyle
Les valeurs reconnues sont normal et italic.
letterSpacing
letterSpacing
Seule la partie numérique de la valeur est utilisée.
Les unités (px, pt) ne sont pas analysées ; les
pixels et les points sont équivalents.
text-indent
textIndent
Seule la partie numérique de la valeur est utilisée.
Les unités (px, pt) ne sont pas analysées ; les
pixels et les points sont équivalents.
font-family
fontFamily
Liste des polices à utiliser, séparées par des
virgules, classées par ordre de choix décroissant.
Tous les noms de familles de polices peuvent être
utilisés. Si vous spécifiez un nom de police
générique, il est converti dans la police de
périphérique appropriée. Les conversions de
police suivantes sont disponibles : mono est
converti en _typewriter, sans-serif est converti
en_sans et serif est converti en _serif.
color
color
Seules les valeurs hexadécimales de couleur sont
prises en charge. Les couleurs nommées
(comme blue) ne sont pas prises en charge. Les
couleurs sont écrites au format suivant : #FF0000.
464
Utilisation du texte et des chaînes
Création d’un objet feuille de style
Les styles CSS sont représentés dans ActionScript par la classe TextField.StyleSheet. Cette
classe est uniquement disponible pour les fichiers SWF conçus pour Flash Player 7 et les
versions ultérieures. Pour créer un objet feuille de style, appelez la fonction de constructeur de
la classe TextField.StyleSheet.
var newStyle:TextField.StyleSheet = new TextField.StyleSheet();
Pour ajouter des styles à un objet feuille de style, chargez un fichier CSS externe dans l’objet
ou définissez les styles dans ActionScript. Reportez-vous à Chargement de fichiers CSS externes,
page 465 et à Création de nouveaux styles avec ActionScript, page 467.
Vous pouvez trouver un exemple de fichier source, formattedText.fla, dans le dossier Sample
sur votre disque dur, qui vous présente l’application du formatage CSS au texte que vous
chargez dans un fichier SWF à l’exécution.
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples et Tutorials\Samples\ActionScript\LoadText.
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/LoadText.
Chargement de fichiers CSS externes
Vous pouvez définir des styles dans un fichier CSS externe, puis charger ce fichier dans un
objet feuille de style. Les styles définis dans le fichier CSS sont ajoutés à l’objet feuille de style.
Pour charger un fichier CSS externe, utilisez la méthode load() de la classe
TextField.StyleSheet. Pour déterminer le moment où le chargement du fichier CSS est
terminé, utilisez le gestionnaire d’événement onLoad de l’objet feuille de style.
L’exemple suivant crée et charge un fichier CSS et utilise la méthode
pour récupérer les noms des styles chargés.
TextField.StyleSheet.getStyleNames()
Pour charger une feuille de style externe :
1.
Créez un nouveau fichier dans l’éditeur de texte ou l’éditeur CSS de votre choix.
2.
Ajoutez les définitions de style suivantes au fichier :
.bodyText {
font-family: Arial,Helvetica,sans-serif;
font-size: 12px;
}
.headline {
font-family: Arial,Helvetica,sans-serif;
font-size: 24px;
}
Formatage de texte avec les feuilles de style CSS
465
3.
Enregistrez le fichier CSS sous styles.css.
4.
Dans Flash, créez un nouveau fichier FLA.
5.
Dans le scénario (Fenêtre > Scénario), sélectionnez le calque 1.
6.
Ouvrez le panneau Actions (Fenêtre > Actions).
7.
Ajoutez le code suivant au panneau Actions :
var styles:TextField.StyleSheet = new TextField.StyleSheet();
styles.onLoad = function(success:Boolean):Void {
if (success) {
// afficher les noms de style.
trace(this.getStyleNames());
} else {
trace("Error loading CSS file.");
}
};
styles.load("styles.css");
REMARQUE
Dans l’extrait de code précédent, this.getStyleNames() fait référence à l’objet
styles que vous avez construit dans la première ligne d’ActionScript.
8.
Enregistrez le fichier FLA dans le répertoire qui contient styles.css.
9.
Testez le document Flash (Contrôle > Tester l’animation).
Les noms des deux styles devraient s’afficher dans le panneau Sortie :
.bodyText,.headline
Si « Erreur lors du chargement du fichier CSS » s’affiche dans le panneau de sortie, vérifiez
que le fichier FLA et le fichier CSS se trouvent bien dans le même répertoire et que vous
avez correctement saisi le nom du fichier CSS.
Comme pour les autres méthodes ActionScript qui chargent des données via le réseau, le
fichier CSS doit résider dans le même domaine que le fichier SWF qui effectue le chargement
du fichier. (Se reporter à la section Accès inter-domaines et accès aux sous-domaines entre fichiers
SWF, page 759.) Pour plus d’informations sur l’utilisation des styles CSS avec Flash, consultez
StyleSheet (TextField.StyleSheet) dans le Guide de référence du langage ActionScript 2.0.
Vous pouvez trouver un exemple de fichier source, formattedText.fla, dans le dossier Sample
sur votre disque dur, qui vous présente l’application du formatage CSS au texte que vous
chargez dans un fichier SWF à l’exécution.
Sous Windows, ouvrez le dossier lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples et Tutorials\Samples\ActionScript\LoadText.
466
Utilisation du texte et des chaînes
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/LoadText.
Création de nouveaux styles avec ActionScript
Vous pouvez créer de nouveaux styles de texte avec ActionScript en utilisant la méthode
setStyle() de la classe TextField.StyleSheet. Cette méthode prend deux paramètres : le nom
du style et un objet qui définit les propriétés de ce style.
Par exemple, le code suivant crée un objet feuille de style nommé styles qui définit deux
styles identiques à ceux que vous avez déjà importés (consultez Chargement de fichiers CSS
externes, page 465).
var styles:TextField.StyleSheet = new TextField.StyleSheet();
styles.setStyle("bodyText",
{fontFamily: 'Arial,Helvetica,sans-serif',
fontSize: '12px'}
);
styles.setStyle("headline",
{fontFamily: 'Arial,Helvetica,sans-serif',
fontSize: '24px'}
);
Application de styles à un objet TextField
Pour appliquer un objet feuille de style à un objet TextField, affectez cet objet à la propriété
styleSheet de l’objet champ de texte.
textObj_txt.styleSheet = styles;
REMARQUE
Ne confondez pas la propriété TextField.styleSheet avec la classe
TextField.StyleSheet. Les majuscules les distinguent.
Lorsque vous affectez un objet feuille style à un objet TextField, le comportement habituel du
champ de texte est modifié de la manière suivante :
■
Les propriétés text et htmlText du champ de texte, et toute variable qui lui est associée,
contiennent toujours la même valeur et se comportent de la même façon.
■
Le champ de texte est en lecture seule et ne peut plus être modifié par l’utilisateur.
Formatage de texte avec les feuilles de style CSS
467
■
Les méthodes setTextFormat() et replaceSel() de la classe TextField ne fonctionnent
plus avec le champ de texte. La seule façon de modifier le champ consiste à changer la
propriété text ou htmlText du champ de texte ou à modifier les variables associées au
champ de texte.
■
Tout texte affecté à la propriété text ou htmlText ou aux variables du champ de texte est
stocké textuellement. Tout ce qui est écrit dans l’une de ces propriétés peut être récupéré
dans la forme originale du texte.
Application d’une feuille de style à un composant
TextArea
Pour appliquer une feuille de style à un composant TextArea, vous devez créer un objet feuille
de style et lui attribuer des styles HTML par le biais de la classe TextField.StyleSheet. Vous
pouvez alors affecter la feuille de style à la propriété styleSheet du composant TextArea.
Les exemples suivants créent un objet feuille de style, styles et l’affectent à l’occurrence du
composant myTextArea.
Utilisation d’une feuille de style avec un composant TextArea
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom textareastyle.fla.
2.
Faites glisser un composant TextArea de du dossier User Interface du panneau Composants
sur la scène et attribuez-lui le nom d’occurrence myTextArea.
3.
Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
// Create a new style sheet object and set styles for it.
var styles:TextField.StyleSheet = new TextField.StyleSheet();
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 {
468
Utilisation du texte et des chaînes
if (myStr != undefined) {
myTextArea.text = myStr;
} else {
trace("Unable to load text file.");
}
};
myVars.load("http://www.helpexamples.com/flash/myText.htm");
Le bloc de code précédent crée une nouvelle occurrence de TextField.StyleSheet qui
définit trois styles : pour les balises HTML html, body et h1. L’objet feuille de style est
ensuite appliqué au composant TextArea et le formatage HTML est activé. L’ActionScript
restant définit un objet LoadVars qui charge un fichier HTML externe et peuple la zone
de texte avec le texte chargé.
4.
Choisissez Contrôle > Tester l’animation pour tester le document Flash.
Association de styles
Les styles CSS dans Flash Player sont additionnels, c’est-à-dire que lorsque les styles sont
imbriqués, chaque niveau d’imbrication peut fournir des informations de style, qui sont
ajoutées les unes aux autres pour donner le formatage final.
L’exemple suivant présente des données XML affectées à un champ de texte :
<sectionHeading>This is a section</sectionHeading>
<mainBody>This is some main body text, with one
<emphasized>emphatic</emphasized> word.</mainBody>
Pour le mot emphatic du texte ci-dessus, le style emphasized est imbriqué dans le style
mainBody. Le style mainBody fournit les règles de couleur, de taille de police et de décoration.
Le style emphasized ajoute une règle d’épaisseur de police à ces règles. Le mot emphatic sera
formaté en associant les règles spécifiées par mainBody et emphasized.
Formatage de texte avec les feuilles de style CSS
469
Utilisation des classes de style
Vous pouvez créer des « classes » de style (ne constituant pas de véritables classes
ActionScript 2.0) que vous pouvez appliquer à une balise <p> ou <span> par l’intermédiaire
de l’attribut class de l’une de ces balises. Lorsqu’il est appliqué à une balise <p>, le style
affecte tout le paragraphe. A l’aide de la balise <span>, vous pouvez également appliquer un
style à une plage de texte qui utilise une classe de style.
Par exemple, la feuille de style suivante définit deux classes de style : mainBody et emphasis :
.mainBody {
font-family: Arial,Helvetica,sans-serif;
font-size: 24px;
}
.emphasis {
color: #666666;
font-style: italic;
}
A l’intérieur du texte HTML que vous affectez à un champ de texte, vous pouvez appliquer
ces styles aux balises <p> et <span> comme expliqué ci-dessous :
<p class='mainBody'>This is <span class='emphasis'>really exciting!</
span></p>
Définition du style de balises HTML intégrées
Flash Player prend en charge un sous-ensemble de balises HTML. (Pour plus d’informations,
consultez la section Utilisation de texte au format HTML, page 477.) Vous pouvez affecter un
style CSS à chaque occurrence d’une balise HTML intégrée qui apparaît dans un champ de
texte. Par exemple, le code suivant définit un style pour la balise HTML intégrée <p>. Toutes
les occurrences de cette balise voient leur style défini de la manière spécifiée par la règle de
style :
p {
font-family: Arial,Helvetica,sans-serif;
font-size: 12px;
display: inline;
}
470
Utilisation du texte et des chaînes
Le tableau suivant indique les balises HTML intégrées dont le style peut être défini, et la façon
dont chaque style est appliqué :
Nom de
style
Mode d’application du style
p
Affecte toutes les balises <p>.
body
Affecte toutes les balises <body>. S’il est spécifié, le style p est prioritaire par
rapport au style body .
li
Affecte toutes les balises à puce <li>.
a
Affecte toutes les balises d’ancrage <a>.
a:link
Affecte toutes les balises d’ancrage <a>. Ce style est appliqué après tout style
a.
a:hover
Appliqué à une balise d’ancrage <a> lorsque le pointeur de la souris se
déplace sur le lien. Ce style est appliqué après tout style a et a:link.
Une fois que le pointeur la souris s’éloigne du lien, le style a:hover est
supprimé du lien.
a:active
S’applique à une balise d’ancrage <a> lorsque l’utilisateur clique avec la souris
sur le lien. Ce style est appliqué après tout style a et a:link.
Une fois que le bouton de la souris est relâché, le style a:active est supprimé
du lien.
Exemple d’utilisation de styles avec HTML
Cette section présente un exemple de l’utilisation des styles avec des balises HTML. Vous
créez une feuille de style qui définit le style de certaines balises intégrées ainsi que certaines
classes de style. Vous pouvez alors appliquer cette feuille de style à un objet TextField qui
contient du texte au format HTML.
Pour formater du code HTML avec une feuille de style :
1.
Créez un fichier dans l’éditeur de texte ou l’éditeur CSS de votre choix.
2.
Ajoutez la définition de feuille de style suivante dans le fichier :
p {
color: #000000;
font-family: Arial,Helvetica,sans-serif;
font-size: 12px;
display: inline;
}
a:link {
color: #FF0000;
}
Formatage de texte avec les feuilles de style CSS
471
a:hover{
text-decoration: underline;
}
.headline {
color: #000000;
font-family: Arial,Helvetica,sans-serif;
font-size: 18px;
font-weight: bold;
display: block;
}
.byline {
color: #666600;
font-style: italic;
font-weight: bold;
display: inline;
}
Cette feuille de style définit des styles pour deux balises HTML intégrées (<p> et <a>) qui
seront appliqués à toutes les occurrences de ces balises. Elle définit également deux classes
de style (.headline et .byline) qui seront appliquées à des paragraphes et à des plages de
texte spécifiques.
3.
Enregistrez le fichier sous html_styles.css.
4.
Créez un nouveau fichier texte dans un éditeur de texte ou HTML, puis enregistrez-le sous
le nom myText.htm.
Ajoutez le texte suivant au fichier :
<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>
R E M A R QU E
Si vous copiez et collez cette chaîne de texte, veillez à supprimer les éventuels sauts
de ligne qui peuvent y avoir été ajoutés.
5.
Créez un nouveau document Flash dans l’outil auteur de Flash.
6.
Sélectionnez la première image dans le calque 1 du scénario (Fenêtre > Scénario).
472
Utilisation du texte et des chaînes
7.
Ouvrez le panneau Actions (Fenêtre > Actions) et ajoutez-lui le code suivant :
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();
var styles:TextField.StyleSheet = new TextField.StyleSheet();
// 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 {
if (src != undefined) {
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) {
/* Si la feuille de style a été chargée sans erreur,
l’affecter à l’objet texte,
et affecter le texte HTML au champ de texte. */
news_txt.styleSheet = styles;
news_txt.text = storyText;
} else {
trace("Unable to load CSS file.");
}
};
styles.load(css_url);
R EM A R Q U E
Dans cet ActionScript, vous chargez le texte à partir d’un fichier externe. Pour plus
d’informations sur le chargement de données externes, consultez le Chapitre 15,
Utilisation des images, du son et de la vidéo.
8.
Enregistrez le fichier sous news_html.fla dans le même répertoire que celui contenant le
fichier CSS que vous avez créé à l’étape 3.
9.
Sélectionnez Contrôle > Tester l’animation pour voir les styles appliqués au texte HTML
automatiquement.
Formatage de texte avec les feuilles de style CSS
473
Utilisation de styles pour définir de nouvelles balises
Si vous définissez un nouveau style dans une feuille de style, ce style peut être utilisé comme
balise, comme vous utiliseriez une balise HTML intégrée. Par exemple, si une feuille de style
définit un style CSS nommé sectionHeading, vous pouvez utiliser <sectionHeading>
comme élément dans tout champ de texte associé à la feuille de style. Cette fonction vous
permet d’affecter directement du texte aléatoire au format XML dans un champ de texte, afin
que le texte soit automatiquement formaté en utilisant les règles de la feuille de style.
Par exemple, la feuille de style suivante crée les nouveaux styles sectionHeading, mainBody
et 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
}
Vous pouvez ensuite remplir un champ de texte associé à cette feuille de style avec le texte au
format XML suivant :
<sectionHeading>This is a section</sectionHeading>
<mainBody>This is some main body text,
with one <emphasized>emphatic</emphasized> word.
</mainBody>
Exemple d’utilisation de styles avec XML
Dans cette section, vous créez un fichier FLA contenant du texte au format XML. Vous
créerez une feuille de style à l’aide d’ActionScript, au lieu d’importer les styles à partir d’un
fichier CSS comme illustré à la section Exemple d’utilisation de styles avec HTML, page 471
Pour formater du XML avec une feuille de style :
1.
Dans Flash, créez un fichier FLA.
2.
A l’aide de l’outil Texte, créez un champ de texte d’environ 400 pixels de large et 300 pixels
de haut.
474
Utilisation du texte et des chaînes
3.
Ouvrez l’inspecteur des propriétés (Fenêtre > Propriétés > Propriétés) et sélectionnez le
champ de texte.
4.
Dans l’inspecteur des propriétés, sélectionnez Texte dynamique dans le menu Type de
texte, sélectionnez Multiligne dans le menu Type de ligne, sélectionnez l’option Rendre le
texte au format HTML et tapez news_txt dans la zone de texte Nom de l’occurrence.
5.
Dans le calque 1 du scénario (Fenêtre > Scénario), sélectionnez la première image.
6.
Pour créer l’objet feuille de style, ouvrez le panneau Actions (Fenêtre > Actions) et ajoutez
le code suivant au panneau Actions :
var styles:TextField.StyleSheet = new TextField.StyleSheet();
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'
});
Ce code crée un nouvel objet feuille de style nommé xml_styles qui définit les styles à
l’aide de la méthode setStyle(). Les styles correspondent exactement à ceux que vous
avez créés dans un fichier CSS externe, précédemment dans ce même chapitre.
Formatage de texte avec les feuilles de style CSS
475
7.
Pour créer un texte XML à affecter au champ de texte, ouvrez un éditeur de texte et entrez
le texte suivant dans un nouveau document :
<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>
REMARQUE
Si vous copiez et collez cette chaîne de texte, veillez à supprimer les éventuels sauts
de ligne qui peuvent y avoir été ajoutés. Sélectionnez Caractères masqués dans le
menu contextuel du panneau Actions afin d’afficher et de supprimer les éventuels
sauts de ligne supplémentaires.
8.
Enregistrez le fichier texte sous story.xml.
9.
Dans Flash, ajoutez le code suivant dans le panneau Actions, à la suite du code présenté à
l’étape 6.
Ce code charge le document story.xml, applique l’objet feuille de style à la propriété
styleSheet du champ de texte et affecte le texte XML au champ de texte :
var my_xml:XML = new XML();
my_xml.ignoreWhite = true;
my_xml.onLoad = function(success:Boolean):Void {
if (success) {
news_txt.styleSheet = styles;
news_txt.text = my_xml;
} else {
trace("Error loading XML.");
}
};
my_xml.load("story.xml");
REMARQUE
Vous chargez des données XML à partir d’un fichier externe dans cet
ActionScript. Pour plus d’informations sur le chargement de données externes,
consultez le Chapitre 15, Utilisation des images, du son et de la vidéo.
10. Enregistrez
11.
476
le fichier sous news_xml.fla dans le même dossier que le fichier story.xml.
Exécutez le fichier SWF (Contrôle > Tester l’animation) pour voir les styles
automatiquement appliqués au texte dans le champ de texte.
Utilisation du texte et des chaînes
Utilisation de texte au format HTML
Flash Player prend en charge un sous-ensemble de balises HTML comme <p> et <li> que
vous pouvez utiliser pour attribuer un style à un texte dans un champ de texte dynamique ou
de saisie. Dans Flash Player 7 et les versions ultérieures, les champs de texte prennent
également en charge la balise <img>, qui vous permet d’intégrer des fichiers image (JPEG,
GIF, PNG), des fichiers SWF et des clips dans un champ de texte. Dans Flash Player, le texte
enveloppe automatiquement les images intégrées dans les champs de texte, de la même
manière qu’un navigateur Web enveloppe le texte autour des images intégrées dans un
document HTML. Pour plus d’informations, consultez la section Présentation de l’intégration
d’images, de fichiers SWF et de clips dans les champs de texte, page 487.
Flash Player prend également en charge la balise <textformat>, qui vous permet d’appliquer
les styles de formatage de paragraphe de la classe TextFormat aux champs de texte HTML.
Pour plus d’informations, consultez Utilisation de la classe TextFormat, page 459.
Pour plus d’informations sur le formatage HTML du texte, consultez les rubriques suivantes :
■
Propriétés et syntaxe requises pour l’utilisation de texte au format HTML, page 477
■
Présentation des balises HTML prises en charge, page 479
■
Présentation des entités HTML prises en charge, page 486
■
Présentation de l’intégration d’images, de fichiers SWF et de clips dans les champs de texte,
page 487
Propriétés et syntaxe requises pour l’utilisation de
texte au format HTML
Pour utiliser du code HTML dans un champ texte, vous devez définir plusieurs propriétés,
que ce soit avec l’inspecteur de propriétés ou avec le code ActionScript :
■
Activez le formatage HTML du champ de texte en sélectionnant l’option Rendre le texte
au format HTML dans l’inspecteur des propriétés ou en définissant la propriété html du
champ de texte sur true.
■
Pour utiliser des balises HTML, telles que <p>, <br> et <img>, vous devez transformer le
champ de texte en champ multiligne en sélectionnant l’option Multiligne dans
l’inspecteur des propriétés ou en définissant la propriété multiline du champ de texte sur
true.
■
Dans ActionScript, définissez la valeur de TextField.htmlText sur la chaîne de texte au
format HTML que vous souhaitez afficher.
Utilisation de texte au format HTML
477
Par exemple, le code suivant active le formatage HTML pour un champ de texte nommé
titre_txt, puis lui affecte du texte HTML.
this.createTextField("headline_txt", 1, 10, 10, 500, 300);
headline_txt.html = true;
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>";
Pour rendre correctement le texte HTML, vous devez utiliser la syntaxe correcte. Les attributs
des balises HTML doivent être encadrés de guillemets simples (’) ou doubles ("). Les valeurs
des attributs dépourvues de guillemets peuvent engendrer des résultats inattendus, comme le
rendu incorrect du texte. Par exemple, le fragment de code HTML suivant ne peut pas être
rendu correctement par Flash Player, car la valeur affectée à l’attribut align (left) n’est pas
encadrée de guillemets :
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>";
Si vous encadrez les valeurs d’attribut à l’aide de guillemets doubles, vous devez utiliser la
fonction d’échappement pour les guillemets (\"). Les deux méthodes suivantes sont acceptables
pour ce faire :
myField_txt.htmlText
myField_txt.htmlText
p>";
myField_txt.htmlText
myField_txt.htmlText
p>';
= "<p align='left'>This uses single quotes</p>";
= "<p align=\"left\">This uses escaped double quotes</
= '<p align="left">This uses outer single quotes</p>';
= '<p align=\'left\'>This uses escaped single quotes</
Il n’est pas nécessaire d’utiliser la fonction d’échappement pour les guillemets doubles si vous
chargez du texte à partir d’un fichier externe. Cette action est uniquement nécessaire pour
l’affectation des chaînes de texte dans ActionScript.
478
Utilisation du texte et des chaînes
Présentation des balises HTML prises en charge
Cette section répertorie les balises HTML intégrées prises en charge par Flash Player. Vous
pouvez également créer de nouveaux styles et balises en utilisant les feuilles de style en cascade
(consultez Formatage de texte avec les feuilles de style CSS, page 462.
Pour plus d’informations sur les balises HTML prises en charge, consultez les rubriques
suivantes :
■
Balise d’ancrage, page 479
■
Balise Bold, page 480
■
Balise Break, page 480
■
Balise Font, page 480
■
Balise Image, page 481
■
Balise Italic, page 482
■
Balise List item, page 482
■
Balise Paragraph, page 483
■
Balise Span, page 484
■
Balise Text format, page 484
■
Balise Underline, page 486
Balise d’ancrage
La balise <a> crée un hyperlien et prend en charge les attributs suivants :
■
Une chaîne comprenant 128 caractères au maximum et spécifiant l’URL de la page
à charger dans le navigateur. L’URL peut être absolue ou relative à l’emplacement du
fichier SWF qui charge la page. Par exemple, l’URL http://www.macromedia.com
constitue une référence absolue, alors que /index.html est une référence relative.
■
Spécifie le nom de la fenêtre cible dans laquelle vous chargez la page. Les options
comprennent _self, _blank, _parent et _top. L’option _self spécifie l’image actuelle
dans la fenêtre en cours, _blank spécifie une nouvelle fenêtre, _parent spécifie le parent
de l’image actuelle et _top spécifie l’image de plus haut niveau dans la fenêtre en cours.
href
target
Par exemple, le fragment de code HTML suivant crée le lien « Go home », qui ouvre
www.macromedia.com dans une nouvelle fenêtre du navigateur :
urlText_txt.htmlText = "<a href='http://www.macromedia.com'
target='_blank'>Go home</a>";
Utilisation de texte au format HTML
479
Vous pouvez utiliser le protocole spécial asfunction pour que le lien exécute une fonction
ActionScript dans un fichier SWF au lieu d’ouvrir une URL. Pour plus d’informations sur le
protocole asfunction, voir asfunction protocol dans le Guide de référence du langage
ActionScript 2.0.
Vous pouvez également définir des styles a:link, a:hover et a:active pour les balises
d’ancrage en utilisant les feuilles de style. Voir Définition du style de balises HTML intégrées,
page 470.
REMARQUE
Les URL absolues doivent être précédées du préfixe http:// ; dans le cas contraire,
Flash les considère comme des URL relatives.
Balise Bold
La balise <b> permet de mettre le texte en gras, comme dans l’exemple suivant :
text3_txt.htmlText = "He was <b>ready</b> to leave!";
Les caractères gras doivent être disponibles dans la police utilisée pour afficher le texte.
Balise Break
La balise <br> introduit un saut de ligne dans le champ texte. Le champ de texte doit être
multiligne pour utiliser cette balise.
Dans l’exemple suivant, le saut de ligne sépare deux phrases :
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.";
Balise Font
La balise <font> spécifie une police ou une liste de polices pour l’affichage du texte.
La balise font prend en charge les attributs suivants :
■
color Seules les valeurs de couleur hexadécimales (#FFFFFF) sont prises en charge. Par
exemple, le code HTML suivant crée du texte rouge :
myText_txt.htmlText = "<font color='#FF0000'>This is red text</font>";
480
Utilisation du texte et des chaînes
■
Spécifie le nom de la police à utiliser. Comme indiqué dans l’exemple suivant, vous
pouvez spécifier des noms de police séparés par des virgules, auquel cas Flash Player
sélectionne la première balise disponible :
face
myText_txt.htmlText = "<font face='Times, Times New Roman'>Displays as
either Times or Times New Roman...</font>";
Si la police spécifiée n’est pas installée sur le système informatique de l’utilisateur ou si elle
n’est pas intégrée dans le fichier SWF, Flash Player sélectionne une police de
remplacement.
Pour plus d’informations sur l’intégration de polices dans les applications Flash, consultez
la rubrique embedFonts (TextField.embedFonts property) dans le Guide de référence du
langage ActionScript 2.0. et Définition des options de texte dynamique et de saisie dans
Utilisation de Flash.
■
size
Spécifie la taille de la police en pixels, comme indiqué dans l’exemple suivant :
myText_txt.htmlText = "<font size='24' color='#0000FF'>This is blue,
24-point text</font>";
Vous pouvez aussi utiliser des tailles de points relatives au lieu d’une taille de pixels, par
exemple +2 ou -4.
Balise Image
La balise <img> vous permet d’intégrer des fichiers image (JPEG, GIF, PNG), des fichiers
SWF et des clips externes à l’intérieur des champs de texte et des occurrences de composant
TextArea. Le texte se déroule automatiquement autour des images intégrées dans les champs
de texte ou les composants. Pour utiliser cette balise, vous devez définir votre champ de texte
dynamique ou de saisie sur le multiligne et le retour à la ligne.
Pour créer un champ de texte multiligne avec retour à la ligne automatique,
effectuez l’une des opérations suivantes :
■
Dans l’environnement auteur Flash, sélectionnez un champ de texte sur la scène, puis,
dans l’inspecteur des propriétés, sélectionnez Multiligne dans le menu contextuel Type de
texte.
■
Pour un champ de texte créé à l’exécution à l’aide de createTextField
(MovieClip.createTextField method), définissez les propriétés multiline
(TextField.multiline property) et multiline (TextField.multiline property) de l’occurrence
du nouveau champ de texte sur true.
La balise <img> a un attribut requis, src, qui spécifie le chemin vers un fichier image, un
fichier SWF ou l’identifiant de liaison d’un symbole de clip dans la bibliothèque. Tous les
autres attributs sont facultatifs.
Utilisation de texte au format HTML
481
La balise <img> prend en charge les attributs suivants :
Spécifie l’URL vers un fichier image ou SWF, ou l’identifiant de liaison pour un
symbole de clip dans la bibliothèque. Cet attribut est requis ; tous les autres attributs sont
facultatifs. Les fichiers externes (JPEG, GIF, PNG et SWF) ne s’affichent pas tant qu’ils ne
sont pas entièrement téléchargés.
■
src
■
id Spécifie le nom d’une occurrence de clip (créée par Flash Player) contenant le fichier
image, SWF ou le clip intégré. Cette fonction s’avère utile pour contrôler le contenu
intégré avec ActionScript.
■
width
■
height
■
align
■
hspace
■
vspace
Largeur de l’image, du fichier SWF ou du clip inséré, en pixels.
Hauteur de l’image, du fichier SWF ou du clip, en pixels.
Spécifie l’alignement horizontal de l’image intégrée dans le champ de texte. Les
valeur valides sont left et right. La valeur par défaut est left.
Spécifie l’espace horizontal qui entoure l’image là où aucun texte n’apparaît. La
valeur par défaut est 8.
Spécifie l’espace vertical qui entoure l’image là où aucun texte n’apparaît. La
valeur par défaut est 8.
Pour plus d’informations et d’exemples sur l’utilisation de la balise <img>, consultez
Présentation de l’intégration d’images, de fichiers SWF et de clips dans les champs de texte,
page 487.
Balise Italic
La balise <i> affiche le texte qu’elle entoure en italiques, comme dans l’exemple de code
suivant :
That is very <i>interesting</i>.
Cet exemple de code produirait le résultat suivant :
That is very interesting.
Des caractères italiques doivent être disponibles dans la police utilisée.
Balise List item
La balise <li> place une puce devant le texte qu’elle encadre, comme dans l’exemple de code
suivant :
Grocery list:
<li>Apples</li>
<li>Oranges</li>
<li>Lemons</li>
482
Utilisation du texte et des chaînes
Cet exemple de code produirait le résultat suivant :
Grocery list:
■
Apples
■
Oranges
■
Lemons
REMARQUE
Les listes ordonnées et non ordonnées (balises <ol> et <ul>) ne sont pas reconnues
par Flash Player, de sorte qu’elles ne modifient pas le rendu de votre liste. Tous les
éléments de la liste utilisent des puces.
Balise Paragraph
La balise <p> crée un paragraphe. Le champ de texte doit être multiligne pour utiliser cette
balise.
La balise <p> prend en charge les attributs suivants :
Spécifie l’alignement du texte dans le paragraphe. Les valeurs valides sont left,
right, justify et center.
■
align
■
class
Spécifie une classe de style CSS définie par un objet TextField.StyleSheet. (Pour
plus d’informations, consultez la section Utilisation des classes de style, page 470.)
L’exemple suivant utilise l’attribut align pour aligner le texte sur le côté droit d’un champ
de texte.
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>";
L’exemple suivant utilise l’attribut class pour affecter une classe de style de texte à une
balise <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>.";
Utilisation de texte au format HTML
483
Balise Span
La balise <span> peut uniquement être utilisée avec les styles de texte CSS. (Pour plus
d’informations, consultez la section Formatage de texte avec les feuilles de style CSS, page 462.)
Elle prend en charge l’attribut suivant :
■
Spécifie une classe de style CSS définie par un objet TextField.StyleSheet. Pour
plus d’informations sur la création de classes de style, reportez-vous à la section Utilisation
des classes de style, page 470.
class
Balise Text format
La balise <textformat> permet d’utiliser un sous-ensemble de propriétés de formatage des
paragraphes de la classe TextFormat dans les champs de texte HTML, dont l’interlignage, le
retrait, les marges et les taquets de tabulation. Vous pouvez associer des balises <textformat>
aux balises HTML intégrées.
La balise <textformat> possède les attributs suivants :
■
Spécifie l’indentation d’un bloc, en points. Correspond à
(Consultez la rubrique blockIndent
(TextFormat.blockIndent property) dans le Guide de référence du langage ActionScript 2.0.)
blockindent
TextFormat.blockIndent.
■
indent Spécifie l’indentation, de la marge gauche au premier caractère du paragraphe.
Correspond à TextFormat.indent. Permet d’utiliser des entiers négatifs. (Consultez la
rubrique indent (TextFormat.indent property) dans le Guide de référence du langage
ActionScript 2.0.)
■
Spécifie l’espace séparant les lignes (espace vertical). Correspond à
TextFormat.leading. Permet d’utiliser des entiers négatifs. (Consultez la rubrique
leading (TextFormat.leading property) dans le Guide de référence du langage ActionScript
2.0.)
■
Spécifie la marge gauche du paragraphe, en points. Correspond à
(Consultez la rubrique leftMargin (TextFormat.leftMargin
property) dans le Guide de référence du langage ActionScript 2.0.)
leading
leftmargin
TextFormat.leftMargin.
■
Spécifie la marge droite du paragraphe, en points. Correspond à
(Consultez la rubrique rightMargin
(TextFormat.rightMargin property) dans le Guide de référence du langage ActionScript 2.0.)
rightmargin
TextFormat.rightMargin.
■
Spécifie des taquets de tabulation personnalisés, sous forme d’un tableau
d’entiers non négatifs. Correspond à TextFormat.tabStops. (Consultez la rubrique
tabStops (TextFormat.tabStops property) dans le Guide de référence du langage ActionScript
2.0.)
tabstops
484
Utilisation du texte et des chaînes
Le tableau de données suivant présentant des en-têtes de ligne en gras est produit par
l’exemple de code illustré dans la procédure ci-après :
Name
Age
Occupation
Rick
33
Détective
AJ
34
Détective
Pour créer un tableau de données formaté en utilisant des taquets de
tabulation :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom tabstops.fla.
2.
Dans le scénario, sélectionnez la première image sur le Calque 1.
3.
Ouvrez le panneau Actions (Fenêtre > Actions) et ajoutez-lui le code suivant :
// Créer un nouveau champ de texte
this.createTextField("table_txt", 99, 50, 50, 450, 100);
table_txt.multiline = true;
table_txt.html = true;
// Crée des en-têtes de colonne, formatés en gras et séparés par des
balises.
var rowHeaders:String = "<b>Name\tAge\tOccupation</b>";
// Crée des lignes contenant des données.
var row_1:String = "Rick\t33\tDetective";
var row_2:String = "AJ\t34\tDetective";
// Définit deux tabulations, à 50 et 100 points.
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>";
L’utilisation de la séquence d’échappement des caractères de tabulation (\t) ajoute des
tabulations entre chaque « colonne » dans le tableau. Vous ajoutez le texte à l’aide de
l’opérateur +=.
4.
Choisissez Contrôle > Tester l’animation pour visualiser le tableau formaté.
Utilisation de texte au format HTML
485
Balise Underline
La balise <i> souligne le texte qu’elle entoure, comme dans l’exemple de code suivant :
This is <u>underlined</u> text.
Ce code produirait le résultat suivant :
Présentation des entités HTML prises en charge
Les entités HTML vous aident à afficher certains caractères dans les textes au format HTML,
afin qu’ils ne soient pas interprétés comme du HTML. Par exemple, vous utilisez les caractères
inférieur à (<) et supérieur à (>) pour encadrer les balises HTML, telles que <img> et <span>.
Pour afficher les caractères inférieur à ou supérieur à dans des champs de texte au format
HTML dans Flash, vous devez remplacer ces caractères par des entités HTML. L’ActionScript
suivant crée un champ de texte au format HTML sur la scène et utilise des entités HTML
pour afficher la chaîne “<b>” sans que le texte apparaisse en gras :
this.createTextField("my_txt", 10, 100, 100, 100, 19);
my_txt.autoSize = "left";
my_txt.html = true;
my_txt.htmlText = "The <b> tag makes text appear <b>bold</b>.";
A l’exécution, l’exemple de code précédent dans Flash affiche le texte suivant sur la scène :
The <b> tag makes text appear bold.
Outre les symboles supérieur à et inférieur à, Flash reconnaît également d’autres entités
HTML répertoriées dans le tableau suivant.
Entité
Description
<
< (Inférieur à)
>
> (Supérieur à)
&
& (esperluette)
"
" (guillemets doubles)
'
’ (apostrophe, guillemet simple)
Flash prend également en charge les codes de caractères explicites, tels que ' (esperluette
- ASCII) et & (esperluette - Unicode).
486
Utilisation du texte et des chaînes
L’ActionScript suivant démontre l’utilisation des codes de caractères ASCII ou Unicode pour
intégré un caractère tilde (~) :
this.createTextField("my_txt", 10, 100, 100, 100, 19);
my_txt.autoSize = "left";
my_txt.html = true;
my_txt.htmlText = "~"; // tilde (ASCII)
my_txt.htmlText += "\t"
my_txt.htmlText += "~"; // tilde (Unicode)
Présentation de l’intégration d’images, de fichiers
SWF et de clips dans les champs de texte
Dans Flash Player 7 et les versions ultérieures, vous pouvez utiliser la balise <img> pour
intégrer des fichiers image (JPEG, GIF, PNG), des fichiers SWF et des clips dans les champs
de texte dynamiques et de saisie et les occurrences du composant TextArea. (pour obtenir la
liste complète des attributs de la balise <img>, consultez Balise Image, page 481).
Flash affiche le média intégré dans un champ de texte, à sa taille normale. Pour spécifier les
dimensions du média à intégrer, utilisez les attributs height et width de la balise <img>. (Se
reporter à la section Présentation de la spécification des valeurs de hauteur et de largeur,
page 489.)
En général, une image intégrée dans un champ de texte apparaît sur la ligne qui suit la balise
<img>. Cependant, lorsque la balise <img> est le premier caractère dans le champ de texte,
l’image apparaît sur la première ligne du champ de texte.
Intégration de fichiers image et SWF
Pour intégrer un fichier image ou SWF dans un champ de texte, spécifiez le chemin absolu ou
relatif qui mène au fichier image (GIF, JPEG ou PNG) ou au fichier SWF dans l’attribut
<sec> de la balise img. Ainsi, l’exemple code suivant insère un fichier GIF situé dans le même
répertoire que le fichier SWF (une adresse relative, ou hors ligne).
Intégration d’une image dans un champ de texte :
1.
Créez un nouveau document Flash, puis enregistrez-le sous embedding.fla.
2.
Ajoutez le code ActionScript suivant à l’image 1 du scénario 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'>";
Le code précédent crée un nouveau champ de texte dynamique sur la scène, active le
formatage HTML et ajoute du texte et une image locale au champ de texte.
Utilisation de texte au format HTML
487
3.
Ajoutez l’ActionScript suivant sous le code ajouté à l’étape précédente :
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'>";
Vous pouvez aussi insérer une image en utilisant une adresse absolue. Le code précédent
insère un fichier JPEG situé dans un répertoire qui se trouve sur un serveur. Le fichier
SWF contenant ce code peut se trouver sur votre disque dur ou sur un serveur.
4.
Enregistrez le document et choisissez Contrôle > Tester l’animation pour tester le
document.
Le champ de texte supérieur devrait contenir une phrase de texte et plus probablement un
message d’erreur dans le panneau Sortie indiquant que Flash n’a pas trouvé un fichier
nommé beach.gif dans le répertoire courant. Le champ de texte inférieur doit contenir une
phrase de texte et l’image d’une fleur qui a été chargée à partir d’un serveur distant.
Copiez une image GIF vers le même répertoire que le fichier FLA et renommez l’image
beach.gif, puis sélectionnez Contrôle > Tester l’animation afin de tester de nouveau le
document Flash.
REMARQUE
Lorsque vous utilisez des URL absolues, vous devez veiller à ce que l’URL soit
précédée du préfixe http://.
Intégration de symboles de clip
Pour intégrer un symbole de clip dans un champ de texte, spécifiez l’identifiant de liaison du
symbole pour l’attribut src de la balise <img> (pour plus d’informations sur la définition d’un
identifiant de liaison, consultez Attacher un symbole de clip à la scène, page 394).
Par exemple, le code suivant insère un symbole de clip avec l’identificateur de liaison
symbol_ID dans un champ texte dynamique avec le nom d’occurrence textField_txt.
Pour intégrer un clip dans un champ de texte :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom embeddedmc.fla.
2.
Tracez une nouvelle forme sur la scène ou sélectionnez Fichier > Importer > Importer dans
la scène, puis sélectionnez une image mesurant environ 100 pixels de large sur 100 pixels
de haut.
3.
Convertissez la forme ou l’image importée à l’étape précédente en la sélectionnant sur la
scène et en appuyant sur la touche F8 pour ouvrir la boîte de dialogue Convertir en
symbole.
488
Utilisation du texte et des chaînes
4.
Définissez le comportement sur Clip et saisissez un nom descriptif pour le symbole.
Sélectionnez le carreau supérieur gauche de la grille du point d’alignement, puis cliquez sur
Avancé pour passer au mode avancé si ce n’est pas encore fait.
5.
Cochez les cases Exportation d’ActionScript et Exporter dans la première image.
6.
Entrez l’identifiant de liaison img_id dans la zone de texte Identifiant, puis cliquez sur OK.
7.
Ajoutez le code ActionScript suivant à l’image 1 du scénario 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'>";
Pour qu’un clip intégré soit correctement et entièrement affiché, le point d’alignement de
son symbole doit être (0,0).
8.
Enregistrez vos modifications dans le document Flash.
9.
Choisissez Contrôle > Tester l’animation pour tester le document Flash.
Présentation de la spécification des valeurs de hauteur et de
largeur
Si vous spécifiez les attributs width et height d’une balise <img>, un espace est réservé dans le
champ de texte pour le fichier image, le fichier SWF ou le clip. Une fois qu’un fichier image
ou SWF est complètement téléchargé, il apparaît dans l’espace réservé. Flash modifie la taille
du média en fonction des valeurs que vous spécifiez pour height et width. Vous devez entrer
des valeurs pour les attributs height et width pour pouvoir redimensionner l’image.
Si vous ne spécifiez pas de valeurs pour height et width, aucun espace n’est réservé au média
intégré. Une fois le fichier JPEG ou SWF téléchargé, Flash l’insère dans le champ de texte à sa
taille normale et sépare de nouveau le texte autour de lui.
R E M A R QU E
Si vous chargez de façon dynamique vos images dans un champ texte contenant déjà
du texte, la meilleure pratique consiste à spécifier la largeur et la hauteur de l’image
d’origine de façon à ce que le texte s’enroule correctement autour de l’espace réservé à
l’image.
Contrôle du média intégré avec ActionScript
Flash Player crée un nouveau clip pour chaque balise <img> et l’intègre dans l’objet TextField.
L’attribut id de la balise <img> permet d’affecter un nom d’occurrence au clip créé Cela vous
permet de contrôler le clip avec ActionScript.
Le clip créé par Flash est ajouté en tant que clip enfant du champ de texte contenant l’image.
Ainsi, l’exemple suivant intègre un fichier SWF dans un champ de texte.
Utilisation de texte au format HTML
489
Pour intégrer un fichier SWF dans un champ de texte :
1.
Créez un nouveau document Flash.
2.
Redimensionnez la scène du document à 100 pixels sur 100 pixels.
3.
A l’aide de l’outil Rectangle, dessinez un carré rouge sur la scène.
4.
Redimensionnez le carré à 80 pixels sur 80 pixels à l’aide de l’inspecteur des propriétés, puis
déplacez la forme vers le centre de la scène.
5.
Sélectionnez l’Image 20 du scénario, puis appuyez sur la touche F7 (Windows ou
Macintosh) pour insérer une nouvelle image clé vierge.
6.
Utilisez l’outil Ovale pour tracer un cercle bleu sur la scène dans l’Image 20.
7.
Redimensionnez le cercle à 80 pixels sur 80 pixels à l’aide de l’inspecteur des propriétés,
puis déplacez-le vers le centre de la scène.
8.
Cliquez sur une image vierge entre les Images 1 et 20, puis définissez le type d’interpolation
sur Forme dans l’inspecteur des propriétés.
9.
Enregistrez le document courant sous animation.fla.
10. Choisissez
Contrôle > Tester l’animation pour prévisualiser l’animation.
Le fichier SWF est créé dans le même répertoire que le fichier FLA. Pour que cet exercice
fonctionne correctement, le fichier SWF doit se générer pour vous permettre de le charger
dans un fichier FLA distinct.
11.
Créez un nouveau fichier FLA, puis enregistrez-le sous le nom animationholder.fla.
Enregistrez le fichier dans le même dossier que le fichier animation.fla que vous avez créé
précédemment.
12. Ajoutez
le code ActionScript suivant à l’image1 du scénario 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'>";
Dans ce cas, le chemin entièrement qualifié vers le nouveau clip créé est
textField_txt.animation_mc.
13.
Enregistrez les modifications apportées au document Flash, puis sélectionnez Contrôle >
Tester l’animation pour prévisualiser l’animation dans le champ de texte.
Pour contrôler le fichier SWF lorsqu’il est lu dans un fichier texte, effectuez l’exercice suivant.
490
Utilisation du texte et des chaînes
Pour contrôler un fichier SWF qui est lu dans un champ de texte :
1.
Suivez les étapes de la première procédure sous Contrôle du média intégré avec ActionScript,
page 489.
2.
Créez une occurrence de bouton sur la scène et attribuez-lui le nom d’occurrence stop_btn
dans l’inspecteur des propriétés.
3.
Ajoutez le code ActionScript suivant sous le code existant dans l’image 1 du scénario
principal :
stop_btn.onRelease = function() {
textField_txt.animation_mc.stop();
};
4.
Sélectionnez Contrôle > Tester l’animation pour tester l’application.
Désormais, chaque fois que vous cliquerez sur l’occurrence de bouton stop_btn, le
scénario de l’animation imbriqué dans le champ de texte s’interrompra.
Pour plus d’informations sur la transformation de vos médias imbriqués en hyperliens,
consultez la rubrique Présentation de la transformation de médias imbriqués en liens hypertexte,
page 491.
Présentation de la transformation de médias imbriqués en
liens hypertexte
Pour créer un lien hypertexte à partir d’un fichier image, d’un fichier SWF ou d’un clip
intégré, incluez la balise <img> dans une balise <a> :
textField_txt.htmlText = "Click the image to return home<a
href='home.htm'><img src='home.jpg'></a>";
Lorsque le pointeur de la souris survole une image, un fichier SWF ou un clip que vous avez
placé entre des balises <a>, il prend la forme d’une « main », à l’instar des hyperliens standard.
L’interactivité, telle que les clics de souris et la pression sur les touches du clavier, n’est pas
enregistrée dans les fichiers SWF et les clips placés entre les balises <a>.
Pour plus d’informations sur l’imbrication de médias, consultez la section Présentation de la
transformation de médias imbriqués en liens hypertexte, page 491.
Utilisation de texte au format HTML
491
Exemple : Création de texte défilant
Plusieurs méthodes sont à votre disposition pour créer un texte défilant dans Flash. Pour faire
défiler des champs de texte dynamique et de saisie, vous pouvez sélectionner l’option Défilant
dans le menu Texte ou le menu contextuel, ou double-cliquer sur la poignée du champ de
texte tout en maintenant la touche Maj enfoncée.
Vous pouvez utiliser les propriétés scroll et maxscroll de l’objet TextField pour contrôler le
défilement vertical et les propriétés hscroll et maxhscroll pour contrôler le défilement
horizontal d’un champ de texte. Les propriétés scroll et hscroll spécifient respectivement
les positions de défilement vertical et horizontal ; vous pouvez lire et définir ces propriétés. Les
propriétés maxscroll et maxhscroll spécifient les positions verticales et horizontales
maximales, respectivement ; vous pouvez uniquement lire ces propriétés.
Le composant TextArea offre un moyen aisé de créer un champ de texte défilant avec un
minimum de programmation. Pour plus d’informations, consultez la rubrique Composant
TextArea dans la Référence du langage des composants.
Pour créer un champ de texte dynamique à défilement :
Effectuez l’une des opérations suivantes :
■
Double-cliquez sur la poignée du champ texte dynamique tout en maintenant la touche
maj enfoncée.
■
Sélectionnez le champ texte dynamique avec l’outil Sélection et choisissez Texte >
Défilant.
■
Sélectionnez le champ texte dynamique avec l’outil Sélection. Cliquez avec le bouton droit
de la souris (Windows) ou tout en appuyant sur la touche Contrôle (Macintosh) sur le
champ texte dynamique et sélectionnez Texte > Défilant.
Pour utiliser la propriété scroll afin de créer du texte défilant :
1.
Effectuez l’une des opérations suivantes :
■
■
Sélectionnez l’outil Texte et tracez un champ de texte sur la scène. Affectez le nom
d’occurrence textField_txt au champ de texte dans l’inspecteur des propriétés.
Utilisez ActionScript pour créer un champ de texte dynamiquement à l’aide de la
méthode MovieClip.createTextField(). Affectez le nom d’occurrence
textField_txt au champ de texte en tant que paramètre de la méthode.
R E M AR QU E
492
Si vous ne chargez pas le texte de façon dynamique dans le fichier SWF,
sélectionnez Texte > Défilant dans le menu principal.
Utilisation du texte et des chaînes
2.
Créez un bouton Vers le haut et un bouton Vers le bas ou sélectionnez Fenêtre >
Bibliothèques communes > Boutons, puis faites glisser vos boutons sur la scène.
Vous utiliserez ces boutons pour faire défiler le texte vers le haut et vers le bas.
3.
Sélectionnez le bouton Vers le bas sur la scène et tapez down_btn dans le champ Nom de
l’occurrence.
4.
Sélectionnez le bouton Vers le haut sur la scène et tapez up_btn dans le champ Nom de
l’occurrence.
5.
Sélectionnez Image 1 dans le scénario et, dans le panneau Actions Fenêtre > Actions),
entrez le code suivant pour faire défiler le texte vers le bas dans le champ de texte :
down_btn.onPress = function() {
textField_txt.scroll += 1;
};
6.
Suite à l’ActionScript de l’étape 5, entrez le code suivant pour faire défiler le texte vers le
haut :
up_btn.onPress = function() {
textField_txt.scroll -= 1;
};
Tout texte se chargeant dans le champ textField_txt peut défiler à l’aide des boutons
Vers le haut et Vers le bas.
Présentation des chaînes et de la classe
String
En programmation, une chaîne est une série ordonnée de caractères. Les chaînes sont souvent
utilisées dans les documents Flash et les fichiers de classe pour afficher du texte dans des
applications, par exemple dans des champs de texte. De même, vous pouvez stocker des
valeurs sous forme de chaînes exploitables dans une application pour diverses raisons. Vous
pouvez créer les chaînes directement dans votre code ActionScript en plaçant les caractères de
données entre guillemets. Pour plus d’informations sur la création de chaînes, consultez la
rubrique Création de chaînes, page 502. Pour plus d’informations sur l’utilisation des champs
de texte, veuillez consulter la rubrique Utilisation de la classe TextField, page 418.
Présentation des chaînes et de la classe String
493
Vous pouvez associer chaque caractère à un code de caractère spécifique, que vous pouvez
même éventuellement utiliser pour afficher du texte. Par exemple, le caractère "A" est
représenté par le caractère Unicode 0041, ou 65 en ASCII (American Standard Code for
Information Interchange). Pour plus d’informations sur les codes de caractères et les tableaux
de codes, consultez le site www.unicode.org/charts. Comme vous pouvez le constater, la
manière dont vous représentez les chaînes dans un document Flash dépend beaucoup du jeu
de caractères choisi et de la manière dont vous encodez les caractères.
Le codage de caractères fait référence au code, ou à la méthode, utilisé(e) pour représenter un
jeu de caractères d’une langue en codes représentatifs, tels que des valeurs numériques. Le code
de caractères (tel que mentionné au paragraphe précédent) est le tableau des valeurs mappées
(par exemple, le tableau ASCII, dans lequel le A est égal à 65). La méthode d’encodage le
déchiffre dans un programme informatique.
Par exemple, chaque lettre de la langue anglaise correspond à un code numérique représentatif
dans un codage de caractères. L’ASCII encode chaque lettre, chaque chiffre ainsi que certains
symboles en versions binaires 7 bits de chaque entier. L’ASCII est un jeu de caractères
comprenant 95 caractères imprimables et de nombreux caractères de contrôle ; l’ASCII est
utilisé par les ordinateurs pour représenter le texte.
Comme le standard ASCII, le codage Unicode est un autre moyen d’associer un code à chaque
lettre de l’alphabet. Dans la mesure où l’ASCII ne prend pas en charge les jeux de caractères
volumineux, tels que le Chinois, le Standard Unicode est utile pour encoder les langues.
Unicode est le standard utilisé pour les jeux de caractères et peut représenter n’importe quelle
langue. Ce standard est destiné à faciliter le développement d’applications en plusieurs
langues. Le code de caractère désigne le caractère qu’il représente et le standard tente de
fournir un moyen universel pour coder tous les caractères constituant une langue. Les chaînes
peuvent alors être affichées n’importe où, quel que soit le système informatique, la plate-forme
ou le logiciel. L’application impliquée (telle que Flash ou un navigateur Web) doit alors être
capable d’afficher les glyphes (la représentation graphique) de chaque caractère.
Au fil des années, le nombre de caractères pris en charge par Unicode s’est développé pour
intégrer la prise en charge de langues plus nombreuses (et plus volumineuses). Les encodages
de caractères sont appelés UTF (Unicode Transformation Format) et UCS (Universal
Character Set), et comprennent les codes UTF-8, UTF-16 et UTF-32. Les nombres suivant
l’encodage UTF représentent le nombre de bits présents dans une unité et les nombres suivant
l’encodage UCS représentent des octets.
■
UTF-8 est actuellement le codage standard pour les échanges de texte, tels que les
systèmes de messagerie en ligne. L’UTF est un système 8 bits.
■
L’UTF-16 est utilisé couramment pour le traitement interne.
494
Utilisation du texte et des chaînes
La longueur des chaînes peut varier dans vos applications. Vous pouvez déterminer cette
longueur, même si elle peut varier, en fonction de la langue utilisée. De même, vous pouvez
rencontrer un caractère de terminaison (null) à la fin d’une chaîne, qui n’a pas de valeur. Ce
caractère de terminaison n’est pas un véritable caractère, mais vous pouvez l’utiliser pour
localiser la fin d’une chaîne. Par exemple, si vous utilisez des connexions socket, vous pouvez
rechercher le caractère de terminaison pour localiser la fin d’une chaîne (dans un logiciel de
discussion en ligne par exemple).
Vous trouverez un exemple de fichier source, strings.fla, dans le dossier Samples de votre
disque dur. Ce fichier vous indique comment élaborer un traitement de texte simple qui
compare et récupère les sélections de chaînes et de sous-chaînes.
■
Sous Windows, naviguez jusqu’au lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples et Tutorials\Samples\ActionScript\Strings.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Strings.
Pour plus d’informations sur les chaînes et sur la classe String, consultez les rubriques
suivantes :
■
Présentation du panneau Chaînes, page 495
■
Utilisation de la classe Locale, page 496
■
Utilisation d’un IME (input method editor), page 498
■
Présentation de la classe String, page 501
■
Création de chaînes, page 502
■
Présentation du caractère d’échappement, page 504
■
Analyse et comparaison des caractères dans les chaînes, page 504
■
Conversion et concaténation de chaînes, page 508
■
Renvoi de sous-chaînes, page 511
Présentation du panneau Chaînes
Le panneau Chaînes vous permet de créer et de mettre à jour un contenu multilingue. Vous
pouvez spécifier un contenu pour les champs de texte recouvrant plusieurs langues, et
demander à Flash de déterminer automatiquement le contenu qui doit apparaître dans une
certaine langue en fonction de la langue de l’ordinateur qui exécute Flash Player.
Présentation des chaînes et de la classe String
495
Pour obtenir des informations générales sur le panneau Chaînes et pour savoir comment les
utiliser dans vos applications, consultez les rubriques suivantes dans Utilisation de Flash :
■
Programmation de texte multilingue à l'aide du panneau Chaînes, page 425
■
A propos de la modification de chaînes à l'aide du panneau Chaînes, page 429
■
Traduction de texte dans le panneau Chaînes ou dans un fichier XML, page 434
■
Importation d'un fichier XML dans le panneau Chaînes, page 435
Vous pouvez utiliser la classe Locale pour contrôler l’affichage du texte multilingue. Pour plus
d’informations, consultez les sections Utilisation de la classe Locale, page 496 et Locale
(mx.lang.Locale) dans le Guide de référence du langage ActionScript 2.0.
Utilisation de la classe Locale
La classe Locale (mx.lang.Locale) vous permet de contrôler l’affichage du texte multilingue
dans une application Flash à l’exécution. Le panneau Chaînes vous permet d’utiliser les
identifiants de chaînes au lieu de leur texte littéral dans des champs de texte dynamiques, ce
qui vous permet de créer un fichier SWF affichant le texte chargé à partir d’un fichier XML
spécifique à la langue. Vous pouvez utiliser les méthodes suivantes pour afficher les chaînes
spécifiques à la langue figurant dans les fichiers XlIFF (XML Localization Interchange File
Format).
Automatiquement à l’exécution
Flash Player remplace les identifiants de chaînes par des
chaînes provenant du fichier XML, lequel correspond au code de langue par défaut du
système qui est retourné par language (capabilities.language property).
Manuellement à l’aide du langage de la scène Les identifiants de chaînes sont remplacés
par des chaînes lorsque le fichier SWF est compilé et ne peuvent pas être modifiés par Flash
Player.
Utilisation d’ActionScript à l’exécution
Vous pouvez contrôler le remplacement des
identifiants de chaînes à l’aide d’ActionScript, lequel est contrôlé à l’exécution. Cette option
vous permet de contrôler le moment et la langue du remplacement de l’identifiant de chaîne.
Vous pouvez utiliser les propriétés et les méthodes de la classe Locale lorsque vous souhaitez
remplacer les identifiants de chaîne à l’aide d’ActionScript pour contrôler l’application
lorsqu’elle est exécutée dans Flash Player. Pour obtenir une démonstration de l’utilisation de la
classe Locale, respecez la procédure suivante :
496
Utilisation du texte et des chaînes
Pour utiliser la classe Locale pour créer des sites multilingues :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom locale.fla.
2.
Ouvrez le panneau Chaînes (Fenêtre > Autres panneaux > Chaînes) et cliquez sur
Paramètres.
3.
Sélectionnez deux langues, en (anglais) et fr (français), puis cliquez sur Ajouter pour ajouter
les langues au panneau Langues actives.
4.
Sélectionnez l’option Via ActionScript à l’exécution, définissez la langue d’exécution par
défaut sur Français, puis cliquez sur OK.
5.
Faites glisser un composant ComboBox de du dossier User Interface du panneau
Composants (Fenêtre > Composants) sur la scène et attribuez-lui le nom d’occurrence
lang_cb.
6.
Créez un champ de texte dynamique sur la scène à l’aide de l’outil Texte et donnez au
champ de texte le nom d’occurrence greeting_txt.
7.
Après avoir sélectionné le champ de texte sur la scène, tapez l’identifiant de chaîne greeting
dans le champ ID du panneau Chaînes, puis cliquez sur Appliquer.
Vous remarquerez que Flash convertit la chaîne d’accueil en IDS_GREETING.
8.
Dans la grille du panneau Chaînes, tapez la chaîne hello dans la colonne en.
9.
Tapez la chaîne bonjour dans la colonne fr.
Vous utilisez ces chaînes lorsque vous utilisez la liste déroulante lang_cb pour modifier la
langue de la scène.
10. Ajoutez
le code ActionScript suivant à l’image 1 du scénario 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.";
}
}
Présentation des chaînes et de la classe String
497
L’ActionScript précédent est divisé en deux sections. La première section de code importe
la classe Local et spécifie un écouteur de rappel qui sera appelé chaque fois que le
chargement d’un fichier XML de langue sera terminé. La liste déroulante lang_cb est
ensuite peuplée par un tableau trié des langues disponibles. Chaque fois que la valeur
lang_cb est modifiée, le value changes, le diffuseur d’événements de Flash déclenche la
fonction langListener(), laquelle charge le fichier XML dans la langue spécifiée. La
deuxième section de code définit deux fonctions, langListener() et
localeListener(). La première fonction, langListener(), est appelée chaque fois que
la valeur de la liste déroulante lang_cb est modifiée par l’utilisateur. La deuxième
fonction, localeListener(), est appelée chaque fois que le chargement du fichier XML
d’une langue est terminé. Cette fonction vérifie que le chargement a réussi et, si tel est le
cas, définit la propriété text de l’occurrence greeting_txt sur l’accueil dans la langue
sélectionnée.
11.
Choisissez Contrôle > Tester l’animation pour tester le document Flash.
C ON S E I L
Le fichier XML que vous utilisez doit utiliser le format XLIFF (XML Localization
Interchange File Format).
A TT E N TI O N
La classe Locale est différente des autres classes dans le Guide de référence du
langage ActionScript 2.0, dans la mesure où elle ne fait pas partie de Flash Player.
Dans la mesure où cette classe est installée dans le chemin de classe Auteur de
Flash, elle est automatiquement compilée dans vos fichiers SWF. L’utilisation de la
classe Locale augmente légèrement la taille du fichier SWF, car la classe doit être
compilée dans le fichier SWF.
Pour plus d’informations, consultez la rubrique Locale (mx.lang.Locale) dans le Guide
de référence du langage ActionScript 2.0.
Utilisation d’un IME (input method editor)
L’IME (input method editor) permet aux utilisateurs de taper des caractères de texte nonASCII dans des langues asiatiques telles que le Chinois, le Japonais et le Coréen. La classe
IME dans ActionScript vous permet de manipuler directement l’IME du système
d’exploitation dans l’application Flash Player qui s’exécute sur un ordinateur client.
A l’aide d’ActionScript, vous pouvez déterminer les éléments suivants :
■
Si un IME est installé sur l’ordinateur de l’utilisateur.
■
Si l’IME est activé ou désactivé sur l’ordinateur de l’utilisateur.
■
Quel mode de conversion est utilisé par l’IME courant.
498
Utilisation du texte et des chaînes
La classe d’IME peut déterminer le mode de conversion utilisé par l’IME courant : par
exemple, si l’IME japonais est actif, vous pouvez déterminer si le mode de conversion est
Hiragana, Katakana, etc. à l’aide de la méthode System.IME.getConversionMode(). Vous
pouvez le définir à l’aide de la méthode System.IME.setConversionMode() .
REMARQUE
Actuellement, vous ne pouvez pas définir quel IME est actif (éventuellement) ni le
modifier (par exemple, remplacer l’anglais par le japonais ou le coréen par le chinois).
Vous pouvez aussi désactiver ou activer l’IME à l’aide de votre application à l’exécution et
effectuer d’autres fonctions, selon le système d’exploitation de l’utilisateur. Vous pouvez
vérifier si un système est équipé d’un IME à l’aide de la propriété
System.capabilities.hasIME. L’exemple suivant indique comment déterminer si
l’utilisateur dispose d’un IME installé et actif.
Pour déterminer si l’utilisateur dispose d’un IME installé et actif :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom ime.fla.
2.
Ajoutez le code ActionScript suivant à l’image 1 du scénario 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.");
}
Le code précédent détermine d’abord si le système courant est équipé d’un IME. Si un
IME est installé, Flash regarde s’il est actuellement activé.
3.
Sélectionnez Contrôle > Tester l’animation pour tester le document.
Un pessage apparaît dans le panneau Sortie, indiquant si un IME est installé et
actuellement actif.
Vous pouvez aussi utiliser la classe IME pour activer et désactiver l’IME dans Flash à
l’exécution. L’exemple suivant requiert qu’un IME soit installé sur votre système. Pour plus
d’informations sur l’installation d’un IME sur votre plate-forme spécifique, consultez les liens
suivants :
■
www.microsoft.com/globaldev/default.mspx
■
http://developer.apple.com/documentation/
■
http://java.sun.com
Présentation des chaînes et de la classe String
499
Vous pouvez activer et désactiver un IME pendant que le fichier SWF s’exécute, comme
indiqué dans l’exemple suivant.
Pour activer et désactiver un IME à l’exécution :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom ime2.fla.
2.
Créez deux occurrences de symboles de boutons sur la scène et donnez-leur les noms
d’occurrences enable_btn et disable_btn.
3.
Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
checkIME();
var my_fmt:TextFormat = new TextFormat();
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;
}
}
500
Utilisation du texte et des chaînes
Ce code se compose de cinq sections différentes. La première section appelle la méthode
checkIME(), qui affiche un message dans le panneau Sortie si un IME est installé ou
activé sur le système. La deuxième section définit un objet format de texte personnalisé,
qui définit la police sur _sans. La troisième section crée un champ de texte de saisie et
applique le format de texte personnalisé. La quatrième section crée des gestionnaires
d’événements pour les occurrences enable_btn and disable_btn créées lors d’une étape
précédente. La cinquième et dernière section de code définit la fonction personnalisée
checkIME(), qui vérifie si le système courant est équipé d’un IME et, si tel est le cas, si cet
IME est actif ou non.
4.
Enregistrez le fichier FLA et choisissez Contrôle > Tester l’animation pour tester le
document.
REMARQUE
Cet exemple requiert qu’un IME soit installé sur votre système. Pour plus
d’informations sur l’installation d’un IME, consultez les liens mentionnés plus haut.
Tapez du texte dans le champ de texte de saisie sur la scène. Commutez votre IME sur une
autre langue et tapez de nouveau dans le champ de texte de saisie. Flash Player entre des
caractères à l’aide du nouvel IME. Si vous cliquez sur le bouton disable_btn sur la scène,
Flash revient à l’utilisation de la langue précédente et ignore les paramètres d’IME
courants.
Pour plus d’informations sur System.capabilities.hasIME, consultez hasIME
dans le Guide de référence du langage ActionScript 2.0.
(capabilities.hasIME property)
Présentation de la classe String
Dans le langage ActionScript de base, une chaîne est également une classe et un type de
données. Le type de données String représente une séquence de caractères 16 bits qui peuvent
comprendre des lettres, des chiffres et des caractères de ponctuation. Les chaînes sont stockées
sous forme de caractères Unicode, au format UTF-16. Toute opération effectuée sur la valeur
d’une chaîne renvoie une nouvelle occurrence de la chaîne. La valeur par défaut d’une variable
déclarée avec ce type de données est null.
Pour plus d’informations sur les chaînes, les données et les valeurs, consultez le Chapitre 4,
Données et types de données.
Présentation des chaînes et de la classe String
501
La classe String contient des méthodes qui vous permettent de manipuler des chaînes de texte.
Les chaînes sont importantes pour travailler avec la plupart des objets, et les méthodes décrites
dans ce chapitre sont très utiles pour manipuler les chaînes utilisées dans la plupart des objets,
tels que les occurrences TextField, XML, ContextMenu et FileReference.
La classe String est une enveloppe pour le type de données de base String et fournit des
méthodes et des propriétés qui vous permettent de manipuler les valeurs de base des chaînes.
Vous pouvez convertir la valeur de tout objet en chaîne à l’aide de la fonction String().
Toutes les méthodes de la classe String, à l’exception de concat(), fromCharCode(),
slice() et substr(), sont génériques, ce qui signifie que les méthodes appellent la fonction
toString() avant d’effectuer leurs opérations, et que vous pouvez utiliser ces méthodes avec
d’autres objets non String.
Dans la mesure où tous les index des chaînes ont une base de zéro, l’index du dernier caractère
de toute chaîne myStr est myStr.length - 1.
Vous trouverez un exemple de fichier source, strings.fla, dans le dossier Samples de votre
disque dur. Ce fichier vous indique comment élaborer un traitement de texte simple qui
compare et récupère les sélections de chaînes et de sous-chaînes.
■
Sous Windows, naviguez jusqu’au lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples et Tutorials\Samples\ActionScript\Strings.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Strings.
Création de chaînes
Vous pouvez appeler n’importe quelle méthode de la classe String à l’aide de la méthode de
constructeur new String() ou en utilisant une valeur littérale pour la chaîne. Si vous
spécifiez une chaîne littérale, l’interprète d’ActionScript la convertit automatiquement en un
objet String temporaire, appelle la méthode et élimine l’objet String temporaire. Vous pouvez
aussi utiliser la propriété String.length avec une chaîne littérale.
Ne confondez pas un littéral de chaîne avec un objet String. Pour plus d’informations sur la
création de chaînes littérales et sur l’objet String, consultez le Chapitre 5, Présentation des
littéraux, page 142.
Dans l’exemple suivant, la ligne de code crée la chaîne littérale firstStr. Pour déclarer une
chaîne littérale, utilisez les guillemets simples droits (’) ou les guillemets doubles droits (")
comme délimiteurs.
502
Utilisation du texte et des chaînes
Pour créer et utiliser des chaînes :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom strings.fla.
2.
Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
var firstStr:String = "foo";
var secondStr:String = new String("foo");
trace(firstStr == secondStr); // true
var thirdStr:String;
trace(thirdStr); // undefined
Ce code définit trois objets String, un utilisant une chaîne littérale, un autre utilisant
l’opérateur new, et le dernier sans valeur initiale. Les chaînes peuvent être comparées à
l’aide de l’opérateur d’égalité (==), comme indiqué dans la troisième ligne de code. En ce
qui concerne les variables, vous spécifiez le type de données uniquement lorsque la
variable est en cours de définition.
3.
Sélectionnez Contrôle > Tester l’animation pour tester le document.
Utilisez toujours des chaînes littérales, sauf si vous devez spécifiquement utiliser un objet
String. Pour plus d’informations sur la création de chaînes littérales et sur l’objet String,
consultez le Chapitre 5, Présentation des littéraux, page 142.
Pour utiliser les guillemets simples droits (’) et les guillemets doubles droits (") en tant que
délimiteurs dans une chaîne littérale, utilisez la barre oblique inversée (\) comme caractère
d’échappement. Les deux chaînes suivantes sont équivalentes :
var firstStr:String = "That's \"fine\"";
var secondStr:String = 'That\'s "fine"';
Pour plus d’informations sur l’utilisation de la barre oblique inversée dans les chaînes,
consultez la rubrique Présentation du caractère d’échappement, page 504.
N’oubliez pas que vous ne pouvez pas utiliser les “guillemets recourbés” ni les « guillemets
spéciaux » dans votre code ActionScript ; ils sont différents des guillemets droits (’) et (") que
vous utilisez dans votre code. Lorsque vous collez du texte à partir d’une autre source dans
ActionScript, par exemple depuis le Web ou un document Word, veillez à utiliser des
guillemets droits comme délimiteurs.
Vous trouverez un exemple de fichier source, strings.fla, dans le dossier Samples de votre
disque dur. Ce fichier vous indique comment élaborer un traitement de texte simple qui
compare et récupère les sélections de chaînes et de sous-chaînes.
■
Sous Windows, naviguez jusqu’au lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples et Tutorials\Samples\ActionScript\Strings.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Strings.
Présentation des chaînes et de la classe String
503
Présentation du caractère d’échappement
Vous pouvez utiliser le caractère d’échappement (\) pour définir d’autres caractères dans des
chaînes littérales.
Séquence
d’échappement
Description
\b
Le caractère de retour arrière.
\f
Le caractère de changement de page.
\n
Le caractère de changement de ligne.
\r
Le retour de chariot.
\t
Le caractère de tabulation.
\unnnn
Le caractère Unicode dont le code est spécifié par le nombre
hexadécimal nnnn. Par exemple, \u263a est le caractère sourire.
\xnn
Le caractère ASCII dont le code est spécifié par le nombre
hexadécimal nn.
\’
Un guillemet simple.
\"
Un guillemet double.
\\
Une barre oblique inversée.
Pour plus d’informations sur les chaînes littérales, voir le Chapitre 5, Présentation des littéraux,
page 142 et la rubrique Création de chaînes, page 502.
Analyse et comparaison des caractères dans les
chaînes
Chaque caractère d’une chaîne possède une position d’index dans la chaîne (un entier). La
position d’index du premier caractère est 0. Par exemple, dans la chaîne yellow, le caractère y
occupe la position 0 et le caractère w occupe la position 5.
Chaque chaîne possède une propriété length correspondant au nombre de caractères qu’elle
contient :
var companyStr:String = "macromedia";
trace(companyStr.length); // 10
Une chaîne vide et une chaîne nulle présentent une longueur de zéro :
var firstStr:String = new String();
trace(firstStr.length); // 0
504
Utilisation du texte et des chaînes
var secondStr:String = "";
trace(secondStr.length); // 0
Si une chaîne ne contient aucune valeur, sa longueur est indéfinie :
var thirdStr:String;
trace(thirdStr.length); // undefined
AV E R T I S S E M E N T
Si votre chaîne contient un caractère d’octet nul (\0), la valeur de la chaîne sera
tronquée.
Vous pouvez également définir une chaîne à l’aide de codes de caractère. Pour plus
d’informations sur les codes et l’encodage des caractères, voir Présentation des chaînes et de la
classe String, page 493.
L’exemple suivant crée une variable nommée myStr et définit la valeur de la chaîne en
fonction des valeurs ASCII communiquées à la méthode String.fromCharCode() :
var myStr:String =
String.fromCharCode(104,101,108,108,111,32,119,111,114,108,100,33);
trace(myStr); // hello world!
Chaque nombre figurant dans la méthode fromCharCode() dans le code précédent représente
un seul caractère. Par exemple, la valeur ASCII de 104 correspond à un h minuscule, alors que
la valeur ASCII 32 représente le caractère d’échappement.
Vous pouvez aussi utiliser la méthode String.fromCharCode() pour convertir les valeurs
Unicode, même si la valeur Unicode doit être convertie de valeurs hexadécimales en valeurs
décimales, comme indiqué dans l’ActionScript suivant :
// Unicode 0068 == "h"
var letter:Number = Number(new Number(0x0068).toString(10));
trace(String.fromCharCode(letter)); // h
Vous pouvez examiner les caractères situés à différentes positions dans une chaîne, comme
dans l’exemple suivant.
Présentation des chaînes et de la classe String
505
Pour contourner une chaîne :
1.
Créez un nouveau document Flash.
2.
Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
var myStr:String = "hello world!";
for (var i:Number = 0; i < myStr.length; i++) {
trace(myStr.charAt(i));
}
3.
Choisissez Contrôle > Tester l’animation pour prévisualiser votre document Flash. Chaque
caractère doit être tracé dans le panneau Sortie sur une ligne distincte.
4.
Modifiez le code ActionScript existant afin qu’il trace la valeur ASCII correspondant à
chaque caractère :
var myStr:String = "hello world!";
for (var i:Number = 0; i < myStr.length; i++) {
trace(myStr.charAt(i) + " - ASCII=" + myStr.charCodeAt(i));
}
5.
Enregistrez le document Flash courant et choisissez Contrôle > Tester l’animation pour
prévisualiser le fichier SWF.
Lorsque vous exécutez ce code, l’affichage suivant apparaît dans le panneau Sortie :
h
e
l
l
o
w
o
r
l
d
!
-
ASCII=104
ASCII=101
ASCII=108
ASCII=108
ASCII=111
ASCII=32
ASCII=119
ASCII=111
ASCII=114
ASCII=108
ASCII=100
ASCII=33
C ON S E I L
Vous pouvez aussi diviser une chaîne en un tableau de caractères à l’aide de la
méthode String.split() et en entrant une chaîne vide ("") en tant que délimiteur ; par
exemple, var charArray:Array = myStr.split("");
Vous pouvez utiliser les opérateurs pour comparer les chaînes. Pour plus d’informations sur
l’utilisation des opérateurs avec les chaînes, consultez Utilisation d’opérateurs avec des chaînes,
page 198.
Vous pouvez utiliser ces opérateurs avec des instructions conditionnelles, telles que if et
while. L’exemple suivant fait une comparaison à l’aide d’opérateurs et de chaînes.
506
Utilisation du texte et des chaînes
Pour comparer deux chaînes :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom comparestr.fla.
2.
Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
var str1:String = "Apple";
var str2:String = "apple";
if (str1 < str2) {
trace("Uppercase letters sort first.");
}
3.
Enregistrez le document Flash et choisissez Contrôle > Tester l’animation pour tester le
fichier SWF.
Vous pouvez utiliser les opérateurs d’égalité (==) et d’inégalité (!=) pour comparer des chaînes
avec d’autres types d’objets, comme indiqué dans l’exemple suivant.
Pour comparer les chaînes à d’autres types de données :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom comparenum.fla.
2.
Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
var myStr:String = "4";
var total:Number = 4;
if (myStr == total) {
trace("Types are converted.");
}
3.
Enregistrez le document Flash et choisissez Contrôle > Tester l’animation pour tester le
fichier SWF.
Lorsque vous comparez deux types de données différents (par exemple, des chaînes et des
nombres), Flash tente de convertir les types de données pour permettre une comparaison.
Utilisez les opérateurs d’égalité stricte (===) et d’inégalité stricte (!==) pour vérifier que les
deux objets comparés sont du même type. Les exemples suivants utilisent des opérateurs de
comparaison stricte pour s’assurer que Flash ne tente pas de convertir les types de données en
essayant de comparer les valeurs.
Présentation des chaînes et de la classe String
507
Pour forcer des comparaisons strictes de types de données :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom comparestrict.fla.
2.
Ajoutez le code ActionScript suivant à l’image 1 du scénario principal :
var str1:String = "4";
var str2:String = "5";
var total:Number = 4;
if (str1 !== total) {
trace("Types are not converted.");
}
if (str1 !== str2) {
trace("Same type, but the strings don't match.");
}
3.
Sauvegardez le document Flash et sélectionnez Contrôle > Tester l’animation.
Pour plus d’informations sur l’utilisation des opérateurs avec les chaînes, consultez Utilisation
d’opérateurs avec des chaînes, page 198.
Vous trouverez un exemple de fichier source, strings.fla, dans le dossier Samples de votre
disque dur. Ce fichier vous indique comment élaborer un traitement de texte simple qui
compare et récupère les sélections de chaînes et de sous-chaînes.
■
Sous Windows, naviguez jusqu’au lecteur de démarrage\Program Files\Macromedia\Flash
8\Samples et Tutorials\Samples\ActionScript\Strings.
■
Sur Macintosh, ouvrez le dossier Disque dur Macintosh/Applications/Macromedia Flash 8/
Samples and Tutorials/Samples/ActionScript/Strings.
Conversion et concaténation de chaînes
Vous pouvez utiliser la méthode toString() pour convertir de nombreux objets en chaînes.
La plupart des objets intégrés disposent d’une méthode toString() pour ce faire :
var n:Number = 0.470;
trace(typeof(n.toString())); // string
Lorsque vous utilisez l’opérateur d’addition (+) avec une combinaison d’occurrences de
chaînes et d’autres objets, vous n’avez pas à utiliser la méthode toString(). Pour plus de
détails sur la concaténation, consultez la deuxième procédure de cette section.
Les méthodes toLowerCase() et toUpperCase() convertissent les caractères alphabétiques
des chaînes en majuscules et minuscules, respectivement. L’exemple suivant démontre la
conversion d’une chaîne de caractères minuscules en caractères majuscules.
508
Utilisation du texte et des chaînes
Pour convertir une chaîne de caractères minuscules en majuscules :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom convert.fla.
2.
Tapez le code suivant dans l’image 1 du scénario :
var myStr:String = "Dr. Bob Roberts, #9.";
trace(myStr.toLowerCase()); // dr. bob roberts, #9.
trace(myStr.toUpperCase()); // DR. BOB ROBERTS, #9.
trace(myStr); // Dr. Bob Roberts, #9.
3.
Enregistrez le document Flash et sélectionnez Contrôle > Tester l’animation.
REMARQUE
Une fois que ces méthodes sont exécutées, la chaîne source reste inchangée. Pour
transformer la chaîne source, utilisez ce qui suit :
myStr = myStr.toUpperCase();
Lorsque vous concaténez des chaînes, vous réunissez deux chaînes de manière séquentielle
pour en former une seule. Par exemple, vous pouvez utiliser l’opérateur d’addition (+) pour
concaténer deux chaînes. L’exemple suivant présente la procédure à suivre pour concaténer
deux chaînes.
Pour concaténer deux chaînes :
1.
Créez un nouveau document Flash, puis enregistrez-le sous le nom concat.fla.
2.
Ajoutez le code suivant à l’image 1 du scénario :
var str1:String
var str2:String
trace(str2); //
//
var str3:String
str3 += "ish";
trace(str3); //
= "green";
= str1 + "ish";
greenish
= "yellow";
yellowish
Le code précédent présente deux méthodes de concaténation de chaînes. La première
méthode utilise l’opérateur d’addition (+) pour joindre la chaîne str1 et la chaîne "ish".
La deuxième méthode utilise l’opérateur d’addition et d’affectation (+=) pour concaténer
la chaîne "ish" avec la valeur courante de str3.
3.
Sauvegardez le document Flash et sélectionnez Contrôle > Tester l’animation.
Vous pouvez aussi utiliser la méthode concat() de la classe String pour concaténer des
chaînes. Ceci est illustré par l’exemple suivant :
Présentation des chaînes et de la classe String
509
Pour concat">