PROGRAMMATION AVEC ACTIONSCRIPT

turnmaryDéveloppement de logiciels

5 juil. 2012 (il y a 5 années et 3 mois)

1 795 vue(s)

PROGRAMMATION AVEC
ACTIONSCRIPT

3.0
© 2007 Adobe Systems Incorporated. Tous droits réservés.
Programmation avec ActionScript™ 3.0
Si le présent guide est fourni avec un logiciel régi par un contrat d’utilisateur final, ce guide ainsi que le logiciel décrit, sont
fournis sous licence et peuvent être utilisés ou copiés uniquement selon les clauses et conditions de la licence. Sauf indication
expresse dans le contrat de licence, aucune partie de ce guide ne peut être reproduite, stockée dans un système d’extraction ni
transmise de quelque manière que soit, électronique, mécanique, par enregistrement ou autre, sans l’accord écrit préalable
d’Adobe Systems Incorporated. Veuillez noter que le contenu de ce guide est protégé par les lois de copyright même s’il n’est pas
diffusé avec le logiciel comprenant l’accord de licence utilisateur final.
Le contenu de ce guide est fourni à titre d’information uniquement, peut faire l’objet de modifications sans préavis et ne saurait
être considéré comme un engagement quelconque de la part d’Adobe Systems Incorporated. Adobe Systems Incorporated décline
toute responsabilité quant aux erreurs ou imprécisions susceptibles d’apparaître dans les informations que présente ce guide.
Rappelez-vous que certaines illustrations ou images que vous souhaitez inclure dans votre projet peuvent être protégées par les lois
de copyright. L’inclusion sans autorisation de tels éléments dans vos propres travaux peut porter atteinte aux droits du détenteur
de ce copyright. Veillez à obtenir toutes les autorisations nécessaires auprès de ce dernier.
Toutes les références aux noms de sociétés dans les exemples de modèles sont fournies à titre d’illustration uniquement et ne
visent aucune entreprise existante.
Adobe, le logo Adobe, Flex, Flex Builder et Flash Player sont des marques déposées ou des marques d’Adobe Systems
Incorporated aux Etats-Unis et/ou dans d’autres pays.
ActiveX et Windows sont des marques ou des marques déposées de Microsoft Corporation aux Etats-Unis et dans d’autres pays.
Macintosh est une marque d’Apple Inc., déposée aux Etats-Unis et dans d’autres pays. Toutes les autres marques sont la propriété
de leurs détenteurs respectifs.
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.
Adobe Systems Incorporated, 345 Park Avenue, San Jose, Californie 95110, E.-U.
Avis aux utilisateurs finaux dépendant du gouvernement des Etats-Unis. Le logiciel et la documentation sont des « articles
commerciaux », selon la définition établie par l’article 48 C.F.R. §2.101, composés d’un « logiciel informatique commercial » et
d’une « documentation de logiciel informatique commercial », tels que définis dans les articles 48 C.F.R. §12.212 ou 48 C.F.R.
§227.7202, selon le cas. Conformément aux articles 48 C.F.R. §12.212 ou 48 C.F.R. §§227.7202-1 à 227.7202-4, selon le cas, le
logiciel informatique commercial et la documentation de logiciel informatique commercial sont fournis sous licence aux
utilisateurs finaux dépendant du gouvernement des Etats-Unis (a) comme articles commerciaux uniquement et (b) avec les seuls
droits normalement accordés aux utilisateurs finaux, en accord avec les conditions générales applicables. Les droits non publiés
sont réservés conformément aux lois sur le copyright en vigueur aux Etats-Unis. Adobe Systems Incorporated, 345 Park Avenue,
San Jose, CA 95110-2704, E.-U. Pour les utilisateurs finaux ne dépendant pas du gouvernement des Etats-Unis, Adobe accepte
de respecter toutes les lois applicables relatives à l’égalité des chances, y compris, s’il y a lieu, aux dispositions du décret 11246 et
ses modifications, de la section 402 de la loi sur l’aide à la réhabilitation des vétérans du Vietnam (Vietnam Era Veterans
Readjustment Assistance Act) de 1974 (38 USC 4212), de la section 503 de la loi de réhabilitation (Rehabilitation Act) de 1973
et ses modifications, et des règlements des articles 41 CFR 60-1 à 60-60, 60-250 et 60-741. La clause relative à la discrimination
positive et les régulations énoncées dans la phrase précédente sont incluses par référence.
3
Table des matières
A propos de ce manuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Utilisation de ce manuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Accès à la documentation ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Ressources ActionScript destinées à la formation. . . . . . . . . . . . . . . . .19
Chapitre 1: Introduction à ActionScript 3.0 . . . . . . . . . . . . . . . . . . 21
A propos d’ActionScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Avantages d’ActionScript 3.0. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Nouveautés d’ActionScript 3.0. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Fonctions du langage de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Fonctions API de Flash Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Compatibilité avec les versions précédentes. . . . . . . . . . . . . . . . . . . . . .27
Chapitre 2: Prise en main d’ActionScript. . . . . . . . . . . . . . . . . . . 29
Concepts de programmation de base . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Quel est le rôle d’un programme informatique. . . . . . . . . . . . . . . . . . 29
Variables et constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Types de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Utilisation des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Méthodes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Evénements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Gestion des événements de base . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Description du processus de gestion des événements. . . . . . . . .37
Exemples de gestion d’événements. . . . . . . . . . . . . . . . . . . . . . . . .41
Création d’instances d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Eléments de programme courants. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Exemple: Elément de portfolio d’animation. . . . . . . . . . . . . . . . . . . . . . 46
Création d’applications avec ActionScript . . . . . . . . . . . . . . . . . . . . . . . 50
Options d’organisation du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .51
Choix de l’outil approprié . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Processus de développement ActionScript . . . . . . . . . . . . . . . . . . . 55
4
Création de vos propres classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .56
Stratégies de conception d’une classe . . . . . . . . . . . . . . . . . . . . . . . .56
Ecriture du code d’une classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
Suggestions d’organisation des classes . . . . . . . . . . . . . . . . . . . . . . .59
Exemple: Création d’une application de base . . . . . . . . . . . . . . . . . . . .60
Exécution des exemples suivants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
Chapitre 3: Syntaxe et langage ActionScript . . . . . . . . . . . . . . . . 71
Présentation du langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Objets et classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Packages et espaces de nom. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .80
Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .89
Types de données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .93
Vérification des types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .94
Classes dynamiques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .99
Descriptions des types de données . . . . . . . . . . . . . . . . . . . . . . . . . . .101
Conversions de type. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .118
Instructions conditionnelles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
Boucle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Fonctions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .131
Concepts de fonction de base. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
Paramètres de fonction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
Fonctions comme objets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Domaine de la fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
Chapitre 4: Programmation orientée objet en ActionScript. . . . 147
Principes de la programmation orientée objet . . . . . . . . . . . . . . . . . . . 148
Classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
Définitions de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .151
Attributs de propriété de classe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
Les méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
Les énumérations et les classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
Les classes des éléments incorporés. . . . . . . . . . . . . . . . . . . . . . . . . 169
Interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
Héritage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Rubriques avancées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
Exemple: GeometricShapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
5
Chapitre 5: Utilisation des dates et heures. . . . . . . . . . . . . . . . . 205
Principes de base des dates et des heures. . . . . . . . . . . . . . . . . . . . . . 205
Gestion des dates calendaires et des heures. . . . . . . . . . . . . . . . . . . . 206
Contrôle des intervalles temporels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .210
Exemple: une horloge analogique simple. . . . . . . . . . . . . . . . . . . . . . . .213
Chapitre 6: Utilisation des chaînes . . . . . . . . . . . . . . . . . . . . . . . .217
Principes de base des chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .218
Création de chaînes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
La propriété length. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .221
Utilisation de caractères dans des chaînes. . . . . . . . . . . . . . . . . . . . . . 222
Comparaison de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
Récupération des représentations de chaîne d’autres objets. . . . . . 223
Concaténation de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
Recherche de sous-chaînes et de motifs dans des chaînes. . . . . . . 225
Conversion de la casse dans des chaînes. . . . . . . . . . . . . . . . . . . . . . . 230
Exemple: ASCII art . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .231
Chapitre 7: Utilisation de tableaux. . . . . . . . . . . . . . . . . . . . . . . . 239
Principes de base des tableaux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
Tableaux indexés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
Tableaux associatifs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .251
Tableaux multidimensionnels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
Clonage de tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
Rubriques avancées:. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
Exemple: PlayList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
Chapitre 8: Gestion des erreurs. . . . . . . . . . . . . . . . . . . . . . . . . . .271
Principes de base de la gestion des erreurs. . . . . . . . . . . . . . . . . . . . . 272
Types d’erreurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
Gestion des erreurs dans ActionScript 3.0 . . . . . . . . . . . . . . . . . . . . . 277
Eléments de gestion des erreurs ActionScript 3.0. . . . . . . . . . . . . 278
Stratégies de gestion des erreurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
Utilisation de la version de débogage de Flash Player. . . . . . . . . . . . 280
Gestion des erreurs synchrones dans une application. . . . . . . . . . . . .281
Création de classes d’erreur personnalisées . . . . . . . . . . . . . . . . . . . . 286
Réponse à des événements d’erreurs et au statut . . . . . . . . . . . . . . . 288
6
Comparaison des classes Error . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .292
Classes Error de base ECMAScript . . . . . . . . . . . . . . . . . . . . . . . . . .292
Classes Error de base d’ActionScript. . . . . . . . . . . . . . . . . . . . . . . . 295
Classes Error du package flash.error . . . . . . . . . . . . . . . . . . . . . . . . .296
Exemple: Application CustomErrors . . . . . . . . . . . . . . . . . . . . . . . . . . .298
Chapitre 9: Utilisation d’expressions régulières . . . . . . . . . . . . 305
Principes de base des expressions régulières. . . . . . . . . . . . . . . . . . . 306
Syntaxe d’expression régulière . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Création d’une instance d’une expression régulière . . . . . . . . . . . . 310
Caractères, caractères de remplacement et métaséquences. . . . .311
Classes de caractère . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
Quantificateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
Permutation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318
Groupes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
Indicateurs et propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .322
Méthodes d’utilisation d’expressions régulières avec
des chaînes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .327
Exemple: Un analyseur Wiki. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .328
Chapitre 10: Gestion d’événements. . . . . . . . . . . . . . . . . . . . . . . 335
Principes de base de la gestion des événements. . . . . . . . . . . . . . . . .336
Variation de la gestion d’événements dans ActionScript 3.0
par rapport aux versions antérieures. . . . . . . . . . . . . . . . . . . . . . . . . . . .339
Flux d’événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .343
Objets événements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .345
Ecouteurs d’événements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351
Exemple: un réveil. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
Chapitre 11: Utilisation de XML . . . . . . . . . . . . . . . . . . . . . . . . . . .367
Principes de base de XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .368
L’approche E4X concernant le traitement XML. . . . . . . . . . . . . . . . . .372
Objets XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .374
XMLList, objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .377
Initialisation de variables XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .378
Assemblage et transformation d’objets XML . . . . . . . . . . . . . . . . . . . 380
Parcours de structures XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
Utilisation d’espaces de nom XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . .387
Conversion de type XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .388
Lecture de documents XML externes. . . . . . . . . . . . . . . . . . . . . . . . . . 390
Exemple: Chargement de données RSS depuis Internet . . . . . . . . 390
7
Chapitre 12: Programmation de l’affichage . . . . . . . . . . . . . . . . 395
Bases de la programmation de l’affichage . . . . . . . . . . . . . . . . . . . . . . 395
Classes d’affichage de base. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .401
Avantages de l’utilisation de la liste d’affichage. . . . . . . . . . . . . . . . . . 403
Utilisation des objets d’affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
Propriétés et méthodes de la classe DisplayObject. . . . . . . . . . . . 406
Ajout d’objets d’affichage à la liste d’affichage. . . . . . . . . . . . . . . . 407
Utilisation des conteneurs d’objets d’affichage. . . . . . . . . . . . . . . . 407
Traversée de la liste d’affichage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
Définition des propriétés de la scène . . . . . . . . . . . . . . . . . . . . . . . . .413
Gestion des événements des objets d’affichage . . . . . . . . . . . . . . .417
Choix d’une sous-classe de DisplayObject . . . . . . . . . . . . . . . . . . . .418
Manipulation des objets d’affichage. . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
Modification de la position. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
Défilement horizontal et vertical des objets d’affichage . . . . . . . . 426
Redimensionnement et mise à l’échelle des objets . . . . . . . . . . . . 428
Contrôle de la distorsion lors de la mise à l’échelle . . . . . . . . . . 429
Mise en cache des objets d’affichage. . . . . . . . . . . . . . . . . . . . . . . . 432
Pertinence de la mise en cache . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
Activation de la mise en cache sous forme de bitmap . . . . . . . 435
Définition d’une couleur d’arrière-plan opaque . . . . . . . . . . . . . 435
Application de modes de fondu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436
Modification des couleurs des objets d’affichage. . . . . . . . . . . . . . 437
Modification par code des valeurs des couleurs. . . . . . . . . . . . . 438
Modification par code des effets de couleur et
de luminosité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
Rotation des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .440
Application d’effets de fondu à des objets. . . . . . . . . . . . . . . . . . . .440
Masquage des objets d’affichage. . . . . . . . . . . . . . . . . . . . . . . . . . . .440
Animation des objets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444
Chargement dynamique de contenu à afficher . . . . . . . . . . . . . . . . . . 446
Chargement d’objets d’affichage. . . . . . . . . . . . . . . . . . . . . . . . . . . . 446
Suivi de la progression du chargement. . . . . . . . . . . . . . . . . . . . . . . 447
Spécification du contexte de chargement . . . . . . . . . . . . . . . . . . . . 449
Exemple: SpriteArranger. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .451
Chapitre 13: Utilisation de la géométrie. . . . . . . . . . . . . . . . . . . . 459
Principes de base de la géométrie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459
Utilisation des objets Point. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462
Utilisation d’objets Rectangle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465
Utilisation des objets Matrix. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469
Exemple: Application d’une transformation de matrice
à un objet d’affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470
8
Chapitre 14: Utilisation de l’API de dessin . . . . . . . . . . . . . . . . . 475
Les bases d’utilisation de l’API de dessin. . . . . . . . . . . . . . . . . . . . . . . .476
Présentation de la classe Graphics . . . . . . . . . . . . . . . . . . . . . . . . . . . . .478
Dessin de lignes et de courbes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .479
Dessin de formes à l’aide des méthodes intégrées . . . . . . . . . . . . . . .482
Création de lignes et de remplissages en dégradé. . . . . . . . . . . . . . . .483
Utilisation de la classe Math avec les méthodes de dessin . . . . . . . 489
Animation avec l’API de dessin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490
Exemple: générateur algorithmique d’effets visuels. . . . . . . . . . . . . . 491
Chapitre 15: Filtrage des objets d’affichage. . . . . . . . . . . . . . . . 495
Bases du filtrage des objets d’affichage. . . . . . . . . . . . . . . . . . . . . . . . 495
Création et application de filtres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .497
Création d’un nouveau filtre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .497
Application d’un filtre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
Le fonctionnement des filtres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500
Problèmes potentiels d’utilisation des filtres. . . . . . . . . . . . . . . . . . 500
Filtres d’affichage disponibles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502
Filtre de biseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503
Filtre de flou . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504
Filtre d’ombre portée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504
Filtre de rayonnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505
Filtre de biseau dégradé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506
Filtre de rayonnement dégradé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .507
Exemple: combinaison de filtres de base . . . . . . . . . . . . . . . . . . . . 508
Filtre matrice de couleurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
Filtre de convolution. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .511
Filtre mappage de déplacement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514
Exemple: Filter Workbench . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520
Chapitre 16: Utilisation des clips . . . . . . . . . . . . . . . . . . . . . . . . . .521
Principes de base des clips. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521
Utilisation des objets MovieClip. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524
Contrôle de la lecture d’un clip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524
Utilisation des séquences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .527
Création d’objets MovieClip à l’aide d’ActionScript. . . . . . . . . . . . . . .528
Exportation des symboles de bibliothèque pour
ActionScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .528
Chargement d’un fichier SWF externe. . . . . . . . . . . . . . . . . . . . . . . . . .532
Exemple: RuntimeAssetsExplorer . . . . . . . . . . . . . . . . . . . . . . . . . . . . .533
9
Chapitre 17: Utilisation de texte . . . . . . . . . . . . . . . . . . . . . . . . . . 539
Les bases de l’utilisation du texte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .540
Affichage du texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543
Types de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543
Modification du contenu d’un champ texte . . . . . . . . . . . . . . . . . . . 544
Affichage du texte HTML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545
Utilisation d’images dans des champs texte . . . . . . . . . . . . . . . . . . 545
Défilement du texte dans un champ texte . . . . . . . . . . . . . . . . . . . . 546
Sélection et manipulation de texte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547
Capture de la saisie de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 549
Restriction de la saisie de texte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550
Formatage du texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .551
Attribution de formats texte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .551
Application de feuilles de style en cascade . . . . . . . . . . . . . . . . . . . 552
Chargement de fichiers CSS externes . . . . . . . . . . . . . . . . . . . . . . . 553
Formatage de plages de texte au sein d’un champ texte . . . . . . . 555
Fonctions avancées d’affichage de texte . . . . . . . . . . . . . . . . . . . . . . . 556
Utilisation de texte statique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 558
Exemple: formatage du texte dans le style « journal ». . . . . . . . . . . . 560
Lecture du fichier CSS externe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .561
Disposition des éléments de l’article sur la page . . . . . . . . . . . . . . 564
Modification de la taille de la police en fonction de
la taille du champ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564
Répartition du texte sur plusieurs colonnes. . . . . . . . . . . . . . . . . . . 567
Chapitre 18: Utilisation des graphismes bitmap. . . . . . . . . . . . . .571
Les bases de l’utilisation des bitmaps . . . . . . . . . . . . . . . . . . . . . . . . . . .571
Les classes Bitmap et BitmapData . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575
Manipulation des pixels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 577
Manipulation individuelle de pixels. . . . . . . . . . . . . . . . . . . . . . . . . . . 577
Détection de collision au niveau des pixels . . . . . . . . . . . . . . . . . . . 579
Copie de données bitmap. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .581
Création de textures avec les fonctions de bruit aléatoire. . . . . . . . . 582
Défilement du contenu d’images bitmap. . . . . . . . . . . . . . . . . . . . . . . . 584
Exemple: animation d’objets Sprite à l’aide d’une image
bitmap hors écran. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585
Chapitre 19: Utilisation de la vidéo. . . . . . . . . . . . . . . . . . . . . . . . 587
Principes de base de la vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588
Présentation du format vidéo Flash (FLV) . . . . . . . . . . . . . . . . . . . . . . .591
Présentation de la classe Video . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592
10
Chargement de fichiers vidéo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593
Contrôle de la lecture de la vidéo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594
Détection de la fin d’un flux vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . . 595
Lecture de fichiers vidéo en flux continu . . . . . . . . . . . . . . . . . . . . . . . 596
Présentation des points de repère. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .597
Création de méthodes de rappel pour les gestionnaires
d’événements onCuePoint et onMetaData . . . . . . . . . . . . . . . . . . . . . .598
Définir la propriété « client » de l’objet NetStream
comme Object. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 599
Créer une classe et définir des méthodes pour gérer
les méthodes de rappel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 600
Étendre la classe NetStream et lui ajouter des méthodes
pour gérer les méthodes de rappel. . . . . . . . . . . . . . . . . . . . . . . . . 601
Étendre la classe NetStream et la rendre dynamique. . . . . . . . . . 602
Définir la propriété « client » de l’objet NetStream
comme this. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 604
Utilisation des points de repère . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 604
Utilisation des métadonnées de la vidéo . . . . . . . . . . . . . . . . . . . . . . . 605
Capture d’un signal vidéo provenant de la caméra
de l’utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609
Présentation de la classe Camera. . . . . . . . . . . . . . . . . . . . . . . . . . . 609
Affichage du signal provenant de la caméra. . . . . . . . . . . . . . . . . . . 610
Conception d’une application gérant une caméra locale. . . . . . . . 610
Établissement d’une connexion avec la caméra de l’utilisateur . . .611
Vérification de la présence de caméras. . . . . . . . . . . . . . . . . . . . . . . .611
Détection de l’autorisation d’accéder à la caméra. . . . . . . . . . . . . . 612
Optimisation de la qualité d’image vidéo. . . . . . . . . . . . . . . . . . . . . . 614
Suivi des conditions de lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 616
Envoi de vidéo à un serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 617
Rubriques avancées: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 617
Compatibilité de Flash Player avec les fichiers FLV codés. . . . . . 617
La configuration de fichier FLV pour l’hébergement sur
un serveur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618
Le ciblage des fichiers FLV locaux sur Macintosh . . . . . . . . . . . . . 619
Exemple: Video Jukebox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 619
Chapitre 20: Utilisation du son . . . . . . . . . . . . . . . . . . . . . . . . . . .627
Principes de base de l’utilisation du son. . . . . . . . . . . . . . . . . . . . . . . . .628
Présentation de l’architecture audio . . . . . . . . . . . . . . . . . . . . . . . . . . . . 631
Chargement de fichiers audio externes . . . . . . . . . . . . . . . . . . . . . . . . .633
Utilisation des sons incorporés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .636
Utilisation de fichiers audio de lecture en continu . . . . . . . . . . . . . . . .637
11
Lecture de sons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638
Pause et reprise d’un son. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 639
Surveillance de la lecture. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 640
Arrêt de sons diffusés en continu. . . . . . . . . . . . . . . . . . . . . . . . . . . . 642
Sécurité lors du chargement et de la lecture des sons. . . . . . . . . . . . 642
Contrôle du volume du son et de la balance. . . . . . . . . . . . . . . . . . . . . 643
Utilisation des métadonnées audio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 646
Accès aux données audio brutes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 647
Capture de l’entrée de son . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .651
Accès à un microphone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .651
Acheminement de l’audio du microphone vers des
haut-parleurs locaux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 652
Modification de l’audio du microphone. . . . . . . . . . . . . . . . . . . . . . . 653
Détection de l’activité du microphone. . . . . . . . . . . . . . . . . . . . . . . . 653
Envoi d’audio vers et depuis une passerelle multimédia. . . . . . . . 655
Exemple: Podcast Player. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655
Lecture de données RSS pour une chaîne de balado. . . . . . . . . . 657
Simplification de la lecture et du chargement du son
à l’aide de la classe SoundFacade . . . . . . . . . . . . . . . . . . . . . . . . 657
Affichage de la progression de la lecture . . . . . . . . . . . . . . . . . . . . . .661
Interruption et reprise de la lecture. . . . . . . . . . . . . . . . . . . . . . . . . . . 662
Extension de l’exemple Podcast Player . . . . . . . . . . . . . . . . . . . . . . 663
Chapitre 21: Capture des données saisies par l’utilisateur . . . . 665
Principes de base de la saisie utilisateur. . . . . . . . . . . . . . . . . . . . . . . . 665
Capture de la saisie au clavier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 667
Capture des entrées de souris. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 670
Exemple: WordSearch. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 675
Chapitre 22: Réseau et communication. . . . . . . . . . . . . . . . . . . 679
Principes de base de la mise en réseau et de
la communication. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 679
Utilisation de données externes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 683
Connexion à d’autres instances Flash Player. . . . . . . . . . . . . . . . . . . . 690
Connexions socket. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 697
Stockage des données locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 702
Utilisation des chargements et téléchargements
de fichiers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 706
Exemple: création d’un client Telnet. . . . . . . . . . . . . . . . . . . . . . . . . . . . 717
Exemple: chargement et téléchargement de fichiers . . . . . . . . . . . . .721
12
Chapitre 23: Environnement du système client. . . . . . . . . . . . . . 731
Principes de base de l’environnement du système client. . . . . . . . . . 731
Utilisation de la classe System. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .734
Utilisation de la classe Capabilities . . . . . . . . . . . . . . . . . . . . . . . . . . . . .735
Utilisation de la classe ApplicationDomain . . . . . . . . . . . . . . . . . . . . . .736
Utilisation de la classe IME . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .740
Exemple: détection des capacités du système . . . . . . . . . . . . . . . . . .746
Chapitre 24: Impression. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 751
Principes de base de l’impression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .752
Impression d’une page. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .753
Tâches Flash Player et impression système . . . . . . . . . . . . . . . . . . . . .755
Définition de la taille, de l’échelle et de l’orientation . . . . . . . . . . . . . .758
Exemple: Impression sur plusieurs pages. . . . . . . . . . . . . . . . . . . . . . . 761
Exemple: Redimensionnement, recadrage et ajustement. . . . . . . . .764
Chapitre 25: Utilisation de l’API externe . . . . . . . . . . . . . . . . . . .767
Principes de base de l’utilisation de l’API externe . . . . . . . . . . . . . . . .768
Avantages de l’API externe et conditions requises . . . . . . . . . . . . . . .772
Utilisation de la classe ExternalInterface . . . . . . . . . . . . . . . . . . . . . . . .773
Obtention d’informations sur le conteneur externe. . . . . . . . . . . . .774
Appel de code externe à partir d’ActionScript . . . . . . . . . . . . . . . . .774
Appel du code ActionScript à partir du conteneur . . . . . . . . . . . . .775
Format XML de l’API externe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 777
Exemple: utilisation de l’API externe dans un conteneur
de page Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .779
Exemple: utilisation de l’API externe avec un conteneur
ActiveX. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .787
Chapitre 26: La sécurité dans Flash Player. . . . . . . . . . . . . . . . .797
Présentation de la sécurité dans Flash Player . . . . . . . . . . . . . . . . . . .798
Présentation des contrôles d’autorisation . . . . . . . . . . . . . . . . . . . . . . . 801
Sandboxes de sécurité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 812
Restriction des API de réseau. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 815
Sécurité du mode plein écran. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 817
Chargement de contenu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 818
Programmation croisée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .822
Accès aux médias chargés comme s’il s’agissait de données. . . . . .826
Chargement des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .829
Chargement de contenu incorporé à partir de fichiers
SWF importés dans un domaine de sécurité . . . . . . . . . . . . . . . . . . . .832
13
Utilisation de contenus existants. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 833
Définition des autorisations LocalConnection. . . . . . . . . . . . . . . . . . . 833
Contrôle de l’accès aux scripts dans une page Web hôte. . . . . . . . . 834
Objets partagés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 836
Accès à la caméra, au microphone, au presse-papiers,
à la souris et au clavier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 838
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 839
14
15
A propos de ce manuel
Ce manuel peut servir de base au développement d’applications avec ActionScript™ 3.0.
Il est préférable de maîtriser les concepts de programmation généraux (types de données,
variables, boucles et fonctions) afin de mieux comprendre les idées et techniques décrites.
Il est également conseillé de comprendre les concepts de programmation orientés objet (classes
et héritage). La connaissance d’ActionScript 1.0 ou ActionScript 2.0 est utile mais pas
nécessaire.
Contenu
Utilisation de ce manuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Accès à la documentation ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .17
Ressources ActionScript destinées à la formation. . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
16 A propos de ce manuel
Utilisation de ce manuel
Les chapitres de ce manuel sont structurés en groupes logiques (indiqués ci-dessous) afin de
faciliter la recherche de sections de documentation ActionScript connexes:
Ce manuel contient également de nombreux fichiers d’exemple qui décrivent des concepts de
programmation d’applications pour des classes importantes ou couramment utilisées.
Les fichiers d’exemple sont préparés de façon à ce que vous puissez les charger et les utiliser
plus facilement avec Adobe® Flash® CS3 Professional. Ils peuvent inclure des fichiers
enveloppes. Néanmoins, l’exemple de code de base est du code ActionScript 3.0 pur que vous
pouvez utiliser dans l’environnement de développement de votre choix.
ActionScript 3.0 peut être écrit et compilé de plusieurs façons différentes:

En utilisant l’environnement de développement d’Adobe Flex Builder 2

En utilisant un éditeur de texte et un compilateur de ligne de commande (celui fourni
avec Flex Builder 2, par exemple)

En utilisant l’outil de programmation Adobe® Flash® CS3 Professional
Pour plus d’informations sur les environnements de développement d’ActionScript, voir
Chapitre 1, « Introduction à ActionScript 3.0 ».
Chapitres Description
Chapitres 1 à 4, présentation de la
programmation avec ActionScript
Décrit les concepts ActionScript 3.0 de base, y
compris la syntaxe, les instructions et les
opérateurs du langage, la spécification de
langage ECMAScript version 4, la
programmation ActionScript orientée objet et la
nouvelle façon de gérer des objets d’affichage
sur la liste d’affichage Adobe
®
Flash
®
Player 9.
Chapitres 5 à 10, classes et types de
données ActionScript 3.0 de base
Décrit les types de données de niveau supérieur
dans ActionScript 3.0 qui font également partie
de la spécification ECMAScript.
Chapitres 11 à 26, API de Flash Player Décrit les fonctions importantes mises en
œuvre dans des packages et des classes
propres à Adobe Flash Player 9, notamment
la gestion d’événements, la mise en réseau et
les communications, le fichier d’E/S,
l’interface externe, le modèle de sécurité de
l’application, etc.
Accès à la documentation ActionScript 17
Pour comprendre les exemples de code fournis dans ce manuel, vous n’avez pas besoin de
savoir utiliser les environnements de développement intégrés pour ActionScript (Flex Builder
ou l’outil de création Flash, par exemple). En revanche, vous pouvez consulter la
documentation relative à ces outils pour savoir comment les utiliser pour écrire et compiler du
code ActionScript 3.0. Pour plus d’informations, voir « Accès à la documentation
ActionScript », à la page 17.
Accès à la documentation ActionScript
Etant donné que ce manuel traite principalement de la description d’ActionScript 3.0 qui est
un langage de programmation orienté objet riche et puissant, il ne décrit pas de façon détaillée
le processus de développement de l’application ou le flux de travail au sein d’une architecture
serveur ou d’un outil particulier. Par conséquent, outre la Programmation avec ActionScript
3.0, vous pouvez consulter d’autres sources de documentation lorsque vous concevez,
développez, testez et déployez des applications ActionScript 3.0.
Documentation ActionScript 3.0
Ce manuel décrit les concepts qui sous-tendent le langage de programmation ActionScript 3.0
et fournit des détails et des exemples d’implémentation illustrant les fonctions importantes du
langage. Néanmoins, il ne constitue pas un guide de référence du langage complet. Pour cela,
consultez la Référence du langage et des composants ActionScript 3.0, qui décrit chaque classe,
chaque méthode, chaque propriété et chaque événement dans le langage. La Référence du
langage et des composants ActionScript 3.0 fournit des informations de référence détaillées sur le
langage de base, les composants Flash (dans les packages fl) et les API de Flash Player (dans les
packages flash).
Documentation Flash
Si vous utilisez l’environnement de développement Flash, vous pouvez consulter les manuels
suivants:
Manuel Description
Utilisation de Flash Décrit comment développer vos applications
Web dynamiques dans l’environnement de
programmation de Flash
Programmation avec ActionScript 3.0 Décrit l’utilisation spécifique du langage
ActionScript 3.0 et de l’API de base de
Flash Player
18 A propos de ce manuel
Référence du langage et des composants
ActionScript 3.0
Fournit des exemples de code, d’utilisation et
de syntaxe pour les composants de Flash et
l’API d’ActionScript 3.0
Utilisation des composants ActionScript 3.0 Explique comment utiliser les composants pour
développer des applications Flash
Formation à ActionScript 2.0 dans
Adobe Flash
Passe en revue les principes généraux de la
syntaxe ActionScript 2.0 et explique comment
utiliser ce langage pour intervenir sur différents
types d’objet
Guide de référence du langage
ActionScript 2.0
Fournit des exemples de code, d’utilisation et
de syntaxe pour les composants de Flash et
l’API d’ActionScript 2.0
Utilisation des composants ActionScript 2.0 Explique de façon détaillée comment utiliser les
composants ActionScript 2.0 pour développer
des applications Flash
Référence du langage des composants
ActionScript 2.0
Décrit chaque composant disponible dans
l’architecture des composants Adobe, version
2, avec son API
Extension de Flash Décrit les objets, les méthodes et les propriétés
disponibles dans l’API de JavaScript
Prise en main de Flash Lite 2.x Explique comment utiliser Adobe® Flash® Lite™
2.x pour développer des applications et fournit
des exemples de code, d’utilisation et de
syntaxe pour les fonctions ActionScript
disponibles avec Flash Lite 2.x
Développement d’applications Flash Lite 2.0 Explique comment développer des applications
Flash Lite 2.x
Introduction à ActionScript Flash Lite 2.x Explique comment développer des applications
avec Flash Lite 2.x et décrit toutes les fonctions
ActionScript disponibles pour les développeurs
de Flash Lite 2.x
Référence du langage ActionScript Flash
Lite 2.x
Fournit des exemples de code, d’utilisation et
de syntaxe pour l’API d’ActionScript 2.0
disponible dans Flash Lite 2.x
Prise en main de Flash Lite 1.x Présente Flash Lite 1.x et décrit comment tester
votre contenu à l’aide de l’émulateur CS3
d’Adobe® Device Central
Manuel Description
Ressources ActionScript destinées à la formation 19
Ressources ActionScript destinées à
la formation
Outre le contenu de ces manuels, Adobe fournit des articles, des idées de conception et
des exemples mis à jour régulièrement dans le Pôle de développement et le Pôle de
création Adobe.
Pôle de développement Adobe
Le Pôle de développement d’Adobe constitue votre ressource pour consulter les dernières
informations concernant ActionScript, des articles sur le développement d’application et des
informations sur des problèmes importants. Consultez le Pôle de développement à l’adresse
www.adobe.com/go/developer_fr.
Pôle de création Adobe
Consultez les dernières nouveautés en matière de design numérique et d’animations.
Parcourez les œuvres d’artistes renommés, découvrez les nouvelles tendances de design et
consolidez vos connaissances à l’aide de didacticiels, de flux de travail clés et de techniques
avancées. Vérifiez deux fois par mois si de nouveaux didacticiels et articles ainsi que des pièces
de galerie d’inspiration sont disponibles. Consultez le Pôle de création à l’adresse
www.adobe.com/go/designcenter_fr.
Développement d’applications Flash Lite 1.x Décrit comment développer des applications
pour des périphériques mobiles à l’aide de
Flash Lite 1.x
Formation à ActionScript Flash Lite 1.x Explique comment utiliser ActionScript dans
des applications Flash Lite 1.x et décrit toutes
les fonctions ActionScript disponibles avec
Flash Lite 1.x
Guide de référence du langage ActionScript
Flash Lite 1.x
Fournit la syntaxe et l’utilisation d’éléments
ActionScript disponibles avec Flash Lite 1.x
Manuel Description
20 A propos de ce manuel
21
1
CHAPITRE 1
Introduction à ActionScript 3.0
Ce chapitre offre une présentation générale d’ActionScript 3.0, la version la plus récente et la
plus révolutionnaire d’ActionScript.
Contenu
A propos d’ActionScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Avantages d’ActionScript 3.0. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .22
Nouveautés d’ActionScript 3.0. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .23
Compatibilité avec les versions précédentes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
A propos d’ActionScript
ActionScript est un langage de programmation destiné à l’environnement d’exécution
d’Adobe Flash Player. Il assure l’interactivité, le traitement des données et bien d’autres
fonctions du contenu Flash et dans les applications associées.
ActionScript est exécuté par la machine virtuelle ActionScript, un composant de Flash Player.
Le code ActionScript est généralement compilé en pseudo-code binaire (une sorte de langage de
programmation écrit et compris par les ordinateurs) par un compilateur, par exemple celui
intégré dans Adobe Flash CS3 Professional ou Adobe® Flex™ Builder™, ou celui fourni dans le
kit de développement Adobe® Flex™ SDK et les services de données Flex™ Data Services.
Le pseudo-code binaire est incorporé aux fichiers SWF, qui sont exécuté par Flash Player dans
l’environnement d’exécution.
ActionScript 3.0 constitue un modèle de programmation solide, bien connu des développeurs
dotés des connaissances élémentaires de la programmation orientée objet. Les fonctions
principales d’ActionScript 3.0 sont les suivantes:

Une nouvelle machine virtuelle ActionScript, nommée AVM2, qui exploite un nouveau
jeu d’instructions de pseudo-code binaire et améliore grandement les performances.
22 Introduction à ActionScript 3.0

Une base de code de compilation plus moderne, davantage en accord avec la norme
ECMAScript (ECMA 262) et qui accomplit de meilleures optimisations que les versions
antérieures du compilateur.

Une interface de programmation (API) étendue et améliorée, avec contrôle de bas niveau
des objets et un véritable modèle orienté objet.

Un langage de base reposant sur la future version 4 de la spécification ECMAScript
(ECMA-262).

Une API XML reposant sur la spécification ECMAScript pour XML (E4X) (ECMA-357
niveau 2). E4X est une extension de langage d’ECMAScript qui ajoute XML comme type
de données natif.

Un modèle d’événements fondé sur la spécification d’événements du modèle d’objet de
document (DOM, Document Object Model) niveau 3.
Avantages d’ActionScript 3.0
Les possibilités d’ActionScript 3.0 dépassent largement les fonctions de programmation des
versions précédentes. Cette version est conçue pour faciliter la création d’applications très
complexes impliquant d’importants jeux de données et des bases de code orientées objet et
réutilisables. Si ActionScript 3.0 n’est pas indispensable à l’exécution de contenu dans Adobe
Flash Player 9, il ouvre néanmoins la voie à des améliorations de performance uniquement
disponibles dans AVM2, la nouvelle machine virtuelle. Le code d’ActionScript 3.0 peut
s’exécuter jusqu’à dix fois plus vite que le code des versions antérieures d’ActionScript.
L’ancienne version de la machine virtuelle, AVM1, exécute le code ActionScript 1.0 et
ActionScript 2.0. Elle est prise en charge par Flash Player 9 pour assurer la compatibilité
ascendante avec le contenu existant. Pour plus d’informations, voir « Compatibilité avec les
versions précédentes », à la page 27.
Nouveautés d’ActionScript 3.0 23
Nouveautés d’ActionScript 3.0
Bien que de nombreuses classes et fonctions d’ActionScript 3.0 seront familières aux
programmeurs d’ActionScript, son architecture et sa conceptualisation diffèrent des versions
précédentes. Parmi les améliorations d’ActionScript 3.0, on compte de nouvelles fonctions du
langage de base et une API Flash Player avancée, qui accroît le contrôle des objets de bas
niveau.
Fonctions du langage de base
Le langage de base définit les éléments de construction fondamentaux du langage de
programmation, par exemple les arguments, expressions, conditions, boucles et types.
ActionScript 3.0 contient de nombreuses fonctions qui accélèrent le processus de
développement.
Exceptions d’exécution
ActionScript 3.0 peut signaler davantage de conditions d’erreur que les versions précédentes
d’ActionScript. Utilisées pour les conditions d’erreur courantes, les exceptions d’exécution
améliorent la procédure de débogage et vous permettent de développer des applications
susceptibles de gérer les erreurs de manière fiable. Les erreurs d’exécution peuvent fournir des
traces d’empilement qui identifient le fichier source et le numéro de ligne, pour un repérage
plus rapide des erreurs.
Types d’exécution
Dans ActionScript 2.0, les annotations de type visaient avant tout à aider le développeur; lors
de l’exécution, toutes les valeurs étaient typées dynamiquement. Dans ActionScript 3.0, les
informations de type sont préservées lors de l’exécution et utilisées à plusieurs fins. Flash
Player 9 effectue une vérification du type d’exécution afin d’améliorer la sécurité du système
quant aux types. Les informations de type servent également à représenter les variables dans les
représentations machine natives, ce qui accroît les performances et réduit l’utilisation de la
mémoire.
24 Introduction à ActionScript 3.0
Classes scellées
ActionScript 3.0 introduit le concept de classe scellée. Une telle classe possède uniquement un
jeu fixe de propriétés et de méthodes, définies lors de la compilation. Il est impossible
d’ajouter d’autres propriétés et méthodes. Ainsi, la vérification effectuée au moment de la
compilation est plus stricte et garantit une plus grande robustesse des programmes.
L’utilisation de la mémoire est également optimisée puisque la table de hachage n’est pas
requise pour chaque instance d’objet. Les classes dynamiques sont également disponibles, par
le biais du mot-clé
dynamic
. Bien que scellées par défaut, toutes les classes d’ActionScript 3.0
peuvent être déclarées dynamiques grâce au mot-clé
dynamic
.
Fermetures de méthodes
ActionScript 3.0 permet l’utilisation d’une fermeture de méthode qui se rappelle
automatiquement l’instance de l’objet d’origine. Cette fonction s’avère utile dans le traitement
des événements. Dans ActionScript 2.0, les fermetures de méthode ne gardaient pas la trace de
l’instance d’objet à partir de laquelle il était extrait, ce qui provoquait un comportement
inattendu lors de l’appel de la fermeture de méthode. La classe mx.utils.Delegate était une
solution prisée, qui n’est désormais plus nécessaire.
ECMAScript pour XML (E4X)
ActionScript 3.0 intègre ECMAScript pour XML (E4X), récemment normalisé sous le nom
ECMA-357. E4X offre un jeu d’éléments de langage naturels et courants qui permettent de
manipuler XML. Contrairement aux API classiques d’analyse XML, XML et E4X
fonctionnent à la manière d’un type de données natif du langage. E4X simplifie le
développement d’applications exploitant XML grâce à une réduction drastique du volume de
code requis. Pour plus d’informations sur l’intégration d’E4X dans ActionScript 3.0, voir
Chapitre 11, « Utilisation de XML », à la page 367.
Pour visualiser la spécification E4X d’ECMA, consultez le site www.ecma-international.org.
Expressions régulières
ActionScript 3.0 inclut une prise en charge native des expressions régulières afin d’accélérer la
recherche et la manipulation des chaînes. Dans ActionScript 3.0, cette prise en charge suit la
version 3 de la spécification de langage ECMAScript (ECMA-262).
Nouveautés d’ActionScript 3.0 25
Espaces de noms
Les espaces de noms sont semblables aux spécificateurs d’accès classiques qui assurent le
contrôle de visibilité des déclarations (
public
,
private
,
protected
). Ils fonctionnent
comme des spécificateurs d’accès personnalisés, qui portent le nom de votre choix. Les espaces
de noms sont dotés d’un identifiant de ressource universel (URI, Universal Resource
Identifier) afin d’éviter les collisions. Ils servent également à représenter les espaces de noms
XML en cas d’utilisation d’E4X.
Nouveaux types de primitives
ActionScript 2.0 utilise un seul type numérique, Number, un nombre en virgule flottante à
deux décimales. ActionScript 3.0 comprend les types int et uint. Le type int est un entier signé
32 bits qui permet au code ActionScript de profiter de la rapidité de traitement mathématique
de l’unité centrale. Il s’avère pratique pour les compteurs de boucles et les variables utilisant
des entiers. Le type uint est un type d’entier non signé 32 bits, utile pour les valeurs de
couleurs RVB, les compteurs d’octets, etc.
Fonctions API de Flash Player
L’API Flash Player d’ActionScript 3.0 contient un grand nombre de nouvelles classes qui vous
permettent de contrôler les objets de bas niveau. L’architecture du langage est complètement
nouvelle et plus intuitive. Ces nouvelles classes étant trop nombreuses pour autoriser une
présentation détaillée à ce stade, les sections ci-après mettent en avant quelques changements
significatifs.
Modèle d’événements DOM3
Le modèle d’événements Document Object Model de niveau 3 (DOM3) offre une méthode
standard de génération et de traitement des messages d’événement, qui permet aux objets
composant les applications d’interagir et de communiquer tout en conservant leur état et en
réagissant aux changements. Etabli à partir des spécifications d’événements DOM niveau 3 du
World Wide Web Consortium, ce modèle fournit un mécanisme plus clair et plus efficace que
les systèmes d’événement disponibles dans les versions antérieures d’ActionScript.
Les événements et événements d’erreur se trouvent dans le package flash.events. La structure
des composants Flash utilise le même modèle d’événements que l’API de Flash Player; ainsi le
système d’événements est unifié sur l’ensemble de la plate-forme Flash.
26 Introduction à ActionScript 3.0
API de liste d’affichage
L’API d’accès à la liste d’affichage Flash Player, c’est-à-dire l’arborescence contenant tous les
éléments visuels d’une application Flash, est constituée de classes permettant de manipuler les
primitives visuelles dans Flash.
La nouvelle classe Sprite est un élément de construction léger, semblable à la classe MovieClip
mais plus adaptée à la classe de base des composants d’interface. La nouvelle classe Shape
représente des formes vectorielles brutes. Il est possible d’instancier ces classes naturellement à
l’aide de l’opérateur
new
, mais aussi de les redéfinir dynamiquement comme parent à tout
moment.
Grâce à la gestion de profondeur désormais automatique et intégrée à Flash Player, le rendu
d’affectation de numéros de profondeur n’est plus nécessaire. De nouvelles méthodes
permettent de spécifier et de gérer l’ordre z des objets.
Gestion des données et contenus dynamiques
ActionScript 3.0 comprend des mécanismes de chargement et de gestion des actifs et des
données au sein de l’application Flash qui se caractérisent par leur intuitivité et leur cohérence
dans l’ensemble de l’API. La nouvelle classe Loader propose un unique mécanisme de
chargement des fichiers SWF et des actifs d’image, et permet d’accéder à des informations
détaillées sur le contenu chargé. La classe URLLoader

offre un mécanisme distinct de
chargement du texte et des données binaires dans les applications orientées données. La classe
Socket permet la lecture et l’écriture des données binaires dans les sockets de serveur, quel que
soit le format.
Accès aux données de bas niveau
De nombreuses API permettent d’accéder à des données de bas niveau jusqu’ici indisponibles
dans ActionScript. Pour le téléchargement de données, la classe URLStream, mise en oeuvre
par URLLoader, donne accès aux données sous forme binaire brute pendant le
téléchargement. Avec la classe ByteArray, vous pouvez optimiser la lecture, l’écriture et la
manipulation des données binaires. La nouvelle API Sound assure le contrôle précis du son
par le biais des classes SoundChannel et SoundMixer. De nouvelles API liées à la sécurité
fournissent des informations sur les droits de sécurité d’un fichier SWF ou du contenu chargé,
pour une gestion plus efficace des erreurs de sécurité.
Compatibilité avec les versions précédentes 27
Utilisation du texte
ActionScript 3.0 contient un package flash.text destiné à l’ensemble des API relatives au texte.
La classe TextLineMetrics fournit des dimensions détaillées pour les lignes de texte d’un
champ texte; elle remplace la méthode
TextField.getLineMetrics()
dans ActionScript
2.0. La classe TextField contient plusieurs nouvelles méthodes de bas niveau intéressantes, qui
peuvent fournir des informations spécifiques sur une ligne de texte ou un simple caractère
dans un champ texte. Parmi ces méthodes, on compte notamment les suivantes:
getCharBoundaries()
, qui renvoie un rectangle représentant le cadre de sélection d’un
caractère,
getCharIndexAtPoint()
, qui renvoie l’index d’un caractère à un point donné et
getFirstCharInParagraph()
, qui renvoie l’index du premier caractère d’un paragraphe.
Les méthodes de niveau de ligne incluent
getLineLength()
, qui renvoie le nombre de
caractères d’une ligne de texte donnée, et
getLineText()
, qui renvoie le texte de la ligne
spécifiée. La nouvelle classe Font permet de gérer les polices incorporées des fichiers SWF.
Compatibilité avec les versions
précédentes
Comme toujours, Flash Player garantit une compatibilité totale avec les versions précédentes
et les contenus publiés antérieurement. Tous les contenus lisibles dans les anciennes versions
de Flash Player s’exécutent dans Flash Player 9. L’introduction d’ActionScript 3.0 dans cette
dernière version présente cependant quelques problèmes d’interopérabilité entre les contenus
anciens et nouveaux lus dans Flash Player 9. Les problèmes de compatibilité sont les suivants:

Un même fichier SWF ne peut combiner du code ActionScript 1.0 ou 2.0 et du code
ActionScript 3.0.

Le code ActionScript 3.0 peut charger un fichier SWF écrit en ActionScript 1.0 ou 2.0,
mais ne peut accéder aux variables et fonctions de ce fichier.

Les fichiers SWF écrits en ActionScript 1.0 ou 2.0 ne peuvent charger des fichiers SWF
écrits en ActionScript 3.0. Cela a pour conséquence que les fichiers SWF créés dans Flash
8 ou Flex Builder version 1.5 ou antérieure ne peuvent charger des fichiers SWF
ActionScript 3.0.
Il existe une seule exception à cette règle: un fichier SWF ActionScript 2.0 peut se
remplacer par un fichier SWF ActionScript 3.0 à condition que le fichier ActionScript 2.0
n’est effectué aucun chargement à quelque niveau que ce soit. Pour ce faire, le fichier SWF
ActionScript 2.0 doit appeler
loadMovieNum()
et passer la valeur 0 au paramètre
level
.
28 Introduction à ActionScript 3.0

En général, les fichiers SWF écrits en ActionScript 1.0 ou 2.0 doivent faire l’objet d’une
migration s’ils sont destinés à fonctionner avec des fichiers SWF écrits en ActionScript
3.0. Imaginez par exemple que vous ayez créé un lecteur de média avec ActionScript 2.0.
Ce lecteur peut charger de nombreux contenus également créés à l’aide d’ActionScript 2.0.
Mais vous ne pouvez pas créer un contenu avec ActionScript 3.0 et le charger dans ce
lecteur. Vous devez migrer le lecteur vers ActionScript 3.0.
Néanmoins, si vous avez créé un lecteur de média avec ActionScript 3.0, ce lecteur peut
effectuer de simples chargements de votre contenu ActionScript 2.0.
Le tableau ci-après récapitule les limitations des versions précédentes de Flash Player relatives
au chargement de nouveaux contenus et à l’exécution de code, ainsi que les restrictions liées à
la programmation croisée entre les fichiers SWF écrits avec différentes versions d’ActionScript.
Fonctionnalité prise
en charge
Environnement d’exécution
Flash Player 7
Flash Player 8
Flash Player 9
Peut charger les fichiers
SWF pour
version 7 et
antérieure
version 8 et
antérieure
version 9 et antérieure
Machine virtuelle incluse
AVM1
AVM1
AVM1 et AVM2
Exécute les fichiers SWF
écrits en ActionScript
1.0 et 2.0
1.0 et 2.0
1.0, 2.0 et 3.0
Fonctionnalité prise
en charge*
* Contenu lisible dans Flash Player version 9 ou ultérieure. Le contenu lisible dans Flash
Player version 8 ou antérieure peut être chargé, affiché, exécuté et programmé avec
ActionScript 1.0 et 2.0 uniquement.
Contenu créé dans
ActionScript 1.0 et 2.0
ActionScript 3.0
Peut charger du contenu
et exécuter le code de
contenus créé dans
ActionScript 1.0 et 2.0 uniquement
ActionScript 1.0 et 2.0 et
ActionScript 3.0
Peut programmer le
contenu créé dans
ActionScript 1.0 et 2.0 uniquement†
† ActionScript 3.0 via LocalConnection
ActionScript 3.0‡
‡ ActionScript 1.0 et 2.0 via LocalConnection
29
2
CHAPITRE 2
Prise en main d’ActionScript
Ce chapitre vise à vous familiariser avec la programmation d’ActionScript et à vous offrir les
informations nécessaires à la compréhension des concepts et des exemples présentés dans le
reste de ce manuel. Nous commencerons par évoquer les concepts de base de la
programmation, tels qu’ils s’appliquent à ActionScript. Nous verrons aussi les principes
fondamentaux qui régissent l’organisation et la construction d’une application ActionScript.
Contenu
Concepts de programmation de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .29
Utilisation des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .33
Eléments de programme courants. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .44
Exemple: Elément de portfolio d’animation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .46
Création d’applications avec ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .50
Création de vos propres classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .56
Exemple: Création d’une application de base. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .60
Exécution des exemples suivants. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
Concepts de programmation de base
ActionScript étant un langage de programmation, il vous sera plus facile de l’apprendre si vous
maîtrisez déjà quelques concepts généraux de programmation.
Quel est le rôle d’un programme informatique
Pour commencer, il est intéressant d’avoir une idée conceptuelle de la nature et du rôle d’un
programme informatique. Un tel programme présente deux aspects principaux:

Il s’agit d’une série d’instructions ou d’étapes que l’ordinateur doit effectuer.

Chaque étape implique à terme la manipulation d’informations ou de données.
30 Prise en main d’ActionScript
Dans un sens général, un programme informatique n’est rien d’autre qu’une liste d’actions pas
à pas que vous ordonnez à l’ordinateur, qui les exécute une à une. Chacune de ces actions
représente une instruction. Comme vous le verrez tout au long de ce manuel, dans
ActionScript, chaque instruction se termine par un point-virgule.
Par nature, le seul rôle d’une instruction d’un programme consiste à manipuler quelques
données stockées dans la mémoire de l’ordinateur. Voici un exemple simple: vous pouvez
demander à l’ordinateur d’ajouter deux nombres et de stoker le résultat dans sa mémoire.
Dans un cas de figure plus compliqué, imaginez un rectangle dessiné sur l’écran; vous écrivez
un programme pour le déplacer à un autre endroit de l’écran. L’ordinateur garde une trace de
certaines informations relatives au rectangle: les coordonnées x, y de sa position, sa largeur et
sa longueur, sa couleur, etc. Chacune de ces informations est stockée dans la mémoire de
l’ordinateur. Un programme qui déplacerait le rectangle vers un autre emplacement
comprendrait des procédures du type « remplacer la coordonnée x par 200, remplacer la
coordonnée y par 150 », c’est-à-dire qui spécifieraient de nouvelles valeurs pour les
coordonnées x et y. Bien entendu, l’ordinateur agit sur ces données pour effectivement
modifier l’image à l’écran en fonction de ces chiffres. Cependant, pour ce qui nous intéresse, il
est suffisant de savoir que le déplacement d’un rectangle sur l’écran n’implique réellement que
la modification de quelques bits de données dans la mémoire de l’ordinateur.
Variables et constantes
La programmation reposant sur la modification d’informations dans la mémoire de
l’ordinateur, il est nécessaire d’établir une représentation de chaque information au sein du
programme. Une variable est un nom qui représente une valeur dans la mémoire de
l’ordinateur. Lorsque l’on écrit des instructions visant à manipuler des valeurs, on écrit le nom
de la variable plutôt que la valeur. Chaque fois que l’ordinateur rencontre le nom de la variable
dans le programme, il cherche dans sa mémoire la valeur à utiliser. Si vous disposez par
exemple de deux variables nommées
value1
et
value2
, chacune contenant un nombre, vous
pouvez additionner ces deux nombres à l’aide de l’instruction suivante:
value1 + value2
Lorsqu’il exécute véritablement la procédure, l’ordinateur recherche les valeurs correspondant
à chaque variable et les ajoute.
Dans ActionScript 3.0, une variable se compose de trois éléments:

La nom de la variable

Le type de données qui peut être stocké dans la variable

La valeur réelle stockée dans la mémoire de l’ordinateur
Concepts de programmation de base 31
Nous venons de voir comment l’ordinateur utilise le nom comme une balise d’emplacement
destinée à la valeur. Le type de données a également une importance. Lorsque vous créez une
variable ActionScript, vous spécifiez le type de données qu’elle contiendra. A partir de là, les
instructions de votre programme peuvent uniquement stocker ce type de données dans la
variable considérée et la valeur peut être manipulée selon les caractéristiques associées à ce type
de données. Dans ActionScript, la création d’une variable (on parle également de déclaration
de variable) s’effectue à l’aide de l’instruction
var
:
var value1:Number;
Dans ce cas, nous indiquons à l’ordinateur qu’il doit créer une variable
value1
, qui
contiendra uniquement des données Number, un type de données spécialement défini dans
ActionScript. Il est possible de stocker immédiatement une valeur dans la variable:
var value2:Number = 17;
Adobe Flash CS3 Professional offre une autre méthode de déclaration des variables. Lorsque
vous placez un symbole de clip, un symbole de bouton ou un champ texte sur la scène, vous
pouvez lui attribuer un nom d’occurrence dans l’inspecteur Propriétés. Derrière les séquences,
Flash crée une variable du même nom que le nom d’occurrence, que vous pouvez utiliser dans
votre code ActionScript pour faire référence à l’élément de la scène. Par exemple, si un
symbole de clip se trouve sur la scène et que vous lui attribuez le nom d’occurrence
rocketShip
, chaque fois que vous utilisez la variable
rocketShip
dans votre code
ActionScript, c’est en fait ce clip que vous manipulez.
Types de données
Dans ActionScript, de nombreux types de données sont à votre disposition pour la création de
variables. Certains d’entre eux peuvent être considérés comme « simples » ou
« fondamentaux »:

String : une valeur textuelle, telle qu’un nom ou le texte d’un chapitre de livre

Numeric: ActionScript 3.0 inclut trois types de données spécifiques aux valeurs
numériques:

Number: toute valeur numérique, y compris les valeurs avec ou sans fraction

int: un nombre entier (sans fraction)

uint: un nombre entier « non signé », c’est-à-dire un nombre qui ne peut être négatif

Boolean: une valeur vrai/faux, qui indique par exemple si une instruction Switch est
active ou si deux valeurs sont égales
32 Prise en main d’ActionScript
Les types de données simples représentent une seule information: par exemple, un seul
nombre ou une seule séquence de texte. Cependant, la majorité des types de données définis
dans ActionScript peuvent être considérés comme complexes puisqu’ils représentent un
ensemble de valeurs regroupées. Par exemple, une variable du type Date représente une valeur
unique, un point temporel. Néanmoins, la valeur de date est représentée par différentes
valeurs: le jour, le mois, l’année, les heures, les minutes, les secondes, etc., et toutes
correspondent à des nombres distincts. Ainsi, bien que nous percevions une date comme une
valeur unique (et qu’il soit possible de la traiter comme telle en créant une variable Date),
l’ordinateur, en interne, la considère comme un groupe de valeurs qui, ensemble, définissent
une seule date.
La plupart des types de données intégrés et ceux créés par les programmeurs, sont des types de
date complexes. Voici quelques exemples de types de données complexes que vous pourriez
rencontrer:

MovieClip: un symbole de clip

TextField: un champ texte dynamique ou saisi

SimpleButton: un symbole de bouton

Date: une information relative à un point temporel (date et heure)
Deux termes sont souvent utilisés comme synonymes de type de données: classe et objet.
Une classe est tout simplement la définition d’un type de données. Il s’agit d’un modèle
applicable à tous les types d’objets du type de données, comme si l’on déclarait: « toutes les
variables du type de données Exemple présentent les caractéristiques suivantes: A, B et C ». A
l’inverse, un objet n’est qu’une instance de classe: une variable dont le type de données est
MovieClip peut être décrite comme un objet MovieClip. Les exemples ci-après décrivent la
même chose:

Le type de données de la variable
myVariable
est Number.

La variable
myVariable
est une instance de Number.

La variable
myVariable
est un objet Number.

La variable
myVariable
est une instance de la classe Number.
Utilisation des objets 33
Utilisation des objets
ActionScript constitue ce que l’on appelle un langage de programmation orienté objet.
Ce terme désigne une simple approche de la programmation, rien d’autre qu’une manière
d’organiser le code d’un programme à l’aide d’objets.
Nous avons défini plus haut un programme informatique comme une série de procédures ou
d’instructions que l’ordinateur effectue. Nous pouvons alors considérer qu’un programme
informatique n’est qu’une longue liste d’instructions. Dans le cas de la programmation
orientée objet, les instructions du programme se divisent néanmoins en différents objets: le
code étant rassemblé en groupes de fonctionnalités, un même conteneur réunit des types de
fonctionnalités et des informations connexes.
En fait, si vous avez travaillé avec des symboles dans Flash, vous savez déjà manipuler les
objets. Imaginons que vous ayez défini un symbole de clip, par exemple le dessin d’un
rectangle, et que vous en ayez placé une copie sur la scène. Ce symbole de clip constitue aussi
un objet (au sens littéral) dans ActionScript; il s’agit d’une instance de la classe MovieClip.
Vous avez la possibilité de modifier plusieurs caractéristiques du clip. S’il est sélectionné, vous
pouvez par exemple modifier certaines valeurs de l’inspecteur Propriétés, telles que la
coordonnée x ou la largeur, ou encore différents réglages de couleur comme la transparence
alpha ou l’application d’un filtre d’ombre portée. D’autres outils Flash vous permettent
d’effectuer davantage de modifications, par exemple l’outil Transformer librement pour faire
pivoter le rectangle. Toutes ces actions de transformation du symbole de clip disponibles dans
l’environnement de programmation de Flash sont également disponibles dans ActionScript.
Pour les utiliser, vous devez modifier les données réunies dans un ensemble appelé objet
MovieClip.
Dans la programmation orientée objet que propose ActionScript, chaque classe comprend
trois types de caractéristiques:

Propriétés

Méthodes

Evénements
Pris ensemble, ces éléments servent à gérer les données que le programme utilise, et à
déterminer les actions à exécuter ainsi que l’ordre d’exécution.
34 Prise en main d’ActionScript
Propriétés
Une propriété représente l’une des données réunies dans un objet. Un objet song, par
exemple, peut présenter des propriétés nommées
artist
et
title
. La classe MovieClip
possède des propriétés telles que
rotation
,
x
,
width
et
alpha
. Les propriétés s’utilisent
comme des variables individuelles; on pourrait même envisager les propriétés comme les
variables « enfant » d’un objet.
Voici des exemples de code ActionScript utilisant des propriétés. Cette ligne de code déplace
le MovieClip nommé
square
vers la coordonnée x 100 pixels:
square.x = 100;
Le code ci-après utilise la propriété rotation pour faire pivoter le MovieClip
square
de
manière à lui donner la même orientation que le MovieClip
triangle
:
square.rotation = triangle.rotation;
Ce code altère l’échelle horizontale du MovieClip
square
pour qu’il soit une fois et demie
plus large que précédemment:
square.scaleX = 1.5;
Vous remarquerez la structure commune: vous utilisez une variable (
square
,
triangle
) pour
nommer l’objet, suivie d’un point (
.
), puis le nom de la propriété (
x
,
rotation
,
scaleX
).
Le point, ou opérateur point, sert à indiquer que vous accédez à l’un des éléments enfant d’un
objet. La structure dans son ensemble, « nom de variable-point-nom de propriété » est utilisée
telle une variable, comme le nom d’une valeur unique dans la mémoire de l’ordinateur.
Méthodes
Une méthode est une action qui peut être effectuée par un objet. Par exemple, si vous avez
élaboré dans Flash un symbole de clip dont le scénario contient plusieurs cadres et
animations, ce clip peut être lu ou arrêté, ou recevoir l’instruction de placer la tête de
lecture sur un cadre donné.
Le code ci-dessous indique au MovieClip nommé
shortFilm
de commencer la lecture:
shortFilm.play();
Cette ligne de code arrête la lecture du MovieClip
shortFilm
(la tête de lecture s’arrête à
l’endroit où elle se trouve, comme lorsque vous suspendez une vidéo):
shortFilm.stop();
Ce code-ci indique au MovieClip
shortFilm
de placer la tête de lecture sur Frame 1 et
d’arrêter la lecture (comme si vous rembobiniez une vidéo):
shortFilm.gotoAndStop(1);
Utilisation des objets 35
Comme vous pouvez le constater, l’accès aux méthodes, comme pour les propriétés, s’effectue
en écrivant le nom de l’objet (une variable), suivi d’un point puis du nom de la méthode et de
parenthèses. Les parenthèses servent à indiquer que vous appelez la méthode, c’est-à-dire que
vous demandez à l’objet d’effectuer une action. Certaines valeurs (ou variables) sont placées
dans ces parenthèses de manière à transmettre des informations supplémentaires nécessaires à
l’exécution de l’action. On appelle ces valeurs des paramètres de méthode. Par exemple, la
méthode
gotoAndStop()
doit savoir quel cadre atteindre; un paramètre est donc requis dans
les parenthèses. D’autres méthodes, telles
play()
et
stop()
, ont une signification univoque et
ne requièrent donc aucune information complémentaire. Elles sont néanmoins suivies de
parenthèses.
Contrairement aux propriétés (et aux variables), les méthodes ne servent pas d’espaces
réservés. Certaines méthodes peuvent cependant effectuer des calculs et renvoyer des résultats
pouvant servir de variables. Par exemple, la méthode
toString()
de la classe Number
convertit une valeur numérique en une représentation textuelle:
var numericData:Number = 9;
var textData:String = numericData.toString();
Par exemple, vous pouvez utiliser la méthode
toString()
si vous souhaitez afficher la valeur
d’une variable Number dans un champ texte à l’écran. La propriété
text
de la classe TextField
(qui représente le contenu textuel réel affiché à l’écran) se définit comme une chaîne (String),
de manière qu’elle ne puisse contenir que des valeurs textuelles. Cette ligne de code convertit
la valeur numérique de la variable
numericData
en texte, puis la fait apparaître à l’écran dans
l’objet TextField nommé
calculatorDisplay
:
calculatorDisplay.text = numericData.toString();
Evénements
Tel que nous l’avons décrit, un programme informatique est une série d’instructions que
l’ordinateur effectue pas à pas. Certains programmes très simples ne sont rien de plus:
l’ordinateur effectue quelques procédures, puis le programme se termine. Toutefois, les
programmes ActionScript sont conçus pour poursuivre leur exécution, dans l’attente d’une
saisie utilisateur, par exemple. Les événements sont des mécanismes qui déterminent quelles
instructions l’ordinateur doit suivre et quand.
36 Prise en main d’ActionScript
Par essence, des événements sont des faits qui surviennent et auxquels ActionScript peut
répondre parce qu’il les connaît. De nombreux d’événements sont liés à l’interaction de
l’utilisateur, par exemple un clic sur un bouton ou une pression sur une touche du clavier.
Il existe néanmoins d’autres types d’événement. Par exemple, si vous utilisez ActionScript
pour charger une image externe, un événement est capable de vous prévenir lorsque le
chargement de l’image est terminé. Pendant l’exécution d’un programme ActionScript, Adobe
Flash Player attend que des événements se produisent et lorsque c’est le cas, il exécute le code
ActionScript que vous avez spécifié en réponse.
Gestion des événements de base
La gestion des événements est la technique qui permet de spécifier les actions à exécuter en
réponse à des événements particuliers. Lors de l’écriture de code ActionScript en vue de la
gestion des événements, trois éléments importants sont à identifier:

La source de l’événement: quel objet sera concerné par l’événement? Par exemple, sur
quel bouton aura lieu le clic ou quel objet Loader charge-t-il l’image? La source de
l’événement est également appelée cible de l’événement car elle représente l’objet où
l’événement est ciblé par Flash Player (là où l’événement a lieu).

L’événement: que doit-il se passer, à quel événement voulez-vous répondre? Ce point est
très important, car de nombreux objets déclenchent plusieurs événements.

La réponse: quelles actions doivent faire suite à l’occurrence de l’événement?
Tout code ActionScript de gestion des événements doit contenir ces trois éléments et respecte
la structure de base suivante (les éléments en gras sont des espaces réservés à remplir selon le
cas envisagé):
function eventResponse(eventObject:EventType):void
{
// Les actions exécutées en réponse à l’événement apparaissent ici.
}
eventSource.addEventListener(EventType.EVENT_NAME, eventResponse);
Ce code a deux rôles. Tout d’abord, il définit une fonction, qui est une manière de spécifier les
actions à exécuter en réponse à l’événement. Ensuite, il appelle la méthode
addEventListener()
de l’objet source, « inscrivant » ainsi la fonction auprès de l’événement
spécifié de manière que lorsque l’événement survient, les actions de la fonction ont lieu.
Nous allons étudier chacun de ces rôles en détail.
Utilisation des objets 37
Une fonction sert à regrouper des actions sous un nom unique, un raccourci qui vous permet
de les exécuter. La fonction est identique à la méthode, à cette exception près qu’elle n’est pas
nécessairement associée à une classe particulière (on pourrait d’ailleurs définir la méthode
ainsi: une fonction associée à une classe donnée). Lorsque vous créez une fonction de gestion
des événements, vous devez choisir le nom de la fonction (dans ce cas
eventResponse
) mais
aussi spécifier un paramètre (
eventObject
dans cet exemple). La spécification d’un paramètre
de fonction ressemble à la déclaration de variable; vous devez dans ce cas aussi indiquer le
type de données du paramètre. Il existe une classe ActionScript définie pour chaque
événement, et le type de données que vous spécifiez pour le paramètre de fonction est toujours
la classe associée à l’événement particulier auquel vous souhaitez répondre. Enfin, entre les
accolades ouvrantes et fermantes (
{
...
}
), vous devez écrire les instructions que l’ordinateur
doit suivre lorsque l’événement survient.
Une fois que vous avez écrit la fonction de gestion d’événement, vous devez indiquer à l’objet
source (l’objet qui cause l’événement, par exemple le bouton) que la fonction à appeler lorsque
l’événement survient est votre fonction. Pour ce faire, appelez la méthode
addEventListener()
de cet objet (tous les objets liés à des événements ont une méthode
addEventListener()
). La méthode
addEventListener()
réclame deux paramètres:

Tout d’abord, le nom de l’événement auquel vous voulez répondre. Comme nous l’avons
déjà vu, chaque événement est affilié à une classe spécifique pour laquelle est définie une
valeur spéciale à chaque événement (en quelque sorte le nom unique de l’événement).
Cette valeur sert de premier paramètre.

Vient ensuite le nom de votre fonction de réponse à l’événement. Sachez qu’un nom de
fonction est écrit sans parenthèses lors du transfert en tant que paramètre.
Description du processus de gestion des événements
Vous trouverez ci-dessous une description détaillée du processus ayant lieu lorsque vous créez
un écouteur d’événements. Dans ce cas, il s’agit d’un exemple illustrant la création d’une
fonction d’écouteur appelée lorsque vous cliquez sur un objet
myButton
.
Le code écrit par le programmeur est le suivant:
function eventResponse(event:MouseEvent):void
{
// Actions performed in response to the event go here.
}
myButton.addEventListener(MouseEvent.CLICK, eventResponse);
38 Prise en main d’ActionScript
Voici comment ce code devrait fonctionner lorsqu’il est exécuté dans Flash Player:
1.
Lors du chargement du fichier SWF, Flash Player remarque qu’il existe une fonction
eventResponse()
.
2.
Flash Player exécute ensuite le code (notamment les lignes de code qui ne sont pas dans une
fonction). Dans ce cas, il n’y a qu’une ligne de code: l’appel à la méthode
addEventListener()
sur l’objet source (appelé
myButton
) et le transfert de la fonction
eventResponse
en tant que paramètre.
Utilisation des objets 39
a.
En interne,
myButton
a une liste de fonctions qui écoutent chaque événement.
Par conséquent, lorsque sa méthode
addEventListener()
est appelée,
myButton

stocke la fonction
eventResponse()
dans sa liste d’écouteurs d’événements.
3.
A un certain moment, l’utilisateur clique sur l’objet
myButton
et déclenche ainsi son
événement
click
(identifié comme
MouseEvent.CLICK
dans le code).
A ce stade, les opérations suivantes ont lieu:
40 Prise en main d’ActionScript
a.
Flash Player crée un objet, une instance de la classe associée à l’événement en question
(MouseEvent dans cet exemple). Pour de nombreux événements, il s’agira d’une
instance de la classe Event; pour des événements de souris, une instance MouseEvent
et pour d’autres événements, une instance de la classe associée à cet événement.
Cet objet créé est appelé l’objet événement. Il contient des informations spécifiques sur
l’événement qui a eu lieu: le type d’événement, l’endroit où il s’est produit et d’autres
informations propres à l’événement, le cas échéant.
b.
Flash Player consulte ensuite la liste des écouteurs d’événements stockés par
myButton
.
Il parcourt ces fonctions l’une après l’autre en les appelant et en transmettant l’objet
événement à la fonction en tant que paramètre. Etant donné que la fonction
eventResponse()
est l’un des écouteurs de
myButton
, Flash Player appelle la fonction
eventResponse()
dans le cadre de ce processus.
Utilisation des objets 41
c.
Lorsque la fonction
eventResponse()
est appelée, le code qu’elle contient est exécuté
et vos actions spécifiées sont effectuées.
Exemples de gestion d’événements
Voici quelques exemples plus concrets d’événements qui vous donneront une idée des