Programmation d’ADOBE

turnmarySoftware and s/w Development

Jul 5, 2012 (5 years and 1 month ago)

1,932 views

Programmation

d’ADOBE
®
ACTIONSCRIPT
®
3.0
Copyright
© 2008 Adobe Systems Incorporated. Tous droits réservés.
Programmation avec Adobe
®
ActionScript
®
3.0 pour Adobe
®
Flash
®
Si ce guide accompagne un logiciel qui inclut un contrat de licence utilisateur final, ce guide et le logiciel qu'il décrit sont fournis sous licence et peuvent
uniquement être utilisés ou copiés dans le respect des conditions de cette licence. Sous réserve des clauses de cette licence, aucune partie de ce guide ne peut être
reproduite, enregistrée dans un système de recherche automatique ou transmise sous une forme ou par un moyen quelconque, électronique, mécanique ou autre,
sans l'autorisation écrite préalable d'Adobe Systems Incorporated. Veuillez noter que le contenu de ce manuel est protégé par les lois sur les droits d'auteur, même
s'il n'est pas distribué avec un logiciel comprenant un contrat de licence utilisateur final.
Le contenu de ce guide est fourni à titre purement informatif ; il est susceptible d'être modifié sans préavis et ne doit pas être considéré comme un engagement
de la part d'Adobe Systems Incorporated. Adobe Systems Incorporated décline toute responsabilité quant aux éventuelles erreurs ou inexactitudes pouvant
apparaître dans le contenu informatif de ce guide.
Il est important de se rappeler que certaines illustrations ou images que vous souhaitez inclure dans votre projet peuvent être protégées par les lois sur les droits
d'auteur. L'inclusion sans autorisation de tels éléments dans vos propres travaux peut constituer une violation des droits du détenteur de ce copyright. Veillez à
obtenir toutes les autorisations nécessaires auprès de ce dernier.
Toute référence à des noms de sociétés dans les modèles types n'est utilisée qu'à titre d'exemple et ne fait référence à aucune société réelle.
Adobe, the Adobe logo, Adobe AIR, ActionScript, Flash, Flash Lite, Flex, Flex Builder, MXML, and Pixel Bender are either registered trademarks or trademarks
of Adobe Systems Incorporated in the United States and/or other countries.
ActiveX and Windows are either registered trademarks or trademarks of Microsoft Corporation in the United States and other countries. Macintosh is a
trademark of Apple Inc., registered in the United States and other countries. Java is a trademark or registered trademark of Sun Microsystems, Inc. in the United
States and other countries. All other trademarks are the property of their respective owners.
This product includes software developed by the Apache Software Foundation (
h
t
t
p://w
w
w
.a
p
ac
h
e
.o
r
g/).
MPEG Layer-3 audio compression technology licensed by Fraunhofer IIS and Thomson Multimedia (
h
t
t
p://w
w
w
.m
p3licen
sin
g
.co
m)
Speech compression and decompression technology licensed from Nellymoser, Inc. (
w
w
w
.n
e
l
l
y
m
os
er
.co
m).
Video compression and decompression is powered by On2 TrueMotion video technology. © 1992-2005 On2 Technologies, Inc. All Rights Reserved.
h
t
t
p://w
w
w
.o
n2.co
m.
This product includes software developed by the OpenSymphony Group (
h
t
t
p://w
w
w
.o
p
en
sy
m
p
h
o
n
y
.co
m/).
This product contains either BSAFE and/or TIPEM software by RSA Security, Inc.
Sorenson Spark

video compression and decompression technology licensed from Sorenson Media, Inc.
Adobe Systems Incorporated, 345 Park Avenue, San Jose, California 95110, USA
Notice to U.S. government end users. The software and documentation are “Commercial Items,” as that term is defined at 48 C.F.R. §2.101, consisting of
“Commercial Computer Software” and “Commercial Computer Software Documentation,” as such terms are used in 48 C.F.R. §12.212 or 48 C.F.R. §227.7202,
as applicable. Consistent with 48 C.F.R. §12.212 or 48 C.F.R. §§227.7202-1 through 227.7202-4, as applicable, the Commercial Computer Software and
Commercial Computer Software Documentation are being licensed to U.S. Government end users (a) only as Commercial items and (b) with only those rights
as are granted to all other end users pursuant to the terms and conditions herein. Unpublished-rights reserved under the copyright laws of the United States.
Adobe Systems Incorporated, 345 Park Avenue, San Jose, CA 95110-2704, USA. For U.S. Government End Users, Adobe agrees to comply with all applicable
equal opportunity laws including, if appropriate, the provisions of Executive Order 11246, as amended, Section 402 of the Vietnam Era Veterans Readjustment
Assistance Act of 1974 (38 USC 4212), and Section 503 of the Rehabilitation Act of 1973, as amended, and the regulations at 41 CFR Parts 60-1 through 60-60,
60-250 ,and 60-741. The affirmative action clause and regulations contained in the preceding sentence shall be incorporated by reference.
iii
Sommaire
Chapitre 1 : A propos de ce manuel
Utilisation de ce manuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Accès à la documentation ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Ressources ActionScript destinées à la formation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Chapitre 2 : Introduction à ActionScript 3.0
A propos d'ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Avantages d'ActionScript 3.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Nouveautés d'ActionScript 3.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Compatibilité avec les versions précédentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Chapitre 3 : Prise en main d'ActionScript
Concepts de programmation de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Utilisation des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Eléments de programme courants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Exemple : élément de portfolio d'animation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Création d'applications avec ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Création de vos propres classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Exemple : création d'une application de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Exécution des exemples suivants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Chapitre 4 : Syntaxe et langage ActionScript
Présentation du langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Objets et classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Packages et espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Types de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
Instructions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Boucle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Chapitre 5 : Programmation orientée objets en ActionScript
Principes de base de la programmation orientée objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
Rubriques avancées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
Exemple : GeometricShapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
Chapitre 6 : Utilisation des dates et des heures
Principes de base des dates et des heures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Gestion des dates calendaires et des heures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
iv
PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH
Sommaire
Contrôle des intervalles temporels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
Exemple : horloge analogique simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
Chapitre 7 : Utilisation des chaînes
Principes de base des chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
Création de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
Propriété length . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
Utilisation de caractères dans des chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Comparaison de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Récupération des représentations de chaîne d'autres objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
Concaténation de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
Recherche de sous-chaînes et de modèles dans des chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
Conversion de la casse dans des chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
Exemple : ASCII art . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
Chapitre 8 : Utilisation de tableaux
Principes de base des tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
Tableaux indexés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
Tableaux associatifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
Tableaux multidimensionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
Clonage de tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
Rubriques avancées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
Exemple : PlayList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
Chapitre 9 : Gestion des erreurs
Principes de base de la gestion des erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
Types d'erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
Gestion des erreurs dans ActionScript 3.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
Utilisation des versions de débogage de Flash Player et AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
Gestion des erreurs synchrones dans une application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
Création de classes d'erreur personnalisées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
Réponse à des événements et au statut d'erreur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
Comparaison des classes Error . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
Exemple : application CustomErrors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
Chapitre 10 : Utilisation d'expressions régulières
Principes de base des expressions régulières . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
Syntaxe d'expression régulière . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
Méthodes d'utilisation d'expressions régulières avec des chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
Exemple : un analyseur Wiki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
Chapitre 11 : Utilisation de XML
Principes de base de XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
Approche E4X concernant le traitement XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
Objets XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
Objets XMLList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
Initialisation de variables XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
Assemblage et transformation d'objets XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
v
PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH
Sommaire
Parcours de structures XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
Utilisation des espaces de noms XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
Conversion de type XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
Lecture de documents XML externes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
Exemple : chargement de données RSS depuis Internet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
Chapitre 12 : Gestion des événements
Principes de base de la gestion des événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
Variation de la gestion d'événements dans ActionScript 3.0 par rapport aux versions antérieures . . . . . . . . . . . . . . . . . . . . . . 257
Flux d'événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
Objets événement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
Les écouteurs d'événement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264
Exemple : Alarm Clock . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
Chapitre 13 : Programmation de l'affichage
Concepts fondamentaux de la programmation de l'affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
Classes d'affichage de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
Avantages de l'utilisation de la liste d'affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
Utilisation des objets d'affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
Manipulation des objets d'affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
Animation des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317
Chargement dynamique du contenu d'affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
Exemple : SpriteArranger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
Chapitre 14 : Utilisation de l'API de dessin
Principes de base de l'utilisation de l'API de dessin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
Présentation de la classe Graphics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
Dessin de lignes et de courbes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
Dessin de formes à l'aide des méthodes intégrées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332
Création de lignes et de remplissages en dégradé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
Utilisation de la classe Math avec les méthodes de dessin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
Animation avec l'API de dessin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
Exemple : générateur algorithmique d'effets visuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
Utilisation avancée de l'API de dessin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
Tracés de dessin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
Définition des règles d'enroulement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
Utilisation des classes de données graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
A propos de l'utilisation de drawTriangles() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
Chapitre 15 : Utilisation de la géométrie
Principes de base de la géométrie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
Utilisation des objets Point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
Utilisation des objets Rectangle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354
Utilisation des objets Matrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
Exemple : application d'une transformation de matrice à un objet d'affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
vi
PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH
Sommaire
Chapitre 16 : Filtrage des objets d'affichage
Principes de base du filtrage des objets d'affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
Création et application de filtres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
Filtres d'affichage disponibles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
Exemple : Filter Workbench . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
Chapitre 17 : Utilisation des shaders de Pixel Bender
Principes de base des shaders de Pixel Bender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395
Chargement ou intégration d'un shader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397
Accès aux métadonnées du shader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
Spécification des valeurs des entrées et des paramètres d'un shader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
Utilisation d'un shader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
Chapitre 18 : Utilisation des clips
Principes de base des clips . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
Utilisation des objets MovieClip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418
Contrôle de la lecture d'un clip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419
Création d'objets MovieClip à l'aide d'ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
Chargement d'un fichier SWF externe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
Exemple : RuntimeAssetsExplorer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425
Chapitre 19 : Utilisation des interpolations de mouvement
Principes de base des interpolations de mouvement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
Copie de scripts d'interpolation de mouvement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430
Incorporation de scripts d'interpolation de mouvement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431
Description de l'animation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
Ajout de filtres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434
Association d'une interpolation de mouvement à ses objets d'affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436
Chapitre 20 : Utilisation de la cinématique inverse
Principes de base de la cinématique inverse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437
Aperçu de l'animation de squelettes IK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
Obtention d'informations sur un squelette IK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440
Instanciation de l'objet IKMover et restriction du mouvement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440
Mouvement d'un squelette IK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441
Utilisation d'événements IK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441
Chapitre 21 : Utilisation de texte
Principes de base de l'utilisation du texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
Utilisation de la classe TextField . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
Utilisation de Flash Text Engine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467
Chapitre 22 : Utilisation des images bitmap
Principes de base de l'utilisation des images bitmap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494
Classes Bitmap et BitmapData . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 497
Manipulation des pixels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
Copie de données bitmap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500
Création de textures avec les fonctions de bruit aléatoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501
vii
PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH
Sommaire
Défilement du contenu d'images bitmap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503
Utilisation du mipmapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504
Exemple : lune en rotation animée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505
Chapitre 23 : Travail en trois dimensions (3D)
Principes de base de la 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516
Description des fonctions 3D de Flash Player et du moteur d'exécution AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517
Création et déplacement d'objets 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519
Projection d'objets 3D sur un affichage 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521
Exemple : projection de perspective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523
Transformations 3D complexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 525
Création d'effets 3D à l'aide de triangles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528
Chapitre 24 : Utilisation de la vidéo
Principes de base de la vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 536
Présentation des formats vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538
Présentation de la classe Video . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541
Chargement de fichiers vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541
Contrôle de la lecture de la vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542
Lecture de vidéos en mode plein écran . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544
Lecture de fichiers vidéo en flux continu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 548
Présentation des points de repère . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 548
Ecriture de méthodes de rappel pour les métadonnées et les points de repère . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 549
Utilisation des points de repère et des métadonnées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 554
Capture d'un signal vidéo provenant de la caméra de l'utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563
Envoi de vidéo à un serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 569
Rubriques avancées pour les fichiers FLV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 570
Exemple : Video Jukebox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 571
Chapitre 25 : Utilisation du son
Principes de base de l'utilisation du son . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 577
Présentation de l'architecture audio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 579
Chargement de fichiers audio externes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 580
Utilisation des sons intégrés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 582
Utilisation de fichiers audio de lecture en continu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583
Utilisation de données audio générées de façon dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 584
Lecture de sons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586
Sécurité lors du chargement et de la lecture des sons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590
Contrôle du volume du son et de la balance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 591
Utilisation des métadonnées audio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592
Accès aux données audio brutes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593
Capture de l'entrée de son . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597
Exemple : Podcast Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 600
Chapitre 26 : Capture des données saisies par l'utilisateur
Principes de base de la saisie utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608
Capture de la saisie au clavier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609
viii
PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH
Sommaire
Capture des entrées de souris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611
Exemple : WordSearch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 616
Chapitre 27 : Mise en réseau et techniques de communication
Principes de base de la mise en réseau et de la communication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620
Utilisation de données externes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623
Connexion à d'autres occurrences de Flash Player et d'AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 628
Connexions socket . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 633
Stockage des données locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 637
Utilisation des fichiers de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 639
Exemple : création d'un client Telnet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653
Exemple : chargement et téléchargement de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 656
Chapitre 28 : Environnement du système client
Principes de base de l'environnement du système client . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 662
Utilisation de la classe System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 664
Utilisation de la classe Capabilities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 665
Utilisation de la classe ApplicationDomain . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 666
Utilisation de la classe IME . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 668
Exemple : détection des capacités du système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 673
Chapitre 29 : Copie et collage
Principes de base de la copie et du collage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 678
Lecture en provenance et écriture à destination du presse-papiers du système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 679
Formats de données Clipboard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 679
Chapitre 30 : Impression
Principes de base de l'impression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 684
Impression d'une page . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 685
Tâches Flash Player et AIR et impression système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 686
Définition de la taille, de l'échelle et de l'orientation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 689
Exemple : impression de plusieurs pages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 690
Exemple : redimensionnement, recadrage et ajustement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 692
Chapitre 31 : Utilisation de l'API externe
Principes de base de l'utilisation de l'API externe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 695
Avantages de l'API externe et conditions requises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 698
Utilisation de la classe ExternalInterface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 699
Exemple : utilisation de l'API externe dans un conteneur de page Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 702
Exemple : utilisation de l'API externe avec un conteneur ActiveX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 708
Chapitre 32 : Sécurité dans Flash Player
Présentation de la sécurité dans Flash Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 714
Les sandbox de sécurité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 716
Contrôles des autorisations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 718
Restriction des API de réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 725
Sécurité du mode plein écran . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 727
Chargement de contenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 728
ix
PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH
Sommaire
Programmation croisée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 731
Accès aux médias chargés comme s'il s'agissait de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 734
Chargement des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 736
Chargement de contenu incorporé à partir de fichiers SWF importés dans un domaine de sécurité . . . . . . . . . . . . . . . . . . . . . 739
Utilisation de contenus existants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 739
Définition des autorisations LocalConnection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 740
Contrôle de l'accès URL externe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 740
Objets partagés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 742
Accès à la caméra, au microphone, au presse-papiers, à la souris et au clavier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 743
Index ...............................................................................................................744
1
Chapitre 1 : A propos de ce manuel
Ce manuel peut servir de base au développement d'applications avec Adobe® 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 les techniques décrites. Il est également conseillé de comprendre les concepts de la
programmation orientée objets (classes et héritage). La connaissance d'ActionScript 1.0 ou ActionScript 2.0 est utile,
mais pas nécessaire.
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 conçus pour une
utilisation et un chargement plus facile avec Adobe® Flash® CS4 Professional. Ils peuvent inclure des fichiers enveloppe.
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 3

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

En utilisant l'outil de programmation Adobe® Flash® CS4 Professional
Pour plus d'informations sur les environnements de développement ActionScript, consultez « Introduction à
ActionScript 3.0 » à la page 4.
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 programmation de 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, consultez la section « Accès à la
documentation ActionScript » à la page 2.
Chapitres Description
Chapitres 2 à 5 : 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, ainsi que la programmation ActionScript orientée objet
Chapitres 6 à 11 : 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.
Chapitres 12 à 32 : Flash Player et les interfaces de
programmation d'Adobe AIR
Décrit les fonctions importantes implémentées dans des packages et des classes
propres à Adobe Flash Player, notamment la gestion d'événement, l'utilisation
d'objets d'affichage et de la liste d'affichage, la mise en réseau et les
communications, le fichier d'entrée-sortie, l'interface externe, le modèle de sécurité
de l'application, etc.
2
PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH
A propos de ce manuel
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 des
applications ni 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. A cet effet, consultez le Guide de 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 du langage. Le
Guide de 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 de l'outil de programmation Flash (dans les packages fl) et les interfaces de
programmation Flash Player et Adobe AIR (dans les packages flash).
Documentation Flash
Si vous utilisez l'outil de programmation, vous, vous pouvez consulter les manuels suivants :
Manuel Description
Utilisation de Flash Décrit comment développer vos applications Web dynamiques dans l'outil de
programmation Flash
Programmation avec ActionScript 3.0 Décrit l'utilisation spécifique du langage ActionScript 3.0 et de l'interface de
programmation de base de Flash Player et d'Adobe AIR
Guide de référence du langage et des composants
ActionScript 3.0
Fournit des exemples de syntaxe, d'utilisation et de code pour les composants de
l'outil de programmation Flash et l'interface de programmation ActionScript 3.0
Utilisation des composants ActionScript 3.0 Explique de façon détaillée comment utiliser des composants pour développer
des applications créées par Flash.
Développement d'applications AIR avec Adobe Flash CS4
Professional
Explique comment développer et déployer des applications Adobe AIR par le
biais d'ActionScript 3.0 et de l'API d'Adobe AIR dans 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 syntaxe, d'utilisation et de code pour les composants de
l'outil de programmation Flash et l'interface de programmation 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 créées par Flash.
Guide de référence du langage et 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.x Explique comment développer des applications Flash Lite 2.x
3
PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH
A propos de ce manuel
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 Adobe vous permet d'accéder aux informations les plus récentes sur ActionScript, aux
articles sur le développement d'applications réelles et aux informations sur les problèmes importants. Accédez au Pôle
de développement à l'adresse www.adobe.com/devnet/.
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 renforcez vos connaissances à l'aide de didacticiels, de flux
de travail clés et de techniques avancées. Connectez-vous deux fois par mois pour accéder aux didacticiels et aux
articles les plus récents, ainsi qu'aux galeries qui seront votre source d'inspiration. Accédez au Pôle de création à
l'adresse www.adobe.com/designcenter/.
Présentation du code ActionScript pour 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
Guide de 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 CS4 d'Adobe
®
Device Central
Développement d'applications Flash Lite 1.x Décrit comment développer des applications pour 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
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
4
Chapitre 2 : Introduction à
ActionScript 3.0
Ce chapitre présente Adobe® ActionScript® 3.0, la version la plus récente et la plus révolutionnaire d'ActionScript.
A propos d'ActionScript
ActionScript est le langage de programmation des environnements d'exécution d'Adobe® Flash® Player et
Adobe® AIR™. Il assure l'interactivité, le traitement des données et bien d'autres fonctions pour le contenu Flash, Flex
et AIR et les applications associées.
ActionScript est exécuté par la machine virtuelle ActionScript, un composant de Flash Player et AIR. Le code
ActionScript est généralement compilé en pseudo-code binaire (sorte de langage de programmation écrit et compris
par les ordinateurs) par un compilateur, tel celui intégré à Adobe® Flash® CS4 Professional ou Adobe® Flex™ Builder™,
ou celui fourni dans le kit de développement d'Adobe® Flex™. Le pseudo-code binaire est intégré aux fichiers SWF, qui
sont exécutés par Flash Player et AIR.
ActionScript 3.0 constitue un modèle de programmation solide, bien connu des développeurs dotés des connaissances
élémentaires sur la programmation orientée objets. Parmi les principales fonctionnalités d'ActionScript 3.0 qui ont été
améliorées par rapport aux versions antérieures d'ActionScript figurent :

Une nouvelle machine virtuelle ActionScript, appelée AVM2, qui exploite un nouveau jeu d'instructions de
pseudo-code binaire et améliore grandement les performances.

Un code de compilateur plus moderne qui effectue des optimisations de plus bas niveau 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.

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, 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 et 10 pour assurer la compatibilité ascendante avec le contenu existant. Pour plus
d'informations, consultez la section « Compatibilité avec les versions précédentes » à la page 8.
5
PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH
Introduction à ActionScript 3.0
Nouveautés d'ActionScript 3.0
Bien que de nombreuses classes et fonctions d'ActionScript 3.0 soient bien connues des programmeurs 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.
Remarque : les applications Adobe® AIR™ peuvent également utiliser les API de Flash Player.
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. 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 de pile 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 et Adobe AIR vérifient les types lors de l'exécution, optimisant ainsi
l'intégrité des types du système. 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.
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'en ajouter d'autres. 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 puisqu'une table de hachage interne n'est pas requise pour chaque occurrence
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'occurrence de son
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'occurrence 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.
6
PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH
Introduction à ActionScript 3.0
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 comme 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, consultez le chapitre « Utilisation de XML » à la
page 232.
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).
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
Les API Flash Player d'ActionScript 3.0 contiennent un grand nombre de classes qui vous permettent de contrôler les
objets de bas niveau. L'architecture du langage est conçue pour être plus intuitive que les versions antérieures. 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.
Remarque : les applications Adobe® AIR™ peuvent également utiliser les API de Flash Player.
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. Il 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
utilisant le même modèle d'événements que l'API de Flash Player, le système d'événements est unifié sur l'ensemble de
la plate-forme Flash.
7
PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH
Introduction à ActionScript 3.0
API de liste d'affichage
L'API d'accès à la liste d'affichage Flash Player et Adobe AIR, 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 et Adobe AIR, 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 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, implémentée 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é.
Utilisation de texte
ActionScript 3.0 contient un package flash.text destiné à l'ensemble des API relatives au texte. La classe
TextLineMetrics propose des mesures détaillées relatives à une ligne de texte au sein d'un champ de texte. Elle remplace
la méthode
TextFormat.getTextExtent()
intégrée à ActionScript 2.0. La classe TextField contient diverses
méthodes de bas niveau intéressantes, qui peuvent fournir des informations déterminées sur une ligne de texte ou un
caractère unique dans un champ de texte. Parmi ces méthodes figurent :
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 intégrées à des fichiers SWF.
8
PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH
Introduction à ActionScript 3.0
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. Tout contenu qui s'exécutait dans les versions antérieures de Flash Player s'exécute dans Flash Player 9
et ultérieur. L'introduction d'ActionScript 3.0 dans Flash Player 9 présente toutefois certains problèmes de
compatibilité entre le contenu créé dans des versions antérieures et tout nouveau contenu qui s'exécute dans Flash
Player 9 ou ultérieur, Voici quelques problèmes de compatibilité :

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 pas charger les fichiers SWF écrits en
ActionScript 3.0. Cela signifie que les fichiers SWF créés dans Flash 8, Flex Builder 1.5 ou une version antérieure
ne peuvent pas charger les fichiers SWF écrits en ActionScript 3.0.
Il existe une seule exception à cette règle : un fichier SWF écrit en ActionScript 2.0 peut être remplacé par un fichier
SWF écrit en ActionScript 3.0, sous réserve que le fichier écrit en ActionScript 2.0 n'ait effectué aucun chargement
à quelque niveau que ce soit. Pour ce faire, le fichier SWF écrit en ActionScript 2.0 doit appeler
loadMovieNum()

et transmettre la valeur 0 au paramètre
level
.

En règle générale, les fichiers SWF écrits en ActionScript 1.0 ou 2.0 doivent faire l'objet d'une migration pour
fonctionner conjointement avec des fichiers SWF écrits en ActionScript 3.0. Supposons, par exemple, que vous ayez
créé un lecteur multimédia avec ActionScript 2.0. Ce lecteur multimédia charge des contenus divers également
créés en ActionScript 2.0. Il est impossible de créer un contenu en ActionScript 3.0 et de le charger dans le lecteur
multimédia. Vous devez effectuer une migration du lecteur vers ActionScript 3.0.
Néanmoins, si vous créez un lecteur multimédia en ActionScript 3.0, il peut effectuer de simples chargements de
votre contenu en ActionScript 2.0.
Le tableau ci-après récapitule les limites 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
en différentes versions d'ActionScript.
Dans le tableau ci-dessous, « Fonctionnalité prise en charge » fait référence au contenu lisible dans Flash Player 9 ou
une version 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.
Fonctionnalité prise en charge Flash Player 7 Flash Player 8 Flash Player 9 et 10
Peut charger les fichiers SWF pour version 7 et antérieure version 8 et antérieure version 9 (ou 10) 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 créé en ActionScript 1.0 et 2.0 Contenu créé en 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 1.0 et 2.0 via LocalConnection
ActionScript 3.0
9
Chapitre 3 : Prise en main d'ActionScript
Ce chapitre vise à vous expliquer les principes de base de la programmation avec 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.
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.
Celui-ci présente deux aspects principaux :

Il est constitué 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.
En fait, un programme informatique n'est rien d'autre qu'une liste d'actions que vous demandez à l'ordinateur
d'exécuter l'une après l'autre. Chacune de ces demandes d'exécution d'action s'appelle 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 de 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 stocker le résultat dans sa mémoire. Dans un cas de figure plus compliqué, imaginez un rectangle dessiné sur
l'écran ; vous rédigez un programme pour le déplacer à un autre emplacement 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 rédige 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 appelées
value1
et
value2
, chacune contenant un nombre, vous pouvez additionner ces deux nombres à l'aide de l'instruction
suivante :
value1 + value2
10
PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH
Prise en main d'ActionScript
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 :

Le 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
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 dans 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 CS4 Professional propose une autre méthode de déclaration des variables. Lorsque vous placez un
symbole de clip, un symbole de bouton ou un champ de texte sur la scène, vous pouvez lui attribuer un nom
d'occurrence dans l'Inspecteur des Propriétés. En arrière-plan, Flash crée une variable du même nom que celui de
l'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.
Une constante s'apparente à une variable dans la mesure où elle correspond à un nom représentant une valeur dans la
mémoire de l'ordinateur et est associée à un type de données spécifique. En revanche, vous ne pouvez affecter qu'une
seule valeur à une constante dans une application ActionScript. Une fois affectée à une constante, une valeur reste la
même dans l'ensemble de l'application. La syntaxe de déclaration d'une constante est identique à celle de la déclaration
d'une variable, à la différence près que vous substituez le mot-clé
const
au mot-clé
var
.
const SALES_TAX_RATE:Number = 0.07;
Une constante permet de définir une valeur qui s'utilise à plusieurs emplacements dans un projet et reste identique
dans des circonstances normales. L'utilisation d'une constante plutôt que d'une valeur littérale améliore la lisibilité de
votre code. Il est plus facile, par exemple, de comprendre la finalité d'une ligne de code qui multiplie un prix par
SALES_TAX_RATE
, plutôt que par
0,07
. En outre, si vous représentez une constante par une valeur dans l'ensemble de
votre projet et qu'il s'avère nécessaire de modifier cette valeur, il vous suffit d'intervenir à un seul emplacement (dans
la déclaration de la constante), alors que si vous utilisez des valeurs littérales codées en dur, vous devez changer chaque
occurrence.
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
11
PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH
Prise en main d'ActionScript

int : un nombre entier (sans fraction)

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

Boolean : une valeur vrai/faux, qui indique par exemple si une instruction Switch est active ou si deux valeurs sont
égales
Les types de données simples représentent une information unique : un nombre ou une séquence de texte, par
exemple. 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. Toutefois, la valeur date se compose en réalité de plusieurs valeurs
(le jour, le mois, l'année, les heures, les minutes, les secondes, etc.), qui correspondent elles-mêmes à des nombres
individuels. 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, y compris ceux définis par les programmeurs, sont des types de données
complexes. Voici quelques exemples de types de données complexes que vous pourriez rencontrer :

MovieClip : un symbole de clip

TextField : un champ de 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 ; un modèle, en quelque sorte, s'appliquant à tous les objets du type de
données et qui revient à dire « toutes les variables du type de données Exemple sont dotées des caractéristiques
suivantes : A, B et C ». Un objet, quant à lui, est une occurrence réelle d'une classe. Une variable dont le type de données
correspond à MovieClip, par exemple, 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 occurrence de Number.

La variable
myVariable
est un objet Number.

La variable
myVariable
est une occurrence de la classe Number.
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