ADOBE Flash CS3 Programmation avec ActionScript 3.0 [fr]

PROGRAMMATION AVEC

™

ACTIONSCRIPT

3.0

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.

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.

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

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

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

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

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

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

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

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

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

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

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

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

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 :

Chapitres Description

Chapitres 1 à 4, présentation de la programmation avec ActionScript

Chapitres 5 à 10, classes et types de données ActionScript 3.0 de base

Chapitres 11 à 26, API de Flash Player Décrit les fonctions importantes mises en

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

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

Décrit les types de données de niveau supérieur dans ActionScript 3.0 qui font également partie de la spécification ECMAScript.

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

® Flash® Player 9.

16 A propos de ce manuel

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

Accès à la documentation ActionScript 17

Manuel Description

Référence du langage et des composants ActionScript 3.0

Utilisation des composants ActionScript 3.0 Explique comment utiliser les composants pour

Formation à ActionScript 2.0 dans Adobe Flash

Guide de référence du langage ActionScript 2.0

Utilisation des composants ActionScript 2.0 Explique de façon détaillée comment utiliser les

Référence du langage des composants ActionScript 2.0

Extension de Flash Décrit les objets, les méthodes et les propriétés

Prise en main de Flash Lite 2.x Explique comment utiliser Adobe® Flash® Lite™

Développement d’applications Flash Lite 2.0 Explique comment développer des applications

Introduction à ActionScript Flash Lite 2.x Explique comment développer des applications

Référence du langage ActionScript Flash Lite 2.x

Prise en main de Flash Lite 1.x Présente Flash Lite 1.x et décrit comment tester

Fournit des exemples de code, d’utilisation et de syntaxe pour les composants de Flash et l’API d’ActionScript 3.0

développer des applications 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

Fournit des exemples de code, d’utilisation et de syntaxe pour les composants de Flash et l’API d’ActionScript 2.0

composants ActionScript 2.0 pour développer des applications Flash

Décrit chaque composant disponible dans l’architecture des composants Adobe, version 2, avec son API

disponibles dans l’API de JavaScript

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

Flash Lite 2.x

avec Flash Lite 2.x et décrit toutes les fonctions ActionScript disponibles pour les développeurs de 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

votre contenu à l’aide de l’émulateur CS3 d’Adobe® Device Central

18 A propos de ce manuel

Manuel Description

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

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.

Ressources ActionScript destinées à la formation 19

20 A propos de ce manuel

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.

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

22 Introduction à ActionScript 3.0

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.

Nouveautés d’ActionScript 3.0 23

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é peuvent être déclarées dynamiques grâce au mot-clé

dynamic. Bien que scellées par défaut, toutes les classes d’ActionScript 3.0

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

24 Introduction à ActionScript 3.0

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

public, private, protected). Ils fonctionnent

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.

Nouveautés d’ActionScript 3.0 25

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

offre un mécanisme distinct de

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

26 Introduction à ActionScript 3.0

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,

getFirstCharInParagraph(), qui renvoie l’index du premier caractère d’un paragraphe.

Les méthodes de niveau de ligne incluent caractères d’une ligne de texte donnée, et

getCharIndexAtPoint(), qui renvoie l’index d’un caractère à un point donné et

getLineLength(), qui renvoie le nombre de

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.

Compatibilité avec les versions précédentes 27

■ 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

Environnement d’exécution

en charge

Flash Player 7 Flash Player 8 Flash Player 9

Peut charger les fichiers SWF pour

Machine virtuelle incluse

Exécute les fichiers SWF écrits en ActionScript

Fonctionnalité prise

version 7 et

antérieure

AVM1 AVM1 AVM1 et AVM2

1.0 et 2.0 1.0 et 2.0 1.0, 2.0 et 3.0

version 8 et

antérieure

version 9 et antérieure

Contenu créé dans

en charge*

ActionScript 1.0 et 2.0 ActionScript 3.0

Peut charger du contenu et exécuter le code de contenus créé dans

Peut programmer le contenu créé dans

* 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. † ActionScript 3.0 via LocalConnection ‡ ActionScript 1.0 et 2.0 via LocalConnection

ActionScript 1.0 et 2.0 uniquement

ActionScript 1.0 et 2.0 uniquement†

ActionScript 1.0 et 2.0 et

ActionScript 3.0

ActionScript 3.0‡

28 Introduction à ActionScript 3.0

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.

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

value1 et value2, chacune contenant un nombre, vous

30 Prise en main d’ActionScript

+ 828 hidden pages