UTILISATION DES COMPOSANTS ACTIONSCRIPT 3

velodromegoodyearSoftware and s/w Development

Jul 5, 2012 (4 years and 11 months ago)

1,069 views

UTILISATION DES COMPOSANTS
ACTIONSCRIPT

3.0
© 2007 Adobe Systems Incorporated. Tous droits réservés.
Utilisation des composants ActionScript™ 3.0
Si le présent guide est fourni avec un logiciel régi par un contrat d’utilisateur final, ce guide ainsi que le logiciel décrit, sont
fournis sous licence et peuvent être utilisés ou copiés uniquement selon les clauses et conditions de la licence. A moins d’une
autorisation expresse accordée par cette licence, aucune partie du présent guide ne peut être reproduite, stockée dans un système
d’interrogation ou transmise, sous quelque forme ou par quelque moyen que ce soit (électronique, mécanique, par enregistrement
ou autre) sans l’autorisation écrite préalable d’Adobe Systems Incorporated. Veuillez noter que le contenu du présent guide est
protégé par la loi sur les droits d’auteur, même s’il n’est pas distribué avec un logiciel régi par un contrat de licence utilisateur.
Les informations contenues dans le présent guide sont fournies à titre purement informatif; elles sont susceptibles d’être
modifiées sans préavis et ne doivent pas être interprétées comme étant un engagement de la part d’Adobe Systems Incorporated.
Adobe Systems Incorporated n’accepte aucune responsabilité quant aux erreurs ou inexactitudes pouvant être contenues dans le
présent guide.
Veuillez noter que les illustrations et images existantes que vous souhaiterez éventuellement inclure dans votre projet sont
susceptibles d’être protégées par les lois sur les droits d’auteur. L’inclusion non autorisée de tels éléments dans vos nouveaux
travaux peut constituer une violation des droits du propriétaire. Veuillez vous assurer que vous obtenez toute autorisation
nécessaire auprès du détenteur du copyright.
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, le logo Adobe, ActionScript, Flash, Flash Player et Flash Video sont des marques commerciales ou des marques déposées
d’Adobe Systems Incorporated aux Etats-Unis et/ou dans d’autres pays.
Macintosh est une marque commerciale d’Apple Inc., déposée aux Etats-Unis et dans d’autres pays. Windows est une marque
commerciale ou une marque déposée de Microsoft Corporation aux Etats-Unis et/ou dans d’autres pays. Toutes les autres
marques citées appartiennent à leurs propriétaires respectifs.
Ce produit inclut des logiciels développés par Apache Software Foundation (http://www.apache.org/). Technologie MPEG
Layer-3 de compression audio utilisée sous licence de Fraunhofer IIS et Thomson Multimedia (http://www.iis.fhg.de/amm/).
Vous ne pouvez pas utiliser les données audio compressées au format MP3 dans le Logiciel pour les diffusions en temps réel ou en
direct. Si vous devez utiliser un décodeur MP3 pour les diffusions en temps réel ou en direct, l’obtention de cette licence de
technologie MP3 relève de votre responsabilité. Technologie de compression et décompression audio discours utilisée sous licence
de Nellymoser, Inc. (www.nellymoser.com). La vidéo de Flash CS3 est optimisée par la technologie vidéo On2 TrueMotion.
© 1992-2005 On2 Technologies, Inc. Tous droits réservés. http://www.on2.com. Ce produit inclut les logiciels développés par le
groupe OpenSymphony (http://www.opensymphony.com/).
Technologie de compression et décompression vidéo Sorenson Spark™ utilisée sous licence de
Sorenson Media,Inc.
Adobe Systems Incorporated, 345 Park Avenue, San Jose, Californie 95110, Etats-Unis.
A l’attention des utilisateurs du Gouvernement des Etats-Unis. Ce logiciel et sa documentation sont des « articles commerciaux »,
conformément à la définition de ce terme dans le document 48 C.F.R. §2.101, comprenant d’une part un « logiciel informatique
commercial » et d’autre part une « documentation de logiciel informatique commercial », conformément à la définition de ces
termes dans le document 48 C.F.R. §12.212 ou 48 C.F.R. §227.7202, si approprié. Conformément aux documents 48 C.F.R.
§12.212 ou 48 C.F.R. §§227.7202-1 à 227.7202-4, si approprié, le logiciel informatique commercial et la documentation de
logiciel informatique commercial sont accordés sous licence aux tilisateurs du Gouvernement des Etats-Unis (a) uniquement en
tant que produits commerciaux et (b) uniquement avec les droits accordés à tous les autres utilisateurs selon les termes et
conditions mentionnés dans le présent contrat. Droits non publiés réservés dans le cadre des lois sur les droits d’auteur en vigueur
aux Etats-Unis. Adobe Systems Incorporated, 345 Park Avenue, San Jose, CA 95110-2704, Etats-Unis. A l’attention des
utilisateurs du Gouvernement des Etats-Unis, Adobe s’engage à respecter la législation relative à l’égalité des chances y compris, le
cas échéant, les dispositions du décret 11246, tel qu’amendé, à la section 402 de la loi sur l’assistance aux vétérans du Vietnam
(Vietnam Era Veterans Readjustment Assistance Act) de 1974 (38 USC 4212), et à la section 503 de la loi sur la réadaptation
(Rehabilitation Act) de 1973, telle qu’amendée, et la réglementation des articles 41 CFR, alinéas 60-1 à 60-60, 60-250 et 60-741.
La clause relative à l’égalité des chances et les règlements énoncés dans la phrase précédente doivent être compris comme tels
lorsqu’il y est fait référence.
3
Table des matières
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11
Public visé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Configuration système requise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Présentation de la documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Conventions typographiques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Termes employés dans ce manuel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Ressources supplémentaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Chapitre 1:A propos des composants ActionScript 3.0. . . . . . . 15
Avantages des composants. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Types de composants. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Ajout et suppression dans un document. . . . . . . . . . . . . . . . . . . . . . . . . . 21
Suppression d’un composant. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Recherche de la version . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Modèle de gestion des événements ActionScript 3.0. . . . . . . . . . . . . 26
Application simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .27
Conception de l’application. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .27
Création de l’application Greetings . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Exécution des exemples suivants. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Chapitre 2:Utilisation des composants. . . . . . . . . . . . . . . . . . . . .37
Architecture des composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37
Composants ActionScript 3.0 basés sur un fichier FLA. . . . . . . . . 38
Composants basés sur un fichier SWC . . . . . . . . . . . . . . . . . . . . . . . 39
API des composants ActionScript 3.0 . . . . . . . . . . . . . . . . . . . . . . . . 40
Utilisation des fichiers de composants . . . . . . . . . . . . . . . . . . . . . . . . . . .41
Emplacement de stockage des fichiers de composants. . . . . . . . . .41
Emplacement de stockage des fichiers source de composant . . . . .42
Fichiers source de composant et variable Classpath. . . . . . . . . . . . 42
Modification des fichiers de composant. . . . . . . . . . . . . . . . . . . . . . . 43
Débogage des applications de composants . . . . . . . . . . . . . . . . . . . . . 44
Définition des paramètres et des propriétés. . . . . . . . . . . . . . . . . . . . . . 45
Définition de propriétés de composant dans ActionScript. . . . . . . .47
La bibliothèque. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .47
4 Table des matières
Dimensionnement des composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . .49
Aperçu en direct. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .50
Gestion d’événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
Ecouteurs d’événements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
Objet événement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .52
Utilisation de la liste d’affichage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .53
Ajout d’un composant à la liste d’affichage. . . . . . . . . . . . . . . . . . . . .54
Déplacement d’un composant dans la liste d’affichage. . . . . . . . . .55
Suppression d’un composant dans la liste d’affichage. . . . . . . . . . .55
Utilisation de FocusManager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .56
Utilisation des composants basés sur des listes. . . . . . . . . . . . . . . . . . .58
Utilisation d’un fournisseur de données . . . . . . . . . . . . . . . . . . . . . . . . . .59
Création d’un fournisseur de données . . . . . . . . . . . . . . . . . . . . . . . . .60
Utilisation du paramètre dataProvider. . . . . . . . . . . . . . . . . . . . . . .60
Utilisation d’ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .63
Manipulation d’un fournisseur de données . . . . . . . . . . . . . . . . . . . . .66
Utilisation d’un composant CellRenderer. . . . . . . . . . . . . . . . . . . . . . . . .70
Mise en forme des cellules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .70
Définition d’une classe CellRenderer personnalisée. . . . . . . . . . . . . .71
Propriétés CellRenderer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Application d’une classe CellRenderer à une colonne
d’un objet DataGrid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Définition d’une classe CellRenderer pour une
cellule modifiable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Utilisation d’une image, d’un fichier SWF ou d’un clip
en tant que classe CellRenderer. . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Accessibilité des composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Chapitre 3:Utilisation des composants de
l’interface utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Utilisation du composant Button . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .82
Interaction de l’utilisateur avec le bouton. . . . . . . . . . . . . . . . . . . . . . .82
Paramètres du composant Button . . . . . . . . . . . . . . . . . . . . . . . . . . . .83
Création d’une application avec le composant Button. . . . . . . . . . .84
Utilisation du composant CheckBox. . . . . . . . . . . . . . . . . . . . . . . . . . . . .86
Interaction de l’utilisateur avec le composant CheckBox . . . . . . . .86
Paramètres du composant CheckBox. . . . . . . . . . . . . . . . . . . . . . . . . 87
Création d’une application avec le composant CheckBox . . . . . . .88
Utilisation du composant ColorPicker. . . . . . . . . . . . . . . . . . . . . . . . . . . .90
Interaction de l’utilisateur avec le composant ColorPicker . . . . . . .90
Paramètres du composant ColorPicker. . . . . . . . . . . . . . . . . . . . . . . . 91
Création d’une application avec le composant ColorPicker . . . . . .92
Table des matières 5
Utilisation du composant ComboBox . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Interaction de l’utilisateur avec le composant ComboBox . . . . . . . 94
Paramètres du composant ComboBox . . . . . . . . . . . . . . . . . . . . . . . 95
Création d’une application avec le composant ComboBox. . . . . . 95
Utilisation du composant DataGrid. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Interaction de l’utilisateur avec le composant DataGrid . . . . . . . . . 98
Paramètres du composant DataGrid. . . . . . . . . . . . . . . . . . . . . . . . . . 101
Création d’une application avec le composant DataGrid . . . . . . . . 101
Utilisation du composant Label. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .105
Interaction de l’utilisateur avec le composant Label . . . . . . . . . . . .106
Paramètres du composant Label. . . . . . . . . . . . . . . . . . . . . . . . . . . . .106
Création d’une application avec le composant Label . . . . . . . . . . .106
Utilisation du composant List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .108
Interaction de l’utilisateur avec le composant List . . . . . . . . . . . . . .108
Paramètres du composant List. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Création d’une application avec le composant List . . . . . . . . . . . . . 110
Utilisation du composant NumericStepper. . . . . . . . . . . . . . . . . . . . . . . 113
Interaction de l’utilisateur avec le composant
NumericStepper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Paramètres du composant NumericStepper. . . . . . . . . . . . . . . . . . . 115
Création d’une application avec le composant
NumericStepper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Utilisation du composant ProgressBar . . . . . . . . . . . . . . . . . . . . . . . . . . 117
Interaction de l’utilisateur avec le composant ProgressBar. . . . . . 118
Paramètres du composant ProgressBar . . . . . . . . . . . . . . . . . . . . . . 118
Création d’une application avec le composant ProgressBar. . . . . 118
Utilisation du composant RadioButton . . . . . . . . . . . . . . . . . . . . . . . . . .124
Interaction de l’utilisateur avec le composant RadioButton. . . . . .124
Paramètres du composant RadioButton . . . . . . . . . . . . . . . . . . . . . .125
Création d’une application avec le composant RadioButton. . . . .125
Utilisation du composant ScrollPane. . . . . . . . . . . . . . . . . . . . . . . . . . . .128
Interaction de l’utilisateur avec le composant ScrollPane . . . . . . .129
Paramètres du composant ScrollPane. . . . . . . . . . . . . . . . . . . . . . . .130
Création d’une application avec le composant ScrollPane . . . . . .130
Utilisation du composant Slider. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .132
Interaction de l’utilisateur avec le composant Slider . . . . . . . . . . . .132
Paramètres du composant Slider. . . . . . . . . . . . . . . . . . . . . . . . . . . . .133
Création d’une application avec le composant Slider . . . . . . . . . . .133
Utilisation du composant TextArea . . . . . . . . . . . . . . . . . . . . . . . . . . . . .135
Interaction de l’utilisateur avec le composant TextArea . . . . . . . . .136
Paramètres du composant TextArea. . . . . . . . . . . . . . . . . . . . . . . . . .137
Création d’une application avec le composant TextArea . . . . . . . .137
6 Table des matières
Utilisation du composant TextInput. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
Interaction de l’utilisateur avec le composant TextInput . . . . . . . . 140
Paramètres du composant TextInput. . . . . . . . . . . . . . . . . . . . . . . . . 140
Création d’une application avec le composant TextInput . . . . . . . .141
Utilisation du composant TileList. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Interaction de l’utilisateur avec le composant TileList . . . . . . . . . . 144
Paramètres du composant TileList. . . . . . . . . . . . . . . . . . . . . . . . . . . 145
Création d’une application avec le composant TileList . . . . . . . . . 145
Utilisation du composant UILoader. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Interaction de l’utilisateur avec le composant UILoader. . . . . . . . . 147
Paramètres du composant UILoader. . . . . . . . . . . . . . . . . . . . . . . . . 148
Création d’une application avec le composant UILoader . . . . . . . 148
Utilisation du composant UIScrollBar. . . . . . . . . . . . . . . . . . . . . . . . . . . 149
Interaction de l’utilisateur avec le composant UIScrollBar . . . . . . 150
Paramètres du composant UIScrollBar. . . . . . . . . . . . . . . . . . . . . . . 150
Création d’une application avec le composant UIScrollBar . . . . . 150
Chapitre 4:Personnalisation des composants
de l’interface utilisateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .153
A propos de la personnalisation des composants
de l’interface utilisateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
Définition de styles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
Présentation des paramètres de style . . . . . . . . . . . . . . . . . . . . . . . . 155
Accès aux styles par défaut d’un composant . . . . . . . . . . . . . . . . . . 156
Définition et obtention de styles pour l’occurrence
d’un composant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
Utilisation de l’objet TextFormat pour définir
des propriétés de texte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
Définition d’un style pour toutes les occurrences
d’un composant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
Définition d’un style pour tous les composants . . . . . . . . . . . . . . . . 158
A propos des enveloppes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
Création d’une enveloppe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .161
Création d’une enveloppe pour toutes les occurrences. . . . . . . .161
Création d’enveloppes pour certaines occurrences. . . . . . . . . . .161
Personnalisation du composant Button. . . . . . . . . . . . . . . . . . . . . . . . . 163
Utilisation de styles avec le composant Button . . . . . . . . . . . . . . . . 163
Utilisation d’enveloppes avec le composant Button. . . . . . . . . . . . 164
Personnalisation du composant CheckBox . . . . . . . . . . . . . . . . . . . . . 166
Utilisation de styles avec le composant CheckBox. . . . . . . . . . . . . 166
Utilisation d’enveloppes avec le composant CheckBox . . . . . . . . 167
Personnalisation du composant ColorPicker . . . . . . . . . . . . . . . . . . . . 168
Utilisation de styles avec le composant ColorPicker. . . . . . . . . . . . 169
Utilisation d’enveloppes avec le composant ColorPicker . . . . . . . 170
Table des matières 7
Personnalisation du composant ComboBox . . . . . . . . . . . . . . . . . . . . . 171
Utilisation de styles avec le composant ComboBox . . . . . . . . . . . .172
Utilisation d’enveloppes avec le composant ComboBox . . . . . . . .173
Personnalisation du composant DataGrid . . . . . . . . . . . . . . . . . . . . . . .174
Utilisation de styles avec le composant DataGrid. . . . . . . . . . . . . . .174
Définition des styles pour une colonne individuelle. . . . . . . . . . .174
Définition de styles d’en-tête . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
Utilisation d’enveloppes avec le composant DataGrid . . . . . . . . . .178
Personnalisation du composant Label . . . . . . . . . . . . . . . . . . . . . . . . . .180
Utilisation de styles avec le composant Label. . . . . . . . . . . . . . . . . .180
Utilisation d’enveloppes avec le composant Label . . . . . . . . . . . . . 181
Personnalisation du composant List . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
Utilisation de styles avec le composant List . . . . . . . . . . . . . . . . . . . 181
Utilisation d’enveloppes avec le composant List . . . . . . . . . . . . . . .182
Personnalisation du composant NumericStepper . . . . . . . . . . . . . . . .184
Utilisation de styles avec le composant NumericStepper. . . . . . . .185
Utilisation d’enveloppes avec le composant NumericStepper. . . . . 186
Personnalisation du composant ProgressBar. . . . . . . . . . . . . . . . . . . .187
Utilisation de styles avec le composant ProgressBar . . . . . . . . . . .187
Utilisation d’enveloppes avec le composant ProgressBar. . . . . . .188
Personnalisation du composant RadioButton. . . . . . . . . . . . . . . . . . . .189
Utilisation de styles avec le composant RadioButton . . . . . . . . . . .190
Utilisation d’enveloppes avec le composant RadioButton. . . . . . . 191
Personnalisation du composant ScrollPane . . . . . . . . . . . . . . . . . . . . .192
Utilisation de styles avec le composant ScrollPane. . . . . . . . . . . . .193
Utilisation d’enveloppes avec le composant ScrollPane . . . . . . . .193
Personnalisation du composant Slider . . . . . . . . . . . . . . . . . . . . . . . . . .194
Utilisation de styles avec le composant Slider. . . . . . . . . . . . . . . . . .194
Utilisation d’enveloppes avec le composant Slider . . . . . . . . . . . . .194
Personnalisation du composant TextArea . . . . . . . . . . . . . . . . . . . . . . .196
Utilisation de styles avec le composant TextArea . . . . . . . . . . . . . .196
Utilisation d’enveloppes avec le composant TextArea . . . . . . . . . .197
Personnalisation du composant TextInput. . . . . . . . . . . . . . . . . . . . . . .198
Utilisation de styles avec le composant TextInput . . . . . . . . . . . . . .199
Utilisation d’enveloppes avec le composant TextInput. . . . . . . . . .199
Personnalisation du composant TileList. . . . . . . . . . . . . . . . . . . . . . . .200
Utilisation de styles avec le composant TileList . . . . . . . . . . . . . . . .201
Utilisation d’enveloppes avec le composant TileList. . . . . . . . . . . 202
Personnalisation du composant UILoader . . . . . . . . . . . . . . . . . . . . . . 203
Personnalisation du composant UIScrollBar. . . . . . . . . . . . . . . . . . . . 204
Utilisation de styles avec le composant UIScrollBar . . . . . . . . . . . 204
Utilisation d’enveloppes avec le composant UIScrollBar. . . . . . . 205
8 Table des matières
Chapitre 5:Utilisation du composant FLVPlayback . . . . . . . . 207
Utilisation du composant FLVPlayback. . . . . . . . . . . . . . . . . . . . . . . . 208
Création d’une application avec le composant FLVPlayback. . . . 210
Paramètres du composant FLVPlayback . . . . . . . . . . . . . . . . . . . . . 214
Définition du paramètre source. . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
Utilisation de l’aperçu en direct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
Prise en charge du plein écran. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
Alignement de la disposition pour lire plusieurs fichiers FLV . . . . 218
Lecture automatique des fichiers FLV téléchargés
progressivement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
Utilisation des points de repère . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
Utilisation de la boîte de dialogue Points de repère
des vidéos Flash. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
Utilisation d’ActionScript avec des points de repère . . . . . . . . .223
Ajout de points de repère ActionScript. . . . . . . . . . . . . . . . . . . . .223
Ecoute des événements cuePoint . . . . . . . . . . . . . . . . . . . . . . . . .224
Recherche de points de repère. . . . . . . . . . . . . . . . . . . . . . . . . . . .224
Recherche de points de repère de navigation. . . . . . . . . . . . . . .225
Activation et désactivation des points de repère
intégrés au fichier FLV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .226
Suppression d’un point de repère ActionScript. . . . . . . . . . . . . .227
Lecture de plusieurs fichiers FLV . . . . . . . . . . . . . . . . . . . . . . . . . . . .227
Utilisation de plusieurs lecteurs vidéo . . . . . . . . . . . . . . . . . . . . . .228
Lecture de fichiers FLV en continu à partir de
Flash Media Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
Détection de la bande passante native ou absence
de détection de la bande passante . . . . . . . . . . . . . . . . . . . . . . 231
Détection de la bande passante non native . . . . . . . . . . . . . . . . . 231
Personnalisation du composant FLVPlayback. . . . . . . . . . . . . . . . . . .232
Sélection d’une enveloppe prédéfinie . . . . . . . . . . . . . . . . . . . . . . . .233
Application d’enveloppe aux composants particuliers
de l’interface utilisateur personnalisée Lecture
de fichiers FLV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .235
Composants Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .235
Composant BufferingBar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .237
Composants SeekBar et VolumeBar. . . . . . . . . . . . . . . . . . . . . . .237
Connexion aux composants de l’interface utilisateur
personnalisée Lecture de fichiers FLV. . . . . . . . . . . . . . . . . . 240
Création d’une enveloppe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .243
Utilisation de la disposition d’enveloppe. . . . . . . . . . . . . . . . . . . 244
Barre de mise en mémoire tampon . . . . . . . . . . . . . . . . . . . . . . . .247
Barre de recherche et barre de volume. . . . . . . . . . . . . . . . . . . . .247
Clips d’arrière-plan et de premier plan. . . . . . . . . . . . . . . . . . . . . 249
Modification du comportement d’enveloppe . . . . . . . . . . . . . . . . . 250
Table des matières 9
Utilisation d’un fichier SMIL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
<smil> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
<head> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
<meta> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
<layout> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
<root-layout>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
<body> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
<video>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
<ref> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
<switch>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
Chapitre 6:Utilisation du composant
FLVPlaybackCaptioning. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .261
Utilisation du composant FLVPlaybackCaptioning . . . . . . . . . . . . . . 262
Ajout de sous-titrage au composant FLVPlayback . . . . . . . . . . . . 262
Définition des paramètres du composant
FLVPlaybackCaptioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264
Définition du paramètre source . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
Affichage des légendes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
Utilisation des légendes Timed Text . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
Utilisation des points de repère avec le sous-titrage . . . . . . . . . . . . . 267
Présentation des normes des points de repère
du composant FLVPlaybackCaptioning . . . . . . . . . . . . . . . . . 267
Présentation de la création du sous-titrage pour
les points de repère d’événement intégrés. . . . . . . . . . . . . . . 268
Prise en charge de plusieurs pistes de langue avec
des points de repère intégrés. . . . . . . . . . . . . . . . . . . . . . . . . . . 270
Lecture de plusieurs fichiers FLV avec le sous-titrage . . . . . . . . . . . .271
Personnalisation du composant FLVPlaybackCaptioning . . . . . . . . .271
Annexe A:Balises Timed Text . . . . . . . . . . . . . . . . . . . . . . . . . . 275
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .281
10 Table des matières
11
Introduction
Adobe® Flash® CS3 Professional est l’outil de programmation standard pour la création de
contenu Web percutant. La création de ces applications Internet enrichies repose sur des
unités élémentaires appelées composants. Un composant est un clip qui contient des
paramètres permettant de personnaliser le composant pendant la phase de programmation
dans Flash ou lors de l’exécution à l’aide des méthodes, des propriétés et des événements
ActionScript™. Les composants sont conçus pour permettre aux développeurs de réutiliser et
de partager du code. Ils permettent également d’encapsuler une fonctionnalité complexe que
les concepteurs peuvent utiliser et personnaliser sans avoir à se servir d’ActionScript.
Les composants vous permettent de créer facilement et rapidement des applications robustes à
la présentation et au comportement cohérents. Ce manuel explique comment créer des
applications avec les composants ActionScript 3.0. Le manuel intitulé Guide de référence du
langage et des composants ActionScript 3.0 décrit tous les composants, ainsi que l’interface de
programmation (API) de chacun d’entre eux.
Vous pouvez utiliser les composants créés par Adobe, télécharger des composants créés par
d’autres développeurs ou créer vos propres composants.
Ce chapitre contient les sections suivantes:
Public visé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Configuration système requise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Présentation de la documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Conventions typographiques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Termes employés dans ce manuel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Ressources supplémentaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
12 Introduction
Public visé
Ce manuel est destiné aux développeurs qui créent des applications Flash et qui souhaitent
exploiter des composants pour accélérer le développement. Il demande des notions de
développement d’applications dans Flash et d’écriture de code ActionScript.
Si vous avez peu d’expérience en écriture de code ActionScript, vous pouvez ajouter des
composants à un document, définir leurs paramètres dans l’Inspecteur des propriétés ou dans
l’Inspecteur des composants, puis gérer leurs événements via le panneau Comportements.
Par exemple, sans écrire aucun code ActionScript, vous pouvez affecter un comportement
Atteindre la page Web à un composant Button pour qu’une adresse URL s’ouvre dans un
navigateur Web lorsque l’utilisateur clique sur ce bouton.
Si vous êtes programmeur et que vous souhaitez créer des applications plus robustes, vous
pouvez créer les composants dynamiquement, utiliser ActionScript pour définir les propriétés
et appeler les méthodes à l’exécution. Vous pouvez également exploiter le modèle d’événement
écouteur pour gérer les événements.
Pour plus d’informations, consultez le Chapitre 2, « Utilisation des composants », à la
page 37.
Configuration système requise
Aucune configuration particulière n’est requise pour les composants Flash outre Flash.
Tout fichier SWF qui utilise les composants Flash CS3 doit être affiché avec Adobe® Flash®
Player 9.0.28.0 ou une version ultérieure et doit être publié pour ActionScript 3.0 (vous
pouvez définir ceci dans Fichier > Paramètres de publication, sous l’onglet Flash).
Présentation de la documentation
Ce document explique comment utiliser les composants pour développer des applications
Flash. Il présume que vous connaissez déjà Flash et ActionScript 3.0. La documentation
spécifique à Flash et aux produits apparentés est disponible séparément.
Ce document est disponible sous forme de fichier PDF et d’aide en ligne. Pour afficher l’aide
en ligne, lancez Flash et choisissez Aide > Aide de Flash > Utilisation des composants
ActionScript 3.0.
Pour plus d’informations sur Flash, consultez les documents suivants:

Utilisation de Flash

Programmation d’ActionScript 3.0

Guide de référence du langage et des composants ActionScript 3.0
Ressources supplémentaires 13
Conventions typographiques
Ce manuel utilise les conventions typographiques suivantes:

La police en italique indique une valeur qui devrait être remplacée (par exemple, dans le
chemin d’un dossier).

La police de code
indentifie le code ActionScript, y compris les noms de méthode et de
propriété.

La police de code en italique
désigne un élément de code à remplacer (par exemple,
un paramètre ActionScript).

La police en gras désigne une valeur à saisir.
Termes employés dans ce manuel
Ce manuel emploie les termes suivants:
à l’exécution
Lorsque le code est exécuté dans Flash Player.
pendant la programmation
Lors du travail exécuté dans l’environnement auteur de Flash.
Ressources supplémentaires
Outre le contenu de ces manuels, Adobe fournit des articles mis à jour régulièrement, des
idées de conception et des exemples dans le Centre des développeurs Adobe et dans le Centre
de conception Adobe.
Vous trouverez d’autres exemples de composants à l’adresse
www.adobe.com/go/learn_fl_samples_fr.
Centre des développeurs Adobe
Le Centre des développeurs Adobe est votre ressource d’accès 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. Le Centre des développeurs est accessible à
l’adresse www.adobe.com/go/flash_devcenter_fr.
14 Introduction
Centre de conception Adobe
Accédez aux informations les plus récentes en matière de conception numérique et
d’animations. Recherchez les travaux effectués par les artistes éminents, découvrez les
nouvelles tendances en matière de conception et améliorez vos compétences grâce aux
didacticiels, aux flux de travail fondamentaux et aux 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. Le Centre de conception est accessible à l’adresse
www.adobe.com/go/fl_designcenter_fr.
15
1
CHAPITRE 1
A propos des composants
ActionScript 3.0
Les composants Adobe® Flash® CS3 Professional sont des clips vidéo dont les paramètres vous
permettent de modifier l’apparence et le comportement. Un composant peut être une simple
commande d’interface utilisateur, tel qu’un bouton radio ou une case à cocher, ou peut
contenir du contenu, tel qu’un objet List ou DataGrid.
Les composants vous permettent de créer facilement et rapidement des applications Flash
robustes à la présentation et au comportement cohérents. Plutôt que de créer vos propres
boutons, listes et zones déroulantes, vous pouvez utiliser les composants Flash qui
implémentent ces commandes. Il vous suffit de les faire glisser du panneau Composants dans
le document de votre application. Vous pouvez également personnaliser facilement l’aspect de
ces composants pour les adapter à votre application.
Même si vous pouvez effectuer toutes ces opérations sans pour autant maîtriser ActionScript,
vous pouvez également utiliser ActionScript 3.0 pour modifier le comportement d’un
composant ou implémenter un nouveau comportement. Chaque composant possède un jeu
unique de méthodes, de propriétés et d’événements ActionScript constituant son interface de
programmation (API). L’API vous permet de créer et de manipuler des composants lorsque
l’application s’exécute.
L’API vous permet également de créer vos propres composants personalisés. Vous pouvez
télécharger des composants développés par des membres de la communauté Flash sur le site
Adobe Exchange à l’adresse http://www.adobe.com/go/flash_exchange_fr. Pour plus
d’informations sur la création d’un composant, consultez le site
www.adobe.com/go/learn_fl_creating_components_fr.
16 A propos des composants ActionScript 3.0
L’architecture des composants d’ActionScript 3.0 inclut des classes sur lesquelles sont basés
tous les composants, des enveloppes et des styles qui vous permettent de personaliser l’aspect
des composants, un modèle de gestion des événements, la gestion du focus, une interface
d’accessibilité et bien plus encore.
Pour obtenir une liste complète des composants Flash ActionScript 3.0, reportez-vous à
« Types de composants », à la page 18.
Ce chapitre contient les sections suivantes:
Avantages des composants. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Types de composants. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Ajout et suppression dans un document. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Recherche de la version . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .24
Modèle de gestion des événements ActionScript 3.0. . . . . . . . . . . . . . . . . . . . . . . . .26
Application simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Avantages des composants
Les composants vous permettent de séparer le processus de conception de votre application du
processus de codage. Ils permettent aux développeurs de créer des fonctionnalités que les
concepteurs pourront exploiter dans les applications. Les développeurs peuvent encapsuler les
fonctionnalités fréquemment utilisées dans des composants. Les concepteurs peuvent, quant à
eux, personnaliser la taille, l’emplacement et le comportement de ces composants en
modifiant leurs paramètres. Ils peuvent également changer l’apparence d’un composant en
modifiant ses éléments graphiques ou enveloppes.
Les composants partagent les mêmes fonctionnalités de base: styles, enveloppes et gestion du
focus. Lorsque vous ajoutez le premier composant dans une application, ces fonctionnalités de
base représentent environ 20 Ko de la taille. Lorsque vous ajoutez d’autres composants, cette
allocation de mémoire initiale est partagée par les composants ajoutés, réduisant ainsi la
croissance de la taille de votre application.
REMARQUE
Adobe Flash CS3 inclut les composants ActionScript 2.0 et les composants
ActionScript 3.0. Vous ne pouvez pas mélanger ces deux ensembles de composants.
Vous devez utiliser un ensemble ou l’autre pour une application donnée. Flash CS3
intègre les composants ActionScript 2.0 ou les composants ActionScript 3.0 selon que
vous ouvrez un fichier ActionScript 2.0 ou un fichier ActionScript 3.0. Lorsque vous
créez un nouveau document Flash CS3, vous devez spécifier un fichier Flash
(ActionScript 3.0) ou un fichier Flash (ActionScript 2.0). Lorsque vous ouvrez un
document existant, Flash examine les paramètres de publication afin de déterminer quel
ensemble de composants utiliser. Pour plus d’informations sur les composants
ActionScript 2.0, consultez Utilisation des composants ActionScript 2.0.
Avantages des composants 17
Cette section présente les principaux avantages des composants ActionScript 3.0.
La puissance d’ActionScript 3.0
offre un langage de programmation orienté objet puissant
qui constitue une étape importante de l’évolution des fonctionnalités de Flash Player.
Le langage est conçu pour créer des applications Internet enrichies sur une base de code
réutilisable. ActionScript 3.0 repose sur ECMAScript, le langage de script international
normalisé. Il est conforme à la spécification du langage ECMAScript (ECMA-262), 3ème
édition. Vous trouverez une présentation complète d’ActionScript 3.0 dans le guide
Programmation d’ActionScript 3.0. Pour obtenir des informations de référence sur le langage,
consultez le Guide de référence du langage et des composants ActionScript 3.0.
Les composants de l’interface utilisateur basés sur un fichier FLA
permettent d’accéder
facilement aux enveloppes afin de les personnaliser aisément au cours de la programmation.
Ces composants fournissent également des styles, notamment des styles d’enveloppe, qui vous
permettent de personnaliser l’aspect des composants et de charger des enveloppes lors de
l’exécution. Pour plus d’informations, consultez le Chapitre 4, « Personnalisation des
composants de l’interface utilisateur », à la page 153 et le Guide de référence du langage et des
composants ActionScript 3.0.
Le nouveau composant FVLPlayback ajoute le composant FLVPlaybackCaptioning
et
intègre la prise en charge plein écran, l’aperçu en direct amélioré, des enveloppes qui vous
permettent d’ajouter des paramètres de couleur et alpha, ainsi que des fonctionnalités de
téléchargement et de mise en forme de fichiers FLV améliorées.
L’Inspecteur des propriétés et l’Inspecteur des composants
vous permettent de modifier
les paramètres des composants au cours de la programmation dans Flash. Pour plus
d’informations, consultez les sections « Ajout et suppression dans un document », à la page 21
et « Définition des paramètres et des propriétés », à la page 45.
La nouvelle boîte de dialogue de collection
des composants ComboBox, List et TileList
vous permet de renseigner leur propriété
dataProvider
via l’interface utilisateur. Pour plus
d’informations, consultez la section « Création d’un fournisseur de données », à la page 60.
Le modèle d’événements ActionScript 3.0
permet à votre application d’écouter des
événements et d’appeler des gestionnaires d’événements pour y répondre. Pour plus
d’informations, consultez les sections « Modèle de gestion des événements ActionScript 3.0 »,
à la page 26 et « Gestion d’événements », à la page 51.
Les classes Manager
fournissent un moyen aisé de traiter le focus et de gérer les styles dans
une application. Pour plus d’informations, consultez le Guide de référence du langage et des
composants ActionScript 3.0.
18 A propos des composants ActionScript 3.0
La classe de base UIComponent
fournit les méthodes, les propriétés et les événements
élémentaires aux composants qui l’étendent. Tous les composants de l’interface utilisateur
ActionScript 3.0 héritent de la classe UIComponent. Pour plus d’informations, consultez la
classe UIComponent du Guide de référence du langage et des composants ActionScript 3.0.
L’utilisation d’un fichier SWC
dans les composants basés sur un fichier FLA de l’interface
utilisateur fournit des définitions ActionScript comme un actif faisant partie intégrante du
scénario du composant afin d’accélérer la compilation.
Une hiérarchie des classes facilement extensible
avec ActionScript 3.0 permet de créer des
espaces de nom uniques et d’importer des classes si nécessaire et des sous-classes afin d’étendre
les fonctionnalités des composants. Pour plus d’informations, consultez le Guide de référence
du langage et des composants ActionScript 3.0.
Types de composants
L’installation des composants Flash s’effectue lors de l’installation de Flash CS3.
Les composants ActionScript 3.0 incluent les composants de l’interface utilisateur suivants:
REMARQUE
Flash CS3 prend en charge à la fois les composants basés sur un fichier FLA et SWC.
Pour plus d’informations, consultez la section « Architecture des composants », à
la page 37.
Composants de l’interface utilisateur
Button List TextArea
CheckBox NumericStepper TextInput
ColorPicker RadioButton TileList
ComboBox ProgressBar UILoader
DataGrid ScrollPane UIScrollBar
Label Slider
Types de composants 19
Outre les composants de l’interface utilisateur, les composants Flash ActionScript 3.0 incluent
les composants et les classes de prise en charge suivants:

Le composant FLVPlayback (fl.video.FLVPlayback), qui est un composant basé sur un
fichier SWC.
Le composant FLVPlayback vous permet d’inclure un lecteur vidéo dans votre application
Flash afin de lire de la vidéo progressive en continu sur HTTP depuis un service FVSS
(Adobe® Flash® Video Streaming Service - service de diffusion en continu des vidéos de
Flash) ou FMS (Macromedia® Flash® Media Server) de Adobe. Pour plus d’informations,
consultez le Chapitre 5, « Utilisation du composant FLVPlayback », à la page 207.

Les composants de l’interface utilisateur personnalisée FLVPlayback, basés sur un fichier
FLA et compatibles avec les versions ActionScript 2.0 et ActionScript 3.0 du composant
FLVPlayback. Pour plus d’informations, consultez le Chapitre 5, « Utilisation du
composant FLVPlayback », à la page 207.

Le composant de sous-titrage FLVPlayback, permettant de créer le sous-titrage fermé pour
FLVPlayback. Chapitre 6, « Utilisation du composant FLVPlaybackCaptioning », à la
page 261
Pour obtenir une liste complète des classes de composant ActionScript 3.0 et de leurs classes
de prise en charge, consultez le Guide de référence du langage et des composants ActionScript 3.0.
Pour afficher les composants Flash:
Vous pouvez afficher les composants Flash ActionScript 3.0 dans le panneau Composants en
effectuant les étapes suivantes.
1.
Démarrez Flash.
2.
Créez un nouveau fichier Flash (ActionScript 3.0) ou ouvrez un document Flash existant
dans lequel les paramètres de publication spécifient ActionScript 3.0.
20 A propos des composants ActionScript 3.0
3.
Choisissez Fenêtre > Composants pour ouvrir le panneau Composants s’il n’est pas déjà
visible.
Panneau Composants incluant les composants de l’interface utilisateur et vidéo
Les composants de l’interface utilisateur et vidéo sont affichés séparément pour
économiser de l’espace. Le panneau Composants contient tous les composants affichés.
Vous pouvez également télécharger des composants supplémentaires depuis le site Adobe
Exchange à l’adresse http://www.adobe.com/go/flash_exchange_fr. Pour installer des
composants téléchargés à partir du site Exchange, téléchargez et installez Adobe® Extension
Manager à l’adresse http://www.adobe.com/go/exchange_fr. Cliquez sur le lien Accueil Adobe
Exchange et recherchez le lien Extension Manager.
Tous les composants doivent apparaître dans le panneau Composants de Flash. Pour installer
les composants sur un ordinateur Windows® ou Macintosh®, respectez la procédure suivante.
Ajout et suppression dans un document 21
Pour installer des composants sur un ordinateur Windows ou Macintosh:
1.
Fermez Flash.
2.
Placez le fichier SWC ou FLA contenant le composant dans le dossier suivant de votre
disque dur:

Sous Windows:
C:\Program Files\Adobe\Flash CS3\langue\Configuration\Components

Sous Macintosh:
DD Macintosh:Applications:Adobe Flash CS3:Configuration:Components
3.
Démarrez Flash.
4.
Choisissez Fenêtre > Composants pour visualiser le composant dans le panneau
Composants s’il n’est pas déjà ouvert.
Pour plus d’informations sur les fichiers de composant, consultez la section « Utilisation des
fichiers de composants », à la page 41
Ajout et suppression dans un document
Lorsque vous faites glisser un composant basé sur un fichier FLA depuis le panneau
Composants vers la scène, Flash importe un clip modifiable dans la bibliothèque. Lorsque
vous faites glisser un composant basé sur un fichier SWC sur la scène, Flash importe un clip
compilé dans la bibliothèque. Une fois le composant importé dans la bibliothèque, vous
pouvez faire glisser ses occurrences sur la scène depuis le panneau Bibliothèque ou le panneau
Composants.
Ajout d’un composant pendant la programmation
Vous pouvez ajouter un composant à un document en le faisant glisser depuis le panneau
Composants. Vous pouvez définir les propriétés de chaque occurrence d’un composant dans
l’onglet Paramètres de l’Inspecteur des propriétés ou de l’Inspecteur des composants.
Pour ajouter un composant à un document Flash via le panneau Composants:
1.
Choisissez Fenêtre> Composants.
2.
Dans le panneau Composants, double-cliquez sur le composant ou faites-le glisser sur la
scène.
3.
Sélectionnez le composant sur la scène.
4.
Si l’Inspecteur des propriétés n’est pas visible, sélectionnez Fenêtre > Propriétés >
Propriétés.
22 A propos des composants ActionScript 3.0
5.
Dans l’Inspecteur des propriétés, nommez l’occurrence de composant.
6.
Cliquez sur l’onglet Paramètres et définissez les paramètres de l’occurrence.
L’illustration suivante présente l’Inspecteur des propriétés pour un composant Button.
Paramètres du composant dans l’Inspecteur des propriétés
Pour plus d’informations, consultez la section « Définition des paramètres et des
propriétés », à la page 45.
7.
Changez la taille du composant comme vous le souhaitez en modifiant les valeurs de la
largeur (L:) et de la hauteur (H:).
Pour plus d’informations sur le dimensionnement des types spécifiques de composants,
consultez le Chapitre 4, « Personnalisation des composants de l’interface utilisateur », à la
page 153.
8.
Choisissez Contrôle > Tester l’animation ou appuyez sur Ctrl+Entrée pour compiler le
document et afficher les résultats de vos paramètres.
Vous pouvez également modifier la couleur et la mise en forme du texte d’un composant en
définissant ses propriétés de style ou en personnalisant son apparence en modifiant les
enveloppes du composant. Pour plus d’informations sur ces rubriques, consultez le
Chapitre 4, « Personnalisation des composants de l’interface utilisateur », à la page 153.
Lorsque vous faites glisser un composant sur la scène au cours de la programmation, il suffit
de l’appeler par le nom de son occurrence pour y faire référence (par exemple,
myButton
).
Ajout et suppression dans un document 23
Ajout de composants à l’exécution avec ActionScript
Pour ajouter un composant à un document à l’exécution avec ActionScript, le composant doit
d’abord se trouver dans la bibliothèque de l’application (Fenêtre > Bibliothèque) lorsque le
fichier SWF est compilé. Pour ajouter un composant à la bibliothèque, faites-le glisser du
panneau Composants vers le panneau Bibliothèque. Pour plus d’informations sur la
bibliothèque, consultez la section « La bibliothèque », à la page 47.
Vous devez également importer le fichier de classe du composant afin que son API soit
disponible pour votre application. Les fichiers de classe de composant sont installés dans des
paquets contenant une ou plusieurs classes. Pour importer une classe de composant, utilisez
l’instruction
import
et spécifiez le nom de paquet et le nom de classe. Par exemple, vous
pouvez importer la classe Button à l’aide de l’instruction
import
suivante:
import fl.controls.Button;
Pour savoir dans quel paquet se trouve un composant, consultez le Guide de référence du
langage et des composants ActionScript 3.0. Pour plus d’informations sur l’emplacement des
fichiers source de composant, consultez la section « Utilisation des fichiers de composants », à
la page 41.
Pour créer une occurrence du composant, vous devez appeler la méthode constructeur
ActionScript du composant. Par exemple, l’instruction suivante crée une occurrence d’un
composant Button appelée
aButton
:
var aButton:Button = new Button();
La dernière étape consiste à appeler la méthode statique
addChild()
pour ajouter
l’occurrence du composant sur la scène ou dans le conteneur de l’application. Par exemple,
l’instruction suivante ajoute l’occurrence
aButton
:
addChild(aButton);
A ce stade, vous pouvez utiliser l’API du composant pour spécifier de façon dynamique la
taille et la position du composant sur la scène, écouter des événements et définir des propriétés
pour modifier son comportement. Pour plus d’informations sur l’API d’un composant
particulier, consultez le Guide de référence du langage et des composants ActionScript 3.0.
Pour plus d’informations sur la méthode
addChild()
, consultez la section « Utilisation de la
liste d’affichage », à la page 53.
24 A propos des composants ActionScript 3.0
Suppression d’un composant
Pour supprimer une occurrence de composant dans la scène au cours de la programmation, il
vous suffit de la sélectionner et d’appuyer sur la touche Suppr. Vous supprimerez ainsi
l’occurrence de la scène; en revanche, le composant se trouve toujours dans votre application.
Pour supprimer un composant dans votre document Flash après l’avoir placé sur la scène ou
dans la bibliothèque, vous devez le supprimer, ainsi que les actifs qui lui sont associés, de la
bibliothèque. Supprimer le composant de la scène ne suffit pas. Si vous ne le supprimez pas de
la bibliothèque, il sera inclus à votre application lors de la compilation.
Pour supprimer un composant d’un document:
1.
Dans le panneau Bibliothèque, sélectionnez le symbole du composant.
2.
Cliquez sur le bouton Supprimer en bas du panneau Bibliothèque ou choisissez Supprimer
dans le menu du panneau Bibliothèque.
Répétez ces étapes pour supprimer les actifs associés au composant.
Pour plus d’informations sur la suppression d’un composant de son conteneur lors de
l’exécution de votre application, consultez la section « Suppression d’un composant dans la
liste d’affichage », à la page 55.
Recherche de la version
Les composants Flash ActionScript 3.0 possèdent une propriété version que vous pouvez
afficher si vous devez la fournir au support technique d’Adobe ou si vous devez connaître la
version du composant que vous utilisez.
Pour afficher le numéro de version d’un composant de l’interface utilisateur:
1.
Créez un nouveau document de fichier Flash (ActionScript 3.0).
2.
Faites glisser le composant sur la scène et attribuez-lui un nom d’occurrence. Par exemple,
faites glisser un composant ComboBox dénommé aCb sur la scène.
3.
Appuyez sur la touche F9 ou choisissez Fenêtre > Actions pour ouvrir le panneau Actions.
4.
Cliquez sur l’image 1 du scénario principal et ajoutez le code suivant dans le panneau
Actions.
trace(aCb.version);
Recherche de la version 25
Le numéro de version, similaire à celui de l’illustration suivante, doit apparaître dans le
panneau Sortie.
.
Pour les composants FLVPlayback et FLVPlaybackCaptioning, vous devez vous référer au
nom de la classe plutôt qu’au nom de l’occurrence car le numéro de version est stocké dans
une constante de classe.
Pour afficher le numéro de version des composants FLVPlayback et
FLVPlaybackCaptioning:
1.
Créez un nouveau document de fichier Flash (ActionScript 3.0).
2.
Faites glisser les composants FLVPlayback et FLVPlaybackCaptioning dans le panneau
Bibliothèque.
3.
Appuyez sur la touche F9 ou choisissez Fenêtre > Actions pour ouvrir le panneau Actions.
4.
Cliquez sur l’image 1 du scénario principal et ajoutez le code suivant dans le panneau
Actions.
import fl.video.*;
trace("FLVPlayback.VERSION: " + FLVPlayback.VERSION);
trace("FLVPLaybackCaptioning.VERSION: " +
FLVPlaybackCaptioning.VERSION);
Les numéros de version, similaires à ceux de l’illustration suivante, doivent apparaître dans
le panneau Sortie.
.
Numéros de version de FLVPlayback et FLVPlaybackCaptioning
26 A propos des composants ActionScript 3.0
Modèle de gestion des événements
ActionScript 3.0
ActionScript 3.0 intègre un modèle de gestion des événements unique qui remplace les
différents mécanismes de gestion des événements qui existaient dans les versions précédentes
d’ActionScript. Le nouveau modèle d’événements repose sur la spécification d’événements de
niveau 3 DOM (Document Object Model).
Pour les développeurs habitués à utiliser la méthode
addListener()
ActionScript 2.0, il peut
s’avérer judicieux de souligner les différences qui existent entre le modèle d’écouteur
d’événement ActionScript 2.0 et le modèle d’événement ActionScript 3.0. La liste suivante
décrit les principales différences entre les deux modèles d’événement:

Pour ajouter des écouteurs d’événements dans ActionScript 2.0, vous utilisez la méthode
addListener()
dans certains cas et la méthode
addEventListener()
dans d’autres; en
revanche, dans ActionScript 3.0, vous utilisez la méthode
addEventListener()
dans tous
les cas.

Il n’existe pas de flux d’événements dans ActionScript 2.0, ce qui signifie que la méthode
addListener()
peut être appelée uniquement sur l’objet qui diffuse l’événement; en
revanche, dans ActionScript 3.0, la méthode
addEventListener()
peut être appelée sur
tous les objets qui font partie du flux d’événements.

Dans ActionScript 2.0, les écouteurs d’événements peuvent être des fonctions, des
méthodes ou des objets; en revanche, dans ActionScript 3.0, seules les fonctions ou les
méthodes peuvent faire office d’écouteurs d’événements.

La syntaxe
on(
event
)
n’est plus prise en charge dans ActionScript 3.0; par conséquent,
vous ne pouvez pas lier du code d’événement ActionScript à un clip. Vous pouvez
uniquement utiliser la méthode
addEventListener()
pour ajouter un écouteur
d’événements.
L’exemple suivant, qui écoute un événement
MouseEvent.CLICK
sur un composant Button
appelé
aButton
, illustre le modèle de gestion des événements ActionScript 3.0 de base:
aButton.addEventListener(MouseEvent.CLICK, clickHandler);
function clickHandler(event:MouseEvent):void {
trace("clickHandler detected an event of type: " + event.type);
trace("the event occurred on: " + event.target.name);
}
Pour plus d’informations sur la gestion des événements ActionScript 3.0, consultez le guide
Programmation d’ActionScript 3.0. Pour plus d’informations sur la gestion des événements
ActionScript 3.0 des composants, consultez la section « Gestion d’événements », à la page 51.
Application simple 27
Application simple
Cette section vous indique les étapes à suivre pour créer une application ActionScript 3.0
simple à l’aide des composants Flash et de l’outil de programmation Flash. L’exemple est
fourni en tant que fichier FLA dont le code ActionScript est inclus sur le scénario et en tant
que fichier de classe ActionScript externe incluant un fichier FLA qui contient uniquement les
composants de la bibliothèque. En règle générale, vous avez recours aux fichiers de classe
externes pour développer des applications volumineuses; ces fichiers vous permettent en effet
de partager du code entre les classes et les applications, et facilitent la mise à jour de vos
applications. Pour plus d’informations sur la programmation avec ActionScript 3.0, consultez
le guide Programmation d’ActionScript 3.0.
Conception de l’application
Notre premier exemple d’application de composant ActionScript est une variante de
l’application standard « Hello World » par conséquent, sa conception est relativement simple:

L’application sera appelée Greetings.

Elle utilise un composant TextArea pour afficher un message de bienvenue, initialement
Hello World.

Elle utilise un composant ColorPicker qui vous permet de modifier la couleur du texte.

Elle utilise trois composants RadioButton qui vous permettent de définir la taille du texte
sur Petite, Grande ou Maximale.

Elle utilise un composant ComboBox qui vous permet de sélectionner un message de
bienvenue différent dans une liste déroulante.

L’application utilise les composants du panneau Composants et crée également des
éléments d’application via le code ActionScript.
Après avoir établi cette définition, vous pouvez commencer à créer l’application.
28 A propos des composants ActionScript 3.0
Création de l’application Greetings
Les instructions fournies aux étapes suivantes permettent de créer l’application Greetings à
l’aide de l’outil de programmation Flash pour créer un fichier FLA, placer des composants sur
la scène et ajouter du code ActionScript au scénario.
Pour créer l’application Greetings dans un fichier FLA:
1.
Sélectionnez Fichier > Nouveau.
2.
Dans la boîte de dialogue Nouveau document, sélectionnez Fichier Flash
(ActionScript 3.0) et cliquez sur OK.
Une nouvelle fenêtre Flash s’ouvre.
3.
Choisissez Fichier > Enregistrer, nommez le fichier Flash Greetings.fla, puis cliquez sur le
bouton Enregistrer.
4.
Dans le panneau Composants Flash, sélectionnez un composant TextArea et faites-le glisser
sur la scène.
5.
Dans la fenêtre Propriétés, après avoir sélectionné le composant TextArea sur la scène, tapez
aTa

pour le nom d’occurrence et entrez les informations suivantes:

Entrez 230 pour la valeur W (largeur).

Entrez 44 pour la valeur H (hauteur).

Entrez 165 pour la valeur X (position horizontale).

Entrez 57 pour la valeur Y (position verticale).

Entrez Hello World! pour le paramètre texte, dans l’onglet Paramètres.
6.
Faites glisser un composant ColorPicker sur la scène, placez-le à gauche du composant
TextArea et donnez-lui le nom d’occurrence txtCp. Entrez les informations suivantes dans
l’Inspecteur des propriétés:

Entrez 96 pour la valeur X.

Entrez 72 pour la valeur Y.
7.
Faites glisser trois composants RadioButton sur la scène, l’un après l’autre, et donnez-leur
les noms d’occurrence smallRb, largerRb et largestRb. Entrez les informations suivantes
les concernant dans l’Inspecteur des propriétés:

Entrez 100 pour la valeur W et 22 pour la valeur H de chacun d’entre eux.

Entrez 155 pour la valeur X.

Entrez 120 pour la valeur Y de smallRb, 148 pour largerRb et 175 pour largestRb.

Entrez fontRbGrp pour le paramètre groupName de chacun d’entre eux.

Entrez leurs étiquettes sur l’onglet Paramètres de Petite, Grande, Maximale.
Application simple 29
8.
Faites glisser un composant ComboBox sur la scène et nommez son occurrence msgCb.
Entrez les informations suivantes le concernant dans l’Inspecteur des propriétés:

Entrez 130 pour la valeur W.

Entrez 265 pour la valeur X.

Entrez 120 pour la valeur Y.

Dans l’onglet Paramètres, entrez Greetings pour le paramètre d’invite.

Double-cliquez sur le champ texte du paramètre dataProvider pour ouvrir la boîte de
dialogue Valeurs.

Cliquez sur le signe plus et remplacez la valeur de l’étiquette par Hello World!

Répétez l’étape précédente pour ajouter les valeurs de l’étiquette Have a nice day! et
Top of the Morning!

Cliquez sur OK pour fermer la boîte de dialogue Valeurs.
9.
Enregistrez le fichier.
10.
S’il n’est pas déjà ouvert, ouvrez le panneau Actions en appuyant sur F9 ou en sélectionnant
Actions dans le menu Fenêtre. Cliquez sur l’image 1 du scénario principal et entrez le code
suivant dans le panneau Actions:
import flash.events.Event;
import fl.events.ComponentEvent;
import fl.events.ColorPickerEvent;
import fl.controls.RadioButtonGroup;
var rbGrp:RadioButtonGroup = RadioButtonGroup.getGroup("fontRbGrp");
rbGrp.addEventListener(MouseEvent.CLICK, rbHandler);
txtCp.addEventListener(ColorPickerEvent.CHANGE,cpHandler);
msgCb.addEventListener(Event.CHANGE, cbHandler);
Les trois premières lignes importent les classes d’événement utilisées par l’application.
Un événement se produit lorsqu’un utilisateur interagit avec l’un des composants. Les cinq
lignes suivantes enregistrent des gestionnaires d’événements pour les événements que
l’application souhaite écouter. Un événement
click
se produit pour un composant
RadioButton lorsqu’un utilisateur clique dessus. Un événement
change
se produit
lorsqu’un utilisateur sélectionne une autre couleur dans le composant ColorPicker. Un
événement
change
se produit sur le composant ComboBox lorsqu’un utilisateur choisit
un autre message de bienvenue dans la liste déroulante.
La quatrième ligne importe la classe RadioButtonGroup de manière à ce que l’application
puisse affecter un écouteur d’événements au groupe de composants RadioButtons, plutôt
que d’affecter l’écouteur à chaque bouton individuellement.
30 A propos des composants ActionScript 3.0
11.
Ajoutez la ligne de code suivante au panneau Actions pour créer l’objet TextFormat
tf
,
utilisé par l’application pour modifier les propriétés de style
size
et
color
du texte dans le
composant TextArea.
var tf:TextFormat = new TextFormat();
12.
Ajoutez le code suivant pout créer la fonction de gestion des événements
rbHandler
.
Cette fonction gère un événement
click
lorsqu’un utilisateur clique sur l’un des
composants RadioButton.
function rbHandler(event:MouseEvent):void {
switch(event.target.selection.name) {
case "smallRb":
tf.size = 14;
break;
case "largerRb":
tf.size = 18;
break;
case "largestRb":
tf.size = 24;
break;
}
aTa.setStyle("textFormat", tf);
}
Cette fonction utilise une instruction
switch
pour examiner la propriété
target
de
l’objet
événement
afin de déterminer quel composant RadioButton a déclenché
l’événement. La propriété
currentTarget
contient le nom de l’objet qui a déclenché
l’événement. Selon le composant RadioButton sur lequel l’utilisateur a cliqué,
l’application modifie la taille du texte dans le composant TextArea pour la définir sur 14,
18 ou 24 points.
13.
Ajoutez le code suivant pour implémenter la fonction
cpHandler()
, qui gère une
modification apportée à la valeur dans le composant ColorPicker:
function cpHandler(event:ColorPickerEvent):void {
tf.color = event.target.selectedColor;
aTa.setStyle("textFormat", tf);
}
Cette fonction définit la propriété
color
de l’objet TextFormat
tf
sur la couleur
sélectionnée dans le composant ColorPicker, puis appelle la méthode
setStyle()
pour
l’appliquer au texte dans l’occurrence TextArea
aTa
.
Application simple 31
14.
Ajoutez le code suivant pour implémenter la fonction
cbHandler()
, qui gère une
modification apportée à la sélection dans le composant ComboBox:
function cbHandler(event:Event):void {
aTa.text = event.target.selectedItem.label;
}
Cette fonction remplace simplement le texte du composant TextArea par le texte
sélectionné dans le composant ComboBox,
event.target.selectedItem.label
.
15.
Choisissez Contrôle > Tester l’animation ou appuyez sur Ctrl+Entrée pour compiler le
code et tester l’application Greetings.
La section suivante explique comment créer la même application avec une classe ActionScript
externe et un fichier FLA incluant uniquement les composants requis dans la bibliothèque.
Pour créer l’application Greetings2 à l’aide d’un fichier de classe externe:
1.
Sélectionnez Fichier > Nouveau.
2.
Dans la boîte de dialogue Nouveau document, sélectionnez Fichier Flash
(ActionScript 3.0) et cliquez sur OK.
Une nouvelle fenêtre Flash s’ouvre.
3.
Choisissez Fichier > Enregistrer, nommez le fichier Flash Greetings2.fla, puis cliquez sur le
bouton Enregistrer.
4.
Faites glisser les composants suivants du panneau Composants vers la bibliothèque:

ColorPicker

ComboBox

RadioButton

TextArea
Le fichier SWF compilé utilisera chacun de ces actifs; vous devez donc les ajouter à la
bibliothèque. Faites glisser les composants en bas du panneau Bibliothèque. Lorsque vous
ajoutez ces composants à la bibliothèque, d’autres actifs (tels que List, TextInput et
UIScrollBox) sont ajoutés automatiquement.
5.
Dans la fenêtre Propriétés, pour la classe Document, tapez Greetings2.
Si Flash affiche un message d’avertissement indiquant que la « définition de la classe de
document est introuvable », ignorez-le. Vous définirez la classe Greetings2 lors des étapes
suivantes. Cette classe définit les principales fonctionnalités de l’application.
6.
Enregistrez le fichier Greetings2.fla.
7.
Sélectionnez Fichier > Nouveau.
32 A propos des composants ActionScript 3.0
8.
Dans la boîte de dialogue Nouveau document, sélectionnez Fichier ActionScript et cliquez
sur OK.
Une nouvelle fenêtre de script s’ouvre.
9.
Ajoutez le code suivant dans la fenêtre de script:
package {
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.text.TextFormat;
import fl.events.ComponentEvent;
import fl.events.ColorPickerEvent;
import fl.controls.ColorPicker;
import fl.controls.ComboBox;
import fl.controls.RadioButtonGroup;
import fl.controls.RadioButton;
import fl.controls.TextArea;
public class Greetings2 extends Sprite {
private var aTa:TextArea;
private var msgCb:ComboBox;
private var smallRb:RadioButton;
private var largerRb:RadioButton;
private var largestRb:RadioButton;
private var rbGrp:RadioButtonGroup;
private var txtCp:ColorPicker;
private var tf:TextFormat = new TextFormat();
public function Greetings2() {
Le script définit une classe ActionScript 3.0, intitulée Greetings2. Le script effectue les
opérations suivantes:

Il importe les classes que nous utiliserons dans le fichier. La procédure habituelle
consiste à ajouter ces instructions d’importation au fur et à mesure que vous faites
référence à différentes classes dans le code; cependant, pour plus de concision, cet
exemple les importe toutes au cours de cette étape unique.

Il déclare les variables qui représentent les différents types d’objets de composant que
nous ajouterons au code. Une autre variable crée l’objet TextFormat
tf
.

Il définit une fonction constructeur,
Greetings2()
, pour la classe. Nous ajouterons
des lignes à cette fonction et d’autres méthodes à la classe lors des étapes suivantes.
10.
Choisissez Fichier > Enregistrer, nommez le fichier Greetings2.as, puis cliquez sur le
bouton Enregistrer.
11.
Ajoutez les lignes de code suivantes à la fonction
Greeting2()
:
createUI();
setUpHandlers();
}
Application simple 33
La fonction doit désormais avoir l’aspect suivant:
public function Greetings2() {
createUI();
setUpHandlers();
}
12.
Ajoutez les lignes de code suivantes après l’accolade fermante de la méthode
Greeting2()
:
private function createUI() {
bldTxtArea();
bldColorPicker();
bldComboBox();
bldRadioButtons();
}
private function bldTxtArea() {
aTa = new TextArea();
aTa.setSize(230, 44);
aTa.text = "Hello World!";
aTa.move(165, 57);
addChild(aTa);
}
private function bldColorPicker() {
txtCp = new ColorPicker();
txtCp.move(96, 72);
addChild(txtCp);
}
private function bldComboBox() {
msgCb = new ComboBox();
msgCb.width = 130;
msgCb.move(265, 120);
msgCb.prompt = "Greetings";
msgCb.addItem({data:"Hello.", label:"English"});
msgCb.addItem({data:"Bonjour.", label:"Français"});
msgCb.addItem({data:"¡Hola!", label:"Español"});
addChild(msgCb);
}
private function bldRadioButtons() {
rbGrp = new RadioButtonGroup("fontRbGrp");
smallRb = new RadioButton();
smallRb.setSize(100, 22);
smallRb.move(155, 120);
smallRb.group = rbGrp; //"fontRbGrp";
smallRb.label = "Small";
smallRb.name = "smallRb";
addChild(smallRb);
largerRb = new RadioButton();
largerRb.setSize(100, 22);
largerRb.move(155, 148);
largerRb.group = rbGrp;
largerRb.label = "Larger";
largerRb.name = "largerRb";
34 A propos des composants ActionScript 3.0
addChild(largerRb);
largestRb = new RadioButton();
largestRb.setSize(100, 22);
largestRb.move(155, 175);
largestRb.group = rbGrp;
largestRb.label = "Largest";
largestRb.name = "largestRb";
addChild(largestRb);
}
Ces lignes:

instancient les composants utilisés dans l’application;

définissent la taille, la position et les propriétés de chaque composant;

ajoutent chaque composant sur la scène via la méthode
addChild()
.
13.
Après l’accolade fermante de la méthode
bldRadioButtons()
, ajoutez le code suivant pour
la méthode
setUpHandlers()
:
private function setUpHandlers():void {
rbGrp.addEventListener(MouseEvent.CLICK, rbHandler);
txtCp.addEventListener(ColorPickerEvent.CHANGE,cpHandler);
msgCb.addEventListener(Event.CHANGE, cbHandler);
}
private function rbHandler(event:MouseEvent):void {
switch(event.target.selection.name) {
case "smallRb":
tf.size = 14;
break;
case "largerRb":
tf.size = 18;
break;
case "largestRb":
tf.size = 24;
break;
}
aTa.setStyle("textFormat", tf);
}
private function cpHandler(event:ColorPickerEvent):void {
tf.color = event.target.selectedColor;
aTa.setStyle("textFormat", tf);
}
private function cbHandler(event:Event):void {
aTa.text = event.target.selectedItem.data;
}
}
}
Ces fonctions définissent les écouteurs d’événements des composants.
Application simple 35
14.
Sélectionnez Fichier > Enregistrer pour enregistrer le fichier.
15.
Choisissez Contrôle > Tester l’animation ou appuyez sur Ctrl+Entrée pour compiler le
code et tester l’application Greetings2.
Exécution des exemples suivants
Après avoir développé et exécuté l’application Greetings, vous devriez posséder les
connaissances de base requises pour pouvoir exécuter les autres exemples de code présentés
dans ce manuel. Le code ActionScript 3.0 propre à chaque exemple sera mis en surbrillance et
présenté de manière détaillée. De plus, vous pourrez couper et coller chaque exemple présenté
dans ce manuel dans un fichier FLA, le compiler et l’exécuter.
36 A propos des composants ActionScript 3.0
37
2
CHAPITRE 2
Utilisation des composants
Dans ce chapitre, vous allez apprendre à utiliser les composants dans un document.
Ce chapitre contient les rubriques suivantes:
Architecture des composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Utilisation des fichiers de composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Débogage des applications de composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .44
Définition des paramètres et des propriétés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .45
La bibliothèque. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Dimensionnement des composants. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .49
Aperçu en direct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .50
Gestion d’événements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
Utilisation de la liste d’affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .53
Utilisation de FocusManager. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .56
Utilisation des composants basés sur des listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .58
Utilisation d’un fournisseur de données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .59
Utilisation d’un composant CellRenderer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .70
Accessibilité des composants. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Architecture des composants
Les composants ActionScript 3.0 sont pris en charge par Abobe Flash Player 9.0.28.0 et les
versions ultérieures. Ces composants ne sont pas compatibles avec les composants antérieurs à
Flash CS3. Pour plus d’informations sur l’utilisation des composants ActionScript 2.0,
consultez Utilisation des composants ActionScript 2.0 et le Guide de référence du langage des
composants ActionScript 2.0.
38 Utilisation des composants
Les composants de l’interface utilisateur ActionScript 3.0 sont implémentés en tant que
composants basés sur un fichier FLA mais Flash CS3 prend en charge à la fois les composants
basés sur un fichier SWC et FLA. Par exemple, les composants FLVPlayback et
FLVPlaybackCaptioning sont basés sur un fichier SWC. Vous pouvez placer l’un des types de
composants dans le dossier Composants de manière à ce qu’il apparaisse dans le panneau
Composants. Ces deux types de composants étant créés différemment, ils sont décrits
séparement ici.
Composants ActionScript 3.0 basés sur un
fichier FLA
Les composants de l’interface utilisateur ActionScript 3.0 sont des fichiers FLA (.fla) intégrant
des enveloppes auxquelles vous pouvez accéder afin de les modifier. Pour ce faire, il vous suffit
de double-cliquer sur le composant qui se trouve sur la scène. Les enveloppes et les autres
éléments du composant sont placés sur l’image 2 du scénario. Lorsque vous double-cliquez sur
le composant, Flash passe directement à l’image 2 et ouvre une palette des enveloppes du
composant. L’illustration suivante présente la palette des enveloppes qui s’affichent pour le
composant Button.
Enveloppes du composant Button
Pour plus d’informations sur les enveloppes des composants et la personnalisation des
composants, consultez le Chapitre 4, « Personnalisation des composants de l’interface
utilisateur », à la page 153 et la section « Personnalisation du composant FLVPlayback », à
la page 232.
Architecture des composants 39
Pour accélérer la compilation de vos applications et éviter les conflits avec vos paramètres
ActionScript 3.0, les composants de l’interface utilisateur basés sur un fichier FLA Flash CS3
contiennent également un fichier SWC incluant le code ActionScript déjà compilé du
composant. Le fichier SWC ComponentShim est placé sur la scène, sur l’image 2, dans
chaque composant de l’interface utilisateur de manière à rendre les définitions précompilées
disponibles. Pour être accessible à ActionScript, un composant doit se trouver sur la scène ou
dans la bibliothèque et l’option Exporter dans la première image doit être cochée dans la boîte
de dialogue Propriétés de liaison correspondante. Pour créer un composant via ActionScript,
vous devez également importer la classe avec une instruction
import
pour y accéder. Pour plus
d’informations sur l’instruction
import
, consultez le Guide de référence du langage et des
composants ActionScript 3.0.
Composants basés sur un fichier SWC
Les composants basés sur un fichier SWC possèdent un fichier FLA et un fichier de classe
ActionScript également; en revanche, ils ont été compilés et exportés en tant que fichier
SWC. Un fichier SWC est un paquet de symboles Flash précompilés et de code ActionScript
qui vous évite de devoir recompiler les symboles et le code qui ne changeront pas.
Les composants FLVPlayback et FLVPlaybackCaptioning sont basés sur un fichier SWC.
Ils possèdent des enveloppes externes, et non des enveloppes intégrées. Le composant
FLVPlayback possède une enveloppe par défaut que vous pouvez modifier. Pour ce faire, il
vous suffit de sélectionner une autre enveloppe dans un ensemble d’enveloppes prédéfinies, de
personnaliser les commandes de l’interface utilisateur dans le panneau Composants
(BackButton, BufferingBar, etc.) ou de créer une enveloppe personnalisée. Pour plus
d’informations, consultez la section « Personnalisation du composant FLVPlayback », à
la page 232.
Dans Flash, vous pouvez convertir un clip en clip compilé comme suit.
Pour compiler un clip:

Dans le panneau Bibliothèque, cliquez sur le clip du bouton droit (Windows) ou avec la
touche Contrôle enfoncée (Macintosh), puis choisissez Convertir en clip compilé.
Le clip compilé se comporte exactement comme le clip à partir duquel il a été compilé, mais
les clips compilés sont affichés et publiés beaucoup plus rapidement que les clips ordinaires.
Les clips compilés ne peuvent pas être modifiés, mais leurs propriétés peuvent apparaître dans
l’Inspecteur des propriétés et l’Inspecteur des composants.
Les composants SWC contiennent un clip compilé, les définitions ActionScript précompilées
du composant et d’autres fichiers qui décrivent le composant. Si vous créez votre propre
composant, vous pouvez l’exporter en tant que fichier SWC pour le distribuer.
40 Utilisation des composants
Pour exporter un fichier SWC:

Choisissez le clip dans le panneau Bibliothèque et cliquez du bouton droit (Windows)
ou maintenez la touche Contrôle enfoncée (Macintosh), puis sélectionnez Exporter le
fichier SWC.
Pour plus d’informations sur la création de composants basés sur un fichier SWC, consultez le
site www.adobe.com/go/learn_fl_creating_components_fr.
API des composants ActionScript 3.0
Chaque composant ActionScript 3.0 est basé sur une classe ActionScript 3.0 située dans un
dossier de paquet dont le nom est au format fl.packagename.classname. Par exemple, le
composant Button, dont le nom de paquet est
fl.controls.Button
, est une occurrence de
la classe Button. Vous devez faire référence au nom de paquet lorsque vous importez une classe
de composant dans votre application. Vous pouvez importer la classe Button à l’aide de
l’instruction suivante:
import fl.controls.Button;
Pour plus d’informations sur l’emplacement des fichiers de classe de composant, consultez la
section « Utilisation des fichiers de composants », à la page 41.
La classe d’un composant définit les méthodes, propriétés, événements et styles qui vous
permettent d’interagir avec votre application. Les composants de l’interface utilisateur
ActionScript 3.0 sont des sous-classes des classes Sprite et UIComponent et héritent de leurs
propriétés, méthodes et événements. La classe Sprite est l’élément fondamental de la liste
d’affichage: elle est similaire à un clip mais ne possède pas de scénario. La classe
UIComponent constitue la classe de base de tous les composants visuels, interactifs ou non.
Le chemin de l’héritage de chaque composant, ainsi que ses propriétés, méthodes, événements
et styles sont décrits dans le Guide de référence du langage et des composants ActionScript 3.0.
Tous les composants ActionScript 3.0 utilisent le modèle de gestion des événements
ActionScript 3.0. Pour plus d’informations sur la gestion des événements, consultez la section
« Gestion d’événements », à la page 51 et le guide Programmation d’ActionScript 3.0.
REMARQUE
Le format d’un fichier SWC Flash CS3 est compatible avec le format Flex SWC, ce
qui permet d’échanger les fichiers SWC entre les deux produits, mais pas
nécessairement sans modification.
Utilisation des fichiers de composants 41
Utilisation des fichiers de composants
Cette section explique à quel emplacement sont stockés les fichiers de composants, où se
trouvent les fichiers source ActionScript et comment ajouter et supprimer des composants
dans le panneau Composants.
Emplacement de stockage des fichiers de
composants
Les composants Flash sont stockés dans le dossier Configuration au niveau de l’application.
Les composants sont installés dans les emplacements suivants:

Windows 2000 ou Windows XP:
C:\Program Files\Adobe\Adobe Flash CS3\langue\Configuration\Components

Mac OS X:
DD Macintosh:Applications:Adobe Flash CS3:Configuration:Components
Dans le dossier Composants, les composants de l’interface utilisateur se trouvent dans le
fichier User Interface.fla et les composants FLVPlayback (FLVPlaybackAS3.swc) et
FLVPlaybackCaptioning dans le dossier Video.
Vous pouvez également stocker les composants dans les emplacements utilisateur suivants:

Windows 2000 ou Windows XP:
C:\Documents and Settings\nom d’utilisateur\Local Settings\Application
Data\Adobe\Adobe Flash CS3\fr\Configuration\Components

Mac OS X:
Disque dur Macintosh:Utilisateurs:<utilisateur>:Library:Application Support:Adobe
Flash CS3:Configuration:Components
REMARQUE
Pour pl us d’ i nformati ons sur ces dossi ers, consul tez la section « Dossiers de
configuration installés avec Flash » dans le guide Utilisation de Flash.
42 Utilisation des composants
Emplacement de stockage des fichiers source de
composant
Les fichiers de classe ActionScript (.as) (ou fichiers source) des composants sont installés dans
les dossiers d’application suivants pour Windows 2000 ou Windows XP:

Composants d’interface utilisateur
C:\Program Files\Adobe\Adobe Flash CS3\fr\Configuration\Component
Source\ActionScript 3.0\User Interface\fl

FLVPlayback
C:\Program Files\Adobe\Adobe Flash CS3\fr\Configuration\Component
Source\ActionScript 3.0\FLVPlayback\fl\video

FLVPlaybackCaptioning
C:\Program Files\Adobe\Adobe Flash CS3\fr\Configuration\Component
Source\ActionScript 3.0\FLVPlaybackCaptioning\fl\video
Pour Mac OS X, les fichiers source de composant sont situés aux emplacements suivants:

Composants d’interface utilisateur
Disque dur Macintosh:Applications:Adobe Flash CS3:Configuration:Component
Source:ActionScript 3.0:User Interface:fl

FLVPlayback
Disque dur Macintosh:Applications:Adobe Flash CS3:Configuration:Component
Source:ActionScript 3.0:FLVPlayback:fl:video

FLVPlaybackCaptioning
Disque dur Macintosh:Applications:Adobe Flash CS3:Configuration:Component
Source:ActionScript 3.0:FLVPlaybackCaptioning:fl:video
Fichiers source de composant et variable Classpath
Etant donné que le code des composants ActionScript 3.0 est compilé au sein de ces derniers,
vous ne devez pas spécifier l’emplacement des fichiers de classe ActionScript dans votre
variable Classpath. Si vous incluez leur emplacement à la variable Classpath, le temps requis
pour compiler vos applications augmentera. Toutefois, si Flash découvre des fichiers de classe
de composant dans votre paramètre Classpath, le fichier de classe est toujours prioritaire par
rapport au code compilé dans le composant.
Utilisation des fichiers de composants 43
Lors du débogage d’une application avec les composants, vous voudrez peut-être ajouter
l’emplacement des fichiers source de composant à votre paramètre Classpath. Pour plus
d’informations, consultez la section « Débogage des applications de composants », à
la page 44.
Modification des fichiers de composant
Si vous mettez à jour, ajoutez ou supprimez des composants basés sur un fichier SWC ou
ajoutez de nouveaux composants basés sur un fichier FLA à Flash, vous devez les recharger
dans le panneau Composants afin de les rendre disponibles. Pour recharger les composants, il
vous suffit de redémarrer Flash ou de sélectionner Recharger dans le menu du panneau
Composants. Flash collectera ainsi les composants que vous avez ajoutés dans le dossier
Composants.
Pour recharger des composants dans le panneau Composants lors de
l’exécution de Flash:

Dans le menu du panneau Composants, choisissez Recharger.
Elément de menu Recharger dans le menu du panneau Composants
44 Utilisation des composants
Pour supprimer un composant dans le panneau Composants:

Supprimez le fichier FLA, SWC ou MXP du dossier Composants et redémarrez Flash ou
sélectionnez Recharger dans le menu du panneau Composants. Un fichier MXP est un
fichier de composant téléchargé depuis le site Adobe Exchange.
Vous pouvez supprimer et remplacer les composants basés sur un fichier SWC lors de
l’exécution de Flash: le rechargement reflètera alors les modifications; en revanche, si vous
modifiez ou supprimez des composants basés sur un fichier FLA, les modifications ne sont pas
implémentées tant que vous n’avez pas terminé et redémarré Flash. Vous pouvez, cependant,
ajouter des composants basés sur un fichier FLA et les charger à l’aide de la commande
Recharger.
Débogage des applications de
composants
Les composants ActionScript 3.0 contiennent tous leur code source afin de réduire le temps
de compilation de votre application. Toutefois, le débogueur Flash ne peut pas inspecter le
code des clips compilés. Par conséquent, si vous souhaitez déboguer votre application dans le
code source du composant, vous devez ajouter les fichiers source du composant à votre
paramètre Classpath.
L’emplacement des dossiers de paquet de composants dépend de l’emplacement des fichiers