Débuter la Programmation Flash avec Actionscript 3.0


Télécharger Débuter la Programmation Flash avec Actionscript 3.0

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


PROGRAMMATION FLASH

AVEC ACTIONSCRIPT 3.0

 

mai 2010

Table des matières

1    La configuration d'Adobe Flash CS4 . 5

1.1     Fichier d'aide .. 5

1.2    Organisation d'un projet .. 6

1.3    Paramètres de publication 7

2   Les variables . 8

2.1    Différents types . 8

2.2   Syntaxe .. 9

2.2.1    Déclaration 9

2.2.2   Affectation .. 9

2.2.3   Conversion . 9

2.2.4   Nom dynamique de variable (variable de variable) .. 9

3   Les fonctions .. 10

3.1    Généralités . 10

3.1.1     Principe 10

3.1.2    Recommandations .. 10

3.2   Différents types .. 10

3.2.1    Sans retourner de valeurs . 10

3.2.2   Avec retour de valeurs 11

3.2.3   Paramètres facultatifs . 11

3.2.4   Paramètre reste . 12

4   Les variables globales et locales 12

4.1    Variables locales 12

4.2   Variables globales 13

5   Les objets . 13

5.1    Organisation . 13

5.1.1     Symboles et occurrences . 13

5.1.2    Packages et classes .. 13

5.2   Programmation sur une occurrence .. 14

5.2.1    Identification d'une occurrence .. 14

5.2.2   Propriétés et méthodes d'occurrence . 14

5.2.3   Syntaxe pointée . 14

5.2.4   Syntaxe à crochets . 15

5.2.5   Création d'une occurrence 15

5.2.6   Valeurs d'une occurrence .. 15

5.3   Programmation sur une classe 16

5.3.1    Classe statique . 16

5.3.2   Classe d'énumération . 17

5.3.3   Classe dynamique .. 18

5.3.4   Les classes Array et Vector 19

5.4   Type primitif et type complexe .. 20

5.4.1    Définition . 20

5.4.2   Comportement . 20

5.4.3   Principe . 20

6   Les conditions 21

6.1    Les opérateurs 21

6.2   Les opérateurs logiques .. 21

6.3   L'instruction if .. 21

6.4   L'instruction switch .. 22

6.5   L'opérateur ternaire 22

6.6   Problématique sur les champs de texte 23

7   L'affichage (1ère partie) . 24

7.1    Arborescence d'affichage .. 24

7.2   Héritage . 24

7.3   Affichage d'un objet .. 25

7.4   Exporter un élément de la bibliothèque pour ActionScript . 26

7.4.1    Importer une image dans la bibliothèque . 26

7.4.2   Exporter une image pour ActionScript .. 26

7.4.3   Affichage d'une image avec ActionScript .. 27

7.4.4   Affichage d'un clip de la bibliothèque 28

7.5   Manipulation de l'affichage 29

8   Gestion événementielle .. 31

8.1    Ajout d'un écouteur d'événement .. 31

8.1.1     Syntaxe générique . 31

8.1.2    Syntaxe appropriée . 31

8.2   Suppression d'un écouteur d'événement 32

8.3   Propriétés relatives aux événements . 33

9   Les boucles .. 36

9.1    Principe . 36

9.2   La boucle for .. 36

9.3   Les boucles et . 36

9.4   Les boucles while et do..while .. 37

10   L'affichage (2ème partie) 37

10.1    Menu contextuel sur les objets . 37

10.1.1  Menu contextuel de l'application 37

10.1.2    Menu contextuel d'un objet .. 38

10.2   Les filtres .. 40

10.3   Les modes de fusion 41

10.4   Repositionnement et redimensionnement des objets . 42

10.5   Chargement de swf et d'images .. 43

10.6   Déchargement d'un swf .. 46

11    Mise en forme du texte .. 47

11.1  Avec la classe TextFormat . 47

11.2    En utilisant HTML et CSS dans des fichiers externes . 48

11.3    Intégration de polices de caractères .. 50

12   Le son 53

12.1    Les classes Sound et SoundChannel .. 53

12.2   Lecture d'un son (intégré ou externe) 54

12.2.1    Son en bibliothèque .. 54

12.2.2   Son externe 55

12.3   Modification du volume et du panoramique . 55

12.4   Déplacement dans un son 56

13   Le débogueur de Flash 58

14   Gestion des erreurs à l'exécution . 60

14.1    Identification des erreurs 60

14.2   Prévoir les risques d'erreur grâce à la documentation .. 61

14.3   Gérer les erreurs : utilisation de blocs try / catch . 62

14.3.1    Gérer une erreur . 62

14.3.2   Gérer plusieurs erreurs 62

14.4   Lancer des erreurs . 64

15   Gestion de la mémoire . 65

15.1    Garbage Collector . 65

15.2   Utilisation mémoire . 66

16   Exemples d'applications . 67

16.1    Drag and Drop .. 67

16.1.1  Événements souris, startDrag et stopDrag,  index de profondeur 68

16.2   Diaporama 69

16.2.1    Code Navigation : Object, Array, opérateurs d'incrémentation . 72

16.2.2   Code XML : Chargement et traitement du fichier, création liste et objet .. 73

16.3   Générateur de particules .. 76

16.3.1    Événement ENTER_FRAME, boucle d'animation, collection d'objets 76

16.3.2   comportement aléatoire, classe dynamique, mémoire cache . 76

16.4   Formulaire .. 78

16.4.1    Gestion des ordres de tabulation .. 79

16.4.2   Validation des entrées .. 79

16.4.3   Événements focus . 80

16.4.4   Événements clavier .. 80

16.4.5   Envoyer des variables vers une URL 81

16.5   Jeu de grattage . 82

16.5.1    Classe BitmapData . 82

16.5.2   Événements souris, affichage et masquage curseur . 83

16.5.3   Matrice de transformation 83

16.5.4   Comparaison de la valeurs des pixels . 85

16.5.5   Classe Timer .. 86

  1  La configuration d'Adobe Flash CS4

  1.1  Fichier d'aide

Pour utiliser le fichier d'aide en local au lieu de celui sur Internet :

 

  1.2  Organisation d'un projet

-     Il est important de bien structurer les différents éléments relatifs à un projet et notamment de séparer les documents sources de ceux publiés. Pour travailler ainsi, il est conseillé dans le dossier des projets:

-     de créer un dossier pour chaque projet (au nom du projet),- de créer des sous-dossiers (Sources et Publications) pour séparer les sources des publications.

-     Placer dans le dossier "Sources" du projet tous les documents qui serviront à le réaliser (images, photos, textes, …).

-     Démarrer le programme Flash (Adobe Flash CS4 par exemple), cliquer sur "Fichier Flash (AS 3.0)".

 

-     Cliquer sur "Fichier / Enregistrer sous " pour enregistrer le fichier fla dans le sous-dossier "Sources" du dossier du projet précédemment crées.

 

  1.3  Paramètres de publication

- Dans l'onglet Format :

- Modifier les paramètres de publication pour indiquer le chemin relatif de publication :

 

- Sélectionner Flash Player 10 comme lecteur.

- Sélectionner ActionScript 3.0 comme script.

- Cocher Autoriser le débogage :

Ce qui permet, en cas d'erreur, d'avoir un message plus explicité (endroit où se situe l'erreur).

 

Nota :    Cette option "Autoriser le débogage" sera à décocher à la fin de la conception, avant la publication finale.

 

  2  Les variables

  2.1  Différents types

string

texte valeur par défaut : null

number

nombre à virgule flottante de - 1.79e308 à 1.79e308 64 bits

valeur par défaut : NaN (not a number)

int nombre entier positif ou négatif de– 2 147 483 648 à + 2 147 483 647

32 bits valeur par défaut : 0

uint nombre entier positif de 0 à 4 294 967 295

32 bits également utilisé pour les couleurs avec ou sans alpha :

(sans : 0xrrvvbb - avec : 0xaarrvvbb) valeur par défaut : 0

boolean booleen

2 valeurs possibles : true et false valeur par défaut : false

* n'importe quel type

peut changer de type au cours du programme valeur par défaut : undefined

  2.2  Syntaxe

 2.2.1   Déclaration

 

 2.2.2   Affectation

nombre1 = 20;

 2.2.3   Conversion

E affiche :  2010

E affiche :  1.26

 2.2.4   Nom dynamique de variable (variable de variable)

Pour créer ou utiliser un nom de variable dynamique :


 

  3  Les fonctions

  3.1  Généralités

 3.1.1   Principe

// Déclaration de la fonction function maFonction (parametres)

{

code à exécuter

}

// Appel de la fonction maFonction (parametres);

 3.1.2   Recommandations

–   Il est conseillé de faire commencer le nom des paramètres transmis par un "p" afin de mieux différentier les paramètres transmis des variables dans le code de la fonction (ex: pNombre1).

:Number

, pNombre2

:Number

 )

:Number

–   Comme pour les variables, il est fortement recommandé de spécifier le type des paramètres transmis ainsi que celui de la valeur retournée. Ex: function addition ( pNombre1

  3.2  Différents types

 3.2.1   Sans retourner de valeurs

Il faut spécifié le type "void"

:void

// Fonction addition function addition (pNombre1:Number, pNombre2:Number)

{

trace (pNombre1 + pNombre2);

}

// Appel de la fonction addition addition(pNombre1,pNombre2);

 3.2.2   Avec retour de valeurs    

La transmission du résultat d'une fonction (retour de paramètre) s'effectue grâce à l'instruction return :

// Fonction addition function addition (pNombre1:Number, pNombre2:Number):Number

{

return

 pNombre1 + pNombre2;

// Appel de la fonction addition et affectation du résultat à la variable "total" Number = addition (10, 100);

 (total); // affichage du résultat

}

var total:

trace

Remarques :

–   Toutes les lignes de code de la fonction placées après la ligne contenant "return" ne seront pas exécutées, car l'exécution de la fonction se termine par l'instruction "return".

–   Attention de bien respecter la concordance entre le format transmis et celui de la variable à laquelle on affecte le résultat :

function addition (pNombre1:Number, pNombre2:Number):Number

var total:Number = addition (10, 100);

 3.2.3   Paramètres facultatifs

Si on veut affecter une valeur par défaut à un paramètre (en cas d'absence de valeur) :

function maFonction (pNombre:Number = 0):void

{

trace (pNombre);

}

maFonction ();         E affiche : 0 maFonction (2);  E affiche : 2

Remarques :

– Les paramètres facultatifs se placent toujours après les paramètres obligatoires.

function maFonction (pNombre1:Number , pNombre2:Number

= 0)

:void

page

 3.2.4   Paramètre reste

–   Il existe un type de paramètres très particulier : le paramètre "reste", il s'écrit … suivi du nom du paramètre (ex: pRest). Il n'est pas nécessaire de typer ce paramètre car il accepte n'importe quel type de données, si on désire quand même le typer il faut lui attribuer le type * ( pRest:*).

–   Il prendra toutes les valeurs qui restent après le renseignement des premiers paramètres :

function maFonction (pNombre1:Number , pNombre2:Number, pRest):void

{

trace (pRest);

} maFonction (2, 3, "toto", new MovieClip(), 255);

E affiche : toto, [object MovieClip], 255

–   Pour prendre toutes ces valeurs, il utilise le type Array qui permet de donner des listes de données indexées auxquelles on pourra accéder via un index entre crochets :

function maFonction (pNombre1:Number , pNombre2:Number, pRest):void

{

trace (pRest[0]);

} maFonction (2, 3, "toto", new MovieClip(), 255);

E affiche : toto

–   On pourra également utiliser le concept des boucles pour parcourir l'ensemble des paramètres.

  4  Les variables globales et locales

Si l'utilité d'une variable (ou d'un objet) dépasse le périmètre d'une fonction, il faut alors la

déclarer en "globale" sinon une déclaration en "locale" suffit.

  4.1  Variables locales

–   Pour déclarer une variable en locale, il faut effectuer sa déclaration à l'intérieur de la fonction.

–   Cette variable ne sera accessible qu'à l'intérieur de la fonction dans laquelle elle a été déclarée.

 

function test():void

{ var maVariableLocale:String = "déclarée dans une fonction : je suis une variable locale"; trace (maVariableLocale);

}


  4.2  Variables globales

–   Pour déclarer une variable en globale, il faut effectuer sa déclaration à l'extérieur de la fonction.

–   Cette variable sera alors accessible de n'importe où.

var

 maVariableGlobale:String = "déclarée avant les fonctions : je suis une variable globale";

function test():void

 (maVariableGlobale);

{

}

trace

  5  Les objets

  5.1  Organisation

Chaque objet que l'on peut manipuler en ActionScript appartient à un certain type de données.

 5.1.1   Symboles et occurrences

–   Chaque type de données est crée par des classes.

–   La relation qui existe entre une classe et un objet et un peu celle qui existe entre un moule et un objet qui est sorti de ce moule.

–   Lorsque l'on a un clip sur la scène, le panneau de propriétés indique que c'est une occurrence de puis le nom du symbole en bibliothèque qui a permis de générer cette occurrence de clip. Si on modifie le clip (symbole), chaque occurrence est automatiquement modifiée.

 5.1.2   Packages et classes

–   Dans la documentation (par F1) le lien "Toutes les classes" présente l'ensemble des classes, c'est à dire l'ensemble des types de données que nous pouvons manipuler lorsque l'on programme dans Flash.

–   Étant donné le nombre de classes possibles, nous devons adopter une certaine organisation pour classer ces classes. On utilise une structure sous forme de dossiers et sous-dossiers que l'on nomme "package".

 

–   Les classes sont une sorte de moules qui permettent de créer des occurrences. On pourrait comparer les classes à des boites à outils qui agissent dans un certain contexte d'utilisation. Chaque objet (occurrence) que l'on peut manipuler est donc crée grâce à une classe.

  5.2  Programmation sur une occurrence

 5.2.1   Identification d'une occurrence

–   On crée une occurrence du symbole "monClip" que l'on appelle "clip_1".

–   trace (clip_1);         E affiche :  [object MovieClip]

object pour "occurrence" suivi du nom de la classe (MovieClip)

–   trace (MovieClip); E affiche :  [class MovieClip]

–   On sait donc que l'objet posé sur la scène est un MovieClip.

 5.2.2   Propriétés et méthodes d'occurrence

–   Dans la documentation en cliquant sur la classe "MovieClip", on peut savoir comment utiliser cet objet.

–   Pour connaître toutes les fonctionnalités (notamment celles héritées), il faut cliquer sur "Afficher les propriétés publiques héritées" (faire de même pour les méthodes et les événements).

 

–   Chaque fonctionnalité (propriété, méthode ,événement) héritée est alors indiquées par une flèche grise, le nom de la classe mère est également indiquée.

 

–   On devient ainsi autonome en programmation ActionScript, grâce à la documentation.

 5.2.3   Syntaxe pointée

–   Pour accéder à la propriété d'un objet on utilise le plus souvent la syntaxe pointée (.) : clip_1.x

Une propriété étant une variable, on se sert de l'opérateur d'affectation pour lui donner une valeur :

clip_1 clip_1

.x = 150;

.rotation = 90;

–   On peut également affecter une méthode à cet objet.

Une méthode étant une fonction, on applique cette syntaxe :

clip_1

.startDrag();

 5.2.4   Syntaxe à crochets

 

syntaxe à crochet

nom d'une propriété

 :

     

–   Dans certains cas particuliers, on peut utiliser la    qui consiste à mettre entre crochets une variable contenant le 

var propriete:String = "rotation";

clip_1[

propriete

] = 90;

–   Cette syntaxe est souvent utilisée pour initialiser des objets avec des valeurs externes contenues par exemple dans un fichier XML (en fonction du couple : nom de propriété - valeur).

–   Elle est utilisée également pour accéder aux éléments des objets de type Array ou Vector en indiquant leur index entre crochets.

 5.2.5   Création d'une occurrence

Nous souhaitons créer sur la scène, par programmation ActionScript, un objet de type "Champ de texte" (comme on le ferait avec l'outil Texte).

–   En appliquant la méthode indiquée au chapitre 5.3 (Identification d'une occurrence), nous déterminons que l'objet à créer est du type "TextField".

–   Il va falloir déjà créer une variable qui va mémoriser l'occurrence créée. Le type de données est le nom de la classe qui permet de créer cet objet (TextField).

–   Pour créer une occurrence, nous allons utiliser le mot clé "new" suivi du nom de la classe puis suivi de ()



var champDeTexte:TextField = new TextField ();

–   Cette syntaxe "TextField ()" nous rappelle la syntaxe d'exécution d'une fonction.                     

Cette fonction de même nom que la classe s'appelle la fonction constructeur.

Elle sert à créer une occurrence de la classe comme nous indique la documentation : La fonction constructeur TextField crée une occurrence de TextField.

Ça sera le cas pour chaque classe dont on peut créer des occurrences.

 5.2.6   Valeurs d'une occurrence

Après avoir crée ce champ de texte, nous voulons écrire du texte (Bonjour)  à l'intérieur (toujours en code).

–   Nous revenons sur la documentation de la classe TextField et nous recherchons une propriété ou une fonction nous permettant d'écrire  dans le champ de texte.

–   Nous trouvons la propriété "text" de type "String" :

 

–   On cliquant sur celle-ci, la documentation nous apporte toutes les précisions nécessaires (notamment qu'elle correspond au texte du champ) :

 

–   Nous pouvons alors appliquer à l'occurrence "champDeText" la propriété "text" et lui affecter la valeur voulue en respectant le type de données (ici String) :

champDeText . text = "Bonjour";

–   Pour permettre l'affichage sur la scène, on doit utiliser la fonction "addChield" en lui transmettant le champ à afficher :

addChield (champDeTexte);

–   Soit au final  pour la création, la valeur et l'affichage de l'occurrence :

 

  5.3  Programmation sur une classe

 5.3.1   Classe statique

Nous venons de voir que l'on utilise les propriétés ou les méthodes sur les occurrences, mais il y a certains cas où ces propriétés ou ces méthodes s'utilisent directement sur la classe et non plus sur une occurrence.

Là encore la documentation va nous être très utile car elle nous indique pour chaque propriété ou méthode si elle s'applique a une occurrence ou sur la classe directement.

- Si elle s'applique à la classe, elle est identifiée par le mot clé : "statique" (ou "static") :

 

 5.3.2   Classe d'énumération

C'est une classe qui énumère un ensemble de valeurs.

–   Par exemple : sur la classe "Stage" (qui permet d'agir de manière globale sur le fonctionnement du Flash Player) nous avons une propriété "Align" (qui permet de modifier le mode d'alignement du Flash player lorsqu'il est redimensionné) qui attend un certain nombres de valeurs du type String. Les valeurs que nous lui donnerons doivent être reconnues par la classe "Stage". Pour nous faciliter la tâche, il existe une classe qui se nomme "StageAlign" qui contient les valeurs possibles pour cette propriété.

 

–   Ces valeurs sont stockées sous forme de constantes statiques (donc applicables directement sur la classe).

 

Cette classe n'a comme seul rôle que de stocker (d'énumérer) ces valeurs.

–   Si je souhaite l'utiliser (par exemple : parce que je ne souhaite pas, lorsque je déplace le Flash Player, que les objets se déplacent je souhaite qu'ils gardent leur position en haut à gauche), je vais pouvoir utiliser "l'aide à la saisie"  pour choisir parmi les constantes (écrites en majuscule) celle qui correspond à mon choix :

 

 5.3.3   Classe dynamique

–   Il existe des classes qui sont dites "dynamiques" identifiées dans la documentation par le mot-clé "dynamic".

–   Si une classe est dynamique cela signifie que j'ai le droit de créer, sur une occurrence de cette classe, des propriétés qui n'existent pas dans la classe elle-même.

   

–   Il existe quand même un inconvénient à ce type de classe, c'est que le compilateur ne peut pas gérer les erreurs du fait qu'il est possible de créer ce que l'on veut.

Si l'on utilise quelque chose (fonction) qui n'existe pas, l'erreur ne sera donc pas vue à la compilation mais uniquement à l'exécution (par le Flash Player).

 5.3.4   Les classes Array et Vector

Ces classes nous permettent de créer et de gérer des listes d'objets.

–   Lorsque nous créons une occurrence de la classe Array, nous pouvons transmettre deux types de paramètres :

–   soit un paramètre numérique qui va créer une liste de x éléments vides .

–   soit tout autres paramètres (par exemple une chaine de caractères) qui créera alors une liste contenant ces différents éléments.

 

–   La classe vector a le même rôle que la classe Array. Cependant les éléments auront tous le même type, celui-ci sera spécifié lors de la déclaration et vérifié lorsque l'on ajoutera un élément.

–   La classe vector nécessite Flash Player 10.

–   La syntaxe de la classe vector est un peu particulière :

 

–   Avec la classe vector, nous pouvons fixer et limiter le nombre d'éléments :

 

Dans cet exemple, la liste est créée avec 10 éléments et ne dépassera jamais les 10 éléments.

  5.4  Type primitif et type complexe

 5.4.1   Définition

–   Les types Number, int, uint, String et Boolean sont des types primitifs (ou simples).

–   Tous les autres sont des types complexes.

 

–   On s'aperçoit que :

–   monNombre (type primitif) garde sa valeur d'origine.

–   MonClip.x (type complexe) a été modifié par la fonction.

 5.4.3   Principe

Lorsque l'on donne à un paramètre d'une fonction le type :

–   primitif : l'objet qui est reçu par la fonction n'est qu'une copie de cet objet.

–   complexe : l'objet qui est reçu par la fonction n'est pas une copie mais est la  référence vers l'objet d'origine. L'objet d'origine sera donc modifié par la fonction !

  6  Les conditions

– Chaque condition que l'on va écrire va retourner un Booléen ( true ou false).

  6.1  Les opérateurs

–   Égalité : ==

–   Inégalité : !=

–   Supériorité : >

–   Supériorité ou égalité : >=

–   Infériorité : <

–   Infériorité ou égalité : <=

–   Est : is        ex: if ( maVariable is String)

  6.2  Les opérateurs logiques

–   ET logique : &&     ex: if (nombre > 10 && nombre < 100)

 !

–   OU logique : ||     ex: if (reponse == solution1 || reponse == solution2) – PAS (NOT) : 

 !

                                if ( clip1.hitTestObject (clip2) )                            if ( clip1.hitTestObject (clip2) )

                                {                                                                           {

                                trace ( "collision" );                                              trace ( "pas de collision" );

                                }                                                                           }

  6.3  L'instruction if

 

Remarque : il est conseillé de toujours finir par l'instruction "else" pour être sur que toutes les

conditions ont été testées.

 

  6.4  L'instruction switch

 

–   L'instruction "default" équivaut à l'instruction "else" (sinon)

 

–   Nous avons la possibilité de prolonger une condition sur une autre en supprimant une instruction "break" :

  6.5  L'opérateur ternaire

– Cet opérateur permet de glisser une condition au sein d'une instruction.

 

  6.6  Problématique sur les champs de texte

 

–   Il existe une problématique sur les champs texte liée aux paramètres par défaut, notamment à la combinaison de "crénage automatique" et de "comportement multiligne" :

–   Lorsque nous activons ces 2 options, Flash rajoute dans le texte du code Html qui rend notre condition inefficace.

–   Pour éviter cette contrainte, il suffit de décocher le "crénage automatique" et la condition devient efficace. Notons au passage que n'ayant pas besoin d'un champ multiligne, nous aurions aussi choisir comportement "Une seule ligne".

  7  L'affichage (1ère partie)

 

–   Les différentes classes héritées sont également mentionnées dans la documentation.

–   Dans la majorité des cas, une propriété ou une méthode héritée est utilisable sur la classe qui en hérite.

Il existe des exceptions, celle-ci sont indiquées dans la documentation (ex: classe Stage) :

 

  7.3  Affichage d'un objet

–   Pour afficher un objet en ActionScript, il faut toujours avoir en tête les schémas relatifs à l'arborescence d'affichage et à  l'arbre d'héritage.

–   De plus, il est important de se rappeler que l'objet racine de mon swf : "  root " est un   MovieClip .

–   en ActionScript, pour désigner l'objet sur lequel on est en train d'écrire du code ("root"), on utilise le mot clé "this".

–   On peut demander l'affichage d'un objet, soit directement sur la scène, soit dans un conteneur :

 

  7.4  Exporter un élément de la bibliothèque pour ActionScript

 7.4.1   Importer une image dans la bibliothèque

 

–   Pour importer une image dans la bibliothèque, nous pouvons soit :

–   Directement glisser le fichier de l'explorateur vers la bibliothèque.

–   Faire "Fichier / Importer / Importer dans la bibliothèque ".

 7.4.2   Exporter une image pour ActionScript

–   Pour pouvoir manipuler cette image par le code d'ActionScript, nous allons devoir modifier les paramètres de celle-ci :

–   Dans la bibliothèque, faire un double-clic sur l'image (ou un clic droit puis propriété).

–   Il faudra alors cocher "Exporter pour ActionScript",

–   et donner un nom de classe pour identifier la classe qui sera créée pour cet objet.

Pour respecter la convention de nommage des classes, je fais commencer le nom de la classe par une majuscule.

–   On voit également que la classe de base est la classe BitmapData. Cette classe ne fait pas partie des classes d'affichage que nous avons vu dans l'arbre d'héritage il faudra donc passer par une classe qui permet l'affichage de ces données en l'occurrence la classe Bitmap.

 

 7.4.3   Affichage d'une image avec ActionScript

– Comme indiqué dans la documentation relative à la méthode "constructeur", la classe "BitmapData" possède 2  paramètres obligatoires (width et height) – Il va donc falloir renseigner ces paramètres.

Dans le cas d'une image en bibliothèque, quelque soit les dimensions que l'on indique en paramètres, l'image sera affichée dans ses dimensions d'origine.

On peut donc indiquer ce que l'on veut comme paramètres car ceux-ci ne seront pas pris en compte. Il est recommandé, bien qu'en théorie ça ne soit pas possible, d'indiquer (0, 0) afin de nous indiquer (en voyant le code) que l'image vient de la bibliothèque.

 

 7.4.4   Affichage d'un clip de la bibliothèque

–   Comme pour une image, il va falloir :

–   Exporter le clip pour ActionScript en modifiant ses propriétés :

–   Cocher "Exporter pour ActionScript",

–   Donner un nom de classe pour identifier la classe qui sera créée pour cet objet. Faire commencer le nom de la classe par une majuscule pour respecter la convention de nommage des classes.

–   On voit également que la classe de base est la classe MovieClip. Cette classe fait pas partie des classes d'affichage que nous avons vu dans l'arbre d'héritage.

 

  7.5  Manipulation de l'affichage

Nous allons détailler le fonctionnement de la classe "DisplayObjectContainer" qui nous permet dans un objet qui hérite de cette même classe d'afficher autant d'enfants que l'on souhaite, de supprimer certains enfants et de réorganiser l'ordre (les index) d'affichage.

–   Nous connaissons déjà la méthode "addChild".

–   Nous avons également une méthode "addChildAt" qui nous permet de spécifier un index d'affichage. L'index joue le rôle de calque.

 

Si nous comparons la gestion des index au calque de Flash :

–   L'index 0 correspond à l'arrière plan.

–   Plus l'index est élevé, plus l'objet est proche du premier plan

–   L'index le plus élevé, correspond au premier plan. L'index du premier plan dépendra du nombre d'objets affichés.

Dans le cas de ces 3 objets, le DisplayObjectContainer placera dans le Flash Payer :

Le bleu : clip1 (qui est en arrière plan) sur l'index 0.

Le vert : clip2 (qui est entre les deux) sur l'index 1.

Le jaune : clip3 (qui est au premier plan) sur l'index 2.

–   Un index ne peut contenir qu'un seul objet, contrairement à Flash qui nous permet, sur un même claque, de placer plusieurs objets.

–   Il existe une propriété ("numChildren") qui permet de connaître le nombre d'enfants que possède le conteneur.

Dans notre exemple le conteneur racine a 3 enfants, donc la propriété "numChildren" vaudra 3.

–   Il existe une méthode ("getChildIndex") qui nous permet de connaître l'index d'affichage pour un objet donné:

trace ( getChildIndex ( clip2 ) ); E affiche : 1

–   Il existe une méthode qui permet de supprimer l'affichage d'un objet (seulement l'affichage, pas l'objet lui-même) : removeChild ( clip2 ); E affiche  – On pourra, plus tard dans le programme, ré-afficher clip2 par :

addChild ( clip2 );

Attention lorsque l'on fait un addChild dans un programme, l'objet sera toujours placé au premier plan.

–   Nous pouvons modifier l'index d'un objet par la méthode "setChildIndex".

–   Nous pouvons inverser l'index de 2 objets par les méthodes "swapChildren" et "swapChildrenAt". La différence entre ces deux méthodes est sur les paramètres.

 

Nous utiliserons l'une ou l'autre de ces méthodes selon si l'on connait le nom de l'objet ou l'index d'affichage.

–   Attention lorsque l'on utilise des méthodes qui possède "index" en paramètre, de bien donner une  valeur d'index inférieure à "  numChidren " !

  8  Gestion événementielle

  8.1  Ajout d'un écouteur d'événement

 8.1.1   Syntaxe générique

Pour ajouter un écouteur d'événement, nous allons utiliser la méthode "addEventListener" de la

classe "EventDispatcher" :

 

 8.1.2   Syntaxe appropriée

Grâce à la documentation, nous allons pouvoir définir tous les paramètres appropriés à l'objet sur

lequel nous créons un écouteur.

Exemple : pour gérer un clic sur le clip "clip1" (qui est de type "MovieClip").

La documentation relative à l'événement "click" de la classe "MovieClick" nous apporte les renseignements nécessaires :

 

–   ClasseEvenement = MouseEvent

–   identifiantEvenement = MouseEvent.CLICK

 

Nous pouvons également dire que  nous avons  abonné  la fonction "fonctionEcouteur" sur l'événement  "click" de l'objet "clip1".

  8.2  Suppression d'un écouteur d'événement

Par exemple :

Nous souhaitons que le clip "clip1" ne soit cliquable qu'une seule fois, il faudra supprimer (désabonner) la fonction "fonctionEcouteur" après le premier clic.

La fonction "removeEventListener" nous permet de supprimer (désabonner) un écouteur d'événement.

 

  8.3  Propriétés relatives aux événements

Nous pouvons abonner la même fonction à plusieurs événements du même objet.

La propriété "type" nous permettra alors de faire la distinction entre ces événements :

 

Nous pouvons abonner la même fonction à un ou plusieurs événements de plusieurs objets. La propriété "target" nous permettra alors de faire la distinction entre ces objets :

 

Nous allons également pouvoir utiliser cette propriété associée au principe de la propagation des

événements (propagation en bubbling).

Je crée un symbole que j'appelle "conteneur" qui regroupe mes deux clips ("clip1" et "clip2").

Je souhaite le rendre plus transparent un clip (clip1 ou clip2) lorsque je clic sur celui-ci.

 

Je souhaite le rendre plus transparent un clip (clip1 ou clip2) lorsque je clic sur celui-ci.

Bien que la fonction soit abonné sur le conteneur, l'action (grace à la propriété "target") se fait bien

sur le clip sur lequel l'action a eu lieu.

 

  9  Les boucles

  9.1  Principe

–   Les boucles nous permettent d'effectuer un code un certain nombre de fois pour, par exemple, appliquer un même code à un ensemble ou à une collection d'objets.

–   Chaque fois qu'une boucle effectue le code qu'elle contient une fois, nous appelons cela une itération.

  9.2  La boucle for

–   La 1ère instruction est exécutée avant la première itération. Elle initialise la variable de boucle (ici à 0).

–   La 2ème instruction est une condition, qui va renvoyer true ou false, et qui va indiquer si oui ou non nous commençons la prochaine itération de la boucle.

Lorsque la condition n'est pas vérifiée (false) la suite du code après la boucle est exécuté.

–   La 3ème instruction va s'exécuter à chaque fin d'itération (ici i est incrémenté de 1).

  9.3  Les boucles et

–   Ces boucles permettent de parcourir des objets dynamiques, donc des occurrences de classes dynamiques.

–   La boucle va nous permettre de récupérer les données du tableau.

–   La boucle va nous permettre de récupérer les index du tableau qui eux même nous permettent (grâce à la syntaxe à crochets) d'atteindre les données.

 

  9.4  Les boucles while et do..while

–   Dans une boucle while, une itération est exécutée tant la condition renvoie true.

 

Cet exemple permet de supprimer tous les objets affichés sur la scène (en supprimant celui d'index 0 à chaque fois).

 

–   La boucle do..while exécute, quoi qu'il arrive, une première itération. Puis vérifie si la condition renvoie true et passe alors à la deuxième itération.

  10  L'affichage (2ème partie)

  10.1  Menu contextuel sur les objets

 10.1.1   Menu contextuel de l'application

Par défaut, le menu contextuel du Flash Player se présente comme suit :

 

Pour ceci nous utiliserons :

–   une occurrence de la classe "ContextMenu",

–   la méthode "hideBuiltInItems" appliquée à notre occurrence,

–   la propriété "contextMenu"appliquée ici à this (optionnel), c'est à dire au root de notre application. Nous retrouverons cette propriété sur tous les objets interactifs (voir arbre d'héritage).

 

 10.1.2   Menu contextuel d'un objet

Sur le même principe, nous allons appliquer un menu contextuel à un champ texte en utilisant :

–   une occurrence de la classe "ContextMenu",

–   une occurrence de la classe "ContextMenuItem" pour créer et paramétrer un élément du menu,

–   la propriété "customItems" pour ajouter cet élément,

–   la propriété "contextMenu"appliquée ici à notre champ texte.

     

Nous allons devoir maintenant donner une action à cet élément du menu en utilisant un écouteur d'événement en appliquant la méthode vue au chapitre 9.1 :

 

Ce qui donne au final :

 

10.2 Les filtres

Les objets graphiques représentés par la classe "DisplayObject" possèdent une propriété "filters"

de type "Array" ce qui sous-entend que nous pouvons appliquer plusieurs filtres, une liste de filtres, sur un objet graphique.

Nous trouvons dans la documentation, dans le package "flash.filters" l'ensemble des classes liées

aux filtres graphiques :

 

Par exemple, nous souhaitons appliquer à notre clip une ombre portée et un effet biseau.

 

Nous avons la possibilité, lorsque nous construisons l'occurrence, de renseigner certains paramètres

 

Pour annuler l'effet des filtres, ajouter :

 

10.3 Les modes de fusion

Lorsque nous consultons la propriété "blendMode" de la classe "DisplayObject" nous avons un aperçu

des différentes possibilités de fusion :

 

La plupart vont s'appliquer simplement, mais certains comme "BlendMode.ERASE" vont nécessiter

que le BlendMode de l'objet parent soit défini sur "LAYER" :

 

10.4 Repositionnement et redimensionnement des objets

Nous voulons par exemple réaliser un site totalement en Flash qui occupe toute la place disponible

dans le navigateur et qui utilise un repositionnement et un redimensionnement intelligent des différents objets de la scène.

 

Nous avons besoin d'utiliser les fonctionnalités de l'objet "Stage" :

– La première chose à faire est de vérifier que les paramètres de publication sont réglés sur des dimensions en pourcentage réglées sur 100 % (par défaut : Identique à l'animation) :

   

  10.5  Chargement de swf et d'images

Nous allons utiliser la propriété "contentLoaderInfo" de la classe "Loader" qui renvoie un objet "LoaderInfo" correspondant à l’objet en cours de chargement.

 

Pour gérer les chargement des swf et des images, nous allons utiliser les événements de la classe "LoaderInfo" :

 

Comme à l'accoutumée la documentation nous indique l'identifiant événement pour chaque écouteur :

 

On peut simuler un téléchargement pour voir la progression, dans le Flash Player :

Régler les paramètres de téléchargement, puis cliquer sur "Simuler le téléchargement"

 

Construction de la barre de progression :

–   Nous créons deux calques : barre_contour et barre_remplissage.

–   Sur le calque barre_contour , nous dessinons un rectangle (bords noirs, remplissage vert) sur la largeur de la scène.

–   Nous convertissons le remplissage en symbole (Clip) que nous appelons "barreProgression".

–   Nous le coupons et le collons en place sur un calque inférieur pour garder le contour visible

(barre_remplissage), nous donnons le même nom d'occurrence que le nom en bibliothèque ( "barreProgression").

 

Pour animer la barre de progression :

Nous utilisons les propriétés "bytesLoaded" et "bytesTotal" de la classe "ProgressEvent" pour

calculer le rapport de chargement et le transmettre à la propriété "scaleX" de la barre de progression :

 

10.6 Déchargement d'un swf

Lorsque nous déchargeons un swf externe (par exemple par un nouveau chargement) qui lance une

musique ou une vidéo, nous nous apercevons que celles-ci continuent de jouer.



Il faut savoir que la méthode "unload" du chargeur (effectuée automatiquement lors du chargement

du swf suivant) ne fait que le supprimer de l'affichage mais l'objet continue d'exister.

Dans le Flash Player 10, une méthode "unloadAndStop" a été rajoutée sur la classe "Loader" qui

permet de supprimer tous les comportements gênants de ce swf.

Dans le Flash Player 9, cette méthode n'existe pas, il va falloir utiliser un autre moyen. Nous allons

le gérer dans le swf externe, c'est lui qui lance la musique donc c'est à lui de l'arrêter :

 

  11  Mise en forme du texte

  11.1  Avec la classe TextFormat

La classe "TextFormat" nous permet d"effectuer un formatage sur un objet "TextField" que nous

allons pouvoir appliquer sur la totalité de TextField ou seulement sur une partie de son contenu.

Elle nous permet d'appliquer un format de texte par défaut (par "defaultTextFormat") ainsi qu'un

formatage sur une partie du texte (par "setTextFormat") délimitée par index de début et un index de fin.

 

Nous avons sur la scène, un champ de texte nommé "champ"  ainsi qu'un composant bouton nommé "boutonAppliquer". Nous allons appliquer un formatage sur l'ensemble du champ puis permettre un formatage plus spécifique sur la sélection faite par l'utilisateur après avoir cliquer sur le bouton.

 

11.2 En utilisant HTML et CSS dans des fichiers externes

Nous allons utiliser des fichiers externes, un qui contient le texte formaté HTML et un autre qui

contient notre feuille de style :

     

11.3 Intégration de polices de caractères

L'intégration de polices dans un swf nous permet de nous assurer que l'utilisateur visualisera nos

textes avec la police que nous avons choisie dans Flash, même s'il ne possède pas cette police sur son système.

L'intégration de police alourdira le swf d'un poids qui dépendra de la police et des styles que nous

aurons intégrés.

–   Nous allons commencer par créer en bibliothèque une police par un clic droit sur la bibliothèque :

 

–   Nous choisissons la police et le style, nous lui donnons un nom et nous cochons

"Exporter pour ActionScript"

 

–   Nous devons définir un format en lui indiquant le nom réel de la police.

 

–   Nous devons l'appliquer comme format par défaut.

–   Nous devons indiquer que l'on utilise des polices intégrées.

 

–   Nous avons la possibilité de lisser les polices, pour les rendre plus lisibles, en utilisant la

propriété "ADVANCED" de l'anti aliasing

.

Si nous souhaitons utiliser un format HTML (pour, par exemple mettre en gras le mot polices) :

–   Nous devons le spécifier dans le code par la propriété htmlText.

–   Nous devons insérer les balises HTML dans le texte.

 

–   Nous allons devoir intégrer une deuxième fois notre police en lui indiquant le style qui convient.

 

Si nous utilisons les polices intégrées et une feuille de styles externe, nous devons indiquer dans

font-family uniquement le  nom réel de la police

 :

 

  12   Le son

  12.1  Les classes Sound et SoundChannel

Ces classes nous permettent de manipuler du son en AS3.

La classe "Sound" nous permet principalement de :

– lancer le chargement d'un son (méthode "load"),

 

La classe "SoundChannel" va essentiellement s'occuper de la lecture de son.

  12.2  Lecture d'un son (intégré ou externe)

Il existe deux méthodes pour la lecture d'un son :

–   soit par un son en bibliothèque, réservé aux sons légers (événements).

–   soit par un son externe, réservé aux sons longs (musiques).

 12.2.1   Son en bibliothèque

Modifier les propriétés du son en bibliothèque :

– Cocher "Exporter pour ActionScript".

   

 12.2.2   Son externe

 

Nous pouvons lancer la musique même si le chargement n'est pas terminé.

Il s'agit d'un chargement progressif, la lecture commencera dès que suffisamment de données sont

disponibles. Le chargement continuera en parallèle de la lecture de la musique et l'utilisateur ne s'en rendra pas compte à moi que sa connexion Internet soit plus faible que le débit de la musique.

La classe "Sound" ne permet pas de charger plusieurs sons d'affilé. Si nous souhaitions en charger

un second, nous devrions créer une nouvelle occurrence de la classe "Sound".

  12.3  Modification du volume et du panoramique

Lorsque nous souhaitons modifier le volume ou le panoramique (balance) d'un son, nous disposons sur

la classe "SoundChannel" d'une propriété "soundTransform".

 

Cette propriété attend une occurrence de la classe "SoundTransform" qui contient des propriétés

nous permettant de manipuler volume et panoramique.

   

  12.4  Déplacement dans un son

Lorsque nous souhaitons nous déplacer dans un son, nous disposons via la méthode "play" d'un

paramètre "startTime". Son unité est en milliseconde, et il nous permet de nous déplacer dans la lecture d'un son.

 

Mais à chaque fois que nous lançons la méthode "play" sur un son, il commence une nouvelle lecture

sur un nouveau canal, mais rien ne stoppe la lecture précédente dans le précédent canal. 

Si par exemple nous lançons une musique et que nous souhaitons, via un bouton, nous déplacer sur la 1ère minute du son :

 

  13  Le débogueur de Flash

Le débogueur de Flash nous permet d'exécuter un code pas à pas en maitrisant l'avancement

instruction par instruction.

Pour utiliser le débogueur, nous devons déjà ajouter un point d'arrêt (par un clic devant le numéro

de ligne).

 

Nous utilisons ensuite le raccourci clavier "Ctrl+Shift+Entrée" ou la menu "Déboguer / Déboguer

l'animation".

 

Après un temps d'initialisation, nous avons à l'affichage les différentes propriétés initialisées sur this.

 

On retrouve : maVariable qui vaut 0.

Nous avons en haut à gauche un contrôleur, par lequel nous pouvons faire du pas à pas principal ou du

pas à pas détaillé.

Commençons par le pas à pas principal :

 

La petite flèche qui était, avant que je clique, sur la première ligne  m'indique que la fonction "test" va s'exécuter au prochain pas.

–   Si je clique de nouveau sur "pas à pas principal" je vais effectuer la fonction d'un bloc.

–   Si je souhaite rentrer en pas à pas dans ma fonction, je vais cliquer sur "pas à pas détaillé"

Nous arrivons sur la ligne :maVariable = 1000 pour l'instant elle vaut encore 0.

 

Nous avons d'un pas, maVariable vaut maintenant 1000 et l'instruction contenant est prête à être

exécutée.

 

Pour quitter le pas à pas, cliquer sur "sortir du pas à pas".

Pour quitter le débogueur, cliquer sur la croix rouge.

 

  14  Gestion des erreurs à l'exécution

 

Le message d'erreur nous donne :

–   Le nom de la classe d'erreur.

–   Un code d'erreur.

–   Une description de l'erreur.

–   L'objet et la fonction qui a déclenché l'erreur.

–   La position de l'erreur (fichier, image, ligne), à condition d'avoir coché  "Autoriser le débogage" comme indiqué au paragraphe 1.3 "Paramètres de publication".

La documentation nous apporte, dans certains cas, des renseignements supplémentaires sur l'erreur dans la colonne "Description".

Les codes d'erreur sont accessibles par "Annexes / Erreurs d'exécution" :

 

  14.2  Prévoir les risques d'erreur grâce à la documentation

La partie "Valeur émise (ici, "removeChildAt"), nous indique les

" de la

documentation de la méthode

exception

)

     

risques d'erreur (appelé également                  lorsque nous utilisons cette méthode :

 

Nous allons pouvoir faire en sorte que notre code réagisse correctement même en cas d'erreur.

  14.3  Gérer les erreurs : utilisation de blocs try / catch

Sachant que cette méthode peut déclencher une erreur (s'il n'y a pas d'enfant sur l'index indiqué),

comment aurai-je pu faire pour l'intercepter et pour faire en sorte que mon code s'exécute de manière normale malgré cette erreur ?

Avant de répondre à cette question, il faut savoir que lorsque une erreur se déclenche dans un bloc

de code, le code cesse son exécution. Dans notre cas, nous ne voyons pas le trace OK.

 14.3.1   Gérer une erreur

removeChildAt

 
 

try / catch

     

                         Nous avons vu dans la documentation, que la méthode "                         " peut renvoyer une erreur de

type "RangeError", nous allons donc gérer cette erreur en utilisant un bloc "                  " :

 

Cette méthode peut renvoyer 2 exceptions "RangeError" et "ArgumentError".

Nous allons créer 2 blocs catch pour gérer ces 2 types d'erreur :

   

Si nous ne souhaitons ne pas faire de distinction entre les deux erreurs mais que nous souhaitons les

traiter de la même manière, nous utiliserons alors qu'un seul bloc catch en utilisant la classe de base "Error":

 

Admettons que le code que nous mettons dans le bloc catch déclenche lui aussi une erreur.

Que se passe t-il alors ?

La première erreur a bien été gérée, la deuxième (celle du bloc catch) n'a pas été gérée. De plus le

trace OK ne s'est pas exécuté.

Si nous souhaitons qu'un code s'exécute dans tous les cas, même si une erreur a été déclenchée

dans le bloc catch, nous pouvons terminer l'ensemble des blocs par un bloc "finaly".

 Le code dans "  finally  " s'exécutera quoi qu'il arrive , mais l'erreur n'est pas gérée et nous aurions du

ajouter (imbriquer) un autre bloc "try / catch".

 

Il est préférable, de traiter les erreurs avec une condition "if" au lieu d'utiliser les blocs "try / catch". De plus cette méthode est plus rapide (en performance).

  14.4  Lancer des erreurs

Il est possible de générer nous même des erreurs selon certaines condition dans notre code qui en

justifierais l'emploi.

Si nous testons ce code dans un navigateur et que nous disposons du "Flash Player Debugger", nous

obtiendrons ce popup d'erreur :

 

Nous trouvons les versions "Debugger" des Flash Player sur Internet, sur le site Adobe :

 

  15  Gestion de la mémoire

  15.1  Garbage Collector

Le "Garbage Collector" est le système chargé de gérer les ressources mémoire dans le Flash Player.

Son rôle est de supprimer les objets dont nous ne nous servons plus dans l'application.

–   Lorsque nous créons des objets, nous les  référençons dans des "  variables   ".

–   Le "Garbage Collector" part du principe que si un objet en mémoire n'est plus référencé dans l'application, c'est que celle-ci n'en a plus besoin. Il supprime alors définitivement en mémoire cet objet.

null" à la variable

–   Si je souhaite qu'un objet soit supprimé de la mémoire, je dois supprimer la référence de la variable vers cet objet (en affectant la valeur ").

 

Attention :

–   Il faut savoir que le "Garbage Collector" vérifie nos références à intervalles plus ou moins réguliers.

–   Dans une application qui utilise très peu de mémoire, il ne passera pas forcément pour nettoyer la mémoire ou il passera un peu plus tard (lorsque nous créerons de nouveaux objets) !

Nous avons sur la classe "System" une méthode qui se nomme "gc", qui permet de forcer le "Garbage Collector" à vérifier nos références. Elle n'est utilisable que par le Flash Payer Debug (donc seulement en phase de test et non en production) !

 

  15.2  Utilisation mémoire

Si nous souhaitons suivre l'utilisation mémoire de Flash Player, nous pouvons utiliser la propriété "totalMemory" de la classe "System". Elle renvoie l'utilisation mémoire du Flash Player en octets.

 

Attention : lorsque nous utilisons ce code dans un navigateur à onglets, il peut arriver que

"totalMemory" renvoi le nombre d'octets utilisés par l'ensemble des "Flash Player" ouverts dans les différents onglets.

  16  Exemples d'applications

Nous avons sur la scène :

–   Un clip conteneur dans lequel se trouvent

–   3 clips contenant chacun une image.

–   1 fond vectoriel.

Déroulement :

–   Le curseur devient une main sur un élément déplaçable.

–   Les 3 images sont déplaçables avec la souris et passent alors au premier plan.

–   Le fond n'est pas déplaçable.

 

 16.1.1    É vénements souris, startDrag et stopDrag,  index de profondeur

 

  16.2  Diaporama

 

–   Affichage de l'image, au centre.

–   Une barre de progression du chargement de l'image, en haut.

–   Le titre et la description de l'image, sous l'image.

–   2 boutons qui permettent d'avancer ou de reculer dans la série d'images en tournant en boucle.

Organisation :

–   Les images sont placées dans un dossier "img".

–   L'application est renseignée par le fichier "" placé dans le dossier "xml".

Nous partons d'un document fla qui contient des éléments posés sur la scène : – 2 champs de texte.

–   2 boutons.

–   2 composants :

–   Un UILoader qui permet de charger des images ou des swf, de les centrer et de les redimensionner automatiquement en fonction du rapport largeur sur hauteur.

–   Un ProgressBar, nous lui indiquerons qu'il doit s'appliquer au chargement des images de l'UILoader.

 

Fichier :

 

 16.2.1   Code Navigation : Object, Array, opérateurs d'incrémentation

 

Différents opérateurs d'incrémentation (+) ou de décrémentation (-) :

                  – maVariable =  maVariable + 10            E incrémentation de 10

– maVariable += 10

E incrémentation de 10

– maVariable ++

E incrémentation de 1

– if ( ++maVariable  > 0 )

E incrémentation de 1 puis test

– if ( maVariable++  > 0 )

E test puis incrémentation de 1

 16.2.2   Code XML : Chargement et traitement du fichier, création liste et objet

 

Différents traitements d'un fichier XML :

 

- Filtre du fichier par le nom d'un élément (ex: "photo") :

 

–   Recherche sur la valeur d'un élément  ( url == … )

Pour appliquer une condition, il faut utiliser les parenthèses :

 

–   Recherche sur l'attribut d'un élément  (  @id="1" )

Pour appliquer une condition sur l'attribut, il faut utiliser faire précéder le nom de l'attribut de @ :

 

–   Filtre sur l'élément d'un élément  ( titre ) :

 

–   Code HTML  dans le fichier XML :

Si nous souhaitons utiliser du code HTML dans les éléments, nous devons encadrer le contenu de l'élément par une balise "CDATA" dont la syntaxe est :     ![CDATA[  …  ]]

 

  16.3  Générateur de particules

 16.3.1   Événement ENTER_FRAME, boucle d'animation, collection d'objets

 16.3.2   comportement aléatoire, classe dynamique, mémoire cache

   

  16.4  Formulaire

 

Attention :

Si nous voulons tester (dans Flash) une application qui utilise des entrées clavier, nous devons cocher "désactiver les raccourcis clavier" dans le Flash Player intégré à Flash. Sinon les raccourcis clavier vont être dirigés vers le logiciel Flash plutôt que vers le Flash Player et nous risquerons alors de modifier l'application (ajout image clé, …).

 16.4.1   Gestion des ordres de tabulation

   

 16.4.3   Événements focus

Lorsqu'un champ a le focus, les entrées du clavier sont dirigées sur lui.

Nous voulons que lorsqu'un champ prend le focus, tout son contenu soit sélectionné.

 

 16.4.4   Événements clavier

Nous voulons que la touche "Entrée" valide un champ texte lorsque celui-ci a le focus.

 

16.4.5 Envoyer des variables vers une URL

Pour envoyer les valeurs saisies dans le formulaire vers un script serveur (Php, …), pour par exemple

enregistrer ces valeurs dans une base de données.

 

  16.5  Jeu de grattage

Lorsque nous avons gratté une partie suffisante de l'image, la totalité de l'image se dévoile et nous

pouvons afficher un message à l'utilisateur.

 

Nous allons utiliser la classe BitmapData en tant que masque et dessiner le motif dans l'objet BitmapData. C'est donc l'objet Bitmap qui va servir de masque.

Un BitmapData n'est qu'une grille de pixels, lorsque nous dessinons dans un bitmapData, nous ne

créons pas un nouvel objet mais nous changeons simplement la couleur des pixels de ce BitmapData.

Cette classe permet de faire du traitement d'image. Ce n'est pas un objet graphique car c'est la

classe Bitmap qui est l'objet.

Dans cette classe BitmapData, nous utiliserons la méthode draw avec la matrice de transformation

et la méthode threshold.

Nous avons sur la scène un clip image et un clip fond. Au fur et à mesure que nous allons gratter,

nous allons révéler l'image qui remplacera petit à petit le fond. En ActionScript, lorsque nous utilisons la propriété masque d'un DisplayObject, le contenu du masque ne va pas masquer l'objet qui se trouve dessous mais va le révéler.

Nous allons donc avoir une première couche qui est le fond, une seconde qui est l'image et nous

allons par dessus créer un DisplayOject qui servira de masque. Il sera vide au départ, il ne révélera aucune partie de l'image et le fond sera apparent, au fur et à mesure que le grattage évoluera nous dessinerons dans le masque qui révélera petit à petit l'image.

 

16.5.2 Événements souris, affichage et masquage curseur

Nous allons utiliser 3 événements souris :

–   MOUSE_DOWN lorsque le grattage commence,

–   il enchaine sur MOUSE_MOVE qui va être déclenché à chaque fois que l'on bougera la souris, – qui se terminera par MOUSE_UP au moment où l'on relachera le bouton de la souris.

 16.5.3   Matrice de transformation

Nous allons utiliser le paramètre "matrix" de la méthode draw de la classe BitmapData.

Il s'agit d'une matrice de transformation qui contient l'ensemble des transformations géométriques (translation, rotation, inclinaison, échelle) applicables sur un objet graphique.

Nous allons utiliser la translation (déplacement).

Nous allons utiliser les propriétés tx et ty de cette matrice pour déplacer le motif.

   

16.5.4 Comparaison de la valeurs des pixels

Nous allons utiliser la méthode "threshold" de la classe BitmapData.

Elle renvoi le nombre de pixels répondant à notre méthode de comparaison par rapport au seuil.

 

 16.5.5   Classe Timer

Nous allons utiliser la classe Timer qui permet d'exécuter une fonction à intervalles réguliers, un

certains nombre de fois.

 

Nota :

Nous pouvons modifier la difficulté du jeu soit par :

–   la modification du rapport de grattage,

–   la modification de l'aspect du clip motif.

   



185