ADOBE Flash CS4 User Manual [fr]

Programmation

d’ADOBE

ACTIONSCRIPT® 3.0

Programmation avec Adobe

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 (

MPEG Layer-3 audio compression technology licensed by Fraunhofer IIS and Thomson Multimedia (

Speech compression and decompression technology licensed from Nellymoser, Inc. (

This product includes software developed by the OpenSymphony Group (

This product contains either BSAFE and/or TIPEM software by RSA Security, Inc.

® ActionScript® 3.0 pour Adobe® Flash®

http://www.apache.org/).

http://www.mp3licensing.com)

www.nellymoser.com).

http://www.opensymphony.com/).

Sorenson Spark

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.

™ video compression and decompression technology licensed from Sorenson Media, Inc.

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

iii

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

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

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

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

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

vii

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

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

viii

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

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

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 :

Chapitres Description

Chapitres 2 à 5 : présentation de la programmation avec ActionScript

Chapitres 6 à 11 : classes et types de données ActionScript 3.0 de base

Chapitres 12 à 32 : Flash Player et les interfaces de programmation d'Adobe AIR

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

Décrit les types de données de niveau supérieur dans ActionScript 3.0.

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.

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.

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 avec ActionScript 3.0 Décrit l'utilisation spécifique du langage ActionScript 3.0 et de l'interface de

Guide de référence du langage et des composants ActionScript 3.0

Utilisation des composants ActionScript 3.0 Explique de façon détaillée comment utiliser des composants pour développer

Développement d'applications AIR avec Adobe Flash CS4 Professional

Formation à ActionScript 2.0 dans Adobe Flash Passe en revue les principes généraux de la syntaxe ActionScript 2.0 et explique

Guide de référence du langage ActionScript 2.0 Fournit des exemples de syntaxe, d'utilisation et de code pour les composants de

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

Guide de référence du langage et des composants ActionScript 2.0

Extension de Flash Décrit les objets, les méthodes et les propriétés disponibles dans l'API de

Prise en main de Flash Lite 2.x

programmation Flash

programmation de base de Flash Player et d'Adobe AIR

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

des applications créées par Flash.

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.

comment utiliser ce langage pour intervenir sur différents types d'objet

l'outil de programmation Flash et l'interface de programmation ActionScript 2.0

pour développer des applications créées par Flash.

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

JavaScript

Explique comment utiliser Adobe 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 pour développer des

Développement d'applications Flash Lite 2.x Explique comment développer des applications Flash Lite 2.x

Manuel Description

PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH

A propos de ce manuel

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

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

Prise en main de Flash Lite 1.x Présente Flash Lite 1.x et décrit comment tester votre contenu à l'aide de

Développement d'applications Flash Lite 1.x Décrit comment développer des applications pour périphériques mobiles à l'aide

Formation à ActionScript Flash Lite 1.x Explique comment utiliser ActionScript dans des applications Flash Lite 1.x et

Référence du langage ActionScript Flash Lite 1.x Fournit la syntaxe et l'utilisation d'éléments ActionScript disponibles avec Flash

les fonctions ActionScript disponibles pour les développeurs de Flash Lite 2.x

d'ActionScript 2.0 disponible dans Flash Lite 2.x

l'émulateur CS4 d'Adobe® Device Central

de Flash Lite 1.x

décrit toutes les fonctions ActionScript disponibles avec Flash Lite 1.x

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

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.

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é défaut, toutes les classes d'ActionScript 3.0 peuvent être déclarées dynamiques grâce au mot-clé

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.

dynamic. Bien que scellées par

dynamic.

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.

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 : rectangle représentant le cadre de sélection d'un caractère, 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 ligne de texte donnée, et

getLineText(), qui renvoie le texte de la ligne spécifiée. La nouvelle classe Font permet de

getCharIndexAtPoint(), qui renvoie l'index d'un

getLineLength(), qui renvoie le nombre de caractères d'une

getCharBoundaries(), qui renvoie un

gérer les polices intégrées à des fichiers SWF.

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 et transmettre la valeur 0 au paramètre

level.

loadMovieNum()

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

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

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

Peut programmer le contenu créé dans 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 via LocalConnection)

ActionScript 1.0 et 2.0 via LocalConnection

ActionScript 3.0

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

value1 + value2

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 value1:Number;

var:

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 fois que vous utilisez la variable

rocketShip dans votre code ActionScript, c'est en fait ce clip que vous manipulez.

rocketShip, chaque

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 SALES_TAX_RATE:Number = 0.07;

const au mot-clé var.

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

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 d'instructions. Dans le cas de la programmation orientée objets, les instructions du programme se divisent néanmoins en différents objets : le code étant rassemblé en groupes de fonctionnalités, un même conteneur réunit des types de fonctionnalités et des informations connexes.

En fait, si vous avez travaillé avec des symboles dans Flash, vous savez déjà manipuler les objets. Imaginons que vous ayez défini un symbole de clip (le dessin d'un rectangle, par exemple) et vous en ayez placé une copie sur la scène. Ce symbole de clip constitue aussi un objet (au sens littéral) dans ActionScript ; il s'agit d'une occurrence de la classe MovieClip.

PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH

Prise en main d'ActionScript

Vous avez la possibilité de modifier plusieurs caractéristiques du clip. S'il est sélectionné, vous pouvez par exemple modifier certaines valeurs de l'Inspecteur des Propriétés, telles que la coordonnée x ou la largeur, ou encore différents réglages de couleur comme la transparence alpha ou l'application d'un filtre d'ombre portée. D'autres outils Flash vous permettent d'effectuer davantage de modifications, par exemple l'outil Transformation libre pour faire pivoter le rectangle. Toutes ces actions de transformation du symbole de clip disponibles dans l'environnement de programmation de Flash sont également disponibles dans ActionScript. Pour les utiliser, vous devez modifier les données réunies dans un ensemble appelé objet MovieClip.

Dans la programmation orientée objets que propose ActionScript, chaque classe comprend trois types de caractéristiques :

• Propriétés

• Méthodes

• Evénements

Pris ensemble, ces éléments servent à gérer les données que le programme utilise, et à déterminer les actions à exécuter ainsi que l'ordre d'exécution.

Propriétés

Une propriété représente l'une des données réunies dans un objet. Un objet song, par exemple, peut présenter des propriétés appelées

alpha. Les propriétés s'utilisent comme des variables individuelles; on pourrait même envisager les propriétés comme

les variables enfant d'un objet.

artist et title. La classe MovieClip possède des propriétés telles que rotation, x, width et

Voici des exemples de code ActionScript utilisant des propriétés. Cette ligne de code déplace l'objet MovieClip nommé

square vers la coordonnée x de 100 pixels :

square.x = 100;

Le code ci-après utilise la propriété rotation pour faire pivoter le MovieClip square de manière à lui donner la même orientation que le MovieClip

square.rotation = triangle.rotation;

triangle :

Ce code modifie l'échelle horizontale du MovieClip square pour qu'il soit une fois et demie plus large que précédemment :

square.scaleX = 1.5;

Observez la structure commune : vous utilisez une variable (square, triangle) comme nom de l'objet, suivi d'un point() puis du nom de la propriété (

x, rotation, scaleX). Le point, ou opérateur point, sert à indiquer que vous

accédez à l'un des éléments enfant d'un objet. La structure dans son ensemble, « nom de variable-point-nom de propriété » est utilisée telle une variable, comme le nom d'une valeur unique dans la mémoire de l'ordinateur.

Méthodes

Une méthode est une action qui peut être effectuée par un objet. Par exemple, si vous avez élaboré dans Flash un symbole de clip dont le scénario contient plusieurs images clés et animations, ce clip peut être lu ou arrêté, ou recevoir l'instruction de placer la tête de lecture sur une image donnée.

Le code ci-dessous indique au MovieClip nommé

shortFilm de commencer la lecture :

shortFilm.play();

Cette ligne de code arrête la lecture du MovieClip shortFilm (la tête de lecture s'arrête à l'endroit où elle se trouve, comme lorsque vous mettez une vidéo en pause) :

PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH

shortFilm.stop();

Prise en main d'ActionScript

Ce code-ci indique au MovieClip shortFilm de placer la tête de lecture sur Frame 1 et d'arrêter la lecture (comme si vous rembobiniez une vidéo) :

shortFilm.gotoAndStop(1);

Comme vous pouvez le constater, l'accès aux méthodes, comme pour les propriétés, s'effectue en écrivant le nom de l'objet (une variable) suivi d'un point puis du nom de la méthode et de parenthèses. Les parenthèses servent à indiquer que vous appelez la méthode, c'est-à-dire que vous demandez à l'objet d'effectuer une action. Il arrive que des valeurs (ou variables) soient placées dans ces parenthèses de manière à transmettre des informations supplémentaires nécessaires à l'exécution de l'action. On appelle ces valeurs des paramètres de méthode. Par exemple, la méthode

gotoAndStop() doit savoir quelle image atteindre ; un paramètre est donc requis dans les parenthèses. D'autres

méthodes, telles

play() et stop(), ont une signification univoque et n'ont donc besoin d'aucune information

complémentaire. Elles sont néanmoins suivies de parenthèses.

Contrairement aux propriétés (et aux variables), les méthodes ne servent pas d'espaces réservés. Certaines méthodes peuvent cependant effectuer des calculs et renvoyer des résultats pouvant servir de variables. C'est le cas de la méthode

toString() de la classe Number, qui convertit une valeur numérique en une représentation textuelle :

var numericData:Number = 9; var textData:String = numericData.toString();

Par exemple, vous pouvez utiliser la méthode toString() si vous souhaitez afficher la valeur d'une variable Number dans un champ de texte à l'écran. La propriété

text de la classe TextField (qui représente le contenu textuel réel affiché

à l'écran) se définit comme une chaîne (String), de sorte qu'elle ne puisse contenir que des valeurs textuelles. Cette ligne de code convertit la valeur numérique de la variable TextField nommé

calculatorDisplay.text = numericData.toString();

calculatorDisplay :

numericData en texte, puis la fait apparaître à l'écran dans l'objet

Evénements

Tel que nous l'avons décrit, un programme informatique est une série d'instructions que l'ordinateur exécute l'une après l'autre. Certains programmes très simples ne sont rien de plus : l'ordinateur exécute quelques procédures, puis le programme se termine. Toutefois, les programmes ActionScript sont conçus pour poursuivre leur exécution, dans l'attente d'une saisie utilisateur, par exemple. Les événements sont des mécanismes qui déterminent quelles instructions l'ordinateur doit exécuter et à quel moment.

Par essence, les événements sont des faits qui surviennent et auxquels ActionScript peut répondre parce qu'il en est conscient au moment où ils se produisent. De nombreux événements sont liés à l'interaction de l'utilisateur, par exemple un clic sur un bouton ou une pression sur une touche du clavier. Il existe néanmoins d'autres types d'événement. Par exemple, si vous utilisez ActionScript pour charger une image externe, un événement est capable de vous prévenir lorsque le chargement de l'image est terminé. Pendant l'exécution d'un programme ActionScript, Adobe Flash Player et Adobe AIR attendent que des événements se produisent et lorsque c'est le cas, ils exécutent le code ActionScript que vous avez spécifié en réponse.

Gestion des événements de base

La gestion des événements est la technique qui permet de spécifier les actions à exécuter en réponse à des événements particuliers. Lors de l'écriture de code ActionScript en vue de la gestion des événements, trois éléments importants sont à identifier :

• Source de l'événement : quel objet sera-t-il concerné par l'événement ? Par exemple, sur quel bouton aura lieu le clic

ou quel est l'objet Loader qui charge l'image ? La source de l'événement est également appelée cible de l'événement car elle représente l'objet où l'événement est ciblé par Flash Player ou AIR (là où l'événement a lieu).

PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH

Prise en main d'ActionScript

• Evénement : que doit-il se passer, à quel événement voulez-vous répondre? Ce point est très important, car de

nombreux objets déclenchent plusieurs événements.

• Réponse : quelles actions doivent être exécutées lorsque l'événement se produit ?

Tout code ActionScript de gestion des événements doit contenir ces trois éléments et respecter la structure de base suivante (les éléments en gras sont des espaces réservés à remplir selon le cas envisagé) :

function eventResponse(eventObject:EventType):void { // Actions performed in response to the event go here. }

eventSource.addEventListener(EventType.EVENT_NAME, eventResponse);

Ce code a un double rôle. Tout d'abord, il définit une fonction, qui est une manière de spécifier les actions à exécuter en réponse à l'événement. Ensuite, il appelle la méthode

addEventListener() de l'objet source, « inscrivant » ainsi la

fonction auprès de l'événement spécifié de manière que, dès que l'événement survient, les actions de la fonction aient lieu. Nous allons étudier chacun de ces rôles en détail.

Une fonction sert à regrouper des actions sous un nom unique, un raccourci qui vous permet de les exécuter. La fonction est identique à la méthode, à cette exception près qu'elle n'est pas nécessairement associée à une classe particulière (on pourrait d'ailleurs définir la méthode ainsi : une fonction associée à une classe donnée). Lorsque vous créez une fonction de gestion des événements, vous devez choisir le nom de la fonction (dans ce cas mais aussi spécifier un paramètre (

eventObject dans cet exemple). La spécification d'un paramètre de fonction

eventResponse)

ressemble à la déclaration de variable ; vous devez dans ce cas aussi indiquer le type de données du paramètre

EventType, dans cet exemple).

(

Chaque type d'événement que vous souhaitez écouter est associé à une classe ActionScript. Le type de données que vous spécifiez pour le paramètre de fonction correspond systématiquement à la classe associée à l'événement auquel vous souhaitez réagir. Par exemple, un événement à la classe MouseEvent. Pour écrire une fonction d'écouteur pour un événement de type MouseEvent. Enfin, entre les accolades d'ouverture et de fermeture (

click (déclenché par un clic de souris sur un élément) est associé

click, vous lui associez un paramètre

{ ... }), vous placez les instructions que

l'ordinateur doit exécuter lorsque l'événement a lieu.

Une fois que vous avez écrit la fonction de gestion de l'événement, vous devez indiquer à l'objet source (celui qui provoque l'événement, par exemple le bouton) que cette fonction doit être appelée lorsque l'événement survient. Pour ce faire, appelez la méthode

addEventListener()). La méthode addEventListener() réclame deux paramètres :

addEventListener() de cet objet (tous les objets liés à des événements ont une méthode

• Tout d'abord, le nom de l'événement auquel vous voulez répondre. Comme nous l'avons déjà vu, chaque événement

est affilié à une classe spécifique pour laquelle est définie une valeur propre à chacun d'eux (en quelque sorte le nom unique de l'événement). Cette valeur sert de premier paramètre.

• Vient ensuite le nom de votre fonction de réponse à l'événement. Sachez qu'un nom de fonction est écrit sans

parenthèses lors du transfert en tant que paramètre.

Description du processus de gestion des événements

Vous trouverez ci-dessous une description détaillée du processus ayant lieu lorsque vous créez un écouteur d'événement. Dans ce cas, il s'agit d'un exemple illustrant la création d'une fonction d'écouteur appelée lorsque vous cliquez sur un objet

Le code écrit par le programmeur est le suivant :

myButton.

PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH

Prise en main d'ActionScript

function eventResponse(event:MouseEvent):void { // Actions performed in response to the event go here. }

myButton.addEventListener(MouseEvent.CLICK, eventResponse);

Voici comment ce code devrait fonctionner lorsqu'il est exécuté dans Flash Player. (Ce comportement s'applique également à Adobe AIR.) :

1 Lors du chargement du fichier SWF, Flash Player remarque qu'il existe une fonction eventResponse().

PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH

Prise en main d'ActionScript

2 Flash Player exécute ensuite le code (notamment les lignes de code qui ne sont pas dans une fonction). Dans ce cas,

il s'agit d'une seule ligne de code : l'appel de la méthode

myButton) et la transmission de la fonction eventResponse en tant que paramètre.

(

addEventListener() sur l'objet source de l'événement

a En interne, myButton a une liste des fonctions qui écoutent chaque événement. Par conséquent, lorsque sa

méthode

addEventListener() est appelée, myButton stocke la fonction eventResponse() dans sa liste

d'écouteurs d'événement.

3 A un certain moment, l'utilisateur clique sur l'objet myButton et déclenche ainsi son événement click (identifié

comme

MouseEvent.CLICK dans le code).

PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH

Prise en main d'ActionScript

A ce stade, les opérations suivantes ont lieu :

a Flash Player crée un objet, une occurrence de la classe associée à l'événement en question (MouseEvent dans cet

exemple). Pour de nombreux événements, il s'agit d'une occurrence de la classe Event ; pour des événements de souris, une occurrence de MouseEvent et pour d'autres événements, une occurrence de la classe associée à cet événement. L'objet créé est appelé l'objet événement. Il contient des informations spécifiques sur l'événement qui s'est produit : son type, l'emplacement où il a eu lieu et toute autre information pertinente.

b Flash Player consulte ensuite la liste des écouteurs d'événement stockés par myButton. Il parcourt ces fonctions

l'une après l'autre en les appelant et en transmettant l'objet événement à la fonction en tant que paramètre. Etant donné que la fonction

eventResponse() dans le cadre de ce processus.

eventResponse() est l'un des écouteurs de myButton, Flash Player appelle la fonction

PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH

Prise en main d'ActionScript

c Lorsque la fonction eventResponse() est appelée, le code qu'elle contient est exécuté et vos actions spécifiées

sont effectuées.

Exemples de gestion d'événements

Voici quelques exemples plus concrets d'événements qui vous donneront une idée des éléments les plus courants et des variations que vous pourrez utiliser lors de l'écriture de votre propre code de gestion des événements :

• Clic sur un bouton pour lancer la lecture du clip actif. Dans l'exemple suivant, playButton est le nom d'occurrence

du bouton et

this.stop();

function playMovie(event:MouseEvent):void { this.play(); }

playButton.addEventListener(MouseEvent.CLICK, playMovie);

this est un nom spécial qui signifie « l'objet actif» :

• Détection de la saisie dans un champ de texte. Dans cet exemple, entryText est un champ de saisie de texte et

outputText est un champ de texte dynamique :

function updateOutput(event:TextEvent):void { var pressedKey:String = event.text; outputText.text = "You typed: " + pressedKey; }

entryText.addEventListener(TextEvent.TEXT_INPUT, updateOutput);

• Clic sur un bouton pour atteindre une URL. Dans ce cas, linkButton est le nom d'occurrence du bouton :

function gotoAdobeSite(event:MouseEvent):void { var adobeURL:URLRequest = new URLRequest("http://www.adobe.com/"); navigateToURL(adobeURL); }

linkButton.addEventListener(MouseEvent.CLICK, gotoAdobeSite);

PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH

Prise en main d'ActionScript

Création d'occurrences d'objets

Bien entendu, pour utiliser un objet dans ActionScript, cet objet doit exister. La création d'un objet repose en partie sur la déclaration d'une variable. Toutefois, celle-ci crée uniquement un emplacement vide dans la mémoire de l'ordinateur. Vous devez attribuer une valeur réelle à cette variable (c'est-à-dire créer un objet et le stocker dans la variable) avant de pouvoir l'utiliser ou la manipuler. Le processus de création d'un objet est appelé instanciation de l'objet, soit la création d'une occurrence d'une classe particulière.

La création d'une occurrence d'objet peut passer par une méthode simple qui n'implique pas ActionScript. Dans Flash, lorsque vous placez un symbole de clip, un symbole de bouton ou un champ de texte sur la scène, puis que vous lui attribuez un nom d'occurrence dans l'Inspecteur des Propriétés, l'application déclare une variable dotée de ce nom d'occurrence, crée une occurrence d'objet et stocke cet objet dans la variable. Il en va de même dans Adobe Flex Builder : si vous créez un composant MXML (soit par codage d'une balise MXML, soit en plaçant le composant dans l'éditeur en mode Création) et lui attribuez un identifiant (dans la balise MXML ou dans la vue des propriétés Flex), cet identifiant devient le nom d'une variable ActionScript. A ce moment-là, une occurrence du composant est créée et stockée dans la variable.

Toutefois, vous ne pourrez pas toujours créer un objet visuellement. Plusieurs méthodes permettent aussi de créer des occurrences d'objet à l'aide d'ActionScript uniquement. A partir de plusieurs types de données ActionScript, vous pouvez tout d'abord créer une occurrence en utilisant une expression littérale, une valeur écrite directement dans le code ActionScript. Voici quelques exemples :

• Valeur numérique littérale (entrez le nombre directement) :

var someNumber:Number = 17.239; var someNegativeInteger:int = -53; var someUint:uint = 22;

• Valeur de chaîne littérale (entourez le texte de doubles guillemets) :

var firstName:String = "George"; var soliloquy:String = "To be or not to be, that is the question...";

• Valeur booléenne littérale (utilisez la valeur littérale true ou false) :

var niceWeather:Boolean = true; var playingOutside:Boolean = false;

• Valeur de tableau littérale (placez entre crochets une liste de valeurs séparées par des virgules) :

var seasons:Array = ["spring", "summer", "autumn", "winter"];

• Valeur XML littérale (entrez le XML directement) :

var employee:XML = <employee> <firstName>Harold</firstName> <lastName>Webster</lastName> </employee>;

ActionScript définit également des expressions littérales pour les types de données Array, RegExp, Object et Function. Pour plus de détails sur ces classes, consultez les chapitres « Utilisation de tableaux » à la page 158 et « Utilisation

d'expressions régulières » à la page 211, ainsi que la section « Type de données Object » à la page 60.

Pour tout autre type de données, créez une occurrence d'objet à l'aide de l'opérateur suit :

var raceCar:MovieClip = new MovieClip(); var birthday:Date = new Date(2006, 7, 9);

new et du nom de classe, comme

PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH

Prise en main d'ActionScript

Pour cette méthode de création d'un objet à l'aide de l'opérateur new, on parle souvent « d'appeler le constructeur de la classe ». Un constructeur est une méthode spéciale qui est appelée dans le cadre de la création d'une occurrence de classe. Notez que lorsque vous créez une occurrence ainsi, vous placez des parenthèses après le nom de classe et spécifiez parfois des valeurs de paramètres, comme vous le faites lorsque vous appelez une méthode.

Remarquez que vous pouvez utiliser l'opérateur

new pour créer une occurrence d'objet, même pour les types de

données qui permettent de créer des occurrences avec une expression littérale. Par exemple, ces deux lignes de code produisent exactement le même résultat :

var someNumber:Number = 6.33; var someNumber:Number = new Number(6.33);

Il est important de se familiariser avec la méthode new ClassName() de création d'objets. Dans le cas d'un type de données ActionScript qui ne dispose pas de représentation visuelle (et ne peut donc pas être créé en plaçant un élément sur la scène de Flash ou dans l'éditeur en mode Création de Flex Builder), vous pouvez uniquement créer un objet directement dans ActionScript à l'aide de l'opérateur

Dans Flash, l'opérateur

new peut en outre servir à créer une occurrence d'un symbole de clip défini dans la bibliothèque

new.

sans être placé sur la scène. Pour plus d'informations à ce sujet, consultez la section « Création d'objets MovieClip à

l'aide d'ActionScript » à la page 421.

Eléments de programme courants

Outre la déclaration des variables, la création d'occurrences d'objets et la manipulation d'objets à l'aide des propriétés et des méthodes, d'autres éléments de construction peuvent servir à la création d'un programme ActionScript.

Opérateurs

Les opérateurs sont des symboles spéciaux (et parfois des mots) qui permettent d'effectuer des calculs. Ils sont surtout utilisés dans les opérations mathématiques et la comparaison de valeurs. En règle générale, un opérateur utilise une ou plusieurs valeurs et « établit » un résultat unique. Par exemple :

• L'opérateur de somme (+) ajoute deux valeurs pour obtenir un nombre unique :

var sum:Number = 23 + 32;

• L'opérateur de multiplication (*) multiplie une valeur par une autre pour obtenir un nombre unique :

var energy:Number = mass * speedOfLight * speedOfLight;

• L'opérateur d'égalité (==) compare deux valeurs pour vérifier si elles sont égales, afin d'obtenir une valeur vrai/faux

(booléenne) unique :

if (dayOfWeek == "Wednesday") { takeOutTrash(); }

Comme l'indique la figure ci-dessus, l'opérateur d'égalité et les autres opérateurs de comparaison sont le plus souvent utilisés avec l'instruction

if afin de déterminer si certaines actions sont à effectuer ou non.

Pour plus d'informations et d'exemples sur l'utilisation des opérateurs, consultez la section « Opérateurs » à la page 70.

PROGRAMMATION AVEC ACTIONSCRIPT 3.0 POUR FLASH

Prise en main d'ActionScript

Commentaires

Lors de la rédaction du code ActionScript, il peut s'avérer utile de conserver des notes personnelles, expliquant par exemple le fonctionnement de certaines lignes de code ou la raison pour laquelle vous avez fait tel ou tel choix. Les commentaires de code vous permettent d'insérer du texte dans votre code, que l'ordinateur devra ignorer. ActionScript comprend deux types de commentaires :

• Commentaire sur une ligne : un commentaire sur une ligne est signalé par l'insertion de deux barres obliques en un

emplacement quelconque d'une ligne. Tout ce qui apparaît après les barres obliques et jusqu'à la fin de la ligne est ignoré par l'ordinateur :

// This is a comment; it's ignored by the computer. var age:Number = 10; // Set the age to 10 by default.

• Commentaire sur plusieurs lignes : un commentaire sur plusieurs lignes comprend un marqueur de début (/*), le

commentaire lui-même, puis un marqueur de fin de commentaire ( entre les marqueurs de début et de fin, quel que soit le nombre de lignes utilisé par le commentaire :

/* This might be a really long description, perhaps describing what a particular function is used for or explaining a section of code.

In any case, these lines are all ignored by the computer. */

*/). L'ordinateur ignore tout ce qui apparaît

Une autre utilité des commentaires est de « désactiver » temporairement une ou plusieurs lignes de code ; c'est le cas, par exemple, si vous testez différentes façons d'aboutir à un résultat ou essayez d'identifier pourquoi le code ActionScript ne fonctionne pas comme vous le pensiez.

Contrôle du flux

Dans bien des cas, il vous sera nécessaire de répéter des actions de votre code, d'en effectuer certaines et pas d'autres, de réaliser des actions de remplacement selon les conditions rencontrées, etc. Le contrôle de flux permet de maîtriser les actions exécutées. ActionScript propose plusieurs types d'éléments de contrôle de flux.

• Fonctions : les fonctions sont comme des raccourcis, elles permettent de regrouper sous un même nom une série

d'actions qui serviront à des calculs. Essentielles à la gestion des événements, elles constituent en outre un outil générique de regroupement des instructions. Pour plus d'informations sur les fonctions, consultez la section « Fonctions » à la page 81.

• Boucles : les structures en boucle vous permettent de désigner un jeu d'instructions que l'ordinateur exécutera un

nombre défini de fois ou jusqu'à ce qu'une condition change. Souvent, les boucles sont utilisées pour manipuler plusieurs éléments connexes à l'aide d'une variable dont la valeur change à chaque fois que l'ordinateur achève une boucle. Pour plus d'informations sur les boucles, consultez la section « Boucle » à la page 78.

• Instructions conditionnelles : les instructions conditionnelles permettent de désigner certaines actions à effectuer

uniquement dans certaines circonstances ou de définir des ensembles d'actions destinés à différentes conditions. L'instruction conditionnelle la plus courante est parenthèses. Si le résultat est

true, les lignes de code entre accolades sont exécutées ; dans le cas contraire, elles sont

ignorées. Par exemple :

if (age < 20) { // show special teenager-targeted content }

if. Celle-ci vérifie la valeur ou l'expression placée dans ses

L'instruction if, associée à l'instruction else, vous permet de désigner les actions à effectuer si la condition n'est

true :

pas

+ 737 hidden pages