Cours Lingo version 8-5 9 séances de 3 heures Sujet à traiter 1

Cours Lingo version 8-5
9 séances de 3 heures
Sujet à traiter
1. Rappel
a. La fenêtre de messages
b. Les opérateurs
i. Opérateurs mathématiques
ii. Opérateurs de comparaisons
iii. Opérateurs logiques
iv. Opérateurs de concaténation ( pas fait – manque la notion de variable texte).
c. Les gestionnaires
i. Principes
ii. Paramètres et arguments
iii. Fonctions
d. Les différents types de scripts
i. Scripts d’animations
ii. Comportements (scripts de scénario)
iii. Scripts d’acteurs
iv. Scripts parents
e. Evènements et priorités des scripts
f. Les variables
i. Les différents types de variables
1. Entiers
2. flottants
3. chaînes
4. symboles
5. listes
6. objets
ii. L’étendue des variables
g. Le debbugage
i. La fenêtre de messages
ii. La fenêtre de surveillance
iii. La fenêtre du débogueur
h. Généralité sur les images
i. Généralité sur le son
2. Les listes
3. La programmation orientée objet (POO)
4. Lingo et les images-objets
5. Lingo et le texte
6. Lingo et les formes vectorielles (vecteur et flash)
7. Lingo et le son
8. Lingo et la vidéo
9. Animation dans une fenêtre
10. Les xtras
Bibliographie
Lingo le guide du programmeur
JR NYQUIST R MARTIN
OEM
Collection micro pro
580 pages - 2001
ISBN : 2746401673
DIRECTOR 8.5 (+ CD-ROM)
Andrew ALLENSON
Traduit de l' anglais
DUNOD
880 pages - 2002
ISBN : 2100059238
Lingo 8.5
Rappel
Lingo, le langage de Director
Généralités
Lingo est le langage de développement de director.
Il permet une programmation évènementielle orientée objet.
Il ne s’agit pas d’un langage de bas niveau. Il possède une syntaxe facilement compréhensible par le débutant. A l’origine la syntaxe
dite ‘verbose’ était proche du langage naturel. Depuis la version 7 de Director, Macromédia à intégré une syntaxe dite ‘pointée’ plus
proche des langages modernes tel que le C ou la Java.
La syntaxe ‘verbose’ est toujours utilisable. Toutefois, pour des questions de performance, il semble préférable d’éviter de mélanger
les deux types de syntaxes dans une même instruction.
Les équipes de développement de Macromédia n’ont cessé de faire évoluer le langage Lingo. Aujourd’hui il comprend plusieurs
centaines d’instructions dans les domaines suivants :
• Gestion de l’interactivité
• Gestion des différents médias supportés par Director (textes, images, son, vidéo, flash…)
• Gestion du réseau (NetLingo)
• Gestion du serveur MultiUtilisateurs
• Production ou édition d’images (ImaginLingo)
• Gestion de la 3D
• …
Le fenêtre de Messages (Ctrl + M)
La fenêtre de messages permet de tester toutes les commandes Lingo.
Pour afficher le résultat d’une commande Lingo dans la fenêtre messages, utiliser la commande ‘put’
Dans la fenêtre Messages taper : ‘put the environment'
put the environment
-- [#shockMachine: 0, #shockMachineVersion: "", #platform: "Windows,32", #runMode: "Author", #colorDepth: 16, #in
ternetConnected: #offline, #uiLanguage: "French", #osLanguage: "French", #productBuildVersion: "187"]
Figure 1 : La fenêtre de messages
put "toto"
-- "toto"
put toto
-- <Void>
put 50
-- 50
put 50 + 10
-- 60
La commande put peut également être utilisée des scripts Lingo. Le résultat sera également affiché dans la fenêtre de messages (Voir
le chapitre debugage).
Les commentaires
Il est possible de placer des commentaires dans le code Lingo. Ces commentaires ne seront pas exécutés par le moteur de Lingo.
Les commentaires ont deux finalités principales :
• Documentation du code.
Documenter votre code permet de le rendre le programme que vous écrivez plus compréhensible pour vous-même mais
aussi pour les développeurs qui prendront le relais de votre travail dans l’avenir.
• Test et debugage
Il est parfois utile de supprimer quelques lignes de codes lors de la recherche d’erreurs. Plutôt que de supprimer
physiquement des lignes de codes, vous pouvez les mettre en commentaires. Elles seront ignorées par Director. Nous
reviendrons sur les techniques de débugages dans le chapitre debugage.
Pour insérer un commentaire dans du code Lingo, il faut utiliser le signe ‘--‘.
-- ceci est un commentaire
Il est également possible de placer un commentaire après une instruction Lingo
Put 'toto' -- ce commentaire situe apres l'instruction ne sera pas execute
Si un commentaire tient sur plusieurs ligne, chaque ligne du commentaire devra commencer par ‘—‘.
-- Voici un commentaire sur plusieurs ligne
-- Chaque ligne doit commencer par --
Les variables
Le propre d’un langage de programmation est de faire des opérations (affectation, calcul, comparaison…) sur des valeurs. Ces
valeurs peuvent être saisies par l’utilisateur, issues de calcul ou de fichiers. Pendant l’exécution d’un programme, ces valeurs
sont stockées dans la mémoire vive de l’ordinateur sous forme de variables.
Dans certains langages de programmation, il est obligatoire de déclarer une variable avant de pouvoir l’initialiser. Ce n’est pas
le cas avec Lingo.
Avec Lingo, le simple faite d’affecter une valeur à une variable, crée cette variable en mémoire.
Depuis la version 7 de Director, il n’est même plus obligatoire d’utiliser la commande ‘set’ pour déclarer une variable.
Si Lingo rencontre un mot qu’il ne connaît pas, il considère qu’il s’agit d’une variable.
put MaVariable
-- <Void>
Dans l'exemple précédent, on demande à Lingo d’afficher le contenu de la variable MaVariable.
Cette variable n’existant pas, Lingo la crée. <Void> signifie que la variable ne contient aucune valeur.
Lingo et la portée des variables.
Dans l’environnement de développement Lingo, les variables peuvent avoir deux portées.
Les variables locales :
Une variable locale n’existe que dans le gestionnaire ou elle est initialisée. Dés que le gestionnaire ayant initialisé une variable
locale est exécuté, la variable disparaît de la mémoire. Elle n’est donc plus accessible.
Deux variables locales peuvent porter le même nom dans deux gestionnaires différents ; cela ne pose pas de problème. Il est
classique d’utiliser plusieurs variables nommées x ou y comme compteur de boucles.
Les variables globales :
Une variable globale a une portée globale. Elle peut être utilisée par tous les gestionnaires de l’application. Si l’application est
découpée en plusieurs animations, les variables globales seront accessibles par toutes les animations.
Pour définir une variable globale, il faut utiliser l’instruction global suivie du nom des variables globales.
Dans l’exemple suivant, trois variables globales sont définies dans une même instruction.
global gJoueur, gTour, gScore
Afin de différencier les variables locales des variables globales, il est de coutume d’utiliser le ‘g’ minuscule comme première
lettre du nom de la variable globale.
L’instruction showGlobals permet d’afficher dans la fenêtre de messages toutes les variables globales initialisées ainsi que
leurs contenus. Cette instruction est pratique pour le débugage.
L’instruction clearGlobals donne à toutes les variables globales la valeur Void.
Lingo et les types de variables :
Type de
variable
Chaine
Entier
Flottant
Exemples
“ Toto “, “aaa ! “, “ Ceci est une chaine de caractères “, “ 12345 “
1, -10
1.5, -10.25, 99999.99
Constante
Symbole
Liste
Objet
True, false, return, quote
#ok, #mort
[1,2,3], [“toto“,1, 2], [[1],[9,9,9]], [#id :121, #lib : “toto”]
<offspring “toto“ 2 12589ac>
1. Les chaînes de caractères
Une variable de type chaîne contient une suite de caractères alphabétiques ou numériques.
Pour tester si une variable est de type chaîne, vous utilisez la fonction StringP
MaVariable = "toto"
Put MaVariable.StringP
-- 1
Le contenu de MaVariable est bien une chaîne.
2. Les entiers
Une variable de type entier contient un nombre entier positif ou négatif.
Pour tester si une variable est de type entier, vous utilisez la fonction IntegerP
MaVariable = -10
Put MaVariable.IntegerP
-- 1
Le contenu de MaVariable est bien un entier.
3. Les flottants
Une variable de type flottant contient un nombre à virgule positif ou négatif.
Pour tester si une variable est de type entier, vous utilisez la fonction FloatP
MaVariable = 1.5
Put MaVariable.FloatP
-- 1
Le contenu de MaVariable est bien un nombre à virgule.
4. Les constantes.
Les constantes sont des éléments dont la valeur ne change pas.
L’exemple suivant permet de tester si l’utilisateur a appuyé sur la touche ‘Entrée’.
if the key = Return then
alert "Vous avez appuye sur la touche Entree"
end if
5. Les symboles.
Un symbole est une chaîne de caractères précédée du signe #. Un symbole est une constante définie par le programmeur
pour les besoins de son développement.
Voici quelques exemples de symboles
#ok
#marche
#course
#arret
Le symbole est traité par Lingo aussi rapidement qu’un entier mais il est plus parlant pour le programmeur.
Dans les deux exemples suivants, le résultat sera identique. Mais le premier exemple sera traité plus rapidement par Lingo
que le second.
if sens = #gauche then
Sprite(1).loch = sprite(1).loch - 5
else
Sprite(1).loch = sprite(1).loch + 5
end if
if sens = "gauche" then
Sprite(1).loch = sprite(1).loch - 5
else
Sprite(1).loch = sprite(1).loch + 5
end if
Une autre solution syntaxe aurait produit le même résultat en conservant la rapidité d’exécution. Par contre, l’interprétation
du code pour le programmeur est moins aisée, surtout si ce programmeur s’occupe de la maintenance de l’application sans
avoir participé au développement.
if sens = 1 then
Sprite(1).loch = sprite(1).loch - 5
else
Sprite(1).loch = sprite(1).loch + 5
end if
Pour tester si une variable est de type symbole, vous utilisez la fonction SymboleP
allure = #course
Put allure.SymboleP
-- 1
6. Les listes
Les listes sont des variables qui permettent de stocker plusieurs valeurs. L’opérateur permettant de désigner une liste est le
crochet [].
Voici un exemple de listes
Joueurs= ["toto","titi","tata"]
Pour tester si une variable est de type liste, vous utilisez la fonction ListeP
Joueurs= ["toto","titi","tata"]
Put Joueurs.ListeP
-- 1
Il existe deux types de listes :
Les listes linéaires
Les listes de propriétés
Nous reviendrons plus en détail sur les listes dans un chapitre ultérieur.
7. Les objets
Les objets sont à la base de la programmation orientée objet (POO).
Un objet permet d’associer des variables appelées propriétés et du code.
Nous reviendrons plus en détail sur le concept d’objet dans les chapitres ultérieurs.
Les opérateurs
Lingo
•
•
•
•
utilise différents opérateurs pour les opérations :
d’affectation
de calcul
de comparaison
de concaténation.
Opérations d’affectation
L’opérateur d’affectation est le signe ‘=’.
Set MaVariable = 10
Le chiffre 10 est affecté à la variable MaVariable.
Vous pouvez utilisez d’autres syntaxes :
MaVariable = 10
set MaVariable to 10
set 10 into Mavariable
Les deux dernières lignes de code correspondent à la syntaxe dite ‘verbose’ de Lingo.
set MaVariable = MaVariable + 1
Cette ligne de code ajoute 1 au contenu de la ma variable appelée MaVariable. L’opération située à droite du signe = est
d’abord effectuée (MaVariable + 1). Puis le résultat obtenu est affecté à MaVariable.
Opérations mathématiques
a. Addition, soustraction, multiplication et division
Les opérateurs + - * / sont utilisés pour les opérations mathématiques. Les opérateurs mathématiques peuvent être
utilisés avec des nombres (entiers ou à virgule) mais aussi avec des chaînes.
MaVariable = 5 + 4
put MaVariable
-- 9
Le résultat de l’addition de deux entiers donne un entier.
MaVariable = "5" + 4
put MaVariable
-- 9.0000
Dans cet exemple, on voit que Director évalue la chaîne ‘5’ en nombre à virgule, puis effectue l’addition.
MaVariable = 5.0 + 4
put MaVariable
-- 9.0000
Si l’un des opérandes de l’addition est un nombre à virgule, le résultat est un nombre à virgule.
Avec la division le résultat est plus visible :
MaVariable = 5 / 2
put MaVariable
-- 2
MaVariable = Mavariable * 2
put mavariable
-- 4
Comme le montre le résultat de l’enchaînement d’une division et d’une multiplication, la division du nombre entier 5 par
le nombre entier 2 donne bien le nombre entier 2.
Pour obtenir un résultat à virgule, l’un des deux opérandes doit être un nombre à virgule ou une chaîne.
MaVariable = 5.0 / 2
put MaVariable
-- 2.5000
MaVariable = Mavariable * 2
put mavariable
-- 5
MaVariable = "5" / 2
put MaVariable
-- 2.5000
b. Le modulo
Le modulo (mod) permet d’obtenir le reste d’une division.
MaVariable = 7 mod 2
put MaVariable
-- 1
Dans cette opération, 5 est le dividende et 2 le diviseur. L’opérateur mod renvoie le reste 1.
L’opérateur mod ne fonctionne qu’avec des entiers. Si l’un des opérandes est un nombre à virgule, Director l’arrondira
avant d’effectuer le modulo.
MaVariable = 7.4 mod 2
put MaVariable
-- 1
Dans cet exemple, le nombre à virgule 5.4 est arrondi à 5 avant que Director n’effectue le modulo.
MaVariable = 7.5 mod 2
put MaVariable
-- 0
Dans cet exemple, le nombre à virgule 5.5 est arrondi à 6 avant que Director n’effectue le modulo.
c. Priorités et parenthèses
Director suit les règles de priorités de l’algèbre.
Vous pouvez utilisez les parenthèses à deux fins :
• faciliter la lecture d’un calcul
put 10 + 2 * 5
-- 20
put 10 + (2 * 5)
-- 20
•
intervenir dans les règles de priorités de l’algèbre.
put (10 + 2) * 5
-- 60
Dans ce cas, l’expression entre parenthèse est évaluée en premier. Puis le résultat est multiplié par 5.
Opérateurs de comparaison
Lingo reconnaît les mêmes opérateurs de comparaison que l’algèbre.
Opérateur
Signification
=
Egal à
>
Supérieur à
<
Inférieur à
>=
Supérieur ou égal à
<=
Inférieur ou égal à
<>
Différent de
Lorsqu’un opérateur de comparaison est utilisé, Lingo retourne une valeur booléenne. Une valeur booléenne est égal à vrai (1)
ou à faux (0).
put 2 = 2
-- 1
L’exemple précédent signifie que la comparaison 2 = 2 est vrai
Voici quelques exemples d’égalités sur des nombres, des expressions et du texte.
put 3 > 2
-- 1
put 3 <> 2
-- 1
put 3 + 2 = 2 + 2 + 1
-- 1
put "Director" = "Director"
-- 1
put 3 = 2
-- 0
L’exemple précédent signifie que la comparaison 3 = 2 est fausse.
Voici quelques exemples d’inégalités entre des nombres, des expressions et du texte.
put 5 < 7
-- 1
put 3 + 2 > 1
-- 1
put "Director" = "Lingo"
-- 0
put "aa" > "ab"
-- 0
put "Director" = "DIRECTOR"
-- 1
L’exemple précédent nous montre que director ne fait pas de distinction entre les majuscules et les minuscules.
Précédemment nous avons vu que la division de deux entiers donne toujours un entier. Si nous voulons obtenir un résultat
avec virgule, un des opérandes de l’opération doit être un nombre à virgule.
Nous pouvons vérifier ici cette méthode de calcul de Director en testant l’égalité suivante :
put 5 / 2 = 5.0 / 2
-- 0
La division de 5 par 2 donne 2. Ce chiffre est bien un entier, il ne s’agit pas d’un format d’affichage sans virgule puisque
l’égalité 5 / 2 = 5.0 / 2 donne un résultat faux.
Les opérateurs logiques
Lingo dispose de trois opérateurs logiques.
Opérateur
And
Or
not
Signification
Et
Ou
Non
Lorsque Lingo rencontre un opérateur de comparaison, il évalue les deux opérandes en tant que valeur booléenne (vrai ou
faux) et retourne une valeur booléenne.
a. L’opérateur And
L’opérateur And permet de tester si les deux opérandes sont vrais.
Si les deux opérandes sont vrais, Lingo retourne vrai. Dans tous les autres cas, Lingo retourne faux.
put 1 and 1
-- 1
Lingo considère que tout entier positif ou négatif est vrai.
put -1 and 3
-- 1
Si l’un des opérandes est faux, Lingo retourne faux.
put 1 and 0
-- 0
put 0 and 5
-- 0
put 0 and 0
-- 0
b. L’opérateur Or
L’opérateur Or permet de tester si au moins un des deux opérandes est vrai. Dans ce cas, Lingo retourne vrai.
Si les deux opérandes sont faux, Lingo retourne faux
put 1 or 0
-- 1
put 1 or 1
-- 1
put 5 or 2
-- 1
put 0 or 0
-- 0
c. L’opérateur Not
L’opérateur Not permet de retourner le contraire d’une valeur booléenne.
put not 1
-- 0
put not 0
-- 1
Les opérateurs logiques peuvent être combinés entre eux. Pour tester des expressions complexes vous pouvez également
utiliser les parenthèses.
put (1 and 1) or (1 and 0)
-- 1
Les différents types de scripts
Dans Director, il existe quatre type de scripts :
• Les scripts d’animations,
• les scripts de comportements,
• les scripts d’acteurs,
• les scripts parents.
Les scripts d’animations.
Les scripts d’animations ont de multiples utilisations :
• Ils sont accessibles depuis toute l’animation, c’est-à-dire que vous pouvez les appeler depuis n’importe quels
gestionnaires.
• Ils servent à stocker les fonctions que vous développerez.
• Il permettent de gérer des évènements comme le lancement ou l’arrêt de l’animation. L’événement startMovie est
parfait pour l’initialisation des variables globales. Il s’exécute automatiquement une fois au lancement de l’animation.
Les comportements.
Un comportement peut être associé dans le scénario à une image-objet ou à une image.
Il faut faire des shoot d’écrans pour illustrer les différentes procédure
a. Les comportements d’image-objet.
Les comportements permettent de gérer les actions de l’utilisateur en rapport avec les images-objets présentes sur la scène
comme le survol (roll-over) ou le clic…
Pour créer un comportement sans l’associer à une image-objet particulière :
• ouvrez la fenêtre de script (CTRL+0),
• cliquez sur l’icône plus pour créer un nouveau script,
• dans l’inspecteur de propriétés, vérifier que le script est bien de type comportement.
Pour créer un comportement en l’associant directement à une image-objet :
• sélectionnez une image-objet dans le scénario,
• ouvrez l’inspecteur de propriété,
• cliquez sur l’onglet comportement,
•
•
•
•
cliquez sur l’icône ‘plus’,
sélectionnez ‘nouveau comportement’,
donnez un nom au nouveau comportement et validez,
le nouveau comportement doit apparaître en sur brillance dans la liste des comportements associés à l’imageobjet,
cliquez sur l’icône fenêtre de script (CTRL+0),
dans la fenêtre de script saisissez le nouveau comportement.
Un même comportement peut être associé à plusieurs image-objets. Par exemple, vous pouvez créer un comportement
unique pour la gestion de tout les rollover de votre application. Il vous suffira ensuite de le placer sur toutes les imagesobjets nécessitant ce type de comportement. Nous verrons plus tard comment écrire ce type de comportement.
Les comportements d’image ou scripts d’image.
Les scripts d’image sont placés au niveau des images sur la piste spécialisée réservée aux scripts.
Il permettent d’intercepter au niveau d’une image des messages tel que enterFrame ou exitFrame.
Le script d’image le plus utilisé est le suivant :
On exitframe
Go to the frame
end
Il permet à la tête de lecture de boucler sur une image. L’utilisateur prendre le temps de découvrir un écran de l’animation
et choisir la suite de ses pérégrinations en fonction de l’interactivité mise en place. Ce type de script doit être utilisé chaque
fois que l’utilisateur doit indiquer un choix.
Pour créer un script d’image :
• Double cliquez sur la piste spécialisée des scripts
la fenêtre de script s’ouvre
• Saisissez le script voulu.
Les scripts d’acteur.
Un script d’acteur est un script attaché directement à un acteur. Chaque image-objet créée à partir de cette acteur possèdera
donc une occurrence du script d’acteur.
Le scripts d’acteurs sont de moins en moins utilisés au profit des comportements d’images-objets.
Pour créer un script d’acteur :
•
•
•
Ouvrez la fenêtre d’édition de l’acteur sur lequel vous voulez créer un script d’acteur,
Cliquez sur l’icône script d’acteur (CTRL+’)
la fenêtre de script s’ouvre
Saisissez le script voulu.
Les scripts parents.
Ils permettent de générer des objets enfants.
Un script parents comprend toutes les propriétés et les gestionnaires nécessaires à la gestion des objets enfants (Voir chapitre
sur la programmation orientée objet).
Programmation évènementielle et hiérarchie des messages.
Lingo est un langage de programmation événementielle. Cela veut dire que la programmation se fait en fonction d’évènements
prédéfinis. Fini le temps ou le développeur écrivait des programmes de plusieurs centaines de lignes d’affilée dans lesquelles il
devait prévoir tous les cas de figure.
Dans un outil de programmation événementielle, les concepteurs de l’environnement de développement ont élaboré un cycle
d’événements récurrents. Pour coder son programme, le développeur d’application utilise ce cycle pour positionner son code
organisé sous forme de petits gestionnaires. Lors de l’exécution du programme, ces gestionnaires seront appelés en fonction de
leur positionnement dans le cycle des évènements.
Voici une liste d’événements non exhaustive classés par type de script.
Evènements gérables au niveau des comportements d’image-objet
On beginSprite
Cet événement est appelé chaque fois que la tête de lecture rencontre une nouvelle image-objet.
Il permet de créer les instances de tous les comportements attachés à l’image-objet.
La référence de l’objet est transmise dans le paramètre me.
Cet événement est généré avant l’événement PrepareFrame.
Si la tête de lecture quitte une image-objet pour y revenir plus tard, l’événement BeginSprite sera à
nouveau appelé.
On EndSprite
Cet événement est appelé chaque fois que la tête de lecture quitte une image-objet.
EndSprite est appelé après l’événement ExitFrame.
On MouseEnter
Cet événement est appelé lorsque la souris entre dans la zone de référence d’une image-objet.
L’événement MouseEnter est généralement utilisé pour permuter deux acteurs pour donner un effet de
rollover.
Si cet événement est utilisé dans un comportement, la référence de l’objet est transmise dans le
On MouseLeave
On MouseWithin
On MouseDown
On MouseUp
On MouseUpOutside
On RightMouseDown
On RightMouseUp
On PrepareFrame
On EnterFrame
On ExitFrame
paramètre me.
Cet événement est appelé lorsque la souris quitte la zone de référence d’une image-objet.
L’événement MouseEnter est généralement utilisé pour permuter deux acteurs pour donner un effet de
rollover.
Si cet événement est utilisé dans un comportement, la référence de l’objet est transmise dans le
paramètre me.
Cet événement est appelé lorsque la souris est sur la zone de référence d’une image-objet.
Si cet événement est utilisé dans un comportement, la référence de l’objet est transmise dans le
paramètre me.
Cet événement est appelé lorsque le bouton gauche de la souris est appuyé.
Si cet événement est utilisé dans un comportement, la référence de l’objet est transmise dans le
paramètre me.
Cet événement est appelé lorsque le bouton gauche de la souris est relâché.
Si cet événement est utilisé dans un comportement, la référence de l’objet est transmise dans le
paramètre me.
Cet événement est appelé lorsque le bouton gauche de la souris est relâché en dehors du rectangle de
l’image-objet.
Si cet événement est utilisé dans un comportement, la référence de l’objet est transmise dans le
paramètre me.
Cet événement est appelé lorsque le bouton droit de la souris est appuyé.
Si cet événement est utilisé dans un comportement, la référence de l’objet est transmise dans le
paramètre me.
Cet événement est appelé lorsque le bouton droit de la souris est relâché.
Si cet événement est utilisé dans un comportement, la référence de l’objet est transmise dans le
paramètre me.
Cet événement est appelé avant que l’image ne soit dessinée à l’écran.
Si cet événement est utilisé dans un comportement, la référence de l’objet est transmise dans le
paramètre me.
Cet événement est appelé lorsque le tête de lecture entre dans une image.
Si cet événement est utilisé dans un comportement, la référence de l’objet est transmise dans le
paramètre me.
Cet événement est appelé lorsque le tête de lecture quitte une image.
Si cet événement est utilisé dans un comportement, la référence de l’objet est transmise dans le
paramètre me.
Evènements gérables au niveau d’un script d’acteur
On MouseEnter
Cet événement est appelé lorsque la souris entre dans la zone de référence d’une image-objet.
L’événement MouseEnter est généralement utilisé pour permuter deux acteurs pour donner un effet de
rollover.
On MouseLeave
Cet événement est appelé lorsque la souris quitte la zone de référence d’une image-objet.
L’événement MouseEnter est généralement utilisé pour permuter deux acteurs pour donner un effet de
rollover.
On MouseWithin
Cet événement est appelé lorsque la souris est sur la zone de référence d’une image-objet.
On MouseDown
Cet événement est appelé lorsque le bouton gauche de la souris est appuyé.
On MouseUp
Cet événement est appelé lorsque le bouton gauche de la souris est relâché.
On MouseUpOutside
Cet événement est appelé lorsque le bouton gauche de la souris est relâché en dehors du rectangle de
l’image-objet.
On RightMouseDown
Cet événement est appelé lorsque le bouton droit de la souris est appuyé.
On RightMouseUp
Cet événement est appelé lorsque le bouton droit de la souris est relâché.
Evènements gérables au niveau d’un script d’image
On PrepareFrame
Cet événement est appelé avant que l’image ne soit dessinée à l’écran.
On EnterFrame
Cet événement est appelé lorsque le tête de lecture entre dans une image.
On ExitFrame
Cet événement est appelé lorsque le tête de lecture quitte une image.
Evènements gérables au niveau des scripts d’animation
On PrepareMovie
Cet événement est appelé une fois dans le cycle de l’application.
Il est appelé en début de programme, juste après le chargement des acteurs, mais avant que la première
image de l’application ne soit affichée.
C’est donc un bon emplacement pour initialiser les variables globales et procéder à des réglages comme la
taille de l’écran ou le nombre de couleurs affichées.
On StartMovie
Cet événement est appelé une fois dans le cycle de l’application.
Il est appelé en début de programme, il intervient après PrepareMovie.
On StopMovie
Cet événement est appelé une fois dans le cycle de l’application.
Il est appelé en fin de programme. C’est l’événement idéal pour libérer les ressources utilisées par
l’application, fermer les fichiers, reconfigurer l’écran correctement…
On idle
Cet événement se produit chaque fois que director n’a plus d’instruction à traiter.
On KeyDown
Cet événement se produit chaque fois qu’une touche du clavier est appuyée.
On KeyUp
Cet événement de produit chaque fois qu’une touche du clavier est relâchée.
Comme vous pouvez le constater, certains événements peuvent être appelés depuis plusieurs types de scripts.
Que se passe-t-il si une image-objet possède un comportement gérant l’événement MouseDown et que l’acteur servant à
l’image-objet a lui aussi un script d’acteur gérant l’événement MouseDown ?
Lequel des deux scripts sera exécuté en premier ?
Pour résoudre ce type de problème, les concepteurs de Director ont défini une hiérarchie dans l’exécution des scripts.
Les messages sont envoyés :
1- Aux comportements associés aux images-objets
2- Au script d’acteur des images-objets
3- Au comportement associé à l’image courante
4- Aux scripts d‘animation
Lorsqu’un message est intercepté par un script, director exécute le script. Le message n’est pas transmis aux scripts situés plus
loin dans la hiérarchie.
Si l’on veut forcer director à poursuivre dans la hiérarchie, il faut utiliser la commande ‘pass’.
Les comportements et la gestion des images objets.
Introduction à la programmation orientée objet.
La programmation orienté objet (POO) permet de définir des variables spéciale appelées propriétés (property) et des
gestionnaires. Quand vous associez un comportement à une image-objet, une instance (copie) de toutes les propriétés du
comportement est crée pour cette image-objet.
Nous allons créer notre premier comportement.
• Ouvrez la fenêtre de script.
• Nommez votre nouveau script ‘bt' (1)
• Cliquez sur l’icône ‘I’. Dans la fenêtre de propriété, vérifiez que le script est bien un comportement (2).
• Dans la fenêtre de script tapez le code suivant :
Property pSprite
On beginSprite me
pSprite = sprite(me.spritenum)
End
•
On mouseEnter me
Put pSprite
end
Dans le fenêtre de dessin vectoriel, créer un bouton et nommez le ‘bouton off’ (3).
Créer trois instance de cet acteur bouton sur la scène et associez leur le comportement ‘bt’
Ouvrez la fenêtre de message
Testez votre application
A chaque fois que la souris survol un bouton, un message, précisant le numéro de la piste de l’image-objet survolée,
apparaît dans la fenêtre de message.
-- (sprite 1)
-- (sprite 3)
-- (sprite 2)
-- (sprite 1)
-- (sprite 1)
-- (sprite 1)
Explication du code
•
•
•
Property pSprite
La commande property permet de définir les propriétés du comportement.
Pour faciliter la lecture du code, prenez l’habitude de nommer les propriétés en commençant par un p minuscule. Ce n’est pas
une règle obligatoire vis à vis de Lingo mais cette convention est utilisée par beaucoup de développeur.
Si plusieurs propriétés doivent être définies, vous pouvez le faire sur la même ligne :
Property pSprite, pSens
On beginSprite me
pSprite = sprite(me.spritenum)
End
Le gestionnaire beginSprite est exécuté, une seule fois, lorsque la tête de lecture rentre sur l’image-objet. Pour le vérifier,
ajoutez la ligne suivante au gestionnaire beginSprite :
put "initialisation" && pSprite
Arrêtez l’animation et relancez la pour tester.
Ce gestionnaire sert à initialiser les propriétés du comportement pour l’image-objet.
Paramètre me
Il sert à passer la référence de l’objet (adresse mémoire) au comportement.
Rappelez vous, quand vous associez un comportement à une image-objet, une instance des propriétés est créé. Le paramètre
me permet à Lingo de faire pointer le comportement vers l’instance des propriétés de l’image-objet.
La propriété spritenum
spritenum est une propriété d’image-objet. Elle contient par défaut le numéro de la piste de l’image-objet.
L’instruction pSprite = sprite(me.spritenum) initialise la propriété pSprite avec la valeur du numéro de la piste de l’imageobjet.
On mouseEnter me
Put pSprite
end
Le gestionnaire mouseEnter n’est appelé que lorsque la souris entre sur l’image-objet associé. Comme vous l’avez vu plus
haut, le paramètre me permet de passer la référence de l’image-objet pour que Lingo puisse
Application : Création d’un comportement pour gérer le rollover sur tous les boutons d’une application.
Objectif : Lorsque la souris survol un bouton, le comportement doit afficher l’acteur correspondant à l’état survoler du bouton.
Lorsque l’utilisateur clic sur le bouton gauche de la souris, le comportement doit afficher l’état cliqué du bouton. Le
comportement doit également gérer l’état normal du bouton.
Les évènements.
BeginSprite va nous permettre d’initialiser les différentes propriétés du comportement.
MouseEnter va nous permettre d’afficher l’état survolé.
MouseDown va nous permettre d’afficher l’état cliqué.
MouseUp va nous permettre de gérer le retour a l’état survolé lorsque l’utilisateur relâche le bouton de la souris.
MouseLeave va nous permettre de gérer le retour à l’état normal du bouton lorsque la souris sort de la zone de référence.
Les propriétés
Pour gérer le rollover sur les boutons, plusieurs technique peuvent être envisagées.
Pour commencer, nous utiliseront le nom des acteurs pour déterminer les acteurs de remplacement. Chaque bouton existe
dans les 3 états (off, survolé, on).
La propriété pName permet de stocker le nom générique du bouton (bt1, bt2).
Les acteurs
Créez deux séries de trois boutons. Chaque série de bouton devra possédez :
• Une version off – ‘bt1 off’
• Une version survol – ‘bt1 survol’
• Une version on – ‘bt1 on’
Le code du comportement rollover
Commencez par créer une distribution spécifique pour stocker les scripts. Nommer la ‘scripts’
Ouvrez la fenêtre de script
Nommez le nouveau script rollover et tapez le code qui suit :
property pName
on BeginSprite me
pName = sprite(me.spritenum).member.name.word[1]
end
on mouseEnter me
sprite(me.spritenum).Member = member(pName && "survol")
end
on mouseDown me
sprite(me.spritenum).member = member(pName && "on")
end
on mouseUp me
sprite(me.spriteNum).member = member(pName && "survol")
on mouseleave me
sprite(me.spritenum).member = member(pName && "off")
end
Explication du code
on BeginSprite me
pName = sprite(me.spritenum).member.name.word[1]
end
pName sert à stocker le premier mot du nom de l’acteur.
L’expression suivante sprite(me.spritenum).member.name.word[1], se lit de la droite vers la gauche.
La propriété name retour le nom de l’acteur utilisé.
La expression word extrait un mot ou un groupe de mot d’une chaîne de caractères. Dans cette exemple, le premier mot du
nom de l’acteur est retourné.
on mouseEnter me
sprite(me.spritenum).Member = member(pName && "survol")
end
Les 4 gestionnaires suivants servent à intervertir l’acteur utilisé par l’image-objet en fonction de l’événement.
La propriété d’image-objet member sert à spécifier l’acteur affiché par une image-objet spécifiée.
Le nom de l’acteur à utiliser est retrouvé en concaténant le contenu de la propriété pName et la terminaison voulue en fonction
de l’événement (‘off’, ‘’survol’ ou ‘on’).
Ce comportement unique est utilisable pour la gestion de tous les boutons d’une application, si la norme de nomage des
boutons est respectée. Si le comportement un utilisée sur un bouton ne possédant pas les trois acteurs correctement nommés,
une erreur de script est générée.
Des comportements pour modifier les propriétés des images objets.
Dans l’exercice qui suit noue allons créer une télécommande permettant de déplacer une image sur la scène.
Ouvrez une nouvelle animation director.
Importer une image dans la distribution (Fichier – importer ou Ctrl+r).
Poser l’image sur la scène.
Créer un acteur flèche. Nommez le ‘flèche off’.
Créez l’état de la flèche pour le rollover.
Créer quatre image-objets à partir de l’acteur flèche. Orientez les flèches dans les quatre direction en utilisant l’outils de
rotation.
Créez un comportement de rollover pour les image-objets flèches.
Testez votre application.
Pour gérer le déplacement de l’image-objet 1 en fonction des clics de l’utilisateur sur les flèches il existe plusieurs solutions :
• Créer 4 gestionnaires différents, un par flèche. Cette solution n’est pas très
• Créer un gestionnaire unique affecté aux quatre image-objets. Dans ce cas, le gestionnaire doit pourvoir identifier
l’image-objet sur laquelle l’utilisateur clic pour déterminer le sens du déplacement.
Une solution simple consiste à repérer l’image-objet et faire un test.
On mousedown me
Case sprite(me.spritenum) of
2: -- gauche
3: -- droite
4: -- haut
5: -- bas
end case
end
Les curseurs
Bibliothèque de curseur de director
Director possède sa propre bibliothèque de curseurs. Ces curseurs sont utilisables à l’aide de l’inspecteur de comportement.
Voici le code Lingo générer :
on MouseEnter
Cursor 280
End
Curseur personnalisés
Il est possible de définir ces propres curseurs.
Un curseur personnalisé est un acteur bitmap répondant à certains impératifs :
• Il doit faire 16*16 pixels au maximum
• Il doit s’agir d’un acteur 1 bit
L’inspecteur de comportement ne permet pas de sélectionner un curseur personnalisé. Il faut modifier le code Lingo
directement dans la fenêtre de script.
on MouseEnter
Cursor (member “Nom de l’acteur 1 bit”)
End
Le point chaud du curseur correspond au point d’alignement de l’acteur utilisé.
Curseur animés
Un curseur animé utilise un ou plusieurs bitmaps répondant à certain impératif :
• Ils doivent faire 32*32 pixels au maximum (16*16 sur mac)
• Il doit s’agir d’acteur 8 bits.
Pour créer un curseur en couleur ou animé, il faut utiliser l’xtra curseur.
Insertion/Elément de média/Curseur
1.
2.
3.
4.
Choix du bitmap à utiliser
Ajouter le bitmap au curseur
La position du point chaud du curseur doit préciser en pixel à partir du coin supérieur gauche
Visualisation du résultat. Le bouton aperçu permet de tester le curseur.
Exercice : Créer une nouvelle animation comportant trois bouton différents.
Utiliser un script de boucle pour attendre le choix de l’utilisateur.
Créer un changement de curseur en utilisant un curseur de la bibliothèque, un curseur personnalisé et un curseur animé.
Rollover
Un rollover consiste à permuter l’acteur d’une zone sensible (bouton par exemple) avec un autre acteur pour signaler la zone à
l’utilisateur.
Pour créer un rollover utiliser l’inspecteur de comportement en sélectionnant l’action associée aux images objets : ‘Changer
d’acteur’.
Un acteur boucle ou un gif animé peuvent être utiliser sur un rollover. L’animation crée alors un effet encore plus saisissant.
Exercice : Créer une nouvelle animation comportant trois bouton différents (Rouge, vert, bleu) et les comportements associés.
Utiliser un script de boucle pour attendre le choix de l’utilisateur.
Créer trois comportements pour gérer le changement de curseur et le rollover.
Créer un comportement pour le retour au menu.
Exercice : Modifier les acteurs de remplacement en utilisant des gif animés.
Exercice : Modifier les acteurs de remplacement en utilisant des acteurs boucles.