Le cours en PDF (partie 3 - LIFL

MASTER IPM EAD 2010-2012 

Cours Flash 

Chapitre 6 : Programmation avec ActionScript 3, partie 3 

Rappel : les fichiers fla et swf sont dans le fichier « 6_Programmation_AS3_3.zip ». 

SOMMAIRE 

1 CHARGEMENT DE FICHIERS SWF ..................................................................................................... 2 

2 CHARGEMENT DE TEXTE ET DE VARIABLES ................................................................................ 3 

2.1 CHARGEMENT DE TEXTE ............................................................................................................................ 3 

2.2 CHARGEMENT DE VARIABLES .................................................................................................................... 3 

3 XML .............................................................................................................................................................. 5 

4 LE DOCUMENTCLASS ............................................................................................................................ 8 

4.1 SI VOUS AVEZ DES CONNAISSANCES EN POO ............................................................................................ 8 

4.2 SI VOUS N’AVEZ PAS DE CONNAISSANCE EN POO ...................................................................................... 9 

5 PROGRAMMATION ORIENTEE OBJET (POO) ............................................................................... 10 

6 CONNEXION AVEC PHP ....................................................................................................................... 11 

6.1 ENVOI DE DONNEES A PHP EN MODE GET .............................................................................................. 11 

6.2 EXEMPLE 2 : ENVOI DISCRET DES DONNEES ET TRAITEMENT APRES EXECUTION DU PHP ........................ 13 

7 PHP ET MYSQL ....................................................................................................................................... 17 

8 APPELER UNE PAGE WEB NAVIGATETOURL .............................................................................. 19 

8.1 PREAMBULE ............................................................................................................................................ 19 

8.2 PARAMETRES DE PUBLICATION DE FLASH CS3 ........................................................................................ 19 

8.3 LA FONCTION NAVIGATETOURL ............................................................................................................. 23 

9 C’EST FINI ! ............................................................................................................................................. 24

MASTER IPM EAD 2010-2012 J.C. Tarby 

1 Chargement de fichiers SWF 

Une animation Flash (SWF) peut charger dynamiquement d’autres SWF. Cette possibilité 

offre plusieurs intérêts : 

- le travail en équipe. Chaque membre de l’équipe peut ainsi travailler sur une 

animation séparée, et il suffit ensuite d’avoir une animation qui s’occupe de charger et 

décharger les animations selon les besoins. 

- la découpe du travail. Même si vous travaillez seul, il est plus facile d’avoir 10 petites 

animations qu’une seule qui représente la somme des 10 petites. 

- la maintenance. Quand vous devez corriger une erreur, modifier une petite animation 

sera plus rapide que modifier une grosse animation. 

- un chargement + rapide. Quand vous découpez une animation, essayez de faire une 

petite première animation. Ainsi, elle se chargera très vite, ce qui est intéressant pour 

Internet… 

Vous trouverez un exemple complet dans « animation qui charge.fla » et « animation 

chargée.fla ». 

- Animation chargée. Cette animation contient : 

o un fond de scène bleu foncé ; 

o un clip « vert » qui réagit au clic sur lui ; 

o un bouton qui envoie un message à l’« animation qui charge » cette animation. 

Pour que le message (c'est-à-dire un événement) soit envoyé à l’animation qui 

charge, on utilise MovieClip(racine) avec racine égal à 

root.parent.root pour accéder à la scène qui charge. La raison est assez 

technique et n’a pas d’intérêt pour votre formation. N’hésitez pas à faire du 

copier-coller de mon code dans vos animations. Reprenez la variable racine et 

le code MovieClip(racine) pour accéder à la scène qui charge. Dans mon 

exemple, vous verrez ainsi qu’on accède au clip « rouge » dans la scène qui 

charge. 

- Animation qui charge. Cette animation contient : 

o un fond de scène jaune ; 

o un clip « rouge » qui ne fait rien ; 

o un bouton qui envoie un message au clip « vert » de l’animation chargée. Pour 

charger l’animation, on utilise un Loader et un URLRequest. Ici aussi, ne vous 

préoccupez pas des détails techniques. Faites du copier-coller et changez 

seulement le nom et le chemin du fichier SWF à charger. Notez que vous 

devez faire un addChild pour que l’animation chargée soit affichée sur la 

scène. Pour accéder à la scène chargée, on utilise 

MovieClip(chargeur.content). 

Quelques remarques : 

- si vous testez « animation chargée » seule, vous aurez un message d’erreur si vous 

cliquez sur le bouton puisque l’animation visée par le bouton n’est pas chargée avant. 

Pour tester l’ensemble correctement, vous devez lancer « animation qui charge » en 

premier. 

- Une animation chargée a toujours sa scène qui devient transparente. Seuls les objets 

présents sur la scène restent visibles. Vous aurez certainement constaté que la couleur 

bleue de la scène chargée a disparu. 

- si vous modifier l’une ou l’autre animation, n’oubliez pas de recréer le SWF associé 

pour que l’ensemble fonctionne correctement. 

Flash : Découverte d’Action Script Page 2 sur 24


2 Chargement de texte et de variables 

2.1 Chargement de texte 

Il est très intéressant de pouvoir charger du texte dynamiquement. Cela vous permet par 

exemple sur une page web d’avoir une animation Flash qui affiche le dicton du jour, le Saint 

du jour, etc., sans devoir regénérer le SWF chaque fois. 

Note : l’aspect multilingue sort du cadre IPM, mais au fur et à mesure des versions de 

Flash, cette fonctionnalité se simplifie. N’hésitez pas à consulter l’aide sur ce point si 

vous en avez besoin en stage. 

Pour charger un fichier texte, il faut d’abord en avoir un ☺. Vous trouverez un exemple 

simple dans « La Programmation Objet.txt ». Son contenu n’a aucune importance en luimême 

pour ce cours, mais il faut juste comprendre que ce doit être du texte pur, c'est-à-dire 

pas de mise en forme tel que gras, italique, polices différentes, etc. Vous pouvez donc le créer 

avec n’importe quel logiciel de texte (bloc note, Wordpad, Word,…). 

Ensuite, pour charger le fichier texte, il suffit de quelques lignes. Vous trouverez un exemple 

simple dans « lecture texte.fla ». Notez que pour que cet exemple fonctionne, j’ai déposé une 

occurrence du composant TextArea sur la scène, et je lui ai donné un nom d’occurrence. Sur 

le principe, il faut vous rappeler que lors d’un chargement d’un fichier externe (comme un 

fichier texte, mais aussi XML comme nous le verrons un peu plus loin) le contenu du fichier 

n’est accessible qu’après avoir été chargé, ce qui est possible grâce au listener sur 

Event.COMPLETE. Vous accédez alors au contenu par URLLoader(e.target).data. 

Dans « lecture texte avec boutons.fla », vous trouverez un autre exemple permettant de 

charger au choix 3 textes grâce à 3 boutons. 

2.2 Chargement de variables 

Maintenant que vous savez comment charger du texte, nous allons améliorer cette technique 

pour charger des variables avec leur contenu. Comme exemple, supposons que dans notre 

animation vous vouliez afficher la date, le dicton et les fêtes du jour, mais que vous ne voulez 

pas passer par une base de données. Dans ce cas, vous pouvez utiliser un fichier de variables 

pour résoudre ce problème. 

Vous trouverez la solution dans « lecture fichiers de variables.fla ». Cette animation charge le 

fichier « dicton du jour.txt » qui est un fichier texte pur (comme précédemment), mais la 

différence est dans son contenu et son interprétation. En effet, le fichier est structuré sous la 

forme : 

nomDeVariable1=valeur&nomDeVariable2=valeur&nomDeVariable3=valeur… 

Dans le fichier, vous trouverez ainsi une variable date_du_jour, une variable dicton et une 

variable saints. Le chargement du fichier se fait de façon similaire à ce que nous avons vu 

juste avant, mais la différence fondamentale est dans l’interprétation du contenu. En effet, la 

ligne uneInfo.dataFormat = URLLoaderDataFormat.VARIABLES dit que Flash doit 

interpréter le contenu comme des variables avec leur valeur, et non pas comme du simple 

texte. Sachez pour information qu’en plus du format VARIABLES, il existe le format TEXT qui 

est le format par défaut (c’est pour cela que je ne l’ai pas écrit précédemment), et le format 

BINARY qui vous permet de charger des données binaires. 



Cet exemple vous montre également comment gérer une erreur de chargement du fichier. Il 

existe beaucoup de types d’erreurs différentes qui peuvent toutes être gérées 

indépendamment, mais ceci est un boulot d’informaticien, pas d’IPM. Retenez juste que ça 

existe. 

Pour en finir sur cet exemple, il n’est pas utile de tout comprendre. Vous pouvez ici encore 

faire du copier-coller en changeant simplement le nom et l’adresse du fichier, ainsi que son 

contenu bien sûr ☺. Par contre, ce format d’échange (variable=valeur&…) est à mémoriser 

car c’est un de ceux que Flash utilise pour communiquer avec PHP. 



3 XML 

Cette partie suppose que vous connaissez XML. Si ce n’est pas le cas, consultez 

éventuellement les ressources nécessaires, par exemple votre cours XML, des livres ou des 

sites internet. 

Pour cette partie, nous nous intéressons uniquement aux fichiers XML (.xml) ; nous 

n’abordons pas les DTD, Schema, fichiers XSL ou XSLT, et autres fichiers en rapport avec la 

technologie XML. 

Le but de cette partie est de comprendre comment Flash peut lire un fichier XML, et naviguer 

dans des données XML. Nous ne verrons pas comment créer des données XML (en mémoire 

uniquement car Flash n’autorise pas la création de fichier sur votre disque dur pour des 

raisons de sécurité) car cela va au-delà de ce qu’on attend de vous en IPM, mais sachez que la 

création de données XML et leur manipulation en mémoire est tout à fait possible avec Flash. 

Depuis la version CS3, Flash manipule XML en utilisant ECMAScript pour XML (E4X), ce 

qui le rend aussi performant que Java par exemple. 

Un exemple courant d’utilisation d’XML est la lecture de flux RSS. Si cela vous intéresse, 

vous trouverez un exemple dans l’aide de Flash dans la rubrique « Utilisation de XML > 

Exemple : Chargement de données RSS depuis Internet ». 

Pour faire simple, au cas où vous n’auriez à ce moment précis aucune connaissance sur XML, 

retenez que XML est un format de données textuelles, structurées en balises (comme HTML) 

où les balises peuvent être ce qu’on veut. 

Voici un petit exemple (fichier « carnet.xml ») qui va nous servir juste après : 

 

 

 

Durand 

Eric 

eric@durand.com 

 

 

Martin 

Eva 

eva@martin.com 

 

 

Dupont 

Luc 

luc@dupont.com 

 

 

Note : vous pouvez ouvrir ce fichier avec le bloc-notes, Wordpad, Word, et même 

votre navigateur web. Attention, certains (comme Chrome) n’afficheront pas les 

balises. Dans ce cas, vous devrez demander à afficher le code source pour voir les 

balises. 



Comme en HTML, toute balise ouverte doit être fermée, et on peut imbriquer des balises dans 

des balises. En XML, on parle de balise (par exemple ), mais également de nœud (le 

nœud ‘nom’) car un fichier XML (comme HTML) peut être vu comme un arbre. Il y a la 

racine (ici le nœud ‘carnet’), et les fils de la racine (les ‘personne’), qui ont eux-mêmes 

d’autres nœuds fils (‘nom’, ‘prenom’ et ‘adressemail’). Un nœud peut avoir des attributs ; 

par exemple le nœud ‘personne’ a 3 fils (‘nom’, ‘prenom’…) et un attribut ‘numeroSecu’. 

Vous avez la même chose avec HTML par exemple où IMG est le nœud et SRC 

est un attribut. 

Le fichier XML ci-dessus contient donc 3 personnes, ayant chacune un nom, un prénom et un 

email, ainsi qu’un n° de sécurité sociale (simplifié). Nous allons voir comment charger ce 

fichier et trouver des informations dans ce fichier (qui pourrait contenir des centaines de 

personnes…). 

Le fichier « XML.fla » contient 3 versions de lecture du fichier XML « carnet ». Vous noterez 

au passage qu’on charge un document XML de façon similaire à un fichier texte… 

- La version 1 se contente d’afficher tout ce qui a été chargé. Vous remarquerez que 

seules les données XML sont gardées, l’en-tête est ignoré 

par Flash. 

- La version 2 fait une requête dans les données pour ne garder que les nœuds ‘nom’ et 

stocke le résultat dans une liste (XMLList), ce qui facilite ensuite le traitement de ces 

données. Cette requête est faite grâce à new XMLList(arboXML.personne.nom). La 

lecture du résultat est traitée par une boucle ‘for each’. Le résultat affiché est : 

Durand 

Martin 

Dupont 

- La version 3 est un exemple de ce que l’on fait généralement avec XML dans Flash, 

c'est-à-dire naviguer dans les données pour en extraire ce dont on a besoin. Rappelezvous 

qu’on peut également créer des données XML en mémoire (fonction 

appendChild par exemple), mais que ceci est hors programme pour IPM. 

Dans cette version 3, on affiche : 

• tous les nœuds ‘personne’ (et leur contenu) avec trace(arboXML.personne) 

• la seconde personne (car les tableaux commencent toujours à l’indice 0) avec 

trace(arboXML.personne[1]) 

• le nombre d’enfants (c'est-à-dire de nœuds fils) du second nœud ‘personne’ 

avec trace(arboXML.personne[1].children().length()). Ce nœud a 3 

fils (nom, prenom et adressemail). 

• Le nom de la personne dont l’attribut numeroSecu est égal à 789 avec 

trace(arboXML.personne.(@numeroSecu=="789").nom), c'est-à-dire 

Dupont. 

• Le nombre de fils de la racine, c'est-à-dire le nombre de fils du nœud ‘carnet’, 

donc le nombre de personnes, c'est-à-dire 3, avec 

trace(arboXML.children().length()). 

• Le nœud ‘personne’ dont le nœud nom est égal à Martin avec 

trace(arboXML.personne.(nom=="Martin")). 

Le résultat final est : 

 

Durand 

Eric 

eric@durand.com 

 



 

Martin 

Eva 


 

 

Dupont 

Luc 

luc@dupont.com 

 

 

Martin 

Eva 


 

3 

Dupont 

3 

 

Martin 

Eva 


 

Pensez pour finir que le fichier XML à charger peut provenir de votre disque dur ou d’une 

URL, donc renvoyé par un script PHP par exemple ☺. 



4 Le documentClass 

Cette partie est à la limite du cours IPM. J’entends par là que vous n’êtes pas du tout obligés 

de la faire, mais que si vous le faites, cela sera un plus pour vous dans votre niveau Flash. De 

plus, ce que nous allons voir ici (ainsi que dans la partie suivante consacrée à la POO) est 

extrêmement courant en programmation Flash. Vous risquez donc fort de le rencontrer dans 

votre future vie professionnelle. 

Ouvrez le fichier « classe de document.fla ». Vous verrez qu’il ne contient qu’un champ texte 

dynamique avec un contenu « aaaaaa…. ». Il n’y a aucune ligne de code AS3 dans ce fichier. 

Pourtant, quand vous l’exécutez, le champ texte affiche un autre contenu et si vous cliquez 

dessus, son contenu change à nouveau. Il y a donc du code « quelque part » ☺, mais où ??? 

La réponse est cachée dans les propriétés du document (cf. Figure 1). Le champ « classe du 

document » contient le nom d’un fichier AS3 contenant le code qui jusqu’à présent était écrit 

dans le scénario principal. Ce fichier s’appelle ici « MaClasse », mais le nom exact est 

« MaClasse.as ». Ce fichier se trouve dans le même dossier que le fichier FLA. Vous pouvez 

l’ouvrir soit depuis votre disque dur (c’est un simple fichier texte qui normalement s’ouvrira 

dans Flash) soit en cliquant sur le stylo à droite du champ « classe du document ». Cette 

dernière solution est la plus rapide et la plus sûre ; si le fichier n’existe pas, Flash vous le dira 

tout de suite. 

Figure 1 : propriétés du document 

Ouvrez à présent ce fichier MaClasse.as. Si vous avez des connaissances en programmation 

orienté objet (POO), vous pouvez lire le paragraphe ci-dessous, sinon passez au paragraphe 

d’après. 

4.1 Si vous avez des connaissances en POO 

- Toute classe AS3 doit être dans un package dont le nom est optionnel s’il se trouve 

dans le même dossier que le FLA. Dans le cas contraire, vous devez lui donner un 

nom et respecter le chemin d’accès comme en Java par exemple. 

- La classe et le nom du fichier .as doivent avoir exactement le même nom. 

- Un package peut contenir plusieurs classes, mais il est fortement conseillé de n’en 

mettre qu’une par fichier .as. 

- AS3 utilise l’héritage simple, les interfaces, et les imports de façon semblable à Java. 

Pour le contenu des packages livrés avec Flash, reportez-vous à l’aide ou autre. 

- Le constructeur d’une classe est obligatoirement public. 

- La définition des méthodes respecte la même structure que les fonctions vues 

précédemment ; il faut juste ajouter public, private, etc. 



- Quand vous créez un SWF à partir d’un FLA qui utilise un fichier .AS, le SWF 

contient à la fois le .FLA et le .AS. Vous ne pouvez pas exécuter directement un .AS ; 

vous devez au minimum avoir un .FLA vide qui l’appelle. 

Pour résumer, cette classe MaClasse étend la classe Sprite qui est la classe associée de base 

à la scène d’une animation Flash. Son constructeur affiche un contenu dans le champ texte 

« zoneAffichage » et définit un comportement sur le clic pour ce champ texte. 

4.2 Si vous n’avez pas de connaissance en POO 

L’utilisation d’un fichier .as comme classe de document permet de séparer clairement le 

travail du graphiste de celui de l’informaticien. Le graphiste se concentre sur la partie 

animation dans Flash, et l’informaticien travaille de son côté sur le comportement des objets 

présents dans l’animation. La seule contrainte est de savoir avant quels sont les objets qui 

seront manipulés par programmation, c'est-à-dire leurs noms et leurs localisations (sur la 

scène, dans des clips, etc.). 

Le fichier « MaClasse.as » définit ainsi le contenu et le comportement du champ texte 

zoneAffichage. Si demain, vous décidez que le contenu doit être différent, ou que le champ 

texte doit réagir au MOUSE_OVER et non plus au MOUSE_CLICK, vous ne changerez que ce 

fichier (vous pouvez essayer en enlevant les commentaires). Par contre, si vous décidez 

d’ajouter un clip et un comportement pour ce clip, il faudra modifier le FLA et le .AS. Nous 

verrons un autre exemple de classe AS3 dans la partie suivante. Sachez enfin que le SWF issu 

du FLA contient également le .AS qui lui est associé. Vous ne livrez donc que le SWF à votre 

client (jamais le FLA et le AS). 



5 Programmation orientée objet (POO) 

Nous allons voir ici comment donner du comportement à un clip en écrivant le code AS3 en 

dehors du fichier FLA qui le contient. Cela permet, comme vu juste avant, de séparer le 

travail du graphiste et de l’informaticien. Nous allons donc écrire une classe AS3 décrivant le 

comportement d’un clip dont le contenu graphique est dans un FLA. 

Note : Si vous avez des connaissances en POO, sachez qu’avec AS3, vous pouvez 

créer vos propres classes, mais nous ne verrons pas cet aspect dans ce cours car cela 

est hors contenu IPM. 

Que vous connaissiez ou non la POO, je ne donne ici que le strict minimum d’informations 

pour que vous compreniez le fonctionnement de ce type de programmation. Je n’attends pas 

de vous que vous sachiez créer des classes de ce type ; ceci est pour les informaticiens ou les 

Flasheurs chevronnés. 

Ouvrez le fichier « Agneaux avec classe agneau.fla » et regardez le code de l’image 1. On y 

trouve un code semblable à celui que nous avons vu il y a quelques temps, unAgneau = new 

Agneau(stage.stageWidth, stage.stageHeight). Ce code crée une occurrence 

d’Agneau, symbole clip présent dans la bibliothèque et exporté pour AS3. La différence ici 

est que j’ai en plus écrit du code dans le fichier « Agneau.as » et que ce code décrit le 

comportement d’une occurrence de ce symbole Agneau. Pour que tout ceci fonctionne, il faut 

que : 

- Le fichier Agneau.as soit dans le même dossier que le FLA 

- Le symbole AgneauClip soit exporté sous le nom Agneau. 

- Le nom d’exportation et le nom du .as soient identiques. 

Si vous regardez à présent le fichier Agneau.as, vous verrez du code très proche de ce que 

nous avons écrit jusqu’à maintenant ; des fonctions décrivent le comportement sur le clic, le 

mouse over, etc. 

Quel est l’intérêt de ceci ? Imaginons que votre client vous demande une modification dans le 

dessin de l’agneau ; dans ce cas, vous demandez à votre graphiste de modifier le clip dans le 

FLA, et donc le .AS reste intact et toujours valable. Maintenant, si votre client vous demande 

de changer le comportement des agneaux, vous demandez à votre programmeur de modifier le 

fichier .AS et donc on garde intact le FLA. Si maintenant on vous demande de modifier les 

deux, vous pouvez le faire faire en parallèle à votre graphiste et votre programmeur. Sur un 

petit exemple comme celui-ci, cela paraît inutile, mais sachez qu’une « vraie » animation 

Flash nécessite souvent des dizaines de FLA et au moins autant de .AS ! 

Si vous ouvrez maintenant « classe agneau.fla », il n’y a plus du tout de code et pourtant 

on crée des occurrences d’agneaux… La solution a été vue précédemment… la classe du 

document ! Je vous laisse regarder son contenu. Il n’y a rien de nouveau. J’ai juste ici utilisé à 

la fois la classe de document et une classe pour le clip Agneau. 



6 Connexion avec PHP 

Nous allons voir dans cette partie comment envoyer des données à PHP et en recevoir de 

PHP. La connexion avec des bases des données type MySQL étant directement associée à 

PHP, nous n’en verrons pas d’exemple ici ; puisque nous aurons vu comment envoyer des 

données de PHP à Flash, que ces données soit issues ou non d’une base de données ne change 

rien à l’envoi de ces données. 

6.1 Envoi de données à PHP en mode GET 

Dans ce premier exemple, nous allons utiliser un formulaire de saisie fait en Flash, affiché 

dans une page web. Quand on valide le formulaire, on envoie son contenu à PHP qui le traite 

et affiche une nouvelle page web avec les données qu’il a reçues de Flash. 

Ouvrez le fichier « envoi de données à PHP.fla ». Je vous laisse le soin de regarder les 

champs texte utilisés et leurs noms d’occurrence. Le code AS3 fonctionne de la façon 

suivante : 

- Pour passer des données de Flash à PHP, Flash appelle la page PHP par la fonction 

navigateToURL contenant une variable contenant l’URL visée. navigateToURL est 

une solution ; nous en verrons une autre dans 6.2. 

- Cette variable précise si on utilise du GET ou du POST pour envoyer les données. 

- Cette variable contient également les données à envoyer dans sa propriété data. 

- Les données textuelles des champs du formulaire sont stockées dans la variable 

donnéesFormulaire. Cette variable est du type URLVariables qui, comme nous 

l’avons déjà vu, contient par défaut du texte. Vous pouvez ajouter autant de données 

textuelles que vous voulez (sans toutefois stocker des Mo !). Cette variable est 

associée au data de la variable du navigateToURL 

Pour le dire plus « simplement », vous stockez les données que vous voulez envoyer dans une 

variable de type URLVariables, et vous stockez ensuite cette variable URLVariable 

dans la propriété data la variable de type URLRequest que vous passez en paramètre à la 

fonction navigateToURL. On peut comparer cela à quelqu'un qui enverrait un vase fragile 

par la poste. Il mettrait son vase (les données que vous voulez envoyer à PHP) dans un carton 

(la variable URLVariable), puis ce carton dans un autre carton (la variable URLRequest) 

qu’il envoie (navigateToURL) ensuite par la poste. 

Code FLA 

// Définition du listener pour le bouton 

boutonEnvoi.addEventListener(MouseEvent.CLICK, envoiMessage); 

// fonction qui récupère les textes dans le formulaire et les envoie à PHP 

function envoiMessage(evt:MouseEvent):void 

{ 

// on récupère les textes saisis dans le formulaire 

var unMessage:URLVariables = new URLVariables(); 

unMessage.sujet = sujet.text; 

unMessage.destinataire = destinataire.text; 

unMessage.messageMail = texteMessage.text; 

// on prépare l'envoi en GET à la page PHP 

var requete:URLRequest = new URLRequest("envoi_GET.php"); 

requete.method = URLRequestMethod.GET; 

// on charge les données dans "data" 


} 

Code PHP 


Figure 2 : Le formulaire Flash avant l’envoi à PHP 

Figure 3 : résultat affiché par PHP après l’envoi depuis Flash 

Note importante : 

Quand vous ferez des essais, n’oubliez pas de vérifier que la version que vous testez dans la 

page HTML est la bonne version. En effet, vos navigateurs utilisent des caches, et vos SWF 

sont stockés dans ces caches. Donc pour être sûr que votre version actuelle est bien celle que 

vous voyez dans votre navigateur, voici deux solutions : 

- la plus simple consiste à changer un petit quelque chose dans votre scène Flash pour 

chaque version, par exemple un mot dans un champ texte. Si le nouveau mot est bien 

celui que vous voyez dans la page web, vous voyez bien la nouvelle version de votre 

SWF. Dans le cas contraire, supprimez le SWF et la page html générée, et faites une 

nouvelle publication depuis Flash, ou bien… 

- la seconde solution consiste à vider le cache de votre navigateur. Chaque navigateur 

possède cette fonctionnalité, mais de façon différente (effacer tout, effacer la dernière 

heure, effacer que certains types de fichiers, etc.). A vous de voir comment procéder 

sur vos machines, mais si le cache est vidé avant de faire votre publication depuis 

Flash, normalement vous aurez toujours la dernière version du SWF dans la page 

HTML. 

6.2 Exemple 2 : envoi discret des données et traitement après 

exécution du PHP 

L’exemple précédent fonctionne très bien, mais il a l’inconvénient d’envoyer les données 

dans l’adresse de la page PHP, ce qui n’est pas discret, par exemple pour un login/mot de 

passe. 

Nous allons voir ici une version améliorée de l’exemple précédent en masquant les données 

envoyées (POST au lieu de GET), et nous allons en profiter pour faire exécuter du code AS3 



quand Flash reçoit des données de PHP. Ainsi, vous saurez envoyer, recevoir, et traiter des 

données circulant entre Flash et PHP. De plus, dans cet exemple, on ne change pas de page ; 

Flash envoie des données à PHP qui à son tour en envoie à Flash, tout ça dans la même page 

web. 

Ouvrez « envoi discret de données à PHP.fla » er regardez le code AS3. Il contient entre 

autre : 

- Une différence pour l’envoi des données (variable de type URLLoader) ; 

- Une fonction qui traite les donnés renvoyées par PHP ; 

- 3 façons de traiter les données renvoyées par PHP. 

Code PHP 

Le code PHP est décomposé comme suit : 

- Une fonction qui permet d’envoyer des données à Flash 

- La récupération des données provenant de Flash 

- L’écriture de ces données dans un fichier texte 

- L’envoi de données à Flash (ici, principalement la variable nom qui contient « Master 

IPM »). 

Concernant l’envoi de données à Flash, j’ai choisi de les envoyer en les entourant des 

nombres 12 et 34 (ceci est totalement arbitraire et vous pouvez utiliser ce que vous voulez, en 

général on utilise des booléens ou des 1). Ainsi, si on veut que PHP envoie à Flash la variable 

Message valant "Coucou", on enverra la chaine "résultat=12&Message=Coucou&fin=34". 

Pourquoi fait-on cela ? La raison est simple : on veut être sûr que Flash a reçu toutes les 

données avant de les traiter. Or, on ne sait pas nécessairement combien de données doivent 

être reçues. Par contre, si on sait qu’on doit toujours avoir reçu « 12 » au début et « 34 » à la 

fin (ou autres valeurs de votre choix), et qu’on reçoit bien ces « 12 » et « 34 » alors on a reçu 

tout ce qui est entre les deux, c'est-à-dire les données au complet, donc on peut les traiter. 

Cette solution est très souvent utilisée. Il existe cependant des façons plus élégantes, mais 

demandant plus de bagages techniques. Par exemple, on utilise souvent AMFPHP 

(http://amfphp.sourceforge.net/ ou http://www.amfphp.org) pour être plus efficace, mais vous 

n’avez pas besoin de regarder cela pour IPM. 

{ 


$message = utf8_decode($message); 

$destinataire = utf8_decode($destinataire) ; 

$sujet = utf8_decode($sujet) ; 

$unMessage ="Destinataire : ".$destinataire ." Sujet : " . $sujet ." 

\n Message : ".$message." \n"; 

} 

else 

{ 

} 

?> 

// écriture des données dans le fichier lesMessages.txt 

$fichier=fopen("lesMessages.txt","a"); 

fputs($fichier,$unMessage); 

fclose($fichier); 

/* 

Pour que l'envoi de données vers AS3 fonctionne, 

il faut envoyer la première donnée sous la forme 

echo "variable=valeur", ou echo "variable=".utf8_encode(valeur), 

et les données suivantes seront envoyées par 

echo "&variable=valeur", ou envoi(variable, valeur). 

On peut aussi faire echo "variable=valeur&variable=valeur..." 

*/ 

echo "resultat=12"; 

envoi("nom", "Master IPM"); 

envoi("fin",34); 

echo "resultat=0"; 

Figure 4 : Le formulaire Flash avant l’envoi des données à PHP 



Figure 5 : Le formulaire Flash après le retour des données de PHP 



7 PHP et MySQL 

Maintenant que vous savez envoyer et recevoir des données entre Flash et PHP, vous aimeriez 

peut-être travailler avec des bases de données. Cela est tout à fait possible en effet, mais nous 

sommes ici hors du cadre du cours pour vous. Cependant, je vais vous donner quelques 

informations à ce sujet… tout en supposant que vous sachiez déjà ce qu’est une base de 

données. Si ce n’est pas le cas, vous devrez par exemple consulter des sites tels que wikipedia 

pour en avoir une idée. 

Tout d’abord, faire des bases de données (les créer, les gérer, etc.) est une vraie spécialité 

informaticienne. Créer une base avec deux ou trois tables est à la portée que tout le monde ou 

presque. Mais une base de données digne de ce nom comporte généralement des dizaines de 

tables, avec des relations complexes entre elles, et elle contient des milliers, des millions, 

voire des milliards d’enregistrements (par exemple la base de données des clients de France 

Télécom ou de La Redoute). 

De telles bases de données ne sont pas écrites en PHP et MySQL, mais avec des langages et 

outils beaucoup plus performants et robustes (Oracle par exemple). Néanmoins, il est tout à 

fait possible de manipuler ces bases de données par une interface en Flash. Cela repose sur un 

principe similaire à ce que je vais expliquer ci-dessous avec PHP. 

Manipuler des données dans une base de données ne peut pas se faire directement par Flash. 

Vous devez passer par un intermédiaire, que ce soit PHP (ou d’autres langages de 

programmation) ou d’autres outils (par exemple AMFPHP, http://amfphp.sourceforge.net/, ou 

des outils encore plus techniques comme des webservices, 

http://fr.wikipedia.org/wiki/Webservice). Je ne parlerai ici que de l’utilisation de PHP. 

Pour accéder aux données d’une base (pour consulter une base, ajouter des enregistrements, 

en supprimer, etc.), on doit donc nécessairement passer par du code PHP. Flash ne sert que 

d’affichage ou de zone de saisie ; ce n’est pas lui qui modifie la base de données, c’est PHP. 

Pour faire simple, prenons un exemple. Imaginons que nous ayons une base de données de 

clients et que nous voulions afficher tous les clients du Nord (code postal = 59). Dans ce cas : 

- vous avez une interface en Flash qui vous permettra de saisir cette information (par 

exemple un champ texte où vous taperez 59 ou bien encore une liste des codes postaux 

dans laquelle vous cliquerez le code postal 59) et d’envoyer cette information (par 

exemple avec un bouton Valider). 

- Une fois que vous avez saisi votre information (le code postal 59), votre validation 

appelle un code PHP spécifique en lui passant en paramètre le code postal 59. Ce code 

PHP a pour objectif de : 

1. récupérer le ou les paramètres envoyés par Flash (ici le code postal, mais on 

aurait pu imaginer une requête où on demande tous les clients femme du 59, 

c'est-à-dire un paramètre pour le sexe et un paramètre pour le code postal) ; 

2. exécuter le traitement correspondant sur la base de données ; ici, le code PHP 

va extraire tous les clients du Nord depuis la base de données. 

3. renvoyer à Flash les données extraites. On suppose ici que seuls les noms, 

prénoms, et emails sont renvoyés à Flash. 

- Flash récupère les données renvoyées par PHP (dans un format qui a été déterminé à 

l’avance bien sûr) et les affiche par exemple dans une liste ou dans une table. 

- Si l’utilisateur veut avoir des informations supplémentaires lorsqu’il clique sur un 

client dans la liste créée ci-dessus, ce clic doit appeler un code PHP en lui passant en 



paramètre toutes les informations nécessaires (par exemple l’email du client). On 

retrouve donc le même principe que précédemment (Flash envoie à PHP des données 

que PHP traite, puis PHP renvoie un résultat à Flash qui l’affiche). 

- Si on veut supprimer un client en cliquant dessus puis en cliquant sur un bouton 

Supprimer, même principe : on appelle un script PHP spécifique. 

Je ne détaille pas ici comment faire tout cela puisque ceci est en dehors du cours. Cependant, 

vous pouvez consulter le petit tutoriel en deux parties ci-dessous, sans oublier de lire 

attentivement (pour votre culture) les problèmes de sécurité que tout informaticien se doit de 

connaître. 

- Tutoriel partie 1 : 

http://ressources.mediabox.fr/tutoriaux/flashplatform/dynamique/php/communication_ 

php_as3 

- Tutoriel partie 2 : 

http://ressources.mediabox.fr/tutoriaux/flashplatform/dynamique/php/communication_ 

php_as3/ecriture 

- Problèmes de sécurité (injection de code) : 

http://flash.mediabox.fr/index.php?/topic/129390-pied-a-letrier-as3-acceder-a-unebase-via-phpmysql/ 



8 Appeler une page web navigateToURL 

8.1 Préambule 

Avec les problèmes de piratage et autres « hacking », Internet a vu se développer beaucoup de 

stratégies de sécurité. Flash fait de même. Au temps de Flash MX 2004 (c'est-à-dire environ 

jusqu’en 2005), il était facile d’écrire une page web contenant du Flash et pouvant accéder à 

d’autres pages web, y compris sur d’autres sites. A présent, ceci est révolu, et les paramètres 

de sécurité ont fait leur apparition. Nous n’allons pas détailler ceci, mais je voudrais juste 

vous y sensibiliser avec quelques mots plus bas. 

Note : ces aspects concernent un niveau avancé dans Flash. Si vous devez travailler sur 

ce sujet, qui n’est pas simple, consultez l’aide pour plus de précisions, en utilisant les 

mots-clés « La sécurité dans Flash Player » dans la zone de saisie de recherche. 

8.2 Paramètres de publication de Flash CS3 

La fenêtre des paramètres de publication de Flash CS3 (menu Fichier>Paramètres de 

publication, ou CTRL+MAJ+F12) permet de choisir entre deux « stratégies » pour la 

sécurité (cf. Figure 6) : accès au réseau uniquement, ou accès aux fichiers 

locaux uniquement. Dans ce second cas, toute tentative d’accès à des pages web sera 

refusée par Flash et provoquera l’affichage d’une page du site de Adobe (donc obligation 

d’être connecté à Internet, sinon aucune chance de résoudre le problème !). Cette page est une 

page qui vous permet de régler/définir les paramètres d’accès de Flash à Internet. 

Si votre animation (par exemple celle présentée sur la Figure 7) est en mode « accès aux 

fichiers locaux uniquement » et que vous tentez d’enfreindre le mode de sécurité, par exemple 

en voulant accéder à la page Web http://www.univ-lille1.fr, vous obtiendrez un message 

d’alerte (cf. Figure 8). 

• Si vous cliquez sur OK, vous n’accéderez plus à la page web voulue, sauf si vous 

rechargez l’animation (ou la page). 

• Si vous cliquez sur « Paramètres… », vous obtenez la page de sécurité chez Adobe 

(cf. Figure 9). Choisissez alors le 3 ème onglet (cf. Figure 10), puis choisissez 

« Ajouter… » dans le menu (cf. Figure 11). Vous obtenez alors le chemin d’accès 

de la dernière animation qui a enfreint la sécurité. Pour l’ajouter, soit vous faites 

un copier-coller de ce chemin dans la zone de texte en haut, soit (plus simple !) 

vous cliquez sur le bouton « Rechercher des fichiers » qui théoriquement vous 

amène directement dans le dossier qui contient l’animation en cause (si ce n’est 

pas le cas, il vous restera à naviguer dans les dossiers). Dans ce dernier cas, il ne 

vous reste plus qu’à la choisir, et vous obtenez alors la Figure 13 qui autorise de 

façon permanente l’accès à Internet pour l’animation choisie. Vous pouvez bien 

évidemment modifier ses paramètres avec le menu associé. 



Figure 6 : Paramètres de publication de Flash 8 

Figure 7 : Une animation qui laisse penser qu’on peut accéder à Internet 



Figure 8 : Message d’alerte de sécurité du lecteur Flash 

Figure 9 : page d’Adobe permettant de régler les paramètres de sécurité 

Figure 10 : Paramètre globaux de sécurité (3 ème onglet) 



Figure 11 : Menu permettant d’ajouter, supprimer, modifier des accès 

Figure 12 : Affichage du dernier accès refusé 

Figure 13 : Autorisation permanente de l’application précisée 



8.3 La fonction navigateToURL 

La fonction navigateToURL de Flash prend deux paramètres, dont seul le premier est 

obligatoire. La syntaxe de la fonction est : navigateToURL(request:URLRequest, 

window:String). 

• request: toute URL est valide, par exemple http://www.free.fr (le http:// est 

obligatoire !), ftp://www.download.com, ou mailto:jean-claude.tarby@univlille1.fr, 

ou encore javascript:alert('coucou'). Comme toute URLRequest, 

vous pouvez y associer des données (des variables par exemple), une méthode d’envoi 

(GET/POST), etc. 

• windows: Spécifie la fenêtre ou le cadre HTML dans lequel le document doit se 

charger. Vous pouvez ignorer ce paramètre, entrer le nom d'une fenêtre spécifique ou 

le sélectionner à partir des noms réservés suivants : 

o _self spécifie le cadre actif de la fenêtre en cours d'utilisation. 

o _blank crée une fenêtre. 

o _parent appelle le parent du cadre actif. 

o _top sélectionne le cadre de plus haut niveau de la fenêtre active. 

Vous pouvez également utiliser le nom d’un cadre existant, ou d’une fenêtre web. 

Vous pouvez voir un exemple de cette fonction dans « navigateToURL.fla ». Pour tester 

correctement, vous devez publier l’animation (touche F12) et pas simplement la tester dans 

Flash. Dans la fenêtre web qui s’ouvrira après la publication, le premier bouton vous envoie à 

http://www.univ-lille1.fr/ et le second à adresse semblable à celle-ci-dessous : 

http://www.univ-lille1.fr/?exampleUserLabel=Master%20IPM&exampleSessionId=1299611211466. 

Cette deuxième page vous affichera le même contenu que la première car le site de Lille 1 ne 

prend pas en compte les paramètres que vous envoyez, mais vous noterez que les paramètres 

affichés dans l’URL sont ceux qui ont été construits par le code AS3 (voir ci-dessous). 

univ_Lille1_btn.addEventListener(MouseEvent.CLICK, lille1); 

univ_Lille1_Données_btn.addEventListener(MouseEvent.CLICK, lille1_données); 

function lille1(evt:MouseEvent):void 

{ 

var url:String = "http://www.univ-lille1.fr"; 

var request:URLRequest = new URLRequest(url); 

navigateToURL(request); 

} 

function lille1_données(evt:MouseEvent):void 

{ 

var url:String = "http://www.univ-lille1.fr"; 

var variables:URLVariables = new URLVariables(); 

variables.exampleSessionId = new Date().getTime(); 

variables.exampleUserLabel = "Master IPM"; 

var request:URLRequest = new URLRequest(url); 

request.data = variables; 

navigateToURL(request); 

} 



9 C’est fini ! 

Et voilà, nous voici arrivés à la fin de ce cours Flash et AS3. J’espère que vous avez appris 

beaucoup de choses et pris du plaisir à les mettre en pratique. Si vous voulez approfondir 

Flash et AS3, il y a encore une foule de choses que nous n’avons pas abordées, mais qui ne 

sont pas du ressort d’un IPM (je vous le rappelle pour la dernière fois ☺ ).

Le cours en PDF (partie 3 - LIFL

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?