1. 1. trace(quot;Pratique d'ActionScript 3quot;); // Thibault IMBERT
2. 2. Remerciements// quot;Je voudrais remercier tout particulirement Mathieu Anthoine (Mama) pour sarelecture soigne et ses conseils aviss durant toute la rdaction de louvrage.Son exprience et sa vision du Flash est une source dinspiration.Jrme Decoster pour sa relecture attentive, son soutien et ses conseils toujourspertinents. Pour nos soires pizza discuter ActionScript 3 et te faire rentrer chez toien vlib. Chris Georgenes (www.mudbubble.com) et Aurelien Marcheguay de Carton Blanc(www.cartonblanc.com) pour leur soutien et leurs illustrations qui mont permisdenrichir graphiquement louvrage.Je remercie tous mes compagnons flasheurs qui mont forcment soutenu et aid un moment donn : Joa Ebert, Didier Brun, Jrme Cordiez, Vincent Maitray, FrdericSaunier, Benjamin Jung.Le centre Regart.net pour mavoir soutenu. A Nicolas pour ses opinions, Eric pourses bonnes blagues, et Guylaine pour ces annes chez Regart.Justin Everett-Church dAdobe et Henri Torgemane de Yahoo pour leur aide et leursoutien.Sgolne (www.chevaldetroie.net) pour avoir relu tous ces chapitres la recherchede fautes dorthographes. Mes amis que je nai pas vu pendant quasiment 8 mois : Sbastien, Bessam, Laurent,Paul, Juan, Pascal, Bob Groove et bien sr Stevie Wonder.Sonia pour ce dimanche 20 aot 2006 o ma vie a change.Mes parents et ma sur qui mont soutenu pendant lcriture. Bien entendu, je ne peux pas terminer les remerciements sans remercier tous messtagiaires que jai pu rencontrer depuis plus de trois ans de formations. Jai apprisnormment chaque jour vos cts, vous avez particip cet ouvrage dune faonou dune autre.quot;
3. 3. trace(quot;Pratique d'ActionScript 3quot;);//Pratique dActionScript 3 sadresse tous les flasheurs.Cet ouvrage dresse un panorama de lutilisation dActionScript 3 et de ses nouveauts, ainsi que du nouveau lecteur Flash 9. Lauteur explique au travers de nombreux exemples et cas concrets comment traiter dsormais les objets, le texte, le son et la vido, le chargement et lenvoi de donnes externes (variables, XML, etc.), les sockets, etc. Certains sujets avancs et peu abords comme les classes bas niveau ou encore Flash Remoting sont galement traits. Enfin, lauteur livre une application complte qui reprend les diffrents points voqus.//Thibault IMBERT est aujourd'hui ingnieur systme chez Adobe France.Il a commenc en tant que dveloppeur Flash pour diffrentes agences, avant de rejoindre Regart.net comme formateur et responsable pdagogique pour toutes les formations conernant la plate-forme Flash.Pendant son temps libre, Thibault exprimente ActionScript 3, comme en tmoigne son site www.bytearray.org. Il travaille galement sur diffrents projets tels que WiiFlash www.wiiflash.org ou AlivePDF www.alivepdf.org Avril 2008 Environ 1200 pages. Pour un livre tlcharg, un platane plant. Graphisme couverture : Guillaume DURAND dgezeo
4. 4. Chapitre 1 Quest ce que lActionScript 3 ? - version 0.11Quest ce que lActionScript 3 HISTORIQUE............................................................................................................1 10 RAISONS DE CODER EN ACTIONSCRIPT 3................................................3 OUTILS.......................................................................................................................3 LA PLATEFORME FLASH.....................................................................................4 Historique Cest en 1996 que laventure Flash commence lorsque la firme Macromedia rachte la petite socit FutureWave auteur dun logiciel danimation vectoriel nomm Future Splash Animator.1/5 Thibault Imbert pratiqueactionscript3.bytearray.org
5. 5. Chapitre 1 Quest ce que lActionScript 3 ? - version 0.1 Figure 1-1. Future Splash Animator sorti en avril1996. Dvelopp lorigine pour pouvoir animer du contenu vectoriel sur Internet, Future Splash Animator intgrait dj les bases de Flash en matire danimation mais ne possdait cette poque aucun langage de programmation associ. Macromedia renomma alors le logiciel sous le nom de Flash 1.0 en 1996, mais il faut attendre 1999 afin que la notion de programmation fasse officiellement son apparition avec Flash 4. Les documentations de lpoque ne parlent pas encore de langage ActionScript mais plus simplement dactions. Grce celles-ci, il devient possible dajouter des comportements avancs aux boutons et autres objets graphiques. De nombreux graphistes laise avec la programmation commencrent dvelopper des comportements avancs et se mirent changer des scripts par le biais de forums et autres plateformes communautaire. Flash connu alors un engouement fulgurant et devint rapidement un outil danimation avanc, capable de produire diffrents types de contenus interactifs comme des sites internet, des jeux, ou des applications multimdia. Cest en 2001 que le langage ActionScript fait officiellement apparition au sein de Flash 5. La notion de syntaxe pointe est intgre au langage qui suit pour la premire fois les spcifications ECMAScript. Nous reviendrons sur cette notion au cours du prochain chapitre intitul Langage et API. Afin de rpondre une demande de la communaut pour un langage ActionScript plus structur, Macromedia dveloppe alors une nouvelle version dActionScript et lintgre en 2003 au sein de Flash MX 2004 sous le nom dActionScript 2.0. Cette nouvelle version rpond aux besoins des dveloppeurs en offrant un langage orient objet et non procdural comme ctait le cas en ActionScript 1.0. A lpoque, Macromedia fait le choix dune migration en douceur, et propose un langage ActionScript 2.0 souple permettant aux dveloppeurs et graphistes de coder au sein dun mme projet en ActionScript 1.0 et 2.0. Si cette nouvelle version du langage ne satisfait pas les dveloppeurs puristes, elle permet nanmoins aux dveloppeurs dbutant de migrer doucement vers un dveloppement orient objet. Macromedia dveloppe alors une nouvelle version 3.0 du langage ActionScript afin doffrir des performances optimales leur nouvelle cration nomme Flex. Deux ans plus tard, la socit Macromedia se voit rachete par le gant Adobe et lActionScript 3 voit le jour au sein de Flash en 2007, lors de la sortie de Flash CS3. 2/5 Thibault Imbert pratiqueactionscript3.bytearray.org
6. 6. Chapitre 1 Quest ce que lActionScript 3 ? - version 0.1 10 raisons de coder en ActionScript 3 Si vous ntes pas encore convaincu de migrer vers ActionScript 3, voici 10 raisons pour ne plus hsiter : En dcembre 2007, le lecteur Flash 9 possde un taux de pntration de plus de 95%. Il demeure le lecteur multimdia le plus prsent sur Internet. La vitesse dexcution du code est environ 10 fois suprieure aux prcdentes versions dActionScript. ActionScript 3 offre des possibilits incomparables aux prcdentes versions dActionScript. Le code ActionScript 3 savre plus logique que les prcdentes versions du langage. Le langage ActionScript 3 permet de dvelopper du contenu en Flash, Flex, ou AIR. Nous reviendrons trs vite sur ces diffrents framework. Il nest pas ncessaire de connatre un autre langage orient objet au pralable. ActionScript 3 est un langage orient objet. Sa connaissance vous permettra daborder plus facilement dautres langages objets tels Java, C#, ou C++. Le langage ActionScript 3 et lAPI du lecteur Flash ont t entirement repenss. Les dveloppeurs ActionScript 1 et 2 seront ravis de dcouvrir les nouveauts du langage et la nouvelle organisation de lAPI du lecteur. La technologie Flash ne cesse dvoluer, vous ne risquez pas de vous ennuyer. ActionScript 3 est un langage souple, qui demeure ludique et accessible. Bien entendu, vous pouvez mmoriser ces diffrents points afin de convaincre vos amis au cours dune soire geek. ActionScript 3 ne vous sera pas dune grande utilis sans un environnement de dveloppement ddi. Nous allons nous attarder quelques instants sur les diffrents outils disponibles permettant de produire du contenu ActionScript 3.Outils Afin quil ny ait pas de confusions, voici les diffrents outils vous permettant de coder en ActionScript 3 : Flash CS3 : permet le dveloppement danimations et dapplications en ActionScript 3. Pour plus dinformations : http://www.adobe.com/fr/products/flash/3/5 Thibault Imbert pratiqueactionscript3.bytearray.org
7. 7. Chapitre 1 Quest ce que lActionScript 3 ? - version 0.1 Flex Builder : il sagit dun environnement auteur permettant le dveloppement dapplications riches (RIA). Flex repose sur deux langages, le MXML afin de dcrire les interfaces, et ActionScript pour la logique. Pour plus dinformations : http://www.adobe.com/fr/products/flex/ Eclipse (SDK Flex et AIR) : les SDK de Flex et AIR permettent de produire du contenu Flex et AIR gratuitement. Il sagit de plugins pour lenvironnement de dveloppement Eclipse. Vous avez dit plateforme ?La plateforme Flash Par le terme de plateforme Flash nous entendons lensemble des technologies travers lesquelles nous retrouvons le lecteur Flash. Nous pouvons diviser la plateforme Flash en trois catgories : Les lecteurs Flash : parmi les diffrents lecteurs, nous comptons le lecteur Flash, le lecteur Flash intgr AIR, ainsi que Flash Lite (notons que Flash lite nest pas ce jour compatible avec ActionScript 3). Les outils de dveloppement : Flex Builder et Flash CS3 sont les deux environnements auteurs permettant de produire du contenu Flash. Notons quil est aussi possible dutiliser lenvironnement Eclipse et les SDK de Flex et AIR. Les framework : Flex est un framework conu pour faciliter le dveloppement dapplications riches. Grce AIR, ces applications peuvent sortir du navigateur et tre dployes sur le bureau. Chaque outil de dveloppement ou framework rpond une attente spcifique et correspond un profil type. Un graphiste-dveloppeur sera intress par le dveloppement dinterfaces animes et de sites Internet au sein de Flash CS3. La connaissance dun environnement comme Flash CS3 lui permettra aussi de dvelopper des composants rutilisablesau sein de Flex et AIR. Un dveloppeur prfrera peut tre un environnement de dveloppement comme celui offert par Flex Builder. Les applications produites grce au framework Flex seront de nature diffrente et pourront facilement tre dployes sur le bureau grce AIR.Notons que les exemples prsents dans cet ouvrage peuvent tre utiliss au sein de Flash CS3, Flex et AIR.Afin dentamer cette aventure au cur dActionScript 3, nous allons nous intresser tout dabord aux diffrentes nouveauts du langage. 4/5 Thibault Imbert pratiqueactionscript3.bytearray.org
8. 8. Chapitre 1 Quest ce que lActionScript 3 ? - version 0.1 En route pour le prochain chapitre intitul Langage et API ! 5/5 Thibault Imbert pratiqueactionscript3.bytearray.org
9. 9. Chapitre 2 Langage et API - version 0.1 2 Langage et API LE LANGAGE ACTIONSCRIPT 3..........................................................................1 MACHINES VIRTUELLES...................................................................................................4 TRADUCTION DYNAMIQUE................................................................................................6 GESTION DES TYPES LEXCUTION..................................................................................7 ERREURS LEXCUTION..............................................................................................13 NOUVEAUX TYPES PRIMITIFS..........................................................................................15 VALEURS PAR DFAUT..................................................................................................19 NOUVEAUX TYPES COMPOSITES......................................................................................21 NOUVEAUX MOTS-CLS.................................................................................................21 FONCTIONS.................................................................................................................22 CONTEXTE DEXCUTION...............................................................................................25 BOUCLES....................................................................................................................26 ENRICHISSEMENT DE LA CLASSE ARRAY..........................................................................27 RAMASSE-MIETTES.......................................................................................................30 BONNES PRATIQUES......................................................................................................33 AUTRES SUBTILITS......................................................................................................34 Le langage ActionScript 3 Le langage ActionScript 3 intgre de nombreuses nouveauts que nous allons traiter tout au long de cet ouvrage. Ce chapitre va nous permettre de dcouvrir les nouvelles fonctionnalits et comportements essentiels tout dveloppeur ActionScript 3. Avant de dtailler les nouveauts lies au langage ActionScript 3, il convient de dfinir tout dabord ce que nous entendons par le terme ActionScript. De manire gnrale, le terme ActionScript englobe deux composantes importantes :1 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
10. 10. Chapitre 2 Langage et API - version 0.1 Le cur du langage : il sagit du langage ActionScript bas sur la spcification ECMAScript (ECMA-262) et intgre partiellement certaines fonctionnalits issues de la spcification ECMAScript 4. LAPI du lecteur Flash : il sagit des fonctionnalits du lecteur Flash. Toutes les classes ncessitant dtre importes font partie de lAPI du lecteur et non du cur du langage ActionScript. Ainsi, linterface de programmation du lecteur ou le langage peuvent tre mise jour indpendamment. Le lecteur Flash 10 devrait normalement intgrer une gestion de la 3D native ainsi quune implmentation plus complte de la spcification ECMAScript 4. La gestion de la 3D concerne ici uniquement linterface de programmation du lecteur Flash, linverse les nouveaux objets dfinis par la spcification ECMAScript 4 sont directement lis au cur du langage ActionScript. Dun ct rside le langage ActionScript 3, de lautre lAPI du lecteur appele gnralement interface de programmation, la figure 2-1 illustre les deux entits : 2 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
11. 11. Chapitre 2 Langage et API - version 0.1 Figure 2-1. Langage ActionScript 3. Contrairement aux prcdentes versions dActionScript, nous remarquons quen ActionScript 3, les diffrentes fonctionnalits du lecteur Flash sont dsormais stockes dans des paquetages spcifiques. Afin dafficher une vido nous utiliserons les objets issus du paquetage flash.media. A linverse, pour nous connecter un serveur, nous utiliserons les objets issus du paquetage flash.net.Flash CS3 est configur afin dimporter automatiquement toutes les classes issues de lAPI du lecteur Flash. Il nest donc pas ncessaire dimporter manuellement les classes lorsque nous codons au sein de lenvironnement auteur. Un fichier implicitImports.xml situ au sein du rpertoire dinstallation de Flash CS3 (C:Program FilesAdobeAdobe Flash3 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
12. 12. Chapitre 2 Langage et API - version 0.1 CS3frConfigurationActionScript 3.0) contient toutes les dfinitions de classe importer :Afin de crer un clip dynamiquement nous pouvons crire directement sur une image du scnario :var monClip:MovieClip = new MovieClip();Si nous plaons notre code lextrieur de Flash au sein de classes, nous devons explicitement importer les classes ncessaires :import flash.display.MovieClip; var monClip:MovieClip = new MovieClip();Dans cet ouvrage nous nimporterons pas les classes du lecteur lorsque nous programmerons dans lenvironnement auteur de Flash. A linverse ds lintroduction des classes au sein du chapitre 8 intitul Programmation oriente objet, nous importerons explicitement les classes utilises.A retenir Le langage ActionScript 3 englobe deux composantes : lecur du langage ActionScript et linterface deprogrammation du lecteur Flash. Le cur du langage est dfini par la spcificationECMAScript.Machines virtuelles Le code ActionScript est interprt par une partie du lecteur Flash appele machine virtuelle. Cest cette dernire qui se charge de retranscrire en langage machine le code binaire (ActionScript byte code) gnr par le compilateur. 4 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
13. 13. Chapitre 2 Langage et API - version 0.1 Les prcdentes versions du lecteur Flash intgraient une seule machine virtuelle appele AVM1 afin dinterprter le code ActionScript 1 et 2. En ralit, le code binaire gnr par le compilateur en ActionScript 1 et 2 tait le mme, cest la raison pour laquelle nous pouvions faire cohabiter au sein dun mme projet ces deux versions du langage ActionScript. La figure 2-2 illustre la machine virtuelle 1 (AVM1) prsente dans le lecteur Flash 8 :Figure 2-2. AVM1 au sein du lecteur Flash 8. Le langage ActionScript 3 nest pas compatible avec cette premire machine virtuelle, pour des raisons videntes de rtrocompatibilit, le lecteur Flash 9 embarque donc deux machines virtuelles. Lors de la lecture dun SWF, le lecteur slectionne automatiquement la machine virtuelle approprie afin dinterprter le code ActionScript prsent au sein du SWF. Ainsi, une application ActionScript 1 et 2 sera interprte au sein du lecteur Flash 9 par la machine virtuelle 1 (AVM1) et ne bnficiera daucune optimisation des performances. La figure 2-3 prsente les deux machines virtuelles au sein du lecteur Flash 9 : 5 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
14. 14. Chapitre 2 Langage et API - version 0.1Figure 2-3. Le lecteur Flash 9 et les deux machinesvirtuelles AVM1 et AVM2. Seules les animations compiles en ActionScript 3 pourront bnficier des optimisations ralises par la nouvelle machine virtuelle (AVM2).A retenir Les prcdentes versions du lecteur Flash intgraient uneseule machine virtuelle afin dinterprter le codeActionScript 1 et 2. La machine virtuelle 1 (AVM1) interprte le codeActionScript 1 et 2. La machine virtuelle 2 (AVM2) interprte seulement le codeActionScript 3. Le lecteur Flash intgre les deux machines virtuelles (AVM1et AVM2). Le langage ActionScript 3 ne peut pas cohabiter avec lesprcdentes versions dActionScript.Traduction dynamique Afin doptimiser les performances, la machine virtuelle 2 (AVM2) du lecteur Flash 9 intgre un mcanisme innovant de compilation du code la vole. Bien que le terme puisse paratre tonnant, ce principe appel gnralement traduction dynamique permet dobtenir de meilleures performances dexcution du code en compilant ce dernier lexcution. Dans les prcdentes versions du lecteur Flash, le code prsent au sein du SWF tait directement retranscrit par la machine virtuelle en langage machine sans aucune optimisation lie la plateforme en cours. 6 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
15. 15. Chapitre 2 Langage et API - version 0.1 En ActionScript 3 la machine virtuelle retranscrit le code binaire (ActionScript byte code) en langage machine laide dun compilateur la vole appel couramment compilateur la vole. (Just-in-time compiler). Ce dernier permet de compiler uniquement le code utilis et de manire optimise selon la plateforme en cours. La machine virtuelle peut donc optimiser les instructions pour un processeur spcifique tout en prenant en considration les diffrentes contraintes de la plateforme. Pour plus dinformations lies la compilation lexcution, rendez vous ladresse suivante : http://en.wikipedia.org/wiki/Just-in-time_compilation http://fr.wikipedia.org/wiki/Compilation_%C3%A0_la_vol%C3%A9eGestion des types lexcution ActionScript 2 introduit au sein de Flash MX 2004 la notion de typage fort. Cela consistait associer un type de donnes une variable laide de la syntaxe suivante :variable:TypeDans le code suivant, nous tentions daffecter une chane une variable de type Number :var distance:Number = quot;150quot;;Lerreur suivante tait gnre la compilation :Incompatibilit de types dans l'instruction d'affectation : String dtect aulieu de Number.En ActionScript 3, nous bnficions du mme mcanisme de vrification des types la compilation. En compilant le mme code en ActionScript 3, lerreur suivante est gnre :1067: Contrainte implicite d'une valeur du type String vers un type sansrapport Number.Ce comportement est appel Mode prcis dans Flash CS3 et peut tre dsactiv par lintermdiaire du panneau Paramtres dActionScript 3.0. A travers le panneau Paramtres de publication, puis de longlet Flash, nous cliquons sur le bouton Paramtres. Nous obtenons un panneau Paramtres dActionScript 3 contenant deux options lies aux erreurs comme lillustre la figure 2-4 : 7 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
16. 16. Chapitre 2 Langage et API - version 0.1Figure 2-4. Options du compilateur ActionScript 3. Nous remarquons que par dfaut, le Mode prcis est activ, nous reviendrons trs vite sur le Mode avertissements. En dcochant la case Mode prcis, nous dsactivons la vrification des types la compilation afin de dcouvrir un comportement extrmement important apport par ActionScript 3. En testant le code suivant en mode non prcis, nous remarquons quaucune erreur de compilation nest gnre :var distance:Number = quot;150quot;;A lexcution, la machine virtuelle 2 (AVM2) convertit automatiquement la chane de caractres 150 en un nombre entier de type int.Afin de vrifier cette conversion automatique, nous pouvons utiliser la fonction describeType du paquetage flash.utils :var distance:Number = quot;150quot;; /* affiche :*/trace( describeType ( distance ) );La fonction describeType renvoie un objet XML dcrivant le type de la variable. Nous pouvons remarquer que lattribut name du nud type renvoie int.En modifiant la chane de caractres nous obtenons une conversion automatique vers le type Number :var distance:Number = quot;150.5quot;; /* affiche :*/trace( describeType ( distance ) ); 8 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
17. 17. Chapitre 2 Langage et API - version 0.1 Si nous tentons daffecter un autre type de donnes celle-ci, la machine virtuelle 2 (AVM2) conserve le type Number et convertit implicitement les donnes lexcution.Contrairement au mode prcis, ce comportement de vrification des types lexcution ne peut pas tre dsactiv.Nous pourrions ainsi en conclure de toujours conserver le mode prcis afin de ne pas tre surpris par ce comportement, mais certaines erreurs de types ne peuvent tre dtectes par le compilateur car celles-ci ninterviennent qu lexcution. Dans le code suivant, le compilateur ne dtecte aucune erreur :var tableauDonnees:Array = [ quot;150quot;, quot;250quot; ]; // l'entre du tableau est automatiquement convertie en intvar distance:Number = tableauDonnees[0];A lexcution, la chane de caractres prsente lindex 0 est automatiquement convertie en int. Cette conversion reste silencieuse tant que celle-ci russie, au cas chant une erreur lexcution est leve. Dans le code suivant, nous tentons de stocker une chane de caractres au sein dune variable de type MovieClip :var tableauDonnees:Array = [ quot;clipquot;, quot;250quot; ]; // lve une erreur l'excutionvar clip:MovieClip = tableauDonnees[0];A lexcution, la machine virtuelle 2 (AVM2) tente de convertir la chane en MovieClip et choue, lerreur lexcution suivante est leve :TypeError: Error #1034: Echec de la contrainte de type : conversion de quot;clipquot;en flash.display.MovieClip impossible.Nous pouvons alors nous interroger sur lintrt dun tel comportement, pourquoi la machine virtuelle svertue-t-elle conserver les types lexcution et convertit automatiquement les donnes ? Afin de garantir des performances optimales, la machine virtuelle 2 (AVM2) sappuie sur les types dfinis par le dveloppeur. Ainsi, lorsque nous typons une variable, loccupation mmoire est optimise spcifiquement pour ce type, ainsi que les instructions processeur. 9 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
18. 18. Chapitre 2 Langage et API - version 0.1Il ne faut donc pas considrer ce comportement commeun dsagrment mais comme un avantage contribuant de meilleures performances.Ce comportement diffre dActionScript 2, o la machine virtuelle 1 (AVM1) valuait dynamiquement tous les types lexcution, aucune optimisation ntait ralise. Le typage des variables ntait quune aide la compilation. La grande nouveaut lie ActionScript 3 rside donc dans lintrt du typage la compilation comme lexcution. En associant un type une variable en ActionScript 3 nous bnficions dune vrification des types la compilation et dune optimisation des calculs raliss par le processeur et dune meilleure optimisation mmoire. Il est donc primordial de toujours typer nos variables enActionScript 3, les performances en dpendent trsnettement. Nous typerons systmatiquement nosvariables durant lensemble de louvrage.Voici un exemple permettant de justifier cette dcision : Une simple boucle utilise une variable dincrmentation i de type int :var debut:Number = getTimer(); for ( var i:int = 0; i< 500000; i++ ) { } // affiche : 5trace( getTimer() - debut );La boucle ncessite 5 millisecondes pour effectuer 500 000 itrations. Sans typage de la variable i, la boucle suivante ncessite 14 fois plus de temps sexcuter :var debut:Number = getTimer(); for ( var i = 0; i< 500000; i++ ) { } // affiche : 72trace( getTimer() - debut ); 10 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
19. 19. Chapitre 2 Langage et API - version 0.1 Dans le code suivant, la variable prenom ne possde pas de type spcifique, la machine virtuelle doit valuer elle-mme le type ce qui ralentit le temps dexcution :var debut:Number = getTimer(); var prenom = quot;Bobbyquot;;var prenomRaccourci:String; for ( var i:int = 0; i< 500000; i++ ) { prenomRaccourci = prenom.substr ( 0, 3 ); } // affiche : 430trace( getTimer() - debut ); // affiche : Bobtrace ( prenomRaccourci );En typant simplement la variable prenom nous divisons le temps dexcution de presque deux fois :var debut:Number = getTimer(); var prenom:String = quot;Bobbyquot;;var prenomRaccourci:String; for ( var i:int = 0; i< 500000; i++ ) { prenomRaccourci = prenom.substr ( 0, 3 ); } // affiche : 232trace( getTimer() - debut ); // affiche : Bobtrace ( prenomRaccourci );Au sein du panneau Paramtres ActionScript 3, nous pouvons apercevoir un deuxime mode de compilation appel Mode avertissements. Ce dernier permet dindiquer plusieurs types derreurs comme par exemple les erreurs lies la migration de code.attachMovie Supposons que nous tentions dutiliser la mthode dans un projet ActionScript 3 :var ref:MovieClip = this.attachMovie (quot;clipquot;, quot;monClipquot;, 0);Au lieu dindiquer un simple message derreur, le compilateur nous renseigne que notre code nest pas compatible avec ActionScript 3 et nous propose son quivalent. 11 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
20. 20. Chapitre 2 Langage et API - version 0.1 Le code prcdent gnre donc le message derreur suivant la compilation :Warning: 1060: Problme de migration : la mthode 'attachMovie' n'est plusprise en charge. Si le nom de la sous-classe de MovieClip est A, utilisez varmc= new A(); addChild(mc). Pour plus d'informations, consultez la classeDisplayObjectContainer.Le Mode avertissements permet davertir le dveloppeur de certains comportements lexcution risquant de le prendre au dpourvu.Attention, les avertissements nempchent ni la compilation du code ni son excution, mais avertissent simplement que le rsultat de lexcution risque de ne pas tre celui attendu.Dans le code suivant, un dveloppeur tente de stocker une chane de caractre au sein dune variable de type Boolean :var prenom:Boolean = quot;Bobbyquot;;A la compilation, lavertissement suivant est affich :Warning: 3590: String utilise alors qu'une valeur boolenne est attendue.L'expression va tre transtype comme boolenne.Il est donc fortement conseill de conserver le Mode prcis ainsi que le mode avertissements afin dintercepter un maximum derreurs la compilation. Comme nous lavons vu prcdemment, le lecteur Flash 9 nchoue plus en silence et lve des erreurs lexcution. Nous allons nous intresser ce nouveau comportement dans la partie suivante.A retenir 12 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
21. 21. Chapitre 2 Langage et API - version 0.1 Il est possible de dsactiver la vrification de type lacompilation. Il nest pas possible de dsactiver la vrification de type lexcution. Le typage en ActionScript 2 se limitait une aide lacompilation. Le typage en ActionScript 3 aide la compilation et lexcution. Dans un souci doptimisation des performances, il estfortement recommand de typer les variables en ActionScript3. Il est fortement conseill de conserver le mode prcis ainsique le mode avertissements afin dintercepter un maximumderreurs la compilation.Erreurs lexcution Nous avons trait prcdemment des erreurs de compilation laide du mode prcis et abord la notion derreurs lexcution. Une des grandes nouveauts du lecteur Flash 9 rside dans la gestion des erreurs. Souvenez-vous, les prcdentes versions du lecteur Flash ne levaient aucune erreur lexcution et chouaient en silence. En ActionScript 3 lorsque lexcution du programme est interrompue de manire anormale, on dit quune erreur dexcution est leve. Afin de gnrer une erreur lexcution nous pouvons tester le code suivant :// dfinition d'une variable de type MovieClip// sa valeur par dfaut est nullvar monClip:MovieClip; // nous tentons de rcuprer le nombre d'images du scnario du clip// il vaut null, une erreur d' excution est levevar nbImages:int = monClip.totalFrames;La fentre de sortie affiche lerreur suivante :TypeError: Error #1009: Il est impossible d'accder la proprit ou lamthode d'une rfrence d'objet nul.Afin de grer cette erreur, nous pouvons utiliser un bloc try catch :// dfinition d'une variable de type MovieClip// sa valeur par dfaut est nullvar monClip:MovieClip; var nbImages:int; // grce au bloc try catch nous pouvons grer l'erreurtry13 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
22. 22. Chapitre 2 Langage et API - version 0.1{ nbImages = monClip.totalFrames; } catch ( pErreur:Error ) { trace ( quot;une erreur d'excution a t leve !quot;); }Bien entendu, nous nutiliserons pas systmatiquement les blocs try catch afin dviter dafficher les erreurs lexcution. Certains tests simples, que nous dcouvrirons au cours de louvrage, nous permettrons quelque fois dviter davoir recours ces blocs. Dans un contexte derreurs lexcution, il convient de dfinir les deux dclinaisons du lecteur Flash existantes : Version de dbogage (Player Debug) : cette version du lecteur est destine au dveloppement et affiche les erreurs lexcution en ouvrant une fentre spcifique indiquant lerreur en cours. Ce lecteur est install automatiquement lors de linstallation de lenvironnement de dveloppement Flash CS3 ou Flex Builder 2 et 3. Version production (Player Release) : cette version du lecteur est disponible depuis le site dAdobe. Les personnes nayant pas denvironnement de dveloppement install utilisent cette version du lecteur. Ce lecteur naffiche pas les erreurs lexcution afin de ne pas interrompre lexprience de lutilisateur. Avec le lecteur de dbogage, les erreurs non gres par un bloc try catch ouvrent un panneau derreur au sein du navigateur comme lillustre la figure 2-5 : Figure 2-5. Exemple derreur lexcution. Lorsquune erreur est leve, lexcution du code est alors mise en pause. Nous pouvons alors dcider de continuer lexcution du code 14 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
23. 23. Chapitre 2 Langage et API - version 0.1 bien quune erreur vienne dtre leve ou bien de stopper totalement lexcution de lapplication.A retenir Le lecteur Flash 9 lve des erreurs lexcution. Ces erreurs ouvrent avec le lecteur de dbogage une fentreindiquant lerreur au sein du navigateur. Toutes les mthodes de lAPI du lecteur en ActionScript 3peuvent lever des erreurs lexcution. Le lecteur Flash 9 nchoue plus en silence, le dbogage estdonc facilit.Nouveaux types primitifs En ActionScript 2, seul le type Number existait afin de dfinir un nombre, ainsi pour stocker un nombre entier ou dcimal le type Number tait utilis :var age:Number = 20; var vitesse:Number = 12.8;Aucune distinction ntait faite entre les nombres entiers, dcimaux et non ngatifs. ActionScript 3 intgre dsormais trois types afin de reprsenter les nombres : int : reprsente un nombre entier 32 bit (32 bit signed integer) uint : reprsente un nombre entier non sign 32 bit. (32 bit unsigned integer) Number : reprsente un nombre dcimal 64 bit (64-bit IEEE 754 double-precision floating-point number) Notons que les deux nouveaux types int et uint ne prennent pas de majuscule, contrairement au type Number dj prsent au sein dActionScript 2. Une variable de type int peut contenir un nombre oscillant entre -2147483648 et 2147483648 :// affiche : -2147483648trace( int.MIN_VALUE ); // affiche : 2147483648trace( int.MAX_VALUE );Une variable de type uint peut contenir un nombre entier oscillant entre 0 et 4294967295 :15 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
24. 24. Chapitre 2 Langage et API - version 0.1// affiche : 0trace( uint.MIN_VALUE ); // affiche : 4294967295trace( uint.MAX_VALUE );Attention, la machine virtuelle ActionScript 3 conserve les types lexcution, si nous tentons de stocker un nombre virgule flottante au sein dune variable de type int ou uint, le nombre est automatiquement converti en entier par la machine virtuelle :var age:int = 22.2; // affiche : 22trace ( age );Notons, que la machine virtuelle arrondi lentier infrieur :var age:int = 22.8; // affiche : 22trace ( age );Cette conversion automatique assure par la machine virtuelle savre beaucoup plus rapide que la mthode floor de la classe Math.Dans le code suivant, nous arrondissons lentier au sein dune boucle laide de la mthode floor, la boucle ncessite 111 millisecondes :var distance:Number = 45.2;var arrondi:Number; var debut:Number = getTimer(); for ( var i:int = 0; i< 500000; i++ ) { arrondi = Math.floor ( distance ); } // affiche : 111trace( getTimer() - debut );A prsent, nous laissons la machine virtuelle grer pour nous larrondi du nombre :var distance:Number = 45.2;var arrondi:int; var debut:Number = getTimer(); for ( var i:int = 0; i< 500000; i++ ) { arrondi = distance; }16 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
25. 25. Chapitre 2 Langage et API - version 0.1// affiche : 8trace( getTimer() - debut ); // affiche : 45trace( arrondi );Nous obtenons le mme rsultat en 8 millisecondes, soit un temps dexcution presque 14 fois plus rapide. Partant du principe quune distance est toujours positive, nous pouvons utiliser le type uint qui offre dans ce cas prcis des performances similaires au type int :var arrondi:uint;Malheureusement, le type uint savre gnralement beaucoup plus lent, ds lors quune opration mathmatique est effectue. En revanche, le type Number savre plus rapide que le type int lors de division. Lors de la dfinition dune boucle, il convient de toujours prfrer lutilisation dune variable dincrmentation de type int :var debut:Number = getTimer(); for ( var i:int = 0; i< 5000000; i++ ) {} // affiche : 61trace( getTimer() - debut );A linverse, si nous utilisons un type uint, les performances chutent de presque 400% :var debut:Number = getTimer(); for ( var i:uint = 0; i< 5000000; i++ ) {} // affiche : 238trace( getTimer() - debut );Gardez lesprit, quen cas dhsitation, il est prfrable dutiliser le type Number :var debut:Number = getTimer(); for ( var i:Number = 0; i< 5000000; i++ ) 17 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
26. 26. Chapitre 2 Langage et API - version 0.1{} // affiche : 102trace( getTimer() - debut );Nous obtenons ainsi un compromis en termes de performances entre le type int et uint. De manire gnrale, il est prfrable dviter le typeuint.La mme optimisation peut tre obtenue pour calculer larrondi suprieur. Nous prfrons laisser la machine virtuelle convertir lentier infrieur puis nous ajoutons 1 :var distance:Number = 45.2;var arrondi:int; var debut:Number = getTimer(); for ( var i:int = 0; i< 500000; i++ ) { arrondi = distance + 1; } // affiche : 12trace( getTimer() - debut ); // affiche : 46trace( arrondi );En utilisant la mthode ceil de la classe Math, nous ralentissons les performances denviron 300% :var distance:Number = 45.2;var arrondi:Number; var debut:Number = getTimer(); for ( var i:int = 0; i< 500000; i++ ) { arrondi = Math.ceil ( distance ) + 1; } // affiche : 264trace( getTimer() - debut ); // affiche : 46trace( arrondi ); 18 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
27. 27. Chapitre 2 Langage et API - version 0.1 Pour plus dastuces lies loptimisation, rendez-vous ladresse suivante : http://lab.polygonal.de/2007/05/10/bitwise-gems-fast-integer-math/ A retenir Le type int permet de reprsenter un nombre entier 32 bit. Le type uint permet de reprsenter un nombre entier 32 bitnon ngatif. Le type Number permet de reprsenter un nombre dcimal64 bit. Il est conseill dutiliser le type int pour les nombresentiers, son utilisation permet doptimiser les performances. Il est dconseill dutiliser le type uint. En cas dhsitation, il convient dutiliser le type Number.Valeurs par dfaut Il est important de noter que les valeurs undefined et null ont un comportement diffrent en ActionScript 3. Dsormais, une variable renvoie undefined uniquement lorsque celle-ci nexiste pas o lorsque nous ne la typons pas :var prenom; // affiche : undefinedtrace( prenom );Lorsquune variable est type mais ne possde aucune valeur, une valeur par dfaut lui est attribue :var condition:Boolean;var total:int;var couleur:uint;var resultat:Number;var personnage:Object;var prenom:String;var donnees:*; // affiche : falsetrace( condition ); // affiche : 0trace( total ); // affiche : 0trace( couleur ); // affiche : NaNtrace( resultat ); // affiche : null 19 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
28. 28. Chapitre 2 Langage et API - version 0.1trace( personnage ); // affiche : nulltrace( prenom ); // affiche : undefinedtrace( donnees );Le tableau suivant illustre les diffrentes valeurs attribues par dfaut aux types de donnes :Type de donnesValeur par dfautBooleanfalseint0Number NaNObject nullString nulluint 0Non type (quivalent au type *) undefinedAutres types null Tableau 1. Valeurs par dfaut associes aux types de donnes. De la mme manire, si nous tentons daccder une proprit inexistante au sein dune instance de classe non dynamique telle String, nous obtenons une erreur la compilation :var prenom:String = quot;Bobquot;; // gnre une erreur la compilationtrace( prenom.proprieteInexistante );Si nous tentons daccder une proprit inexistante, au sein dune instance de classe dynamique, le compilateur ne procde aucune vrification et nous obtenons la valeur undefined pour la proprit cible :var objet:Object = new Object(); // affiche : undefinedtrace( objet.proprieteInexistante );20 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
29. 29. Chapitre 2 Langage et API - version 0.1 Attention, une exception demeure pour les nombres, qui ne peuvent tre null ou undefined. Si nous typons une variable avec le type Number, la valeur par dfaut est NaN :var distance:Number; // affiche : NaNtrace( distance );En utilisant le type int ou uint, les variables sont automatiquement initialises 0 :var distance:int; var autreDistance:uint; // affiche : 0trace( distance ); // affiche : 0trace( autreDistance );A retenir Une variable renvoie undefined uniquement lorsquecelle-ci nexiste pas ou nest pas type. Lorsquune variable est type mais ne possde aucunevaleur, la machine virtuelle attribue automatiquement unevaleur par dfaut.Nouveaux types composites Deux nouveaux types composites sont intgrs en ActionScript 3 : Les expressions rgulires (RegExp) : elles permettent deffectuer des recherches complexes sur des chanes de caractres. Nous reviendrons sur les expressions rgulires au cours de certains exercices. E4X (ECMAScript 4 XML) : la spcification ECMAScript 4 intgre un objet XML en tant quobjet natif. Nous reviendrons sur le format XML et E4X au cours de certains exercices.Nouveaux mots-cls Le mot cl is introduit par ActionScript 3 remplace lancien mot-cl instanceof des prcdentes versions dActionScript.Ainsi pour tester si une variable est dun type spcifique nous utilisons le mot-cl is :var tableauDonnees:Array = [5654, 95, 54, 687968, 97851]; // affiche : truetrace( tableauDonnees is Array ); 21 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
30. 30. Chapitre 2 Langage et API - version 0.1// affiche : truetrace( tableauDonnees is Object ); // affiche : falsetrace( tableauDonnees is MovieClip );Un autre mot-cl nomm as fait aussi son apparition. Ce dernier permet de transtyper un objet vers un type spcifique. Dans le code suivant, nous dfinissons une variable de type DisplayObject, mais celle-ci contient en ralit une instance de MovieClip :var monClip:DisplayObject = new MovieClip();Si nous tentons dappeler une mthode de la classe MovieClip sur la variable monClip, une erreur la compilation est gnre.Afin de pouvoir appeler la mthode sans que le compilateur ne nous bloque, nous pouvons transtyper vers le type MovieClip :// transtypage en MovieClip(monClip as MovieClip).gotoAndStop(2);En cas dchec du transtypage, le rsultat du transtypage renvoie null, nous pouvons donc tester si le transtypage russit de la manire suivante :var monClip:DisplayObject = new MovieClip(); // affiche : truetrace( MovieClip(monClip) != null );Nous aurions pu transtyper avec lcriture traditionnelle suivante :var monClip:DisplayObject = new MovieClip(); // transtypage en MovieClipMovieClip(monClip).gotoAndStop(2);En termes de performances, le mot cl as savre presque deux fois plus rapide. En cas dchec lors du transtypage lcriture prcdente ne renvoie pas null mais lve une erreur lexcution.Fonctions ActionScript 3 intgre de nouvelles fonctionnalits lies la dfinition de fonctions. Nous pouvons dsormais dfinir des paramtres par dfaut pour les fonctions. Prenons le cas dune fonction affichant un message personnalis :function alerte ( pMessage:String ):void { 22 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
31. 31. Chapitre 2 Langage et API - version 0.1trace( pMessage ); }Cette fonction alerte accepte un paramtre accueillant le message afficher. Si nous souhaitons lexcuter nous devons obligatoirement passer un message :alerte (quot;voici un message d'alerte !quot;);Si nous omettons le paramtre :// gnre une erreur la compilationalerte ();Lerreur la compilation suivante est gnre :1136: Nombre d'arguments incorrect.1 attendus.ActionScript 3 permet de dfinir une valeur par dfaut pour le paramtre :function alerte ( pMessage:String=quot;message par dfautquot; ):void { trace( pMessage ); }Une fois dfinie, nous pouvons appeler la fonction alerte sans passer de paramtres :function alerte ( pMessage:String=quot;message par dfautquot; ):void { trace( pMessage ); } // affiche : message par dfautalerte ();Lorsque nous passons un paramtre spcifique, celui-ci crase la valeur par dfaut :function alerte ( pMessage:String=quot;message par dfautquot; ):void { trace( pMessage ); } // affiche : un message personnalis !alerte ( quot;un message personnalis !quot; );En plus de cela, ActionScript 3 intgre un nouveau mcanisme li aux paramtres alatoires. 23 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
32. 32. Chapitre 2 Langage et API - version 0.1 Imaginons que nous devions crer une fonction pouvant accueillir un nombre alatoire de paramtres. En ActionScript 1 et 2, nous ne pouvions lindiquer au sein de la signature de la fonction. Nous dfinissions donc une fonction sans paramtre, puis nous utilisions le tableau arguments regroupant lensemble des paramtres :function calculMoyenne ():Number { var lng:Number = arguments.length;var total:Number = 0; for (var i:Number = 0; i< lng; i++) { total += arguments[i]; } return total / lng; } var moyenne:Number = calculMoyenne ( 50, 48, 78, 20, 90 ); // affiche : 57.2trace( moyenne );Bien que cette criture puisse paratre trs souple, elle posait nanmoins un problme de relecture du code. En relisant la signature de la fonction, un dveloppeur pouvait penser que la fonction calculMoyenne nacceptait aucun paramtre, alors que ce ntait pas le cas. Afin de rsoudre cette ambigut, ActionScript 3 introduit un mot-cl permettant de spcifier dans les paramtres que la fonction en cours reoit un nombre variable de paramtres. Pour cela nous ajoutons trois points de suspensions en tant que paramtre de la fonction, suivi dun nom de variable de notre choix. Le mme code scrit donc de la manire suivante en ActionScript 3 :function calculMoyenne ( ...parametres ):Number { var lng:int = parametres.length;var total:Number = 0; for (var i:Number = 0; i< lng; i++) {24 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
33. 33. Chapitre 2 Langage et API - version 0.1total += parametres[i]; } return total / lng; } var moyenne:Number = calculMoyenne ( 50, 48, 78, 20, 90 ); // affiche : 57.2trace( moyenne );En relisant le code prcdent, le dveloppeur ActionScript 3 peut facilement dtecter les fonctions accueillant un nombre de paramtres alatoires.Contexte dexcution Afin que vous ne soyez pas surpris, il convient de sattarder quelques instants sur le nouveau comportement des fonctions passes en rfrence. Souvenez-vous, en ActionScript 1 et 2, nous pouvions passer en rfrence une fonction, celle-ci perdait alors son contexte dorigine et pousait comme contexte le nouvel objet :var personnage:Object = { age : 25, nom : quot;Bobbyquot; }; // la fonction parler est passe en rfrencepersonnage.parler = parler; function parler ( ) { trace(quot;bonjour, je m'appelle quot; + this.nom + quot;, j'ai quot; + this.age + quot; ansquot;); } // appel de la mthode// affiche : bonjour, je m'appelle Bobby, j'ai 25 anspersonnage.parler();En ActionScript 3, la fonction parler conserve son contexte dorigine et ne sexcute donc plus dans le contexte de lobjet personnage :var personnage:Object = { age : 25, nom : quot;Bobbyquot; }; // la fonction parler est passe en rfrencepersonnage.parler = parler; function parler ( ) { trace(quot;bonjour, je m'appelle quot; + this.nom + quot;, j'ai quot; + this.age + quot; ansquot;); 25 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
34. 34. Chapitre 2 Langage et API - version 0.1} // appel de la mthode// affiche : bonjour, je m'appelle undefined, j'ai undefined anspersonnage.parler();De nombreux dveloppeurs ActionScript se basaient sur ce changement de contexte afin de rutiliser des fonctions. Nous devrons donc garder lesprit ce nouveau comportement apport par ActionScript 3 durant lensemble de louvrage.Boucles ActionScript 3 introduit une nouvelle boucle permettant ditrer au sein des proprits dun objet et daccder directement au contenu de chacune dentre elles. Dans le code suivant, nous affichons les proprits de lobjet personnage laide dune boucle for in :var personnage:Object = { prenom : quot;Bobbyquot;, age : 50 }; for (var p:String in personnage) { /* affiche :ageprenom*/trace( p ); }Attention, lordre dnumration des proprits peut changer selon les machines. Il est donc essentiel de ne pas se baser sur lordre dnumration des proprits. Notons que la boucle for in en ActionScript 3 ne boucle plus de la dernire entre la premire comme ctait le cas en ActionScript 1 et 2, mais de la premire la dernire. Nous pouvons donc dsormais utiliser la boucle for in afin ditrer au sein dun tableau sans se soucier du fait que la boucle parte de la fin du tableau :var tableauDonnees:Array = [ 5654, 95, 54, 687968, 97851]; for ( var p:String in tableauDonnees ) { /* affiche :56549526 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
35. 35. Chapitre 2 Langage et API - version 0.15468796897851*/trace( tableauDonnees[p] ); }La boucle for each accde elle, directement au contenu de chaque proprit :var personnage:Object = { prenom : quot;Bobbyquot;, age : 50 }; for each ( var p:* in personnage ) { /* affiche :50Bobby*/trace( p ); }Nous pouvons donc plus simplement itrer au sein du tableau laide de la nouvelle boucle for each :var tableauDonnees:Array = [ 5654, 95, 54, 687968, 97851 ]; for each ( var p:* in tableauDonnees ) { /* affiche :5654955468796897851*/trace( p ); }Nous allons nous intresser dans la prochaine partie au concept de ramasse-miettes qui savre trs important en ActionScript 3.Enrichissement de la classe Array La classe Array bnficie de nouvelles mthodes en ActionScript 3 facilitant la manipulation de donnes. La mthode forEach permet ditrer simplement au sein du tableau :// Array.forEach procde une navigation simple// sur chaque lement l'aide d'une fonction spcifique var prenoms:Array = [ quot;bobbyquot;, quot;willyquot;, quot;ritchiequot; ]; 27 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
36. 36. Chapitre 2 Langage et API - version 0.1function navigue ( element:*, index:int, tableau:Array ):void { trace ( element + quot; : quot; + index + quot; : quot; + tableau); } /* affiche :bobby : 0 : bobby,willy,ritchiewilly : 1 : bobby,willy,ritchieritchie : 2 : bobby,willy,ritchie*/prenoms.forEach( navigue );Toutes ces nouvelles mthodes fonctionnent sur le mme principe. Une fonction de navigation est passe en paramtre afin ditrer et de traiter les donnes au sein du tableau. La mthode every excute la fonction de navigation jusqu' ce quelle ci ou llment parcouru renvoient false.Il est donc trs simple de dterminer si un tableau contient des valeurs attendues. Dans le code suivant, nous testons si le tableau donnees contient uniquement des nombres :var donnees:Array = [ 12, quot;bobbyquot;, quot;willyquot;, 58, quot;ritchiequot; ]; function navigue ( element:*, index:int, tableau:Array ):Boolean { return ( element is Number ); } var tableauNombres:Boolean = donnees.every ( navigue ); // affiche : falsetrace( tableauNombres );La mthode map permet la cration dun tableau relatif au retour de la fonction de navigation. Dans le code suivant, nous appliquons un formatage aux donnes du tableau prenoms.Un nouveau tableau de prnoms formats est cre :var prenoms:Array = [quot;bobbyquot;, quot;willyquot;, quot;ritchiequot;]; function navigue ( element:*, index:int, tableau:Array ):String { return element.charAt(0).toUpperCase()+element.substr(1).toLowerCase(); } // on cre un tableau partir du retour de la fonction naviguevar prenomsFormates:Array = prenoms.map ( navigue ); 28 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
37. 37. Chapitre 2 Langage et API - version 0.1// affiche : Bobby,Willy,Ritchietrace( prenomsFormates );La mthode map ne permet pas de filtrer les donnes. Toutes les donnes du tableau source sont ainsi places au sein du tableau gnr. Si nous souhaitons filtrer les donnes, nous pouvons appeler la mthode filter. Dans le code suivant nous filtrons les utilisateurs mineurs et obtenons un tableau dutilisateurs majeurs :var utilisateurs:Array = [ { prenom : quot;Bobbyquot;, age : 18 },{ prenom : quot;Willyquot;, age : 20 },{ prenom : quot;Ritchiequot;, age : 16 },{ prenom : quot;Steviequot;, age : 15 } ];function navigue ( element:*, index:int, tableau:Array ):Boolean { return ( element.age >= 18 ); } var utilisateursMajeurs:Array = utilisateurs.filter ( navigue ); function parcourir ( element:*, index:int, tableau:Array ):void { trace ( element.prenom, element.age ); } /* affiche :Bobby 18Willy 20*/utilisateursMajeurs.forEach( parcourir );La mthode some permet de savoir si un lment existe au moins au sein du tableau. La fonction de navigation est excute jusqu ce que celle ci ou un lment du tableau renvoient true :var utilisateurs:Array = [ { prenom : quot;Bobbyquot;, age : 18, sexe : quot;Hquot; }, { prenom : quot;Lindaquot;, age : 18, sexe : quot;Fquot; }, { prenom : quot;Ritchiequot;, age : 16, sexe : quot;Hquot;}, { prenom : quot;Steviequot;, age : 15, sexe : quot;Hquot; } ]function navigue ( element:*, index:int, tableau:Array ):Boolean { return ( element.sexe == quot;Fquot; ); } // y'a t'il une femme au sein du tableau d'utilisateurs ?29 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
38. 38. Chapitre 2 Langage et API - version 0.1var resultat:Boolean = utilisateurs.some ( navigue ); // affiche : truetrace( resultat );Les mthodes indexOf et lastIndexOf font elles aussi leur apparition au sein de la classe Array, celles-ci permettent de rechercher si un lment existe et dobtenir sa position :var utilisateurs:Array = [ quot;Bobbyquot;, quot;Lindaquot;, quot;Ritchiequot;, quot;Steviequot;, quot;Lindaquot; ]; var position:int = utilisateurs.indexOf (quot;Lindaquot;); var positionFin:int = utilisateurs.lastIndexOf (quot;Lindaquot;); // affiche : 1trace( position ); // affiche : 4trace( positionFin );Les mthodes indexOf et lastIndexOf permettent de rechercher un lment de type primitif mais aussi de type composite. Nous pouvons ainsi rechercher la prsence de rfrences au sein dun tableau :var monClip:DisplayObject = new MovieClip(); var monAutreClip:DisplayObject = new MovieClip(); // une rfrence au clip monClip est place au sein du tableauvar tableauReferences:Array = [ monClip ]; var position:int = tableauReferences.indexOf (monClip); var autrePosition:int = tableauReferences.lastIndexOf (monAutreClip); // affiche : 0trace( position ); // affiche : -1trace( autrePosition );Nous reviendrons sur certaines de ces mthodes au sein de louvrage.A retenir Pensez utiliser les nouvelles mthodes de la classe Arrayafin de traiter plus facilement les donnes au sein duntableau.Ramasse-miettes Tout au long de louvrage nous reviendrons sur le concept de ramasse- miettes. Bien que le terme puisse paraitre fantaisiste, ce mcanisme va 30 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
39. 39. Chapitre 2 Langage et API - version 0.1 savrer extrmementimportant durant nos dveloppements ActionScript 3. Pendant la dure de vie dun programme, certains objets peuvent devenir inaccessibles. Afin, de ne pas saturer la mmoire, un mcanisme de suppression des objets inutiliss est intgr au sein du lecteur Flash. Ce mcanisme est appel ramasse-miettes ou plus couramment Garbage collector en Anglais. Afin de bien comprendre ce mcanisme, nous dfinissons un simple objet rfrenc par une variable personnage :var personnage:Object = { prenom : quot;Bobbyquot;, age : 50 };Pour rendre cet objet inaccessible et donc ligible la suppression par le ramasse-miettes, nous pourrions tre tents dutiliser le mot cl delete :var personnage:Object = { prenom : quot;Bobbyquot;, age : 50 }; // gnre une erreur la compilationdelete personnage;Le code prcdent, gnre lerreur de compilation suivante :1189: Tentative de suppression de la proprit fixe personnage.Seules lesproprits dfinies dynamiquement peuvent tre supprimes.Cette erreur traduit une modification du comportement du mot cl delete en ActionScript 3, qui ne peut tre utilis que sur des proprits dynamiques dobjets dynamiques. Ainsi, le mot cl delete pourrait tre utilis pour supprimer la proprit prenom au sein de lobjet personnage :var personnage:Object = { prenom : quot;Bobbyquot;, age : 50 }; // affiche : Bobbytrace( personnage.prenom ); // supprime la proprit prenomdelete ( personnage.prenom ); // affiche : undefinedtrace( personnage.prenom );Afin de supprimer correctement une rfrence, nous devons affecter la valeur null celle-ci : var personnage:Object = { prenom : quot;Bobbyquot;, age : 50 }; // supprime la rfrence vers lobjet personnagepersonnage = null;Lorsque lobjet ne possde plus aucune rfrence, nous pouvons estimer que lobjet est ligible la suppression. 31 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
40. 40. Chapitre 2 Langage et API - version 0.1 Nous devrons donc toujours veiller ce quaucune rfrence ne subsiste vers notre objet, au risque de le voir conserv en mmoire.Attention, laffectation de la valeur null une rfrence ne dclenche en aucun cas le passage du ramasse-miettes. Nous rendons simplement lobjet ligible la suppression. Il est important de garder lesprit passage du ramasse- miettes reste potentiel. Lalgorithme de nettoyage effectu ce dernier tant relativement gourmand en termes de ressources, son dclenchement reste limit au cas o le lecteur utiliserait trop de mmoire.Dans le code suivant, nous supprimons une des deux rfrences seulement :var personnage:Object = { prenom : quot;Bobbyquot;, age : 50 }; // copie d'une rfrence au sein du tableauvar tableauPersonnages:Array = [ personnage ]; // suppression dune seule rfrencepersonnage = null;Une autre rfrence vers lobjet personnage subsiste au sein du tableau, lobjet ne sera donc jamais supprim par le ramasse-miettes :var personnage:Object = { prenom : quot;Bobbyquot;, age : 50 }; // copie d'une rfrence au sein du tableauvar tableauPersonnages:Array = [ personnage ]; // supprime une des deux rfrences seulementpersonnage = null; var personnageOrigine:Object = tableauPersonnages[0]; // affiche : Bobbytrace( personnageOrigine.prenom ); // affiche : 50trace( personnageOrigine.age );Nous devons donc aussi supprimer la rfrence prsente au sein du tableau afin de rendre lobjet personnage ligible la suppression :var personnage:Object = { prenom : quot;Bobbyquot;, age : 50 }; // copie d'une rfrence au sein du tableauvar tableauPersonnages:Array = [ personnage ]; // supprime la premire rfrencepersonnage = null; // supprime la seconde rfrence32 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
41. 41. Chapitre 2 Langage et API - version 0.1tableauPersonnages[0] = null;Si la situation nous le permet, un moyen plus radical consiste craser le tableau contenant la rfrence :var personnage:Object = { prenom : quot;Bobbyquot;, age : 50 }; // copie d'une rfrence au sein du tableauvar tableauPersonnages:Array = [ personnage ]; // supprime la premire rfrencepersonnage = null; // crase le tableau stockant la rfrencetableauPersonnages = new Array();Depuis la version 9.0.115 du lecteur Flash 9, il est possible de dclencher le ramasse-miettes manuellement laide de la mthode gc de la classe System. Notons que cette fonctionnalit nest accessible quau sein du lecteur de dbogage. Nous reviendrons sur cette mthode au cours du prochain chapitre intitul Le modle vnementiel.A retenir Il est possible de dclencher manuellement le ramasse-miettes au sein du lecteur de dbogage 9.0.115. Afin quun objet soit ligible la suppression par le ramasse-miettes nous devons passer toutes ses rfrences null. Le ramasse-miettes intervient lorsque la machine virtuellejuge cela ncessaire.Bonnes pratiques Durant lensemble de louvrage nous ferons usage de certaines bonnes pratiques, dont voici le dtail : Nous typerons les variables systmatiquement afin doptimiser les performances de nos applications et garantir une meilleure gestion des erreurs la compilation. Lors de la dfinition de boucles, nous utiliserons toujours une variable de rfrence afin dviter que la machine virtuelle ne rvalue la longueur du tableau chaque itration. Nous prfrerons donc le code suivant :var tableauDonnees:Array = [ 5654, 95, 54, 687968, 97851]; // stockage de la longueur du tableauvar lng:int = tableauDonnees.length; for ( var i:int = 0; i< lng; i++ ) 33 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
42. 42. Chapitre 2 Langage et API - version 0.1{ }A cette criture non optimise :var tableauDonnees:Array = [ 5654, 95, 54, 687968, 97851]; for ( var i:int = 0; i< tableauDonnees.length; i++ ) { }De la mme manire, nous viterons de redfinir nos variables au sein des boucles. Nous prfrerons lcriture suivante :var tableauDonnees:Array = [5654, 95, 54, 687968, 97851]; var lng:int = tableauDonnees.length; // dclaration de la variable elementEnCours une seule et unique foisvar elementEnCours:int; for ( var i:int = 0; i< lng; i++ ) { elementEnCours = tableauDonnees[i]; }A lcriture suivante non optimise :var tableauDonnees:Array = [5654, 95, 54, 687968, 97851]; for ( var i:int = 0; i< tableauDonnees.length; i++ ) { // dclaration de la variable elementEnCours chaque itrationvar elementEnCours:int = tableauDonnees[i]; }Dcouvrons prsent quelques dernires subtilits du langage ActionScript 3.Autres subtilits Attention, le type Void existant en ActionScript 2, utilis au sein des signatures de fonctions prend dsormais un v minuscule en ActionScript 3. Une fonction ActionScript 2 ne renvoyant aucune valeur scrivait de la manire suivante : 34 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
43. 43. Chapitre 2 Langage et API - version 0.1function initilisation ( ):Void {}En ActionScript 3, le type void ne prend plus de majuscule :function initilisation ( ):void {}ActionScript 3 intgre un nouveau type de donnes permettant dindiquer quune variable peut accueillir nimporte quel type de donnes. En ActionScript 2 nous nous contentions de ne pas dfinir de type, en ActionScript 3 nous utilisons le type * :var condition:* = true;var total:* = 5;var couleur:* = 0x990000;var resultat:* = 45.4;var personnage:* = new Object();var prenom:* = quot;Bobbyquot;;Nous utiliserons donc systmatiquement le type * au sein dune boucle for each, car la variable p doit pouvoir accueillir nimporte quel type de donnes :var personnage:Object = { prenom : quot;Bobbyquot;, age : 50 }; for each ( var p:* in personnage ) { /* affiche :50Bobby*/trace( p ); }En utilisant un type spcifique pour la variable ditration p, nous risquons de convertir implicitement les donnes itres. Dans le code suivant, nous utilisons le type Boolean pour la variable p:var personnage:Object = { prenom : quot;Bobbyquot;, age : 50 }; for each ( var p:Boolean in personnage ) {35 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
44. 44. Chapitre 2 Langage et API - version 0.1/* affiche :truetrue*/trace( p ); }Le contenu des proprits est automatiquement converti en boolen. Au cas o une donne ne pourrait tre convertie en boolen, le code prcdent pourrait lever une erreur lexcution. Passons prsent aux nouveauts lies linterface de programmation du lecteur Flash. Les deux grandes nouveauts du lecteur Flash 9 concernent la gestion de laffichage ainsi que le modle vnementiel. Au cours du prochain chapitre intitul Le modle vnementiel nous allons nous intresser ce nouveau modle travers diffrents exercices dapplications. Nous apprendrons matriser ce dernier et dcouvrirons comment en tirer profit tout au long de louvrage. Puis nous nous intresserons au nouveau mcanisme de gestion de laffichage appele Liste daffichage au cours du chapitre 4, nous verrons que ce dernier offre beaucoup plus de souplesse en termes de manipulation des objets graphiques et doptimisation de laffichage. Vous tes prt pour la grande aventure ActionScript 3 ? 36 / 36 Thibault Imbert pratiqueactionscript3.bytearray.org
45. 45. Chapitre 3 Le modle vnementiel - version 0.13Le modle vnementiel LHISTOIRE..............................................................................................................1 UN NOUVEAU MODLE VNEMENTIEL......................................................5TOUT EST VNEMENTIEL...............................................................................................7ECOUTER UN VNEMENT...............................................................................................9LOBJET VNEMENTIEL...............................................................................................12LA CLASSE EVENT......................................................................................................14 LES SOUS-CLASSES DEVENT...........................................................................15ARRTER LCOUTE DUN VNEMENT...........................................................................17MISE EN APPLICATION.................................................................................................18 LA PUISSANCE DU COUPLAGE FAIBLE........................................................23SOUPLESSE DE CODE....................................................................................................26 ORDRE DE NOTIFICATION...............................................................................28 RFRENCES FAIBLES.......................................................................................30 SUBTILITS............................................................................................................32 Lhistoire ActionScript 3 intgre un tout nouveau modle vnementiel que nous allons tudier ensemble tout au long de ce chapitre. Avant de laborder, rappelons-nous de lancien modle vnementiel apparu pour la premire fois avec le lecteur Flash 6. Jusqu maintenant nous dfinissions des fonctions que nous passions en rfrence lvnement cout. Prenons un exemple simple. Pour couter lvnement onRelease dun bouton nous, devions crire le code suivant :monBouton.onRelease = function () 1 / 33 Thibault Imbert pratiqueactionscript3.bytearray.org
46. 46. Chapitre 3 Le modle vnementiel - version 0.1{ // affiche : _level0.monBoutontrace ( this ); this._alpha = 50; }Une fonction anonyme tait dfinie sur la proprit onRelease du bouton. Lorsquun clic souris intervenait sur le bouton, le lecteur Flash excutait la fonction que nous avions dfinie et rduisait lopacit du bouton de 50%. Cette criture posait plusieurs problmes. Dans un premier temps, la fonction dfinie sur le bouton ne pouvait pas tre rutilise pour un autre vnement, sur un objet diffrent. Pour pallier ce problme de rutilisation, certains dveloppeurs faisaient appels des rfrences de fonctions afin de grer lvnement :function clicBouton () { // affiche : _level0.monBoutontrace (this); this._alpha = 50; } monBouton.onRelease = clicBouton;Cette criture permettait de rutiliser la fonction clicBouton pour dautres vnements lis diffrents objets, rendant le code plus ar en particulier lors de lcoute dvnements au sein de boucles. Point important, le mot-cl this faisait ici rfrence au bouton et non au scnario sur lequel est dfinie la fonction clicBouton. Le contexte dexcution dorigine de la fonction clicBouton tait donc perdu lorsque celle-ci tait passe en rfrence. La fonction pousait le contexte de lobjet auteur de lvnement. Lauto rfrence traduite par lutilisation du mot-cl this tait le seul moyen de faire rfrence ce dernier. Ce comportement tait quelque peu droutant pour une personne dcouvrant ActionScript. Voici un exemple mettant en vidence lambigut possible :function clicBouton () { // afiche : _level0.monBoutontrace ( this );2 / 33 Thibault Imbert pratiqueactionscript3.bytearray.org
47. 47. Chapitre 3 Le modle vnementiel - version 0.1this._alpha = 50; } monBouton.onRelease = clicBouton; clicBouton();En excutant la fonction clicBouton de manire traditionnelle le mot-cl this fait alors rfrence au scnario sur lequel elle tait dfinie, son contexte dorigine. Le code suivant tait peu digeste et rigide :var ref:MovieClip; for ( var i:Number = 0; i< 50; i++ ) { ref = this.attachMovie ( quot;monClipquot;, quot;monClipquot;+i, i ); ref.onRelease = function () { trace(quot;cliququot;); } }Les dveloppeurs prfraient donc lutilisation dune fonction spare rutilisable :var ref:MovieClip; for ( var i:Number = 0; i< 50; i++ ) { ref = this.attachMovie ( quot;monClipquot;, quot;monClipquot;+i, i ); ref.onRelease = clicBouton; } function clicBouton ( ) { trace(quot;cliququot;); }Le mcanisme tait le mme pour la plupart des vnements. Macromedia lpoque de Flash MX (Flash 6) stait rendu compte du manque de souplesse de ce systme de fonctions dfinies sur les vnements, et intgra la notion dcouteurs et de diffuseurs au sein3 / 33 Thibault Imbert pratiqueactionscript3.bytearray.org
48. 48. Chapitre 3 Le modle vnementiel - version 0.1 du lecteur Flash 6. Les classes Key, Selection, TextField furent les premires utiliser cette notion de diffuseurs couteurs. Pour couter la saisie dans un champ texte, nous pouvions utiliser la syntaxe suivante :var monEcouteur:Object = new Object(); monEcouteur.onChanged = function(pChamp:TextField) {trace ( pChamp._name + quot; a diffus lvnement onChangedquot; ); }; monChampTexte.addListener ( monEcouteur );En appelant la mthode addListener sur notre champ texte nous souscrivions un objet appel ici monEcouteur en tant qucouteur de lvnement onChanged. Une mthode du mme nom devait tre dfinie sur lobjet couteur afin que celle-ci soit excute lorsque lvnement tait diffus. Cette approche permettait de souscrire un nombre illimit dcouteurs auprs dun vnement, mais aussi de renvoyer des paramtres la mthode couteur. Ces paramtres taient gnralement des informations lies lvnement, par exemple lauteur de lvnement diffus. En 2004, lors de la sortie du lecteur Flash 7 (Flash MX 2004), ActionScript 2 faisait son apparition, ainsi quun lot de nouveaux composants appels composants V2. Ces derniers tendaient le concept de diffuseurs couteurs en intgrant une mthode addEventListener pour souscrire un couteur auprs dun vnement. Contrairement la mthode addListener, cette mthode tendait le concept dcouteurs diffuseurs en stockant chaque couteur dans des tableaux internes diffrents pour chaque vnement. En regardant lvolution dActionScript au cours des dernires annes, nous pouvons nous rendre compte du travail des ingnieurs visant intgrer la notion dcouteurs auprs de tous nouveaux objets crs. ActionScript 3 a t dvelopp dans le but doffrir un langage puissant et standard et prolonge ce concept en intgrant un nouveau modle vnementiel appel Document Object Model (DOM3 Event Model) valable pour tous les objets lis lAPI du lecteur Flash 9. Le W3C dfinit la spcification de ce modle vnementiel. Vous pouvez lire les dernires rvisions ladresse suivante : http://www.w3.org/TR/DOM-Level-3-Events/ 4 / 33 Thibault Imbert pratiqueactionscript3.bytearray.org
49. 49. Chapitre 3 Le modle vnementiel - version 0.1 Les dveloppeurs ActionScript 2 ayant dj utilis la classe EventDispatcher seront ravis de savoir que tous les objets lis au lecteur Flash hritent directement de cette classe. Nous allons donc dcouvrir en profondeur le concept de diffuseurs couteurs et voir comment cela amliore la clart et la souplesse de notre code.A retenir Lancien modle vnementiel a t entirement revu enActionScript 3. La grande puissance dActionScript 3 rside danslimplmentation native dEventDispatcher. Un nouveau modle vnementiel En ActionScript 3 le modle vnementiel a clairement volu, la manire dont les objets interagissent entre eux a t entirement revue. Le principe mme de ce modle vnementiel est tir dun modle de conception ou Design Pattern appel Observateur qui dfinit linteraction entre plusieurs objets daprs un dcoupage bien spcifique.Habituellement ce modle de conception peut tre dfini de la manire suivante : Le modle de conception observateur dfinit une relation entreobjets de type un plusieurs, de faon que, lorsque un objet change dtat, tous ceux qui en dpendent en soient notifis et soient mis jour automatiquement . Le modle de conception Observateur met en scne trois acteurs : Le sujet Il est la source de lvnement, nous lappellerons sujet car cest lui qui diffuse les vnements qui peuvent tre couts ou non par les observateurs. Ce sujet peut tre un bouton, ou un clip par exemple. Ne vous inquitez pas, tous ces vnements sont documents, la documentation prsente pour chaque objet les vnements diffuss. Lvnement Nous pouvons conceptualiser la notion dvnement comme un changement dtat au sein du sujet. Un clic sur un bouton, la fin dun chargement de donnes provoquera la diffusion dun vnement par lobjet sujet. Tous les vnements existants en ActionScript 3 sont stocks dans des proprits constantes de classes lies lvnement. 5 / 33 Thibault Imbert pratiqueactionscript3.bytearray.org
50. 50. Chapitre 3 Le modle vnementiel - version 0.1 Lcouteur Lcouteur a pour mission dcouter tout vnement du sujet. Il peut tre une fonction ou une mthode. Lorsque le sujet change dtat, il diffuse un vnement appropri, si lcouteur est souscrit auprs de lvnement diffus il en est notifi et excute une action. Il est important de souligner quil peut y avoir de multiples couteurs pour un mme vnement, cest justement lun des points forts de ce nouveau modle vnementiel reprsent par la figure 3-1.Figure 3-1. Schma du modle de conceptionObservateur Nos couteurs sont dpendants du sujet, ils y ont souscrits. Le sujet ne connat rien des couteurs, il sait simplement sil est observ ou non travers sa liste interne dcouteurs. Lorsque celui-ci change dtat un vnement est diffus, nos couteurs en sont notifis et peuvent alors ragir. Tout vnement diffus envoie des informations aux couteurs leur permettant dtre tenus au courant des modifications et donc de rester jour en permanence avec le sujet. Nous dcouvrirons au fil de ces pages, la souplesse apporte par ce nouveau modle vnementiel, et vous apprcierez son fonctionnement trs rapidement. Cela reste encore relativement abstrait, pour y remdier voyons ensemble comment ce modle vnementiel stablit au sein dune application Flash traditionnelle. Prenons un exemple simple constitu dun bouton et dune fonction couteur ragissant lorsque lutilisateur clique sur ce bouton. Nous6 / 33 Thibault Imbert pratiqueactionscript3.bytearray.org
51. 51. Chapitre 3 Le modle vnementiel - version 0.1 avons dans ce cas nos trois acteurs mettant en scne le nouveau modle vnementiel ActionScript 3. Le sujet : le bouton Lvnement : le clic bouton Lcouteur : la fonction Transpos dans une application ActionScript 3 traditionnelle, nous pouvons tablir le schma suivant :Figure 3-2. Modle vnementiel dans une application ActionScript 3 Notre bouton est un sujet pouvant diffuser un vnement. Celui-ci est cout par une fonction couteur.A retenir Il existe un seul et unique modle vnementiel enActionScript 3 Ce modle vnementiel est bas sur le modle deconception Observateur. Les trois acteurs de ce nouveau modle vnementiel sont :le sujet, lvnement, et lcouteur. Nous pouvons avoir autant dcouteurs que nous lesouhaitons. Plusieurs couteurs peuvent couter le mme vnement.Tout est vnementiel Lessentiel du modle vnementiel rside au sein dune seule et unique classe appele EventDispatcher. Cest elle qui offre la 7 / 33 Thibault Imbert pratiqueactionscript3.bytearray.org
52. 52. Chapitre 3 Le modle vnementiel - version 0.1 possibilit un objet de diffuser des vnements. Tous les objets issus de lAPI du lecteur 9 hritent de cette classe, et possdent de ce fait la capacit de diffuser des vnements. Souvenez-vous que toutes les classes issues du paquetage flash sont relatives au lecteur Flash.Avant le lecteur 9, ces objets hritaient simplement de la classe Object, si nous souhaitions pouvoir diffuser des vnements nous devions nous mme implmenter la classe EventDispatcher au sein de ces objets. En ActionScript 3 la classe EventDispatcher est la classe de base pour tous ces objets. Voici la chane dhritage de la classe MovieClip avant le lecteur Flash 9 :Object|+-MovieClipDans les prcdentes versions du lecteur Flash, la classe MovieClip tendait directement la classe Object, si nous souhaitions pouvoir diffuser des vnements partir dun MovieClip nous devions implmenter nous-mmes un nouveau modle vnementiel. Voyons comme cela a volu avec lActionScript 3 au sein du lecteur 9. Depuis lecteur 9 et ActionScript 3 :Object|+-EventDispatcherLa classe EventDispatcher hrite dsormais de la classe Object, tous les autres objets hritent ensuite dEventDispatcher et bnficie donc de la diffusion dvnements en natif. Cest une grande volution pour nous autres dveloppeurs ActionScript, car la plupart des objets que nous manipulerons auront la possibilit de diffuser des vnements par dfaut. Ainsi la classe MovieClip en ActionScript hrite dabord de la classe Object puis dEventDispatcher pour ensuite hriter des diffrentes classes graphiques. Toutes les classes rsidant dans le paquetage flash ne drogent pas la rgle et suivent ce mme principe. Voici la chane dhritage complte de la classe MovieClip en ActionScript 3 :Object|+-EventDispatcher | +-DisplayObject|8 / 33 Thibault Imbert pratiqueactionscript3.bytearray.org
53. 53. Chapitre 3 Le modle vnementiel - version 0.1 +-InteractiveObject | +-DisplayObjectContainer | +-Sprite|+-MovieClipVoyons ensemble comment utiliser ce nouveau modle vnementiel travers diffrents objets courants.Ecouter un vnement Lorsque vous souhaitez tre tenu au courant des dernires nouveauts de votre vidoclub, vous avez plusieurs possibilits. La premire consiste vous dplacer jusquau vidoclub afin de dcouvrir les dernires sorties. Une approche classique qui nest pas vraiment optimise, nous pouvons dj imaginer le nombre de visites que vous effectuerez dans le magasin pour vous rendre compte quaucun nouveau DVD ne vous intresse. Une deuxime approche consiste laisser une liste de films que vous attendez au grant du vidoclub et attendre que celui-ci vous appelle lorsquun des films est arriv. Une approche beaucoup plus efficace pour vous et pour le grant qui en a assez de vous voir repartir du. Le grant incarne alors le diffuseur, et vous-mme devenez lcouteur. Le grant du vidoclub ne sait rien sur vous, il est donc le sujet, vous tes alors lcouteur car vous tes souscrit un vnement prcis : la disponibilit dun film que vous recherchez . En ActionScript 3 les objets fonctionnent de la mme manire. Pour obtenir une notification lorsque lutilisateur clique sur un bouton, nous souscrivons un couteur auprs dun vnement diffus par le sujet, ici notre bouton. Afin dcouter un vnement spcifique, nous utilisons la mthode addEventListener dont voici la signature :addEventListener(type:String, listener:Function, useCapture:Boolean = false,priority:int = 0, useWeakReference:Boolean = false):voidLe premier paramtre attend lvnement couter sous la forme dune chane de caractres. Le deuxime paramtre prend en rfrence lcouteur qui sera souscrit auprs de lvnement. Les trois derniers paramtres seront expliqus plus tard. Souvenez-vous que seuls les objets rsidants dans le paquetage flash utilisent ce modle vnementiel. Voyons laide d'un exemple simple, comment couter un vnement. 9 / 33 Thibault Imbert pratiqueactionscript3.bytearray.org
54. 54. Chapitre 3 Le modle vnementiel - version 0.1 Dans un nouveau document Flash, crez un symbole bouton, et placez une occurrence de ce dernier sur la scne et nommez la monBouton.Sur un calque AS tapez le code suivant :monBouton.addEventListener ( quot;clickquot;, clicBouton ); function clicBouton ( pEvt:MouseEvent ):void {// affiche : vnement diffustrace(quot;vnement diffusquot;); }Nouspassonsen deuximeparamtre la mthode addEventListener une rfrence la fonction couteur clicBouton. Attention ne pas mettre les doubles parenthses lorsque nous passons la rfrence la fonction. Le code suivant ne pourrait pas tre compil :monBouton.addEventListener( quot;clickquot;, clicBouton() ); function clicBouton ( pEvt:MouseEvent ):void { // affiche : vnement diffustrace ( quot;vnement diffusquot; ); }Nous coutons ici lvnement click sur le bouton monBouton et nous passons la fonction clicBouton comme couteur. Lorsque lutilisateur clique sur le bouton, il diffuse un vnement click qui est cout par la fonction clicBouton.Mme si cette syntaxe fonctionne, et ne pose aucun problme pour le moment, que se passe t-il si nous spcifions un nom dvnement incorrect ? Imaginons le cas suivant, nous faisons une erreur et coutons lvnement clicck :monBouton.addEventListener( quot;clicckquot;, clicBouton );Si vous testez le code ci-dessus, la fonction clicBouton ne sera jamais dclenche car lvnement clicck possde une erreur de saisie et de par sa non-existence nest jamais diffus. Afin dviter ces problmes de saisie, tous les noms des vnements sont dsormais stocks dans des classes lies chaque vnement. 10 / 33 Thibault Imbert pratiqueactionscript3.bytearray.org
55. 55. Chapitre 3 Le modle vnementiel - version 0.1 Lorsque vous devez couter un vnement spcifique pensez immdiatement au type dvnement qui sera diffus. Les classes rsidant dans le paquetage flash.events constituent lensemble des classes vnementielles en ActionScript 3. Elles peuvent tre divises en deux catgories. Les vnements autonomes Ce sont les vnements diffuss par les objets sans aucune interaction utilisateur, voici quelques classes lis aux vnements autonomes :flash.events.Event : stocke les vnements de base.flash.events.ProgressEvent:stocke lesvnements lis aux chargements progressifs.flash.events.IOErrorEvent : stocke les vnementslis aux erreurs de chargement. Les vnements interactifs Ce sont les vnements diffuss par les objets, lorsquune interaction utilisateur intervient.flash.events.MouseEvent : stocke les vnementslis la souris. :flash.events.KeyboardEventstocke lesvnements lis au clavier.flash.events.TextEvent : stocke les vnements lisaux champs texte. Dans notre cas, nous souhaitons couter un vnement qui relve dune interactivit