ADOBE Director MX 2004 Référence de scripting de Director [fr]

!"#$%&'#!!"

"##$

Référence de scripting de Director

Marques

Afterburner, AppletAce, Attain, Attain Enterprise Learning System, Attain Essentials, Attain Objects for Dreamweaver, Authorware, Authorware Attain, Authorware Interactive Studio, Authorware Star, Authorware Synergy, Backstage, Backstage Designer, Backstage Desktop Studio, Backstage Enterprise Studio, Backstage Internet Studio, Contribute, Design in Motion, Director, Director Multimedia Studio, Doc Around the Clock, Dreamweaver, Dreamweaver Attain, Drumbeat, Drumbeat 2000, Extreme 3D, Fireworks, Flash, Fontographer, FreeHand, FreeHand Graphics Studio, Generator, Generator Developer's Studio, Generator Dynamic Graphics Server, Knowledge Objects, Knowledge Stream, Knowledge Track, LikeMinds, Lingo, Live Effects, MacRecorder Logo and Design, Macromedia, Macromedia Contribute, Macromedia Coursebuilder for Dreamweaver, Macromedia M Logo & Design, Macromedia Flash, Macromedia Xres, Macromind, Macromind Action, MAGIC, Mediamaker, Multimedia is the Message, Object Authoring, Power Applets, Priority Access, Roundtrip HTML, Scriptlets, SoundEdit, ShockRave, Shockmachine, Shockwave, shockwave.com, Shockwave Remote, Shockwave Internet Studio, Showcase, Tools to Power Your Ideas, Universal Media, Virtuoso, Web Design 101, Whirlwind et Xtra sont des marques de Macromedia, Inc. et peuvent être déposées aux Etats-Unis et dans d'autres pays. Les autres noms de produits, logos, graphiques, mises en page, titres, mots ou phrases mentionnés dans cette publication peuvent être des marques de commerce, des marques de service ou des noms de marque appartenant à Macromedia, Inc. ou à d'autres entités et peuvent être déposés dans certains pays, états ou provinces.

Cette publication contient des liens conduisant à des sites web qui ne sont pas sous le contrôle de Macromedia, qui n'est aucunement responsable de leur contenu. L'accès à ces sites se fait sous votre seule responsabilité. Macromedia mentionne ces liens pour référence, ce qui ne signifie pas son soutien, accord ou responsabilité quant au contenu des sites en question.

Limite de garantie et de responsabilité Apple

APPLE COMPUTER, INC. N'OFFRE AUCUNE GARANTIE, EXPRES OU IMPLICITE, CONCERNANT CE LOGICIEL, SA CAPACITE A ETRE COMMERCIALISE OU A REPONDRE A UN BESOIN PARTICULIER. L'EXCLUSION DES GARANTIES IMPLICITES EST INTERDITE PAR CERTAINS PAYS, ETATS OU PROVINCES. L'EXCLUSION ENONCEE CI-DESSUS PEUT NE PAS S'APPLIQUER A VOTRE CAS PARTICULIER. CETTE GARANTIE VOUS ASSURE DES DROITS SPECIFIQUES. D'AUTRES DROITS VARIANT D'UN PAYS A L'AUTRE PEUVENT EGALEMENT VOUS ETRE ACCORDES.

Copyright © 2004 Macromedia, Inc. Tous droits réservés. La copie, photocopie, reproduction, traduction ou conversion de ce manuel, en partie ou dans sa totalité, sous quelque forme que ce soit, mécanique ou électronique, est interdite sans une autorisation préalable obtenue par écrit auprès de Macromedia, Inc. Numéro de pièce ZDR10M300F

Première édition : Janvier 2004

Macromedia, Inc. 600 Townsend St. San Francisco, CA 94103 États-Unis

TABLE DES MATIERES

CHAPITRE 1 : Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

Public visé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

Nouveautés concernant le scripting de Director. . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

Nouveautés dans cette documentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

Recherche d’informations en matière de scripting dans Director . . . . . . . . . . . . . . . 7

CHAPITRE 2 : Principes de base du scripting dans Director . . . . . . . . . . . . . . . . . 9

Types de scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

Terminologie de scripting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

Syntaxe de scripting. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

Types de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

Valeurs littérales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

Constructions conditionnnelles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

Evénements, messages et gestionnaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

Listes linéaires et listes de propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

Tableaux de la syntaxe JavaScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

CHAPITRE 3 : Rédaction de scripts dans Director . . . . . . . . . . . . . . . . . . . . . . . . 55

Choisir entre Lingo et la syntaxe JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

Format de scripting à syntaxe à points. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

Introduction aux objets de Director. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

Diagramme de modèles d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

Fonctions et propriétés de haut niveau. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

Introduction à la programmation orientée objet dans Director . . . . . . . . . . . . . . . 61

Programmation orientée objet avec Lingo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

Programmation orientée objet avec la syntaxe JavaScript . . . . . . . . . . . . . . . . . . . . 72

Rédaction de scripts dans la fenêtre Script. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

CHAPITRE 4 : Débogage de scripts dans Director. . . . . . . . . . . . . . . . . . . . . . . . 93

Bonnes habitudes de rédaction de scripts. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

Opérations de débogage de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

Débogage dans la fenêtre Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

Débogage dans la fenêtre Messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

Débogage de l’inspecteur d’objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

Débogage dans la fenêtre Débogueur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

Débogage de projections et d’animations Shockwave. . . . . . . . . . . . . . . . . . . . . . 110

Débogage avancé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

CHAPITRE 5 : Objets principaux de Director . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

CHAPITRE 6 : Types de médias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

CHAPITRE 7 : Objets de scripting. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149

CHAPITRE 8 : Objets 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

CHAPITRE 9 : Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

CHAPITRE 10 : Evénements et messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173

CHAPITRE 11 : Mots-clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

CHAPITRE 12 : Méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247

CHAPITRE 13 : Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 635

CHAPITRE 14 : Propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 659

INDEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1165

4 Table des matières

CHAPITRE 1

Introduction

Ce référentiel propose des informations conceptuelles et pratiques sur le scripting dans Director MX 2004 de Macromedia ainsi que des descriptions et des exemples concernant les API (Interfaces de Programmation d’Applications) de scripting que vous utilisez pour rédiger des scripts.

Les API de scripting vous permettent d’accéder aux fonctionnalités de Director et d’augmenter le caractère interactif d’une animation. Ces API vous permettent non seulement de créer des fonctionnalités interactives identiques à celles qui correspondent aux comportements prédéfinis de Director, mais aussi d’en créer d’autres, à la fois plus puissantes et plus variées.

Les comportements prédéfinis vous permettent d’ajouter un caractère interactif de base à une animation. Il est ainsi possible de déplacer la tête de lecture sur un numéro d’image ou de repère, ou d’effectuer un zoom lorsqu’on clique sur une image-objet. Ils vous permettent également d’utiliser des fonctionnalités non interactives telles que l’animation d’images-objets, le chargement de médias et la navigation au sein des images. Les API de scripting vous permettent de développer et de personnaliser ces types de fonctionnalités.

Public visé

Ce référentiel vous concerne si vous envisagez d'effectuer une ou plusieurs des opérations suivantes :

• Développer les fonctionnalités existantes des comportements prédéfinis à l’aide de scripts.

• Ajouter des fonctionnalités à une animation avec des scripts plutôt qu’à l’aide des comporte-

ments prédéfinis.

• Ajouter des fonctionnalités plus puissantes, plus variées et plus personnalisées à une animation

que celles offertes par les comportements prédéfinis.

Le but de ce référentiel est de vous fournir toutes les informations dont vous avez besoin pour ajouter de l’interactivité à vos animations à l’aide de scripts. Il n’est donc pas nécessaire d’être un programmeur chevronné pour rédiger des scripts efficaces dans Director.

Quel que soit votre niveau de familiarité avec la syntaxe de Director, Lingo ou JavaScript, consultez le Chapitre 2, Principes de base du scripting dans Director, page 9 et le Chapitre 3,

Rédaction de scripts dans Director, page 55 avant de commencer à rédiger des scripts. Comme tout

autre produit, Director possède ses propres conventions de scripting, types de données, etc. Pour pouvoir rédiger de bons scripts, il est essentiel que vous vous familiarisiez de façon approfondie avec ces caractéristiques de Director.

Nouveautés concernant le scripting de Director

Si vous avez rédigé des scripts avec les versions précédentes de Director, veuillez prendre note des innovations et changements importants apportés à cette nouvelle version de scripting.

Format de scripting avec syntaxe à base de points

Dans les versions précédentes de Director, il était possible de rédiger des scripts Lingo en utilisant deux types de syntaxe : la syntaxe verbose ou celle à points. La syntaxe verbose est très similaire à l’anglais, et les programmeurs débutants pouvaient l’apprendre facilement. Toutefois, les scripts avec syntaxe verbose sont vite devenus longs, complexes et difficiles à déboguer.

À présent que le modèle de scripting de Director est compatible avec les syntaxes Lingo et JavaScript, les scripts doivent en principe être rédigés uniquement avec la syntaxe à points. Beaucoup de programmeurs connaissent la syntaxe à points puisqu’elle est utilisée dans la plupart des langages orientés objet tels que Java ou C++, et dans plusieurs langages de scripting web tels que Microsoft JScript ou JavaScript.

Pour des raisons de compatibilité en amont, les scripts rédigés en utilisant la syntaxe verbose dans les versions précédentes de Director continueront à être pris en charge. Toutefois, à partir de la version Director MX 2004, la syntaxe à points est la syntaxe recommandée, et la seule qui sera prise en charge et documentée à l’avenir.

Pour plus d’informations concernant l'utilisation de la syntaxe à points dans l'écriture de scripts, consultez Format de scripting à syntaxe à points, page 56.

Compatibilité avec la syntaxe JavaScript

Director est désormais compatible avec la syntaxe JavaScript. Cela signifie que vous pouvez non seulement créer et déboguer des scripts à l’aide de Lingo (le langage de scripting habituel de Director) mais aussi choisir de créer et déboguer des scripts en utilisant la syntaxe JavaScript. La version de JavaScript utilisée dans Director est appelée syntaxe JavaScript dans l'ensemble de ce référentiel.

La prise en charge de la syntaxe JavaScript dans Director permet de créer un environnement de scripting familier non seulement aux développeurs en JavaScript mais aussi à ceux habitués à travailler avec les outils Macromedia Flash ActionScript, Flash Communication Server, Dreamweaver, Authorware, ainsi qu’un certain nombre d’autres environnements.

La version de syntaxe JavaScript utilisée dans Director est JavaSript 1.5, ce qui signifie qu’elle est entièrement compatible avec le standard ECMAScript Language Specification ECMA-262, 3ème Édition. Pratiquement toutes les fonctions et fonctionnalités de JavaScript 1.5 sont désormais disponibles dans Director.

Pour plus d’informations concernant le choix de la syntaxe Lingo ou JavaScript, reportez-vous à la section Choisir entre Lingo et la syntaxe JavaScript, page 55.

Remarque : Ce référentiel se contente d’aborder les principales fonctions et fonctionnalités de la version JavaScript 1.5 nécessaires à la rédaction de scripts utilisant la syntaxe JavaScript dans Director. Il ne constitue pas un référentiel complet de JavaScript 1.5. Pour une information plus détaillée sur JavaScript 1.5, consultez l’un des nombreux documents externes consacrés à ce sujet.

6 Chapitre 1 : Introduction

Nouvelles manières d’accéder aux API de scripting

Dans cette version de Director, les API de scripting ont été groupées par objets, et vous pouvez y accéder par le biais de ces objets. Les objets en question comportent les fonctionnalités requises pour ajouter de l’interactivité à vos animations et sont accessibles aux syntaxes Lingo et JavaScript au sein de Director, des projections et de l'outil Macromedia Shockwave Player.

Même si la méthode pour y accéder peut être différente, vous avez accès aux mêmes API que dans les versions précédentes, sans compter les toutes nouvelles API. La seule différence, c’est que vous y accédez en utilisant les nouveaux objets.

Pour plus d’informations sur les objets et les API de scripting correspondantes, consultez

Introduction aux objets de Director, page 57.

Nouveautés dans cette documentation

Si vous avez appris à rédiger des scripts dans les versions précédentes de Director, veuillez prendre note des changements apportés à la documentation de scripting dans cette nouvelle version. La Référence de scripting de Director remplace le Dictionnaire Lingo accompagnant les versions précédentes de Director. L’organisation de ce référentiel est différente de celle du Dictionnaire Lingo.

Dans le Dictionnaire Lingo, les informations concernant le modèle de scripting étaient classées par fonction. Par exemple, pour apprendre à utiliser les images-objets dans un script, vous deviez consulter l’une des sections se trouvant sous l’en-tête Images-objets, telles que Glissement d’images-objets, Dimensions des images-objets, etc. De plus, toutes les API de scripting étaient répertoriées par ordre alphabétique dans une seule liste, et par conséquent les fonctions, propriétés, événements, etc. figuraient tous dans la même liste.

Dans la Référence de scripting de Director, les informations concernant le modèle de scripting sont classées par objet. Cette classification reflète fidèlement l’organisation des objets de scripting que vous utilisez dans vos scripts. Par exemple, pour apprendre à utiliser les images-objets dans un script, vous pouvez consulter la section Images-objets du chapitre Objets principaux de Director.

Les API de scripting sont toujours répertoriées par ordre alphabétique, mais sont classées par type d’API. Par exemple, les méthodes sont toutes répertoriées par ordre alphabétique sous l’en-tête Méthodes, les propriétés sont toutes classées par ordre alphabétique sous l’en-tête Propriétés, etc.

Recherche d’informations en matière de scripting dans Director

La nouvelle Référence de scripting de Director est organisé comme suit :

Principes de base du scripting dans Director fournit des informations sur les concepts et

composants de base que vous utilisez lorsque vous rédigez des scripts dans Director.

Rédaction de scripts dans Director fournit des informations sur l’environnement de scripting

de Director, en plus de celles concernant les concepts et techniques de scripting avancés.

Débogage de scripts dans Director fournit des informations sur la manière de résoudre les

problèmes liés à vos scripts.

Objets principaux de Director fournit une liste des objets et API utilisés pour accéder aux

principales fonctionnalités et fonctions de Director, telles que le moteur du lecteur de Director, les fenêtres d'animation, les images-objets, les sons, etc.

Recherche d’informations en matière de scripting dans Director 7

Types de médias fournit une liste des types de médias et API que vous utilisez pour accéder

aux fonctionnalités des divers types de médias (RealMedia, DVD, GIF animé, etc.) et qui sont ajoutés aux animations en tant qu'acteurs.

Objets de scripting fournit une liste d'objets de scripting, aussi appelés Xtras, et d'API utilisées

pour étendre les fonctionnalités de base de Director. Les Xtras permettent certaines actions telles que l’importation de filtres et la connexion à Internet.

Objets 3D fournit une liste des objets utilisés pour ajouter des fonctionnalités 3D à une

animation.

Constantes fournit une liste des constantes disponibles dans Director. Evénements et messages fournit une liste des événements disponibles dans Director. Mots-clés fournit une liste des mots clés disponibles dans Director. Méthodes fournit une liste des méthodes disponibles dans Director. Opérateurs fournit une liste des opérateurs disponibles dans Director. Propriétés fournit une liste des propriétés disponibles dans Director.

8 Chapitre 1 : Introduction

CHAPITRE 2

Principes de base du scripting dans Director

Si vous êtes novice en matière de programmation avec Macromedia Director MX 2004, prenez le temps d’apprendre les principaux concepts de scripting qui vous aideront à créer des scripts dans Director avant de commencer. Certains de ces principes de base comprennent des définitions de termes importants, les règles de syntaxe, les types de données disponibles et des informations sur les éléments de base de scripting dans Director, tels que les variables, les tableaux et les opérateurs.

Types de scripts

Une animation Director peut contenir quatre types de scripts : les comportements, les scripts d’animation, les scripts parents et les scripts associés aux acteurs. Les comportements, les scripts d’animation et les scripts parents figurent tous dans la fenêtre Distribution sous la forme d’acteurs indépendants. Un script associé à un acteur figure dans la fenêtre Distribution et n’apparaît pas indépendamment.

• Les comportements sont des scripts associés à des images-objets ou images dans le scénario et

sont appelés comportements d’image-objet ou comportements d’image. La miniature de la fenêtre Distribution de chaque comportement contient une icône de comportement dans l’angle inférieur droit.

Lorsqu’il est utilisé dans la Référence de scripting de Director, le terme comportement se rapporte à un script associé à une image-objet ou une image. Cette définition diffère de celle des comportements figurant dans la Palette des bibliothèques de Director. Pour plus d’informations sur ces comportements de Director, consultez les rubriques Utilisation de Director du centre de support de Director.

Tous les comportements ajoutés à une bibliothèque de distribution figurent dans le menu local Comportements de l’inspecteur de comportement. Les autres types de scripts ne figurent pas ici.

Vous pouvez placer le même comportement à plusieurs endroits du scénario. Lorsque vous modifiez un comportement, la nouvelle version de ce comportement est appliquée à tous les endroits auxquels il est associé dans le scénario.

• Les scripts d’animations contiennent des gestionnaires disponibles globalement ou au niveau

d’une animation. Les gestionnaires d’événement d’un script d’animation peuvent être appelés depuis n’importe quel script de l’animation pendant la lecture.

Une icône de script d’animation apparaît dans l’angle inférieur droit de la miniature correspondante dans la fenêtre Distribution.

Les scripts d’animation sont disponibles pour l’animation entière, quelle que soit l’image où se trouve la tête de lecture ou l’image-objet que l’utilisateur manipule. Lors de la lecture d’une animation dans une fenêtre ou comme animation liée, un script d’animation n’est disponible que pour sa propre animation.

• Les scripts parents sont des scripts spéciaux contenant les éléments Lingo utilisés pour créer des

objets enfants. Vous pouvez utiliser des scripts parents pour générer des objets scripts qui ont une réponse et un comportement similaires tout en se comportant indépendamment les uns des autres. Une icône de script parent apparaît dans l’angle inférieur droit de la miniature correspondante dans la fenêtre Distribution.

Pour obtenir des informations sur l’utilisation des scripts parents et des objets enfants, consultez Programmation orientée objet avec Lingo, page 61.

La syntaxe JavaScript n’utilise pas de scripts parents ou d’objets enfants. Elle utilise des techniques de programmation orientée objet de style JavaScript normales. Pour plus d’informations sur la programmation orientée objet dans la syntaxe JavaScript, consultez Programmation orien-

tée objet avec la syntaxe JavaScript, page 72.

• Les scripts associés aux acteurs sont des scripts directement associés à un acteur, indépendam-

ment du scénario. Lorsque ces acteurs sont affectés à des images-objets, leurs scripts sont mis à la disposition de ces dernières.

Contrairement aux comportements, aux scripts parents et aux scripts d’animation, les scripts d’acteurs n’apparaissent pas dans la fenêtre Distribution. Cependant, si l’option Afficher les icônes de script des acteurs est sélectionnée dans la boîte de dialogue Préférences de la fenêtre Distribution, les acteurs auxquels sont associés des scripts sont identifiés par une petite icône de script dans l’angle inférieur gauche de leur miniature dans la fenêtre Distribution.

Terminologie de scripting

La syntaxe Lingo et la syntaxe JavaScript utilisent toutes deux des termes qui sont propres à chaque langage, en plus de certains termes qui sont partagés par ces langages.

Les termes importants sont présentés ici par ordre alphabétique. Ces termes sont couramment utilisés dans la Référence de scripting de Director, et il est donc nécesaire de bien les assimiler avant de continuer.

• Les constantes sont des éléments dont les valeurs ne changent jamais. Par exemple, en

Lingo, les constantes telles que peuvent pas être modifiées. Dans la syntaxe JavaScript, les constantes telles que Math.PI et

Number.MAX_VALUE ont toujours les mêmes valeurs et ne peuvent pas être modifiées. Vous

pouvez également créer vos propres constantes dans la syntaxe JavaScript à l’aide du mot clé

const.

Pour plus d’informations sur les constantes, consultez Constantes, page 21.

TAB, EMPTY et RETURN ont toujours les mêmes valeurs et ne

• Les événements sont des actions qui se produisent pendant la lecture d’une animation. Les

événements se produisent à l’arrêt d’une animation, au démarrage d’une image-objet, à l’entrée de la tête de lecture dans une image, lors de l’emploi du clavier par l’utilisateur, etc. Les événements de Director sont tous prédéfinis et ont toujours le même sens.

Pour plus d’informations sur les événements, consultez Evénements, page 36.

10 Chapitre 2 : Principes de base du scripting dans Director

• Les expressions sont des parties d’instruction produisant une valeur. Par exemple, 2 + 2 est

une expression.

• Les fonctions font référence à des fonctions de haut niveau ou à des types spécifiques de codes

de la syntaxe JavaScript. Une fonction de haut niveau ordonne à une animation de faire quelque chose pendant la

lecture de l’animation ou renvoie une valeur, mais elle n’est pas appelée à partir d’un objet spécifique. Par exemple, vous appelez la fonction de haut niveau

list(). Comme c’est le cas pour une fonction, une méthode ordonne également à une

list() en utilisant la syntaxe

animation de faire quelque chose pendant la lecture de l’animation ou renvoie une valeur, mais elle est toujours appelée à partir d’un objet.

En JavaScript, une fonction représente un gestionnaire d’événement, un objet personnalisé, une méthode personnalisée, etc. L‘utilisation des fonctions JavaScripts dans des cas pareils est expliquée dans les rubriques appropriées, plus loin dans cette référentiel.

• Les gestionnaires ou gestionnaires d’événement sont des ensembles d’instructions placées

dans un script et exécutées en réponse à un événement déterminé et à un message subséquent. Lorsqu’un événement se produit, Director génère et envoie un message correspondant aux scripts et un gestionnaire approprié est exécuté en réponse au message. Les noms des gestionnaires sont toujours les mêmes que les événements et messages auxquels ils répondent.

Remarque : Bien qu’un événement soit géré par une fonction dans la syntaxe JavaScript, le terme

gestionnaire désigne, dans ce référentiel, à la fois les gestionnaires Lingo et les fonctions de la syntaxe JavaScript qui gèrent les événements.

Pour plus d’informations sur les gestionnaires, consultez Gestionnaires, page 38.

• Les instructions sont des instructions valides que Director peut exécuter. Les scripts sont com-

posés d’ensembles d’instructions. L’instruction Lingo suivante est une instruction complète.

_movie.go("Auteur")

Pour plus d’informations sur la rédaction d’instructions, consultez Format de scripting à syntaxe

à points, page 56.

• Les listes (Lingo) ou tableaux (syntaxe JavaScript) sont des ensembles ordonnés de valeurs

qui permettent le suivi et la mise à jour d’un ensemble de données, comme une série de noms ou de valeurs affectés à un ensemble de variables. Un exemple simple de liste est une liste de nombres tels que

[1, 4, 2].

Pour plus d’informations sur l’utilisation des listes en Lingo et dans la syntaxe JavaScript, consultez Listes linéaires et listes de propriétés, page 42.

Pour plus d’informations sur l’utilisation des tableaux de la syntaxe JavaScript, consultez

Tableaux de la syntaxe JavaScript, page 50.

• Les messages sont des avertissements envoyés aux scripts par Director lorsque des événements

déterminés se produisent dans une animation. Par exemple, lorsque la tête de lecture entre dans une image donnée, l’événement

enterFrame. Si un script contient un gestionnaire enterFrame, les instructions de ce gestion-

naire seront exécutées puisque le gestionnaire a reçu le message enterFrame. Si aucun script ne contient de gestionnaire de message, le message est ignoré dans le script.

Pour plus d’informations sur les messages, consultez Messages, page 37.

enterFrame se produit et Director envoie un message

Terminologie de scripting 11

• Les méthodes sont des termes entraînant une action pendant la lecture de l’animation ou le

renvoi d’une valeur, et sont appelées à partir d’un objet. Par exemple, vous appelez la méthode

insertFrame() de l’objet Animation en utilisant la syntaxe _movie.insertFrame(). Bien

que leurs fonctionnalités soient similaires aux fonctions de haut niveau, les méthodes sont toujours appelées à partir d’un objet, contrairement aux fonctions de haut niveau.

• Mots-clés : mots réservés ayant un sens particulier. Par exemple, en Lingo, le mot clé end

indique la fin d’un gestionnaire. Dans la syntaxe JavaScript, le mot clé terme suivant est une variable.

var indique que le

• Les opérateurs calculent une nouvelle valeur à partir d’une ou de plusieurs valeurs. Par

exemple, l’opérateur d’addition ( nouvelle valeur.

Pour plus d’informations sur les opérateurs, consultez Opérateurs, page 27.

+) additionne deux valeurs ou plus pour produire une

• Les paramètres sont des repères permettant de transmettre des valeurs aux scripts. Les

paramètres s’appliquent aux méthodes et gestionnaires d’événement, mais pas aux propriétés. Ils sont exigés par certaines méthodes, mais ne sont pas obligatoires pour d’autres.

Par exemple, la méthode

go() de l’objet Animation envoie la tête de lecture à une image

précise, et indique éventuellement le nom de l’animation dans laquelle se trouve l’image. Pour effectuer cette tâche, la méthode

go() nécessite au moins un paramètre et en accepte

un autre. Le premier paramètre requis précise l’image à laquelle doit être envoyée la tête de lecture, le second paramètre facultatif indiquant l’animation dans laquelle se trouve l’image. Vu que le premier paramètre est obligatoire, une erreur de script sera renvoyée s’il n’est pas présent au moment où la méthode

go() est invoquée. Étant donné que le second paramètre

est facultatif, la méthode effectuera sa tâche même si ce paramètre n’est pas présent.

• Les propriétés sont des attributs définissant un objet. Par exemple, l’image-objet d’une

animation possède des attributs précis tels que sa largeur, sa hauteur, la couleur de son arrièreplan, etc. Pour accéder aux valeurs de ces trois attributs, vous devez utiliser les propriétés

width, height et backColor de l’objet de l’image-objet.

Pour plus d’informations sur l’attribution de propriétés aux variables, consultez Stockage et mise

à jour de valeurs dans des variables, page 22.

• Les variables sont des éléments servant à stocker et à mettre à jour des valeurs. Les variables

doivent commencer par une lettre, un trait de soulignement ( caractères suivants du nom d’une variable peuvent être des chiffres (0-9). Pour attribuer des valeurs aux variables ou changer les valeurs de plusieurs propriétés, utilisez l’opérateur égal à (

=).

Pour plus d’informations sur l’utilisation des variables, consultez Variables, page 22.

_) ou le signe dollar ($). Les

12 Chapitre 2 : Principes de base du scripting dans Director

Syntaxe de scripting

Les règles générales suivantes s’appliquent à la syntaxe Lingo et JavaScript.

• Les repères de commentaires varient de Lingo à la syntaxe JavaScript.

Les commentaires Lingo sont tous précédés de doubles tirets ( mentaire constitué de plusieurs lignes doit être précédée de doubles tirets.

-- Ceci est un commentaire Lingo à une seule ligne.

-- Ceci est un

-- commentaire Lingo à plusieurs lignes.

Les commentaires d’une seule ligne utilisant la syntaxe JavaScript sont précédés de deux barres obliques (

// Ceci est un commentaire JavaScript d’une seule ligne.

/* Ceci est un commentaire JavaScript de plusieurs lignes.*/

//). Les commentaires à plusieurs lignes sont précédés du signe /* suivi du signe */.

Vous pouvez placer un commentaire sur une ligne séparée ou après une instruction. Le texte qui suit les repères de commentaires sur la même ligne sera ignoré.

Les commentaires peuvent être variés : il peut s’agir de notes concernant un script ou d’un gestionnaire particulier ou d’une instruction dont l’objectif n’est pas évident. Ces commentaires vous permettent de vous familiariser avec une procédure que vous n’avez pas utilisée depuis longtemps.

L’ajout d’un grand nombre de commentaires n’augmente pas la taille de votre fichier d’animation lorsqu’il est enregistré sous forme d’un fichier compressé DCR ou DXR. Les commentaires seront supprimés du fichier lors du processus de décompression.

Vous pouvez également utiliser les repères de commentaires pour ignorer les sections de code que vous souhaitez désactiver à des fins de test ou de débogage. En ajoutant des repères de commentaires à votre code au lieu de le supprimer, vous le transformez provisoirement en commentaires. Sélectionnez le code à activer ou à désactiver et utilisez les boutons Insérer une marque de commentaire ou Supprimer la marque de commentaire de la fenêtre Script pour ajouter ou retirer rapidement les repères de commentaires.

--). Chaque ligne d’un com-

• Les parenthèses sont nécessaires après chaque nom de méthode et de fonction. Par exemple,

lorsque vous appelez la méthode après le mot beep. Autrement, une erreur de script se produira.

// Syntaxe JavaScript _sound.beep(); // cette instruction fonctionnera correctement _sound.beep; // cette instruction entraînera une erreur de script

Lorsque vous appelez une méthode, une fonction ou un gestionnaire à partir d’une autre méthode ou fonction ou d’un autre gestionnaire, vous devez inclure des parenthèses dans l’instruction d’appel. Dans l’exemple suivant, la méthode un appel de gestionnaire

objetCliquée

ne contient pas de parenthèses, vous obtenez une erreur de script.

beep() de l’objet Son, vous devez insérer des parenthèses

modifierImage-objet() contient

image-objetCliquée. Si l’appel du gestionnaire image-

Syntaxe de scripting 13

// Syntaxe JavaScript function modifierImage-objet() {

image-objetCliquée(); // cet appel du gestionnaire fonctionnera correctement image-objetCliquée; // cet appel du gestionnaire entraînera une erreur de script

}

function image-objetCliquée() {

// code gestionnaire ici

}

Vous pouvez également utiliser des parenthèses pour ignorer l’ordre de priorité dans les opérations mathématiques ou pour simplifier la lecture de vos instructions. Par exemple, la première expression mathématique ci-dessous renverra le résultat 13, tandis que la seconde expression renverra le résultat 5 :

5 * 3 - 2 -- renvoie 13 5 * (3 - 2) -- renvoie 5

• La syntaxe des gestionnaires d’événements varie de Lingo à JavaScript. En Lingo, les

gestionnaires utilisent la syntaxe considérés comme des fonctions et utilisent la syntaxe exemple, les instructions suivantes contiennent un gestionnaire qui émet un bip lorsque l’utilisateur clique sur la souris :

--Syntaxe Lingo on mouseDown

_sound.beep()

end

// Syntaxe JavaScript function mouseDown() {

_sound.beep();

}

on nomDeGestionnaire. En JavaScript, les gestionnaires sont

function nomDeGestionnaire(). Par

• La syntaxe des paramètres des gestionnaires d’événements peut varier de Lingo à la syntaxe

JavaScript. Lingo et JavaScript supportent tous deux les paramètres passés à un gestionnaire et mis entre parenthèses. Si plusieurs paramètres sont passés, chaque paramètre est séparé par une virgule. En Lingo, vous pouvez également passer des paramètres qui ne sont pas mis entre parenthèses. Par exemple, le gestionnaire et

--Syntaxe Lingo on additionParam a, b -- sans parenthèses

c = a + b

end

additionParam suivant reçoit les deux paramètres a

on additionParam(a, b) -- avec parenthèses

c = a + b

end

// Syntaxe JavaScript function additionParam(a, b) {

c = a + b;

}

14 Chapitre 2 : Principes de base du scripting dans Director

• Le mot-clé const peut être utilisé dans la syntaxe JavaScript pour préciser une constante dont

la valeur ne change pas. Lingo possède son propre ensemble de constantes prédéfinies (TAB,

EMPTY, etc.) ; le mot-clé const ne s’applique donc pas à Lingo.

Par exemple, l’instruction suivante indique une constante appelée

intAuthors et définit sa

valeur comme étant 12. Cette valeur sera toujours 12 et ne pourra pas être modifiée dans le script.

// Syntaxe JavaScript const intAuthors = 12;

• Le mot-clé var dans la syntaxe JavaScript peut être placé devant un mot pour préciser que ce

terme est une variable. L’instruction suivante crée une variable appelée

// Syntaxe JavaScript var valeurDébut = 0;

Remarque : Bien que l’utilisation de var dans la syntaxe JavaScript soit facultative, il est recom- mandé de toujours déclarer les variables JavaScript locales ou celles au sein d’une fonction à l’aide de var. Pour plus d’informations sur l’utilisation des variables, consultez Variables, page 22.

valeurDébut.

• Le symbole de continuation (\) de Lingo indique qu’une longue ligne d’exemples de codes

s’étale sur deux ou plusieurs lignes. Les lignes Lingo divisées de cette manière ne représentent pas des lignes de codes séparées. Par exemple, le code suivant sera valide.

--Syntaxe Lingo tTexture = member("3D").model("Boîte") \

.shader.texture

La syntaxe JavaScript ne comporte pas de symbole de continuation de ligne. Pour diviser une longue chaîne de codes JavaScript en plusieurs lignes, il vous suffit d’ajouter un retour à la ligne à la fin d’une ligne.

• Le point-virgule peut être utilisé pour indiquer la fin d’une instruction en code JavaScript.

Le point-virgule ne s’applique pas à Lingo. L‘utilisation du point-virgule est facultative. Lorsqu’il est utilisé, il doit être placé à la fin d’une

instruction complète. Par exemple, les deux instructions suivantes créent une variable appelée

valeurDébut. // Syntaxe JavaScript

var valeurDébut = 0 var valeurDébut = 0;

Un point-virgulevirgule n’indique pas nécessairement la fin d’une ligne de codes JavaScript, et plusieurs instructions peuvent être placées sur une ligne. Toutefois, et pour des raisons de clarté, il est conseillé de placer des instructions sur des lignes séparées. Par exemple, les trois instructions suivantes occupent une seule ligne de codes et sont valides, mais la lecture des codes n’est pas aisée.

// Syntaxe JavaScript _movie.go("Auteur"); var valeurDébut = 0; _sound.beep();

• Les espaces entre les caractères au sein des expressions et instructions sont ignorés en Lingo et

en JavaScript. Dans les chaînes de caractères entre guillemets droits, les espaces sont considérés comme des caractères. Si vous souhaitez insérer des espaces dans une chaîne, vous devez les y placer explicitement. Par exemple, la première instruction ci-dessous ignore les espaces entre les éléments de la liste, et la seconde inclut les espaces.

--Syntaxe Lingo maListe1 = ["1", "2", "3"] -- renvoie ["1", "2", "3"] maListe2 = [" 1 ", " 2 ", " 3 "] -- renvoie [" 1 ", " 2 ", " 3 "]

Syntaxe de scripting 15

• La sensibilité à la casse varie de Lingo à la syntaxe JavaScript.

Lingo ne fait pas la différence entre les majuscules et les minuscules, ce qui vous permet d’utiliser les majuscules et les minuscules comme bon vous semble. Par exemple, les quatre instructions suivantes sont équivalentes :

--Syntaxe Lingo member("Chat").hilite = true member("chat").hiLite = True MEMBER("CHAT").HILITE = TRUE Member("Chat").Hilite = true

Bien que Lingo ne soit pas sensible à la casse, il est recommandé de choisir une casse et de l’utiliser de manière cohérente dans les scripts. Cette habitude permet d’identifier plus facilement les noms de gestionnaires, variables, acteurs, etc.

La syntaxe JavaScript est sensible à la casse lorsqu’elle fait référence à des objets, propriétés de haut niveau ou méthodes liées aux variables définies par l’utilisateur. Par exemple, la méthode de haut niveau

sprite() renvoie un référence à une image-objet précise, et est implementée

dans Director avec des lettres minuscules. La première instruction ci-dessous se rapporte au nom de la première image-objet d’une animation, tandis que les deux instructions suivantes entraînent une erreur de script.

// Syntaxe JavaScript sprite(1).name // Cette instruction fonctionne normalement Sprite(1).name // Cette instruction entraîne une erreur de script SPRITE(1).name // Cette instruction entraîne une erreur de script

Les chaînes littérales sont toujours sensibles à la casse en Lingo et en JavaScript. Pour plus d’informations sur l’utilisation des chaînes, consultez Chaînes, page 19.

Types de données

Un type de données est un ensemble de données dont les valeurs possèdent des caractéristiques similaires et prédéfinies. Chaque valeur de variable et de propriété dans Directeur est d’un type de données précis, et les valeurs renvoyées par les méthodes sont d’un type de données précis.

Par exemple, considérons les deux instructions suivantes. Dans la première instruction, il a été attribué à la variable nombre entier. Dans la seconde instruction, il a été attribué à la variable de valeurs de caractères, c’est-à-dire une chaîne. La variable

entX le nombre entier 14. La variable entX est donc du type de données

chaîneX une séquence

chaîneX est donc du type de données

chaîne.

--Syntaxe Lingo entX = 14 chaîneX = "Nouvelles du jour"

// Syntaxe JavaScript var entX = 14; var chaîneX = "Nouvelles du jour";

Les valeurs renvoyées par les méthodes ou fonctions appartiennent également à un type de données. Par exemple, la méthode

windowPresent() de l’objet Lecteur renvoie une valeur

indiquant si une fenêtre est présente. La valeur renvoyée est TRUE (1) ou FALSE (0).

16 Chapitre 2 : Principes de base du scripting dans Director

Certains types de données sont partagés par Lingo et JavaScript, et d’autres se rapportent à l’un ou l’autre langage. L‘ensemble de types de données pris en charge par Director est fixe et ne peut être modifié, ce qui signifie qu’il n’est pas possible d’ajouter de nouveaux types de données ou de supprimer les types de données existants. Director supporte les types de données suivants.

Type de données Description

# (symbole) Unité autonome pouvant représenter une condition ou un indicateur.

Array (Syntaxe JavaScript seulement) Bien qu’il ne s’agisse pas exactement

Boolean Une valeur

Color Représente la couleur d’un objet.

Constant Une donnée dont la valeur ne change pas.

Date Bien qu’il ne s’agisse pas exactement d’un type de données, un objet Date

Float (Lingo seulement) Nombre à virgule flottante. Par exemple, 2,345 ou

Function (Syntaxe JavaScript seulement) Bien qu’il ne s’agisse pas exactement

Integer (Lingo seulement) Nombre entier. Par exemple, 5 ou 298.

List Une liste linéaire ou de propriétés composée respectivement de noms de

Math (Syntaxe JavaScript seulement) Bien qu’il ne s’agisse pas exactement

null (Syntaxe JavaScript seulement) Indique une variable dont la valeur

Number (Syntaxe JavaScript seulement) Bien qu’il ne s’agisse pas exactement

Par exemple,

d’un type de données, un objet Array (tableau) peut être utilisé sur des listes linéaires de valeurs. La fonctionnalité d’un objet Array est identique à celle du type de données Liste de Lingo.

sont de simples constantes de nombres entiers, 1 pour Dans la syntaxe JavaScript, toutes les valeurs défaut, les vraies valeurs booléennes quement converties, le cas échéant, en simples constantes de nombres entiers dans Director. En Lingo, syntaxe JavaScript,

peut être utilisé avec les dates en JavaScript. En Lingo, utilisez la méthode date() pour travailler avec les dates.

45,43.

d’un type de données, un objet Function peut être utilisé pour préciser une chaîne ou un code à exécuter.

valeurs ou de propriétés, et de valeurs.

d’un type de données, un objet Math peut être utilisé pour effectuer des opérations mathématiques.

correspond à 0 dans les contextes numériques et à FALSE dans les contextes booléens.

d’un type de données, un objet Number peut être utilisé pour représenter des constantes numériques telles qu’une valeur maximale, une valeur nota-number (NaN) et une infinité.

#list ou #word.

TRUE (1) ou FALSE (0). En Lingo, toutes les valeurs TRUE ou FALSE

TRUE, 0 pour FALSE.

true ou false sont, par

true ou false, mais sont automati-

TRUE et FALSE peuvent être en majuscules ou minuscules. Dans la

true et false doivent toujours être en minuscules.

Types de données 17

Type de données Description

Object Bien qu’il ne s’agisse pas exactement d’un type de données, un objet

Point Point sur la scène ayant une coordonnée à la fois horizontale et verticale.

Rect Rectangle sur la scène.

RegExp (JavaScript seulement) Modèle d’expression régulier correspondant à des

String Chaîne de symboles clavier ou de valeurs de caractères. Par exemple,

undefined (Syntaxe JavaScript seulement) Indique une variable qui n’a pas de valeur.

Vector Point dans l’espace 3D.

VOID (Lingo seulement) Indique une valeur vide.

Remarque : Plusieurs types de données et d’objets de la syntaxe JavaScript possèdent leur propre ensemble de méthodes et propriétés qui peuvent être utilisées pour manipuler ces types. Bien que la Référence de scripting de Director donne parfois des informations sur certaines de ces méthodes et propriétés, ces informations ne sont pas complètes. Pour plus d’informations sur ces types de données et objets, et leur méthodes et propriétés, consultez l’une des nombreuses ressources sur le sujet.

Object peut être utilisé pour créer un conteneur personnalisé de données et des méthodes agissant sur les données.

combinaisons de caractères dans des chaînes.

"Director" ou "$5.00".

Les propriétés intégrées de Director, telles que la propriété name de l’objet Acteur, ne peuvent recevoir que des valeurs qui sont du même type de données que celui de la propriété. Par exemple, le type de données de propriété du être une chaîne telle que

Nouvelle du jour. Si vous essayez d’attribuer une valeur de type de

name de l’objet Auteur est une chaîne, et la valeur doit donc

données différent à cette propriété, telle que le nombre entier 20, vous obtenez une erreur de script.

Si vous créez vos propres propriétés, leurs valeurs peuvent être de n’importe quel type de données, quel que soit le type de données de la valeur initiale.

Les syntaxes Lingo et JavaScript sont toutes deux dynamiques. Cela signifie que vous n’avez pas à préciser le type de données d’une variable lorsque vous la déclarez et que les types de données sont automatiquement convertis lors de l’exécution d’un script.

Par exemple, la syntaxe JavaScript suivante définit la variable

monAnimation comme étant un

nombre entier, et plus tard, est définie comme étant une chaîne. Lors de l’exécution du script, le type de données de

--Syntaxe Lingo monAnimation = 15 -- monAnimation est défini, au départ, en tant que nombre

entier ... monAnimation = "Animations" -- monAnimation est défini, par la suite, en tant

que chaîne

monAnimation est converti automatiquement.

// Syntaxe JavaScript var monAnimation = 15; // monAnimation est défini, au départ, en tant que

nombre entier ... monAnimation = "Animations " -- monAnimation est défini, par la suite, en tant

que chaîne

18 Chapitre 2 : Principes de base du scripting dans Director

Valeurs littérales

Une valeur littérale est une partie d’instruction ou d’expression qui doit être traitée telle quelle, et non comme une variable ou un élément de script. Les valeurs littérales que vous pourrez rencontrer dans un script sont les chaînes de caractères, les entiers, les nombres décimaux, les noms et numéros d’acteurs, les noms et numéros d’images et d’animations, les symboles et les constantes.

Chaque type de valeur littérale est régi par ses propres règles.

Chaînes

Les chaînes sont des mots ou des groupes de caractères que le script traite en tant que mots standard, et non en tant que variables. Elles doivent être encadrées de guillemets droits. Par exemple, vous pouvez utiliser des chaînes pour transmettre des messages aux utilisateurs de votre animation ou pour attribuer des noms aux acteurs. Dans l’instruction suivante, et Salutations sont des chaînes. Bonjour est le texte littéral placé dans l’acteur texte et

Salutations est le nom de ce dernier.

--Syntaxe Lingo member("Salutations").text = "Bonjour"

De même, lorsque vous testez une chaîne, vous devez l’encadrer de guillemets droits, comme dans l’exemple suivant :

--Syntaxe Lingo if "Bonjour M. Dupont" contains "Bonjour" then gestionnaireAudio

Lingo et JavaScript considèrent les espaces figurant au début ou à la fin d’une chaîne comme une partie littérale de la chaîne. L’expression suivante comprend un espace après le mot à :

// Syntaxe JavaScript trace("Mes pensées se résument à ");

Bien que Lingo ne distingue pas les majuscules des minuscules lorsqu’il fait référence aux acteurs, aux variables, etc., les chaînes littérales sont sensibles à la casse. Par exemple, les deux instructions suivantes placent un texte différent dans l’acteur indiqué, car chaînes littérales.

--Syntaxe Lingo member("Salutations").text = "Bonjour" member("Salutations").text = "BONJOUR"

En Lingo, la fonction string() peut convertir une valeur numérique en une chaîne. Dans la syntaxe JavaScript, la méthode

Remarque : Si vous essayez d’utiliser la méthode toString() de la syntaxe JavaScript sur une valeur null ou undefined, vous obtenez une erreur de script. Ceci n’est pas le cas en Lingo, dont la fonction string() s’applique à toutes les valeurs, y compris celles qui sont VOID.

toString() peut convertir une valeur numérique en une chaîne.

Bonjour et BONJOUR sont des

Bonjour

Valeurs littérales 19

Nombres

Il existe deux types de nombres en Lingo : entiers et décimaux. Un nombre entier ne comporte ni fraction ni décimale, dans les plages -2 147 483 648 et

+2 147 483 647. Entrez des nombres entiers sans utiliser de virgule. Utilisez le signe moins ( pour les nombres négatifs.

Un nombre décimal, également appelé nombre à virgule flottante, est un nombre qui inclut une virgule décimale. En Lingo, la propriété

floatPrecision détermine le nombre de décimales

utilisées pour l’affichage de ces nombres. Director utilise toujours le nombre tout entier, jusqu’à 15 chiffres utiles , dans ses calculs ; il arrondit tout nombre comportant plus de 15 chiffres utiles.

JavaScript ne fait pas de distinction entre les nombres entiers et les nombres à virgule flottante, et n’utilise que des nombres. Par exemple, les instructions suivantes montrent que le nombre 1 est un nombre entier en Lingo et un nombre dans la syntaxe JavaScript, et que le nombre décimal

1.05 est un nombre à virgule flottante en Lingo et un nombre en JavaScript :

--Syntaxe Lingo put(ilk(1)) -- #integer put(ilk(1.05)) -- #float

// Syntaxe JavaScript trace(typeof(1)); // nombre trace(typeof(1.05)); // nombre

En Lingo, vous pouvez convertir un nombre décimal en nombre entier avec la fonction

integer(). Vous pouvez également convertir un nombre entier en nombre décimal en effectuant

une opération mathématique sur le nombre entier, par exemple en multipliant le nombre entier par le nombre décimal. En JavaScript, la fonction chaîne ou un nombre décimal en nombre entier. Contrairement à la fonction Lingo,

parseInt() arrondit au plus petit. Par exemple, l’instruction suivante arrondit le nombre

parseInt() vous permet de convertir une

integer() de

décimal 3.9 et le convertit au nombre entier 4 (Lingo) et 3 (JavaScript).

--Syntaxe Lingo leNombre = integer(3.9) – renvoie la valeur 4

// Syntaxe JavaScript var leNombre = parseInt(3.9); // renvoie la valeur 3

En Lingo, la fonction value() peut convertir une chaîne en une valeur numérique. Vous pouvez également utiliser une notation exponentielle avec les nombres décimaux : par

exemple, -

1.1234e-100 ou 123.4e+9.

En Lingo, vous pouvez convertir un nombre entier ou une chaîne en nombre décimal avec la fonction

float(). En JavaScript, la fonction parseFloat() vous permet de convertir une

chaîne en nombre décimal. Par exemple, l’instruction suivante enregistre la valeur 3.0000 (Lingo) et 3 (syntaxe JavaScript) dans la variable

--Syntaxe Lingo leNombre = float(3) – renvoie une valeur de 3.0000

// Syntaxe JavaScript var leNombre = parseFloat(3) // renvoie une valeur de 3

20 Chapitre 2 : Principes de base du scripting dans Director

leNombre.

Constantes

Une constante est une valeur déclarée dont le contenu ne change jamais. En Lingo, les termes prédéfinis

TRUE, FALSE, VOID et EMPTY sont des constantes car leur valeur ne

change jamais. Les termes prédéfinis BACKSPACE, ENTER, QUOTE, RETURN, SPACE et TAB sont des constantes qui font référence aux touches du clavier. Par exemple, pour tester si la dernière touche enfoncée par l’utilisateur était la barre Espace, utilisez l’instruction suivante :

--Syntaxe Lingo if _key.keyPressed() = SPACE then beep()

En JavaScript, vous pouvez accéder à des constantes prédéfinies à l’aide de types de données propres à la syntaxe JavaScript. Par exemple, objet Number contient des constantes telles que

Number.MAX_VALUE et Number.NaN, l’objet Math renferme des constantes telles que Math.PI et Math.E, etc.

Remarque : Ce référentiel ne fournit pas d’informations complètes sur les constantes prédéfinies dans la syntaxe JavaScript. Pour plus d’informations sur ces constantes, consultez les nombreuses autres ressources consacrées à ce sujet.

Dans la syntaxe JavaScript, vous pouvez également définir vos propres constantes à l’aide du motclé

const. Par exemple, l’instruction suivante crée une constante appelée items et lui attribue la

valeur 20. Cette valeur ne peut pas être modifiée après sa création.

// Syntaxe JavaScript const items = 20;

Pour plus d’informations sur les constantes, consultez le Chapitre 9, Constantes, page 165.

Symboles

En Lingo, un symbole est une chaîne ou toute autre valeur précédée du signe dièse (

#).

Les symboles sont des constantes définies par l’utilisateur. Les comparaisons utilisant des symboles s’effectuent très rapidement, créant ainsi un code plus efficace.

Par exemple, la première instruction ci-dessous s’exécute plus rapidement que la seconde :

--Syntaxe Lingo niveauUtilisateur = #novice niveauUtilisateur = "novice"

Les symboles ne peuvent contenir ni espace ni ponctuation. En Lingo et en JavaScript, convertissez une chaîne en symbole à l’aide de la méthode

--Syntaxe Lingo x = symbol("novice") – renvoie le résultat #novice

symbol().

// Syntaxe JavaScript var x = symbol("novice"); // renvoie le résultat #novice

Reconvertissez un symbole en chaîne à l’aide de la fonction string() (Lingo) ou la méthode

toString() (syntaxe JavaScript).

--Syntaxe Lingo x = string(#novice) -- renvoie "novice"

// Syntaxe JavaScript var x = symbol("novice").toString(); // renvoie le résultat "novice"

Valeurs littérales 21

Dans la syntaxe JavaScript, vous ne pouvez pas comparer des symboles du même nom pour déterminer s’ils font référence au même symbole. Pour comparer des symboles du même nom, vous devez d’abord les convertir en chaîne en utilisant la méthode

toString().

Variables

Director utilise des variables pour conserver et actualiser les valeurs. Comme son nom l’indique, une variable contient une valeur qui peut être modifiée ou mise à jour pendant la lecture de l’animation. En modifiant la valeur d’une variable pendant la lecture de l’animation, vous pouvez par exemple stocker une URL, mémoriser le nombre de fois qu’un utilisateur prend part à une session de discussion en ligne, enregistrer si une opération réseau est terminée ou non, etc.

Il est conseillé de toujours attribuer une valeur connue à une variable la première fois que vous la déclarez. Cette opération est appelée « initialisation d’une variable ». L’initialisation d’une variable facilite le suivi de cette variable et permet de comparer ses différentes valeurs au fur et à mesure de la lecture de l’animation.

Les variables peuvent être globales ou locales. Une variable locale n’existe que tant que le gestionnaire dans lequel elle a été définie est en cours d’exécution. Une variable globale peut exister et conserver sa valeur tant que l’application Director est en cours d’exécution, notamment lorsqu’une animation passe à une autre animation. Une variable peut être globale au sein d’un gestionnaire individuel, un script spécifique ou une animation entière ; la portée dépend de la manière dont la variable globale est initialisée.

Puisque les variables globales doivent en général être disponibles durant toute l’animation, il est d’usage de les déclarer dans un gestionnaire

prepareMovie()

(syntaxe JavaScript). Elles sont ainsi disponibles dès le début de l’animation.

Pour plus d’informations sur l’utilisation des variables globales et locales, consultez Utilisation de

variables globales, page 24 et Utilisation de variables locales, page 26.

on prepareMovie (Lingo) ou function

Stockage et mise à jour de valeurs dans des variables

Les variables peuvent contenir des données pour tous les types de données de Director, qu’il s’agisse de nombres entiers, de chaînes, de valeurs

TRUE ou FALSE, de symboles, de listes ou du

résultat d’un calcul. Pour stocker les valeurs des propriétés et des variables, utilisez l’opérateur égal à (

=).

Comme indiqué dans la section Types de données de ce référentiel, les variables de Lingo et JavaScript sont dynamiques, ce qui signifie qu’elles contiennent des types de données différents à des moments différents. (La possibilité de modifier le type d’une variable distingue Lingo d’autres langages tels que Java et C++, où cette possibilité n’existe pas.)

Par exemple, l’instruction

set x = 1 crée la variable x, qui est une variable nombre entier, car

vous lui avez attribué un entier. Si vous utilisez ensuite l’instruction set x = "un", la variable x devient une variable à chaîne puisqu’elle contient maintenant une chaîne.

Vous pouvez convertir une chaîne en nombre à l’aide de la fonction méthode

string() (Lingo) ou de la méthode toString() (syntaxe JavaScript).

22 Chapitre 2 : Principes de base du scripting dans Director

parseInt() (syntaxe JavaScript), ou un nombre en chaîne à l’aide de la fonction

value() (Lingo) ou de la

Les valeurs de certaines propriétés peuvent être définies (la valeur est attribuée) et renvoyées (la valeur est récupérée), et les valeurs de certaines propriétés ne peuvent être que renvoyées. Les propriétés dont les valeurs peuvent être à la fois définies et renvoyées sont appelées lecture/ écriture, celles qui peuvent seulement être renvoyées étant appelées lecture seule.

Il s’agit en général de propriétés décrivant une condition échappant au contrôle de Director. Par exemple, vous ne pouvez pas définir la propriété d’acteur

numChannels, qui indique le nombre de

pistes d’une animation possédant un contenu Macromedia Shockwave. Par contre, vous pouvez récupérer le nombre de pistes en faisant référence à la propriété

Pour attribuer une valeur à une variable :

numChannels d’un acteur.

• Utilisez l’opérateur égal à (=).

Par exemple, l’instruction suivante attribue une URL à la variable

// Syntaxe JavaScript var endroitsAvisiter = "http://www.macromedia.com";

Les variables peuvent également contenir le résultat d’opérations mathématiques. Par exemple, l’instruction suivante ajoute le résultat d’une addition à la variable

--Syntaxe Lingo maSomme = 5 + 5 -- ceci définit maSomme comme étant égale à 10

En guise d’exemple supplémentaire, l’instruction suivante renvoie l’acteur affecté à l’image-objet 2 en récupérant la valeur de la propriété

ActeurTexte.

--Syntaxe Lingo ActeurTexte = sprite(2).member

member de l’image-objet, et la place dans la variable

Il est recommandé d’utiliser des noms de variables indiquant le rôle de ces variables. Vos scripts n’en seront que plus faciles à lire. Par exemple, la variable

maSomme indique que cette variable

contient le résultat d’une addition.

endroitsAvisiter :

maSomme:

Pour tester la valeur de propriétés ou de variables :

• Utilisez la fonction put() ou trace() dans la fenêtre Messages ou cochez les valeurs de la

fenêtre Surveillance ;

disponibles en Lingo et la syntaxe JavaScript. Par exemple, l’instruction suivante affiche la valeur attribuée à la variable

fenêtre Messages.

--Syntaxe Lingo monNuméro = 20 * 7 put(monNuméro) -- affiche 140 dans la fenêtre Messages

// Syntaxe JavaScript var monNuméro = 20 * 7; trace(monNuméro); // affiche 140 dans la fenêtre Messages

put() et trace() proposent des fonctionnalités identiques et sont

monNuméro dans la

Variables 23

Utilisation de variables globales

Les variables globales peuvent être partagées par les gestionnaires, les scripts ou les animations. Une variable globale existe et garde sa valeur tant que Director est en cours d’exécution ou jusqu’à ce que vous appeliez la méthode

clearGlobals.

Dans Macromedia Shockwave Player, les variables globales subsistent dans les animations affichées par la méthode

goToNetPage().

goToNetMovie(), mais pas dans celles affichées par la méthode

Chaque gestionnaire déclarant une variable globale peut utiliser la valeur de cette variable. S’ils modifient cette valeur, la nouvelle valeur est accessible à tous les autres gestionnaires qui considèrent cette variable comme globale.

Il est d’usage de démarrer les noms de toutes les variables globales par un g minuscule. Cette convention permet d’identifier plus facilement les variables globales lors de l’examen du code.

Director propose une manière d’afficher toutes les variables globales actuelles et leurs valeurs courantes, et d’effacer les valeurs de toutes les variables globales.

Pour afficher toutes les variables globales et leurs valeurs actuelles :

• Utilisez la méthode showGlobals() de l’objet Global dans la fenêtre Messages.

Pour plus d’informations sur la fenêtre Messages, consultez Débogage dans la fenêtre Messages,

page 98.

Pour supprimer toutes les variables globales actuelles :

• Utilisez la méthode clearGlobals() de l’objet Global de la fenêtre Messages pour attribuer à

toutes les variables globales la valeur Le contrôle des valeurs des variables globales, lors de la lecture d’une animation, s’effectue par le

biais de l’inspecteur d’objet. Pour plus d’informations sur l’inspecteur d’objet, consultez Débogage

de l’inspecteur d’objet, page 102.

VOID (Lingo) ou undefined (syntaxe JavaScript).

Variables globales en Lingo

En Lingo, les variables sont, par défaut, considérées comme des variables locales, et vous n’avez donc pas besoin d’insérer un mot-clé avant le nom d’une variable. Pour déclarer une variable globale, vous devez insérer le mot-clé

global avant la variable.

Si vous déclarez une variable globale en haut de la fenêtre Script et avant un gestionnaire, cette variable sera disponible pour tous les gestionnaires de ce script. Si vous déclarez une variable globale au sein d’un gestionnaire, cette variable sera à la disposition de ce gestionnaire uniquement ; toutefois, si vous déclarez une variable globale du même nom au sein de deux gestionnaires distincts, et que vous mettez à jour la valeur de la variable dans un gestionnaire, vous mettez également à jour la valeur de la variable dans l’autre gestionnaire.

24 Chapitre 2 : Principes de base du scripting dans Director

Les exemples suivants illustrent ce qui se passe avec deux variables globales : gScript, qui est à la disposition de tous les gestionnaires dans le script, et gGestionnaire, qui est disponible au sein de son propre gestionnaire et de tout autre gestionnaire qui la déclare à sa première ligne.

--Syntaxe Lingo global gScript -- gScript est à la disposition de tous les gestionnaires

on mouseDown

gGestionnaire global

gScript = 25

gGestionnaire = 30 end

on mouseUp

gGestionnaire global

trace(gGestionnaire) -- affiche 30 end

En Lingo, lorsque vous utilisez le terme global pour définir les variables globales, ces dernières reçoivent automatiquement la valeur initiale

VOID.

Variables globales dans la syntaxe JavaScript

Dans la syntaxe JavaScript, les variables sont considérées comme des variables globales par défaut. La portée d’une variable globale peut être déterminée par la manière dont elle est déclarée et la position à laquelle elle est déclarée.

• Si vous déclarez une variable au sein d’une fonction de la syntaxe JavaScript sans la faire

précéder du mot-clé

la contient.

var, cette variable sera disponible pour toutes les fonctions du script qui

• SI vous déclarez une variable en dehors d’une fonction de la syntaxe JavaScript, avec ou sans le

mot-clé

var, cette variable sera disponible pour toutes les fonctions du script qui la contient.

• Si vous déclarez une variable à l’intérieur ou à l’extérieur d’une fonction de la syntaxe

JavaScript en utilisant la syntaxe

les scripts d’une animation. L’exemple suivant utilise la syntaxe

en tant que variable globale. Cette variable est à la disposition de tous les scripts d’une animation.

// Syntaxe JavaScript _global.gFilm = 1; // déclare gFilm dans un script

_global.nomVar, cette variable sera disponible pour tous

_global.gFilm dans un script pour déclarer la variable gFilm

// Crée une fonction dans un script séparé qui agit sur gFilm function mouseDown() {

_global.gFilm++;

return(_global.gFilm); }

Variables 25

L’exemple suivant déclare la variable globale gScript dans un script. Cette variable est uniquement à la disposition des fonctions de ce script.

// Syntaxe JavaScript var gScript = 1; // déclare gScript dans un script

// gScript est uniquement à la disposition des fonctions du script qui le

définit function mouseDown() {

gScript++;

return(gScript); }

Dans la syntaxe JavaScript, lorsque vous définissez des variables avant les gestionnaires, elles reçoivent automatiquement la valeur intiale

undefined.

Utilisation de variables locales

Une variable locale n’existe que tant que le gestionnaire dans lequel elle a été définie est en cours d’exécution. Toutefois, après avoir créé un variable locale, vous pouvez l’utiliser dans d’autres expressions ou modifier sa valeur tant qu’un script se trouve dans le gestionnaire qui a défini la variable.

Il est préférable de définir une variable comme locale lorsque vous ne souhaitez l’utiliser que provisoirement dans un gestionnaire. Vous limitez ainsi les risques de modification accidentelle de sa valeur dans d’autres gestionnaires utilisant le même nom de variable.

Pour créer une variable locale :

• En Lingo, attribuez une valeur à la variable avec l’opérateur égal à (=).

• Dans la syntaxe JavaScript, et à l’intérieur d’une fonction, insérez le mot-clé var avant le nom

de la variable puis attribuez-lui une valeur à l’aide de l’opérateur égal à.

Remarque : Vu que les variables de la syntaxe JavaScript sont, par défaut, globales, si vous

essayez de déclarer une variable locale à l’intérieur d’une fonction sans utiliser le mot-clé var,

votre script risque de créer un comportement inattendu. Ainsi, et bien que l’utilisation de var soit

facultative, il est fortement recommandé de déclarer toutes les variables JavaScript locales à l’aide

de var pour éviter tout comportement inattendu.

Pour afficher toutes les variables locales d’un gestionnaire :

• En Lingo seulement, utilisez la fonction showLocals().

En Lingo, vous pouvez utiliser cette méthode dans la fenêtre Messages ou dans des gestionnaire pour faciliter le débogage des scripts. Le résultat apparaît dans la fenêtre Messages. La méthode

showLocals() ne s’applique pas à la syntaxe JavaScript.

Pour contrôler les valeurs des variables locales lors de la lecture d’une animation, utilisez l’inspecteur d’objet. Pour plus d’informations sur l’inspecteur d’objet, consultez Débogage de

l’inspecteur d’objet, page 102.

26 Chapitre 2 : Principes de base du scripting dans Director

Opérateurs

Les opérateurs sont des éléments indiquant à Lingo et JavaScript comment combiner, comparer ou modifier les valeurs d’une expression. Plusieurs des opérateurs de Director sont partagés par la syntaxe Lingo et la syntaxe JavaScript, et certains sont propres à un langage.

Certains types d’opérateurs comprennent :

• Des opérateurs arithmétiques (tels que +, -, / et *)

• Des opérateurs de comparaison (tels que <, > et >=), qui comparent deux arguments

• Des opérateurs logiques (not, and, or) qui combinent des conditions simples en conditions

composées

• Des opérateurs de chaînes (tels que &, &&, et +) qui relient ou concatènent des chaînes de

caractères.

Remarque : Il existe beaucoup plus de types d’opérateurs dans la syntaxe JavaScript qu’en Lingo, et ils ne sont pas tous décrits dans ce référentiel. Pour plus d’informations sur les autres opérateurs en JavaScript 1.5, consultez les nombreuses autres ressources consacrées à ce sujet.

Les éléments sur lesquels les opérateurs agissent sont appelés des opérandes. En Lingo, il n’existe que des opérateurs binaires. Dans la syntaxe JavaScript, il existe des opérateurs binaires et unaires. Un opérateur binaire nécessite deux opérandes, l’un placé avant l’opérateur et l’autre après. Un opérateur unaire nécessite un seul opérande, placé soit avant soit après l’opérateur.

Dans l’exemple suivant, la première instruction illustre un opérateur binaire où les variables sont des opérandes et le signe plus ( unaire où la variable

// Syntaxe JavaScript x + y; // opérateur binaire i++; // opérateur unaire

i est l’opérande et ++ l’opérateur.

Pour plus d’informations sur les opérateurs, consultez le Chapitre 13, Opérateurs, page 635.

+) l’opérateur. La seconde instruction illustre un opérateur

x et y

Ordre de priorité des opérateurs

Lorsqu’un ou plusieurs opérateurs sont utilisés dans la même instruction, certains opérateurs sont prioritaires par rapport à d’autres selon une hiérarchie précise qui détermine les opérateurs à exécuter en premier. Cette hiérarchie est appelée « ordre de priorité des opérateurs ». Par exemple, une multiplication est toujours effectuée avant une addition. Cependant, les éléments entre parenthèses sont prioritaires par rapport à la multiplication. Dans l’exemple suivant, en l’absence de parenthèses, la multiplication de cette instruction se produit en premier :

--Syntaxe Lingo total = 2 + 4 * 3 – renvoie une valeur de 14

Lorsque l’addition apparaît entre parenthèses, l’addition s’effectue en premier :

--Syntaxe Lingo total = (2 + 4) * 3 – renvoie une valeur de 18

Vous trouverez ci-dessous une description des types d’opérateurs et leur ordre de priorité. Les opérateurs possédant une priorité élevée sont exécutés en premier. Par exemple, un opérateur dont l’ordre de priorité est 5 est exécuté avant un opérateur dont l’ordre de priorité est 4. Les opérations qui ont le même ordre de priorité sont exécutées de gauche à droite.

Opérateurs 27

Opérateurs arithmétiques

Les opérateurs arithmétiques additionnent, soustraient, multiplient, divisent et effectuent d’autres opérations arithmétiques. Les parenthèses et le signe moins sont aussi des opérateurs arithmétiques.

Opérateur Effet Ordre de priorité

( )

mod

Opérations permettant de contrôler la priorité. 5

Lorsque placé devant un chiffre, en inverse la valeur. 5

Effectue une multiplication. 4

(Lingo seulement) Effectue des opérations de modulos. 4

Effectue une division. 4

(Syntaxe JavaScript seulement) Renvoie le reste du nombre entier résultant d’une division de deux opérandes.

(Syntaxe JavaScript seulement) Ajoute un à son opérande. Lorsque utilisé comme opérateur préfixe ( son opérande après avoir ajouté un. Lorsque utilisé comme opérateur postfixe ( d’ajouter un.

(Syntaxe JavaScript seulement) Soustrait un de son opérande. La valeur renvoyée est analogue à celle de l’opérateur d’incréments.

Lorsque placé entre deux chiffres, effectue une addition. 3

Lorsque placé entre deux chiffres, effectue une soustraction. 3

x++), renvoie la valeur de son opérande avant

++x), renvoie la valeur de

Remarque : En Lingo, lorsque seuls des nombres entiers sont utilisés dans une opération, le résultat est un nombre entier. Si vous utilisez des entiers et des nombres à virgule flottante dans la même opération, le résultat est toujours un nombre à virgule flottante. Dans la syntaxe JavaScript, tous les calculs renvoient comme résultat des nombres à virgule flottante.

Si le résultat de la division d’un entier par un autre entier n’est pas un nombre entier, Lingo arrondit le résultat au nombre entier inférieur le plus proche. Par exemple, le résultat de Dans la syntaxe JavaScript, la valeur à virgule flottante, 1.333, est renvoyée.

Pour forcer Lingo à calculer une valeur sans arrondir le résultat, utilisez plusieurs des valeurs dans l’expression. Par exemple, le résultat de

28 Chapitre 2 : Principes de base du scripting dans Director

float() avec une ou

4/float(3) est 1.333.

4/3 est 1.

Opérateurs de comparaison

Les opérateurs de comparaison comparent deux valeurs et déterminent si la comparaison est vraie (true) ou fausse (false).

Opérateur Signification Ordre de priorité

===

!==

(Syntaxe JavaScript seulement) Deux opérandes sont égaux. Si les opérandes ne sont pas du même type de données, la syntaxe JavaScript essaie de les convertir en type de données approprié afin d’effectuer une comparaison.

(Syntaxe JavaScript seulement) Deux opérandes sont égaux et du même type.

(Syntaxe JavaScript seulement) Deux opérandes ne sont pas égaux. Si les opérandes ne sont pas du même type de données, la syntaxe JavaScript essaie de les convertir en type de données approprié afin d’effectuer une comparaison.

(Syntaxe JavaScript seulement) Deux opérandes ne sont pas égaux et/ou du même type.

(Syntaxe Lingo seulement) Deux opérandes ne sont pas égaux. 1

L’opérande de gauche est inférieur à l’opérande de droite. 1

L’opérande de gauche est inférieur ou égal à l’opérande de droite. 1

L’opérande de gauche est supérieur à l’opérande de droite. 1

L’opérande de gauche est supérieur ou égal à l’opérande de droite.

(Lingo seulement) Deux opérandes sont égaux 1

Opérateurs d’affectation

Un opérateur d’affectation attribue une valeur à son opérande de gauche en fonction de la valeur de son opérande de droite. A l’exception de l’opérateur d’affectation de base égal à (

=), tous les

opérateurs d’affectation de raccourcis suivants ne s’appliquent qu’à la syntaxe JavaScript.

Opérateur Signification Ordre de priorité

= Egal à 1

x += y (Syntaxe JavaScript seulement) x = x + y 1

x -= y (Syntaxe JavaScript seulement) x = x - y 1

x *= y (Syntaxe JavaScript seulement) x = x * y 1

x /= y (Syntaxe JavaScript seulement) x = x / y 1

x %= y (Syntaxe JavaScript seulement) x = x % y 1

Opérateurs 29

Opérateurs logiques

Les opérateurs logiques testent si deux expressions logiques sont vraies (true) ou fausses (false). Faites attention lorsque vous utilisez les opérateurs logiques et les opérateurs de chaînes en Lingo

et en JavaScript. Par exemple, dans la syntaxe JavaScript, mine si deux expressions sont vraies, mais en Lingo,

&& est un opérateur logique qui déter-

&& est un opérateur de chaînes qui concatène

deux chaînes et insère un espace entre deux expressions.

Opérateur Effet Ordre de priorité

and

not

(Lingo seulement) Détermine si les deux expressions sont vraies. 4

(Syntaxe JavaScript seulement) Détermine si les deux expressions sont vraies.

(Lingo seulement) Détermine si une ou les deux expressions sont vraies.

(Syntaxe JavaScript seulement) Détermine si une ou les deux expressions sont vraies.

(Lingo seulement) Inverse une expression 5

(JavaScript seulement) Inverse une expression 5

L’opérateur

TRUE ou FALSE à la valeur opposée. Par exemple, l’instruction suivante active le son s’il est

not (Lingo) ou ! (Syntaxe JavaScript) est utile lorsqu’il s’agit de faire passer la valeur

désactivé, ou le désactive s’il est activé :

--Syntaxe Lingo _sound.soundEnabled = not (_sound.soundEnabled)

// Syntaxe JavaScript _sound.soundEnabled = !(_sound.soundEnabled);

30 Chapitre 2 : Principes de base du scripting dans Director

Opérateurs de chaînes

Les opérateurs de chaînes combinent et définissent des chaînes. Faites attention lorsque vous utilisez les opérateurs logiques et les opérateurs de chaînes en Lingo

et en JavaScript. Par exemple, dans la syntaxe JavaScript, mine si deux expressions sont vraies, mais en Lingo,

&& est un opérateur logique qui déter-

&& est un opérateur de chaînes qui concatène

deux chaînes et insère un espace entre deux expressions.

Opérateur Effet Ordre de priorité

& (Lingo seulement) Concatène deux chaînes 2

+ (Syntaxe JavaScript seulement) Concatène deux valeurs de

chaîne et renvoie une troisième chaîne qui unit les deux opérandes.

+= (Syntaxe JavaScript seulement) Concatène une variable de

chaîne et une valeur de chaîne et attribue la valeur renvoyée à la variable de chaîne.

&& (Lingo seulement) Concatène deux chaînes et insère un espace

entre elles.

" Indique le début ou la fin d’une chaîne. 1

Constructions conditionnnelles

Par défaut, Director exécute toujours les instructions d’un script en commençant par la première instruction et en continuant dans l’ordre dans lequel elles apparaissent, jusqu’à ce qu’il rencontre la dernière instruction, ou une instruction l’envoyant à un autre endroit.

L’ordre d’exécution des instructions est tributaire de l’ordre dans lequel vous les placez. Par exemple, si vous rédigez une instruction nécessitant une valeur calculée, vous devez d’abord placer une instruction calculant cette valeur.

Dans l’exemple suivant, la première instruction additionne deux nombres et la seconde affecte une représentation de la somme sous forme de chaîne à un acteur champ appelé sur la scène. La seconde instruction n’a pu être placée avant la première parce que la variable pas encore été définie.

--Syntaxe Lingo x = 2 + 2 member("Réponse").text = string(x)

Réponse, affiché

x n’a

// Syntaxe JavaScript var x = 2 + 2; member("Réponse").text = x.toString();

Constructions conditionnnelles 31

Lingo et JavaScript proposent tous deux des conventions servant à modifier l’ordre d’exécution ou les instructions de script par défaut et aussi à effectuer des actions en fonction de conditions spécifiques. Par exemple, vous pouvez choisir d’effectuer les actions suivantes dans vos scripts :

• Exécuter une série d’instructions si une condition logique est vraie ou exécuter d’autres

instructions si la condition logique est fausse.

• Evaluer une expression et essayer d’adapter sa valeur à une condition spécifique.

• Exécuter une série d’instructions plusieurs fois de suite jusqu’à ce qu’une condition spécifique

soit remplie.

Test de conditions logiques

Pour exécuter une instruction ou une série d’instructions lorsqu’une condition donnée est vraie ou fausse, vous utilisez les structures JavaScript). Par exemple, vous pouvez créer une structure

if...then...else (Lingo) ou if...else (syntaxe

if...then...else ou if...then

qui vérifie que le téléchargement du texte à partir d’Internet est terminé et qui, le cas échéant, le formate. Ces structures utilisent le modèle suivant pour tester les conditions logiques :

• En Lingo et JavaScript, les instructions vérifiant si une condition est vraie ou fausse

commencent par l’élément

if.

• En Lingo, si la condition existe, les instructions suivant l’élément then sont exécutées. Dans la

syntaxe JavaScript, les accolades (

chaque instruction

if, else ou else if.

{ }) remplacent l’élément Lingo then et doivent encadrer

• En Lingo et la syntaxe JavaScript, si la condition n’existe pas, les scripts passent à l’instruction

suivante du gestionnaire en utilisant l’élément

else ou else if.

• En Lingo, l’élément end if indique la fin du test if. Dans la syntaxe JavaScript, le test if se

termine automatiquement. Pour optimiser les performances de vos scripts, commencez par tester les conditions les plus

vraisemblables. Les instructions suivantes testent plusieurs conditions. Le terme

d’autres tests si les conditions précédentes se sont avérées fausses :

--Syntaxe Lingo if _mouse.mouseMember = member(1) then

_movie.go("Caire") else if _mouse.mouseMember = member(2) then

_movie.go("Nairobi") else

_player.alert("Vous vous êtes perdu.") end if

else if spécifie l’exécution

// Syntaxe JavaScript if (_mouse.mouseMember = member(1)) {

_movie.go("Caire"); } else if (_mouse.mouseMember = member(2)) {

_movie.go("Nairobi"); } else {

_player.alert("Vous vous êtes perdu.") }

32 Chapitre 2 : Principes de base du scripting dans Director

Lorsque vous rédigez des structures if...then en Lingo, vous pouvez placer l’instruction ou les instructions après then sur la même ligne que celle de then, ou les placer sur leur propre ligne en insérant un retour de chariot après ment placer une instruction

Lorsque vous rédigez des structures ou les instructions après

if sur la même ligne que celle de if, ou les placer sur leur propre ligne en

then. Si vous insérez un retour de chariot, vous devez égale-

end if à la fin de la structure if…then.

if dans la syntaxe JavaScript, vous pouvez placer l’instruction

insérant un retour de chariot après if. Par exemple, les instructions suivantes sont équivalentes :

--Syntaxe Lingo if _mouse.mouseMember = member(1) then _movie.go("Caire")

if _mouse.mouseMember = member(1) then

_movie.go("Caire") end if

// Syntaxe JavaScript if (_mouse.mouseMember = member(1)) { _movie.go("Caire"); }

if (_mouse.mouseMember = member(1)) {

_movie.go("Caire"); }

Pour obtenir des informations concernant l’utilisation des structures if...then...else et

if...else, consultez if, page 227.

Evaluation et concordance d’expressions

Les structures tant d’éviter l’utilisation des structures branchements multiples. Les structures plus lisibles que beaucoup de structures

En Lingo, la condition devant être testée suit le terme

case. La comparaison commence par la première ligne, puis passe à la suivante, etc. jusqu’à ce

case (Lingo) et switch...case (syntaxe JavaScript) sont des raccourcis permet-

if...then...else ou if...then dans les structures à

case et switch...case sont souvent plus efficaces et

if...then...else ou if...then.

case dans la première ligne de la structure

que Lingo rencontre une expression correspondant à la condition testée. Lorsqu’une correspondance est trouvée, Director exécute les instructions Lingo qui suivent l’expression.

Dans la syntaxe JavaScript, la condition devant être testée suit le terme ligne de la structure. Chaque comparaison du test suit le terme un test. Vous pouvez mettre fin à une comparaison Lorsque vous insérez le terme

break, vous excluez le programme de la structure switch et

case en utilisant le terme facultatif break.

case dans chaque ligne contenant

switch dans la première

exécutez toute instruction qui suit la structure. Si vous n’insérez pas break, la comparaison case suivante est exécutée.

Une structure Par exemple, les structures

case ou switch...case peut utiliser des comparaisons comme conditions de test.

case et switch...case suivantes testent la dernière touche sur

laquelle l’utilisateur a appuyé, et répond en conséquence.

• Si l’utilisateur a appuyé sur A, l’animation passe à l’image Pomme.

• Si l’utilisateur a appuyé sur B ou C, l’animation exécute la transition demandée et passe à

l’image Oranges.

Constructions conditionnnelles 33

• Si l’utilisateur a appuyé sur n’importe quelle autre touche, l’ordinateur émet un bip sonore.

--Syntaxe Lingo case (_key.key) of

"a" : _movie.go("Pomme")

"b", "c":

_movie.puppetTransition(99) _movie.go("Oranges")

otherwise: _sound.beep() end case

// Syntaxe JavaScript switch (_key.key) {

case "a" :

_movie.go("Pomme"); break;

case "b":

_movie.puppetTransition(99); _movie.go("Oranges"); break;

case "c":

_movie.puppetTransition(99); _movie.go("Oranges"); break;

default: _sound.beep() }

Remarque : Dans la syntaxe JavaScript, vous ne pouvez effectuer qu’une seule comparaison par instruction case.

Pour obtenir des informations concernant l’utilisation des structures case, consultez case,

page 222.

Répétition d’actions

En Lingo et dans la syntaxe JavaScript, vous pouvez répéter une action un certain nombre de fois, ou tant qu’une condition spécifique existe.

Pour répéter une action un certain nombre de fois en Lingo, vous utilisez une structure

with

. Spécifiez le nombre de répétitions sous forme de plage après l’instruction repeat with.

Pour répéter une action un certain nombre de fois dans la syntaxe JavaScript, vous utilisez la structure

for. La structure for nécessite trois paramètres : le premier paramètre initialise généra-

lement une variable de compteur, le second précise une condition à évaluer à chaque fois dans la boucle et le troisème est généralement utilisé pour mettre à jour ou incrémenter la variable de compteur.

Les structures

repeat with et for servent à effectuer la même opération sur une série d’objets.

Par exemple, la boucle suivante applique l’encre Fond transparent aux images-objets 2 à 10 :

--Syntaxe Lingo repeat with n = 2 to 10

sprite(n).ink = 36 end repeat

// Syntaxe JavaScript for (var n=2; n<=10; n++) {

sprite(n).ink = 36; }

34 Chapitre 2 : Principes de base du scripting dans Director

repeat

Cet exemple exécute une action similaire, mais avec des nombres décroissants :

--Syntaxe Lingo repeat with n = 10 down to 2

sprite(n).ink = 36 end repeat

// Syntaxe JavaScript for (var n=10; n>=2; n--) {

sprite(n).ink = 36; }

En Lingo, pour répéter une série d’instructions tant qu’une condition spécifique existe, utilisez la structure repeat while.

Dans la syntaxe JavaScript, pour répéter une série d’instructions tant qu’une condition spécifique existe, utilisez la structure

while.

Par exemple, les instructions suivantes font émettre un bip sonore continu à l’animation à chaque fois que l’utilisateur appuie sur le bouton de la souris :

--Syntaxe Lingo repeat while _mouse.mouseDown

_sound.beep() end repeat

// Syntaxe JavaScript while (_mouse.mouseDown) {

_sound.beep(); }

Les scripts Lingo et JavaScript continuent à effectuer une boucle sur les instructions de la boucle jusqu’à ce que la condition ne soit plus vraie, ou jusqu’à ce que l’une des instructions envoie le script à l’extérieur de la boucle. Dans l’exemple précédent, le script quitte la boucle lorsque l’utilisateur relâche le bouton de la souris puisque la condition

Pour quitter une boucle en Lingo, utilisez l’instruction Pour quitter une boucle dans la syntaxe JavaScript, vous pouvez utiliser le terme

mouseDown cesse d’exister.

exit repeat.

break. Le script

quitte automatiquement la boucle lorsqu’une condition n’est plus vraie. Par exemple, les instructions suivantes font émettre un bip sonore à l’animation lorsque l’utilisa-

teur maintient le bouton de la souris enfoncé, sauf si le pointeur de la souris se trouve au dessus de l’image-objet 1. Dans ce cas, le script quitte la boucle et le bip sonore s’arrête. La méthode

rollover() indique si le pointeur se trouve sur l’image-objet spécifiée.

--Syntaxe Lingo repeat while _mouse.stillDown

_sound.beep()

if _movie.rollOver(1) then exit repeat end repeat

// Syntaxe JavaScript while (_mouse.stillDown) {

_sound.beep();

if (_movie.rollOver(1)) {

break;

} }

Constructions conditionnnelles 35

Pour obtenir des informations sur les structures repeat while et while, consultez repeat while,

page 238.

Evénements, messages et gestionnaires

Pour créer des scripts solides et utiles, il est essentiel de maîtriser les concepts et les fonctionnalités des événements, messages et gestionnaires. Si vous comprenez l’ordre dans lequel les événements et les messages sont envoyés et reçus, vous pouvez déterminer exactement le moment auquel des scripts donnés ou des parties de scripts devraient être exécutés. Ceci vous aidera à déboguer vos scripts si certaines actions ne se produisent pas au moment prévu.

Les événements suivants se produisent durant la lecture d’une animation :

1 Des événements se produisent en réaction à une action du système ou à une action définie par

l’utilisateur

2 Des messages correspondant à ces événements sont envoyés aux scripts d’une animation 3 Les gestionnaires compris dans les scripts contiennent les instructions qui sont exécutées

lorsqu’un message est reçu Le nom d’un événement correspond au nom du message qu’il produit, et le gestionnaire de cet

événement correspond à la fois à l’événement et au message. Par exemple, lorsque l’événement

mouseDown se produit, Director crée et envoie aux scripts un message appelé mouseDown qui est

ensuite pris en charge par un gestionnaire appelé

mouseDown.

Evénements

Durant la lecture d’une animation, deux catégories d’événements se produisent :

• Les événements système se produisent sans qu’il n’y ait d’interaction entre un utilisateur et

l’animation, et sont prédéfinis et nommés dans Director. Lorsque la tête de lecture entre dans

une image, par exemple, lorsque vous cliquez sur une image-objet, etc.

• Les événements définis par l’utilisateur se produisent en réponse aux actions que vous

définissez. Par exemple, vous pouvez créer un événement qui se produit lorsque la couleur

de fond d’une image-objet passe du rouge au bleu, après qu’un son ait été lu cinq fois, etc. Plusieurs événements système tels que

tiquement et dans un ordre prédéfini durant la lecture d’une animation. D’autres événements système, en particulier des événements liés à la souris tels que suite, ne se produisent pas nécessairement de manière automatique durant la lecture d’une animation, mais plutôt après qu’ils aient été déclenchés par un utilisateur.

Par exemple, au début d’une animation, l’événement se produire, l’événement

mouseDown et mouseUp peuvent ne jamais se produire dans une animation, à moins qu’un

prepareFrame toujours le second, etc. Toutefois, les événements

utilisateur ne les déclenche en cliquant sur l’animation. La liste suivante répertorie les événements système qui se produisent toujours durant une

animation, et l’ordre dans lequel ils se produisent.

prepareFrame, beginSprite, etc., se produisent automa-

mouseDown, mouseUp et ainsi de

prepareMovie est toujours le premier à

36 Chapitre 2 : Principes de base du scripting dans Director

Les événements se produisent dans l’ordre suivant au démarrage de l’animation :

1 prepareMovie 2 prepareFrame Immédiatement après l’événement prepareFrame, Director lit les sons,

dessine les images-objets et effectue les transitions ou les effets de palette. Cet événement

se produit avant l’événement

enterFrame. L’utilisation d’un gestionnaire on prepareFrame

est conseillée pour exécuter un script avant que l’image ne soit dessinée.

3 beginSprite Cet événement se produit lorsque la tête de lecture pénètre dans la zone d’une

image-objet.

4 startMovie Cet événement se produit dans la première image qui est lue.

Lorsqu’une animation rencontre une image, les événements se produisent dans l’ordre suivant :

1 beginSprite Cet événement ne se produit que si de nouvelles images-objets commencent

dans l’image.

2 stepFrame 3 prepareFrame

4 enterFrame Après enterFrame mais avant exitFrame, Director gère les délais exigés par les

réglages de cadence, les événements d’inactivité et les événements clavier et souris.

5 exitFrame 6 endSprite Cet événement ne se produit que lorsque la tête de lecture sort d’une image-objet

de l’image.

Les événements se produisent dans l’ordre suivant lorsque la lecture de l’animation s’arrête :

1 endSprite Cet événement ne se produit que si les images-objets existent actuellement dans

l’animation.

2 stopMovie

Pour plus d’informations sur les événements système prédéfinis de Director, consultez le

Chapitre 10, Evénements et messages, page 173.

Messages

Pour exécuter au bon moment le groupe d’instructions approprié, Director doit déterminer ce qui se passe dans l’animation et les instructions à exécuter pour répondre à certains événements.

Director utilise des messages pour indiquer que des événements spécifiques se produisent dans l’animation, tels qu’un clic sur une image-objet, l’enfoncement des touches du clavier, le démarrage de l’animation, l’entrée ou la sortie de la tête de lecture dans une image, ou encore le renvoi d’une valeur spécifique par un script.

L’ordre dans lequel les messages sont envoyés aux objets de l’animation est le suivant :

1 Les messages sont d’abord envoyés aux comportements associés aux images-objets affectées par

l’événement. Si plusieurs comportements sont associés à une image-objet, ceux-ci répondent au

message dans l’ordre dans lequel ils ont été associés à cette image-objet.

2 Les messages sont ensuite envoyés au script de l’acteur affecté à l’image-objet. 3 Les messages sont ensuite envoyés aux comportements associés à l’image courante. 4 Enfin, les messages sont envoyés aux scripts de l’animation.

Evénements, messages et gestionnaires 37

Bien qu’il vous soit possible de définir le nom de vos messages, la plupart des événements communs survenant dans une animation possèdent des noms de message prédéfinis.

Pour plus d’informations sur les messages intégrés à Director, consultez le Chapitre 10,

Evénements et messages, page 173.

Définition de messages personnalisés

En plus d’utiliser les noms de messages prédéfinis, vous pouvez définir vos propres messages et les noms des gestionnaires correspondants. Un message personnalisé peut appeler un autre script, un autre gestionnaire ou le gestionnaire de l’instruction même. Lorsque le gestionnaire appelé a terminé son exécution, l’exécution du gestionnaire qui l’a appelé reprend.

Un nom de message et gestionnaire personnalisé doit répondre aux critères suivants :

• Il doit débuter par une lettre.

• Il doit inclure uniquement des caractères alphanumériques (pas de caractères spéciaux ou de

ponctuation).

• Il doit être composé d’un ou de plusieurs mots reliés par un trait de soulignement (_).

Les espaces ne sont pas autorisés.

• Il ne peut pas être identique au nom d’un élément Lingo ou JavaScript prédéfini.

L’utilisation de mots-clés Lingo ou JavaScript prédéfinis pour les noms de messages et gestionnaires peut prêter à confusion. Bien qu’il soit possible de remplacer ou d’augmenter explicitement la fonctionnalité d’un élément Lingo ou JavaScript en l’utilisant comme nom de gestionnaire ou de message, cette opération ne devrait être effectuée que dans certaines situations avancées.

Lorsque vous utilisez plusieurs gestionnaires remplissant des fonctions similaires, donnez-leur des noms commençant de la même manière afin de les regrouper dans les listes alphabétiques, comme par exemple la liste qui apparaît lorsque vous sélectionnez l’option Edition > Rechercher > Gestionnaire.

Gestionnaires

Un gestionnaire est un ensemble d’instructions placées dans un script et exécutées en réponse à un événement déterminé et à un message subséquent. Bien que Director contienne des événements et des messages prédéfinis, vous devez créer vos propres gestionnaires pour chaque paire d’événements/images que vous voulez gérer.

Stratégie de positionnement des gestionnaires

Vous pouvez placer des gestionnaires dans n’importe quel type de script, un script pouvant contenir plusieurs gestionnaires. Toutefois, il est recommandé de regrouper les gestionnaires apparentés au même endroit afin d’en simplifier la gestion.

Les recommandations suivantes s’appliquent aux situations les plus courantes :

• Pour associer un gestionnaire à une image-objet déterminée ou pour exécuter un gestionnaire

en réponse à une action dans une image-objet précise, placez le gestionnaire dans un comporte-

ment affecté à l’image-objet.

38 Chapitre 2 : Principes de base du scripting dans Director

• Pour définir un gestionnaire disponible à tout moment lorsque l’animation se trouve dans une

image déterminée, placez-le dans un comportement affecté à l’image.

Par exemple, pour qu’un gestionnaire réponde à un clic de la souris lorsque la tête de lecture est

dans une image, quel que soit l’endroit où se produit le clic, placez un gestionnaire

mouseDown

ou mouseUp dans le comportement de l’image plutôt que dans un comportement d’image-

objet.

• Pour définir un gestionnaire exécuté en réponse à des messages d’événements se produisant

n’importe où dans l’animation, placez-le dans un script d’animation.

• Pour définir un gestionnaire exécuté en réponse à un événement affectant un acteur, quelles

que soient les images-objets utilisant cet acteur, placez-le dans un script d’acteur.

Identification du moment auquel les gestionnaires reçoivent un message

Après avoir envoyé un message aux scripts, Director vérifie la présence de gestionnaires dans un ordre défini.

1 Director vérifie d’abord l’existence de gestionnaires dans l’objet à partir duquel le message a été

envoyé. Si un gestionnaire est trouvé, le message est intercepté et le script du gestionnaire est

exécuté.

2 S’il ne trouve pas de gestionnaire, Director vérifie, dans un ordre croissant, les scripts d’anima-

tion associés à un acteur et pouvant contenir un gestionnaire lié au message. Si un gestionnaire

est trouvé, le message est intercepté et le script du gestionnaire est exécuté.

3 Si aucun gestionnaire n’a été trouvé, Director vérifie si un script d’image contient un gestion-

naire pour le message. Si un gestionnaire est trouvé, le message est intercepté et le script du ges-

tionnaire est exécuté.

4 S’il ne trouve pas de gestionnaire, Director vérifie, dans un ordre croissant, les scripts associés

aux images-objets et pouvant contenir un gestionnaire lié au message. Si un gestionnaire est

trouvé, le message est intercepté et le script du gestionnaire est exécuté. Le message n’est pas automatiquement transmis aux emplacements restants après son interception

par le gestionnaire. Toutefois, en Lingo, vous pouvez utiliser la méthode cette règle par défaut et passer le message à d’autres objets.

Si le gestionnaire recherché n’est pas trouvé après l’envoi du message à tous les emplacements possibles, Director ignore le message.

L’ordre exact dans lequel Director envoie un message aux objets dépend du message même. Pour plus d’informations sur l’ordre des objets auxquels Director envoie des messages spécifiques, consultez l’entrée correspondant à chaque message dans Chapitre 10, Evénements et messages,

page 173.

pass() pour ignorer

Utilisation de paramètres pour passer des valeurs à un gestionnaire

L’utilisation de paramètres comme valeurs vous permet de transmettre à un gestionnaire les valeurs exactes nécessaires au moment voulu, sans tenir compte de l’endroit ni du moment auxquels vous appelez le gestionnaire dans l’animation. Les paramètres peuvent être facultatifs ou obligatoires, selon le cas.

Pour créer des paramètres pour un gestionnaire :

• En Lingo, placez les paramètres après le nom du gestionnaire. Dans la syntaxe JavaScript,

mettez les paramètres entre parenthèses puis placez-les après le nom du gestionnaire. Utilisez

des virgules pour séparer les arguments multiples.

Evénements, messages et gestionnaires 39

Lorsque vous appelez un gestionnaire, vous devez fournir des valeurs spécifiques pour les paramètres qu’il utilise. Vous pouvez utiliser n’importe quel type de valeur, tel qu’un nombre, une variable à laquelle une valeur est affectée ou une chaîne. Les valeurs de l’instruction appelante doivent suivre le même ordre que dans les paramètres du gestionnaire et être encadrées de parenthèses.

Dans l’exemple suivant, la variable

maSomme appelle la méthode additionParam qui reçoit les

deux valeurs 2 et 4. Le gestionnaire additionParam remplace les repères d’emplacement de paramètres utilise le mot-clé

a et b par les deux valeurs qu’il a reçues, stocke le résultat dans la variable locale c puis

return pour renvoyer le résultat à la méthode originale qui est ensuite attribuée

à maSomme. Étant donné que 2 figure le premier dans la liste des paramètres, il remplace

a dans le gestion-

naire. De même, étant donné que 4 est le second dans la liste des paramètres, il remplace b dans le gestionnaire.

--Syntaxe Lingo maSomme = additionParam(2, 4) -- instructions d’appel

on additionParam a, b -- gestionnaire

c = a + b

return c – renvoie le résultat à l’instruction d’appel end

// Syntaxe JavaScript var maSomme = additionParam(2, 4); // instructions d’appel

function additionParam(a, b) { // gestionnaire

c = a + b;

return c; // renvoie le résultat à l’instruction d’appel }

En Lingo, lorsque vous appelez une méthode personnalisée à partir d’un objet, une référence à l’objet script de la mémoire est transmise en tant que premier paramètre implicite au gestionnaire de la méthode. Cela signifie que vous devez prendre en charge l’objet script dans votre gestionnaire.

Par exemple, imaginez que vous ayez rédigé une méthode d’image-objet personnalisée appelée

jump() dont le paramètre est un nombre entier simple et que vous l’ayez placée dans un

comportement. Lorsque vous appelez

jump() d’une référence d’un objet image-objet, le

gestionnaire doit également inclure un paramètre représentant la référence de l’objet image-objet, et non pas uniquement le nombre entier. Dans ce cas, le paramètre désigné est représenté par le mot-clé

--Syntaxe Lingo maHauteur = sprite(2).jump(5)

me, mais tout autre terme serait également acceptable.

on jump(me,a)

return a + 15 – ce gestionnaire fonctionne correctement et renvoie 20 end

on jump(a)

return a + 15 -- ce gestionnaire ne fonctionne pas correctement et renvoie 0 end

40 Chapitre 2 : Principes de base du scripting dans Director

Vous pouvez également utiliser des expressions comme valeurs. Par exemple, l’instruction suivante utilise 3+6 pour remplacer a et 8>2 (ou 1, représentant TRUE) pour remplacer b et renvoie

10 :

--Syntaxe Lingo maSomme = additionParam(3+6, 8>2)

En Lingo, tous les gestionnaires commencent par le mot on, suivi du message auquel ils doivent répondre. La dernière ligne du gestionnaire est le mot

end. Vous pouvez répéter le nom du

gestionnaire après end, ce qui n’est pas obligatoire. Dans la syntaxe JavaScript, tous les gestionnaires commencent par le mot

function, suivi du

message auquel ils doivent répondre. Les instructions comprenant le gestionnaire sont mises entre crochets et sont toutes des fonctions de la syntaxe JavaScript.

Renvoi de résultats des gestionnaires

Il est souvent utile qu’un gestionnaire vous indique la présence d’une condition ou le résultat d’une action.

Pour renvoyer des résultats avec un gestionnaire :

• Utilisez le mot-clé return pour qu’un gestionnaire retourne la présence d’une condition ou le

résultat d’une action. Par exemple, le gestionnaire

actuelle de l’image-objet 1 :

--Syntaxe Lingo

on findColor

return sprite(1).foreColor

end

// Syntaxe JavaScript

function findColor() {

return(sprite(1).foreColor);

}

Vous pouvez également utiliser le mot-clé return tout seul pour quitter le gestionnaire actuel et ne renvoyer aucune valeur. Par exemple, le gestionnaire paramètre

--Syntaxe Lingo on jump(aVal)

if aVal = 5 then return

aVal est égal à 5 ; autrement, il renvoie une valeur.

findColor suivant retourne la couleur

jump suivant ne renvoie rien si le

aVal = aVal + 10

return aVal end

// Syntaxe JavaScript function jump(aVal) {

if(aVal == 5) {

return; } else {

aVal = aVal + 10;

return(aVal); }

}

Evénements, messages et gestionnaires 41

Lorsque vous définissez un gestionnaire renvoyant un résultat, vous devez le faire suivre de parenthèses quand vous l’appelez à partir d’un autre gestionnaire. Par exemple, l’instruction

put(findColor()) appelle le gestionnaire on findColor, puis affiche le résultat dans la fenêtre

Messages.

Listes linéaires et listes de propriétés

Dans vos scripts, vous pouvez choisir de faire le suivi et la mise à jour de listes de données, telles qu’une série de noms ou les valeurs affectées à un ensemble de variables. Lingo et la syntaxe JavaScript ont tous deux accès aux listes linéaires et aux listes de propriétés. Dans une liste linéaire, chaque élément est une valeur unique. Dans une liste de propriétés, chaque élément contient deux valeurs ; la première est un nom de propriété, la seconde est la valeur associée à cette propriété.

Vu que Lingo et la syntaxe JavaScript ont tous deux accès aux listes linéaires et aux listes de propriétés, il est recommandé d’utiliser les listes linéaires et les listes de propriétés si les valeurs de votre code sont partagées par les scripts Lingo et JavaScript.

Si certaines valeurs de votre code sont utilisées uniquement dans les scripts de la syntaxe JavaScript, nous vous recommandons d’utiliser des objets Tableau de JavaScript avec vos listes de données. Pour plus d’informations sur l’utilisation des tableaux, consultez Tableaux de la

syntaxe JavaScript, page 50.

Création de listes linéaires

Pour créer une liste linéaire, utilisez l’une des méthodes suivantes :

• En Lingo, utilisez soit la fonction de haut niveau list() ou l’opérateur de liste ([ ]), et

séparez les éléments de la liste par des virgules.

• Dans la syntaxe JavaScript, utilisez la fonction de haut niveau list(), et séparez les éléments

de la liste par des virgules.

L’index d’une liste linéaire commence toujours par 1. Lorsque vous utilisez la fonction de haut niveau

sont des paramètres de la fonction. Cette fonction peut s’avérer pratique si vous utilisez un clavier ne possédant pas de touches de crochets.

Les instruction suivantes créent toutes une liste linéaire de trois noms et l’affectent à une variable.

--Syntaxe Lingo listeCollaborateurs = ["Raymond", "Françoise", "Paul"] – en utilisant

l’opérateur de liste de Lingo

listeCollaborateurs = list("Raymond", "Françoise", "Paul") – en utilisant

list()

list(), vous spécifiez que les éléments de la liste

// Syntaxe JavaScript var listeCollaborateurs = list("Raymond", "Françoise", "Paul"); // en

utilisant list()

42 Chapitre 2 : Principes de base du scripting dans Director

Vous pouvez également créer des listes linéaires vides. Les instructions suivantes créent des listes linaires vides.

--Syntaxe Lingo listeCollaborateurs = [] – en utilisant l’opérateur de liste Lingo listeCollaborateurs = list() – en utilisant list() sans paramètre

// Syntaxe JavaScript var listeCollaborateurs = list(); // en utilisant list() sans paramètre

Création de listes de propriétés

Pour créer une liste de propriétés, effectuez l’une des opérations suivantes :

• En Lingo, utilisez soit la fonction de haut niveau propList() soit l’opérateur de liste ([:]).

Lorsque vous utilisez l’opérateur de liste pour créer une liste de propriétés, vous pouvez utiliser soit un deux-points pour désigner des éléments de nom/valeur et des virgules pour séparer les élément de la liste soit des virgules pour désigner des éléments de nom/valeur et séparer les éléments dans la liste.

• Dans la syntaxe JavaScript, utilisez la fonction de haut niveau propList() et insérez des

virgules pour désigner des éléments de nom/valeur et séparer les éléments dans la liste.

Lorsque vous utilisez la fonction de haut niveau liste de propriétés sont des paramètres de la fonction. Cette fonction peut s’avérer pratique si vous utilisez un clavier ne possédant pas de touches de crochets.

Les propriétés peuvent apparaître plusieurs fois dans une liste de propriétés donnée. Les instruction suivantes créent toutes une liste de propriétés de quatre noms—

bottom—et leurs valeurs correspondantes.

--Syntaxe Lingo locImage-objet1 = [#left:100, #top:150, #right:300, #bottom:350] locImage-objet1 = ["left",400,"top",550, "righ",500, "bottom",750] locImage-objet1 = propList("left",400, "top",550, "right",500, "bottom",750)

propList(), vous spécifiez que les éléments de la

left, top, right

// Syntaxe JavaScript var locImage-objet1 = propList("left",400, "top",550, "right",500,

"bottom",750);

Vous pouvez également créer des listes de propriétés vides. Les instructions suivantes créent des listes de propriétés vides.

--Syntaxe Lingo locImage-objet1 = [:] -- en utilisant l’opérateur de liste de propriétés Lingo locImage-objet1 = propList() – en utilisant propList() sans paramètre

// Syntaxe JavaScript var locImage-objet1 = propList(); // en utilisant propList() sans paramètre

Listes linéaires et listes de propriétés 43

Définition et récupération d’éléments de listes

Vous pouvez définir et récupérer des éléments individuels d’une liste. La syntaxe est différente en fonction du type de liste.

Pour définir une valeur dans une liste linéaire, effectuez l’une des opérations suivantes :

• Utilisez l’opérateur égal à (=).

• Utilisez la méthode setAt().

Les instructions suivantes montrent comment définir la liste linéaire contenant une valeur,

--Syntaxe Lingo listeCollaborateurs = ["Françoise"] – définit une liste linéaire listeCollaborateurs[2] = "Paul" – définit la seconde valeur à l’aide de

l’opérateur égal à

listeCollaborateurs.setAt(2, "Paul") -- définit la seconde valeur à l’aide de

setAt()

// Syntaxe JavaScript var listeCollaborateurs = liste("Françoise"); // définit une liste linéaire listeCollaborateurs[2] = "Paul"; // définit la seconde valeur à l’aide de

l’opérateur égal à.

listeCollaborateurs.setAt(2, "Paul"); // définit la seconde valeur à l’aide de

setAt()

Pour récupérer une valeur d’une liste linéaire :

Françoise, puis ajoute Paul en tant que seconde valeur dans la liste.

listeCollaborateurs

• Utilisez la variable de la liste suivie du numéro indiquant la position de la valeur dans la liste.

Encadrez ce nombre de crochets.

• Utilisez la méthode getAt().

L’instruction suivante crée une liste linéaire valeur de la liste à la variable

--Syntaxe Lingo listeCollaborateurs = ["Raymond", "Françoise", "Paul"] – définit une liste

linéaire

nom2 = listeCollaborateurs[2] -- utilisez un accès par crochets pour récupérer

"Françoise"

nom2 = listeCollaborateurs.getAt(2) -- utilisez getAt() pour récupérer

"Françoise"

nom2.

listeCollaborateurs puis attribue la seconde

// Syntaxe JavaScript var listeCollaborateurs = list("Raymond", "Françoise", "Paul"); var nom2 = listeCollaborateurs[2] // utilisez un accès par crochets pour

récupérer "Françoise"

var nom2 = listeCollaborateurs.getAt(2) // utilisez getAt() pour récupérer

"Françoise"

Pour définir une valeur dans une liste de propriétés, effectuez l’une des opérations suivantes :

• Utilisez l’opérateur égal à (=).

• En Lingo seulement, utilisez la méthode setaProp().

• Utilisez la syntaxe à points.

44 Chapitre 2 : Principes de base du scripting dans Director

L’instruction Lingo suivante utilise l’opérateur égal à pour faire de soupe la nouvelle valeur associée à la propriété Raymond.

--Syntaxe Lingo listeNourriture = [:] -- définit une liste de propriétés vide listeNourriture[#Raymond] = "soupe" – associe soupe à Raymond

L’instruction Lingo suivante utilise setaprop() pour faire de soupe la nouvelle valeur associée à la propriété

--Syntaxe Lingo listeNourriture = [:] -- définit une liste de propriétés vide listeNourriture.setaProp(#Raymond, "soupe") -- utilisez setaProp()

// Syntaxe JavaScript listeNourriture = propList() – définit une liste de propriétés vide listeNourriture.setaProp("Raymond", "soupe") -- utilisez setaProp()

Raymond.

L’instruction suivante utilise la syntaxe à points pour définir la valeur associée à Raymond de

soupe à teriyaki.

--Syntaxe Lingo listeNourriture = [#Raymond:"soupe"] – définit une liste de propriétés trace(listeNourriture) -- affiche [#Raymond: "soupe"] listeNourriture.Raymond = "teriyaki" – utilisez la syntaxe à points pour

définir la valeur de Raymond

trace(listeNourriture) -- affiche [#Raymond: "teriyaki"]

// syntaxe JavaScript var listeNourriture = propList("Raymond", "soupe"); // définit une liste de

propriété

trace(listeNourriture); // affiche ["Raymond": "soupe"] listeNourriture.Bruno = "teriyaki"; // utilisez la syntaxe à points pour

définir la valeur de Raymond

trace(listeNourriture); // affiche [#Raymond: "teriyaki"]

Pour récupérer une valeur d’une liste de propriétés, effectuez l’une des opérations suivantes :

• Utilisez la variable de la liste, suivie du nom de la propriété associée à cette valeur. Encadrez

cette propriété de crochets.

• Utilisez la méthode getaProp() ou getPropAt().

• Utilisez la syntaxe à points.

Les instructions suivantes utilisent un accès par crochets pour récupérer les valeurs associées aux propriétés

--Syntaxe Lingo

-- définir une liste de propriétés listeNourriture = [#petitdéjeuner:"Gauffres", #petitdéjeuner:"Hamburger"] trace(listeNourriture[#petitdéjeuner]) -- affiche"Gauffres" trace(listeNourriture[#petitdéjeuner]) -- affiche "Hamburger"

// Syntaxe JavaScript // définit une liste de propriétés var listeNourriture = propList("petitdéjeuner", "Gauffres", "déjeuner",

"Hamburger");

trace(listeNourriture["petitdéjeuner"]); // affiche Gauffres trace(listeNourriture["déjeuner"]); // affiche Hamburger

petitdéjeuner et déjeuner.

Listes linéaires et listes de propriétés 45

Les instructions suivantes utilisent getaProp() pour récupérer la valeur associée à la propriété

petitdéjeuner, et getPropAt() pour récupérer la propriété à la seconde position d’index de la

liste.

--Syntaxe Lingo

-- définir une liste de propriétés listeNourriture = [#petitdéjeuner:"Gauffres", #déjeuner:"Hamuburger"] trace(listeNourriture.getaProp(#petitdéjeuner)) -- affiche "Gauffres" trace(listeNourriture.getPropAt(2)) -- affiche #déjeuner

// Syntaxe JavaScript // définir une liste de propriétés var listeNourriture = propList("petitdéjeuner", "Gauffres", "déjeuner",

"Hamburger");

trace(listeNourriture.getaProp("petitdéjeuner")); // affiche Gauffres trace(listeNourriture.getPropAt(2)); // affiche déjeuner

Les instructions suivantes utilisent la syntaxe à points pour accéder aux valeurs associées aux propriétés dans la liste de propriétés.

--Syntaxe Lingo

-- définir une liste de propriétés listeNourriture = [#petitdéjeuner:"Gauffres", #déjeuner:"Hamburger"] trace(listeNourriture.petitdéjeuner) -- affiche "Gauffres"

// Syntaxe JavaScript // définir une liste de propriétés var listeNourriture = propList("petitdéjeuner", "Gauffres", "déjeuner",

"Hamburger");

trace(listeNourriture.déjeuner); // affiche Hamburger

Vérification des éléments de listes

Vous pouvez déterminer les caractéristiques d’une liste et le nombre d’éléments qu’elle contient en utilisant les méthodes suivantes.

• Pour afficher le contenu d’une liste, utilisez la fonction put() ou trace() en passant la

variable contenant la liste en tant que paramètre.

• Pour déterminer le nombre d’éléments contenus dans une liste, utilisez la méthode count()

(Lingo seulement) ou la propriété

count.

• Pour déterminer le type d’une liste, utilisez la méthode ilk().

• Pour déterminer la valeur maximale d’une liste, utilisez la méthode max().

• Pour déterminer la valeur minimale d’une liste, utilisez la fonction min().

• Pour déterminer la position d’une propriété spécifique, utilisez la commande findPos,

findPosNear ou getOne.

46 Chapitre 2 : Principes de base du scripting dans Director

Les instructions suivantes utilisent count() et count pour afficher le nombre d’éléments d’une liste.

--Syntaxe Lingo listeCollaborateurs = ["Raymond", "Françoise", "Paul"] – définit une liste

linéaire

trace(listeCollaborateurs.count()) -- affiche 3 trace(listeCollaborateurs.count) -- affiche 3

// Syntaxe JavaScript var listeCollaborateurs = list("Raymond", "Françoise", "Paul"); // définit une

liste linéaire

trace(listeCollaborateurs.count); // affiche 3

Les instructions suivantes utilisent ilk() pour déterminer le type d’une liste.

--Syntaxe Lingo x = ["1", "2", "3"] trace(x.ilk()) // renvoie #liste

// Syntaxe JavaScript var x = list("1", "2", "3"); trace(x.ilk()) // renvoie #liste

Les instructions suivantes utilisent max() et min() pour déterminer les valeurs maximales and minimales d’une liste.

--Syntaxe Lingo listeCollaborateurs = ["Raymond", "Françoise", "Paul"] – définit une liste

linéaire

trace(listeCollaborateurs.max()) -- affiche "Françoise" trace(listeCollaborateurs.min()) -- affiche "Raymond"

// Syntaxe JavaScript var listeCollaborateurs = list("Raymond", "Françoise", "Paul"); // définit une

liste linéaire

trace(listeCollaborateurs.max()); // affiche Françoise trace(listeCollaborateurs.min()); // affiche Raymond

Les instructions suivantes utilisent findPos pour obtenir la position d’index d’une propriété spécifiée dans une liste de propriétés.

--Syntaxe Lingo

-- définit une liste de propriétés listeNourriture = [#petitdéjeuner:"Gauffres", #déjeuner:"Hamburger"] trace(listeNourriture.findPos(#déjeuner)) -- affiche 2

// Syntaxe JavaScript // définit une liste de propriétés var listeNourriture = propList("petitdéjeuner", "Gauffres", "déjeuner",

"Hamburger");

trace(listeNourriture.findPos("petitdéjeuner")); // affiche 1

Listes linéaires et listes de propriétés 47

Ajout et suppression d’éléments de listes

Vous pouvez ajouter des éléments à une liste ou en supprimer à l’aide des méthodes suivantes.

• Pour ajouter un élément à la fin d’une liste, utilisez la méthode append().

• Pour ajouter un élément à l’endroit correct dans une liste triée, utilisez la méthode add() ou

addProp().

• Pour ajouter un élément à un emplacement spécifique d’une liste linéaire, utilisez la méthode

addAt().

• Pour ajouter un élément à un emplacement spécifique d’une liste de propriétés, utilisez la

méthode

addProp().

• Pour supprimer un élément d’une liste, utilisez la méthode deleteAt(), deleteOne(), ou

deleteProp().

• Pour remplacer un élément d’une liste, utilisez le méthode setAt() ou setaProp().

Les instructions suivante utilisent

--Syntaxe Lingo listeCollaborateurs = ["Raymond", "Françoise", "Paul"] – définit une liste

linéaire

listeCollaborateurs.append("David") trace(listeCollaborateurs) -- affiche ["Raymond", "Françoise", "Paul",

"David"]

// Syntaxe JavaScript var listeCollaborateurs = list("Raymond", "Françoise", "Paul"); // définit une

liste linéaire

listeCollaborateurs.append("David"); trace(listeCollaborateurs); // affiche ["Raymond", "Françoise", "Paul",

"David"]

Les instructions suivantes utilisent addProp() pour ajouter une propriété et une valeur associée à une liste de propriétés.

--Syntaxe Lingo

-- définit une liste de propriétés listeNourriture = [#petitdéjeuner:"Gauffres", #déjeuner:"Hamburger"] listeNourriture.addProp(#dîner, "Spaghetti") -- ajoute [#dîner: "Spaghetti"]

append() pour ajouter un élément à la fin d’une liste.

// Syntaxe JavaScript // définit une liste de propriétés var listeNourriture = propList("petitdéjeuner", "Gauffres", "déjeuner",

"Hamburger");

listeNourriture.addProp("dîner", "Spaghetti"); // ajoute ["dîner":

"Spaghetti"]

Il n’est pas nécessaire d’éliminer explicitement les listes. Elles sont automatiquement supprimées lorsque aucune variable n’y fait référence. Les autres types d’objets doivent être retirés de manière explicite, en donnant aux variables qui y font référence la valeur

VOID (Lingo) ou null (syntaxe

JavaScript).

48 Chapitre 2 : Principes de base du scripting dans Director

Copie de listes

L’affectation d’une liste à une variable, puis l’affectation de cette variable à une autre variable ne crée pas automatiquement une copie de cette liste. Par exemple, la première instruction ci-dessous crée une liste contenant les noms de deux continents et affecte la liste à la variable

listeTerres. La seconde instruction affecte la même liste à une nouvelle variable listeContinents. Dans la troisième instruction, l’ajout d’ Australie à listeTerres ajoute

automatiquement l’élément

Australie à la liste listeContinents. La raison en est que les

deux noms de variables font référence au même objet en mémoire. Le même comportement se produit lorsque vous utilisez un tableau dans la syntaxe JavaScript.

--Syntaxe Lingo listeTerres = ["Asie", "Afrique"] listeContinents = listeTerres listeTerres.add("Australie") – ceci ajoute également "Australie" à

listeContinents

Pour créer une copie d’une liste indépendante d’une autre liste :

• Utilisez la méthode duplicate().

Par exemple, les instructions suivantes créent une liste puis font une copie indépendante de la liste.

--Syntaxe Lingo ancienneListe = ["a", "b", "c"] nouvelleListe = ancienneListe.duplicate() – fait une copie indépendante de

ancienneListe

// Syntaxe JavaScript var ancienneListe = list("a", "b", "c"); var nouvelleListe = ancienneListe.duplicate(); // crée une copie indépendante

de ancienneListe

Une fois nouvelleListe créée, la modification de ancienneListe ou de nouvelleListe n’a aucun effet sur l’autre liste.

Tri des listes

Les listes sont triées dans l’ordre alphanumérique, les nombres étant triés avant les chaînes. Les chaînes sont triées en fonction de la première lettre, quel que soit le nombre de caractères qu’elles contiennent. Les listes triées sont traitées un peu plus rapidement que les listes non triées.

Une liste linéaire est triée en fonction des valeurs de la liste. Une liste de propriétés est triée en fonction des noms de propriétés de la liste ou du tableau.

Une fois les valeurs d’une liste linéaire ou d’une liste de propriétés triées, elles restent triées même si des valeurs sont ajoutées ou supprimées des listes.

Listes linéaires et listes de propriétés 49

Pour trier une liste :

• Utilisez la méthode sort().

Par exemple, les instructions suivantes trient une liste alphabétique non triée.

--Syntaxe Lingo ancienneListe = ["d", "a", "c", "b"] ancienneListe.sort() -- renvoie ["a", "b", "c", "d"]

// Syntaxe JavaScript var ancienneListe = list("d", "a", "c", "b"); ancienneListe.sort(); // renvoie ["a", "b", "c", "d"]

Création de listes multidimensionnelles

Vous pouvez également créer des listes multidimensionnelles qui vous permettront d’utiliser les valeurs de plusieurs listes à la fois.

Dans l’exemple suivant, les deux premières instructions créent les listes linéaires séparées et

liste2. La troisième instructions crée une liste multidimensionnelle et l’affecte à listeMd.

Dans une liste multidimensionnelle, les instructions quatre et cinq utilisent des crochets pour accéder aux valeurs de la liste ; le premier crochet donne accès à une liste donnée, le second crochet donnant accès à la valeur se trouvant à la position d’index spécifiée dans la liste.

--Syntaxe Lingo liste1 = list(5,10) liste2 = list(15,20) listeMd = list(liste1, liste2) trace(listeMd[1][2]) -- affiche 10 trace(listeMd[2][1]) – affiche 15

// Syntaxe JavaScript var liste1 = list(5,10); var liste2 = list(15,20); var listeMd = list(liste1, liste2); trace(listeMd[1][2]); // affiche 10 trace(listeMd[2][1]); // affiche 15

liste1

Tableaux de la syntaxe JavaScript

Les tableaux de la syntaxe JavaScript sont similaires aux listes linéaires de Lingo, chaque élément d’un tableau étant une valeur unique. L’une des principales différences entre les tableaux de la syntaxe JavaScript et les listes linéaires de Lingo est que l’index d’un tableau commence toujours par 0.

Vous pouvez créer un tableau de la syntaxe JavaScript en utilisant l’objet Tableau. Vous pouvez utiliser soit des crochets ( instructions suivantes créent un tableau de deux valeurs.

// Syntaxe JavaScript var monTableau = [10, 15]; // en utilisant des crochets var monTableau = new Array(10, 15); // en utilisant le constructeur Tableau

Vous pouvez créer des tableaux vides. Les deux instructions suivantes créent un tableau vide.

// Syntaxe JavaScript var monTableau = []; var monTableau = new Array();

50 Chapitre 2 : Principes de base du scripting dans Director

[ ]) soit le constructeur Tableau pour créer un tableau. Les deux

Remarque : La Référence de scripting de Director ne constitue pas une référence complète pour les objets Tableau de la syntaxe JavaScript. Pour plus d’informations concernant les objets Tableau, consultez les nombreuses autres ressources consacrées à ce sujet.

Vérification d’éléments dans les tableaux

Vous pouvez déterminer les caractéristiques d’un tableau et le nombre d’éléments qui y sont contenus en utilisant les méthodes suivantes.

• Pour afficher le contenu d’une liste, utilisez la fonction put() ou trace(), en passant la

variable contenant la liste en tant que paramètre.

• Pour déterminer le nombre d’éléments contenus dans un tableau, utilisez la propriété length

de l’objet Tableau.

• Pour déterminer le type d’un tableau, utilisez la propriété constructor.

L’exemple suivant montre comment déterminer le nombre d’éléments contenus dans un tableau en utilisant la propriété

constructor. // Syntaxe JavaScript

var x = ["1", "2", "3"]; trace(x.length); // affiche 3 trace(x.contructor == Array); // affiche true

length puis en renvoyant le type d’objet à l’aide de la propriété

Ajout et suppression d’éléments dans des tableaux

Vous pouvez ajouter des éléments à un tableau ou en supprimer à l’aide des méthodes suivantes.

• Pour ajouter un élément à la fin d’un tableau, utilisez la méthode push() de l’objet Tableau.

• Pour placer un élément à sa position correcte dans un tableau trié, utilisez la méthode

splice() de l’objet Tableau.

• Pour placer un élément à un endroit précis d’un tableau, utilisez la méthode splice() de

l’objet Tableau.

• Pour supprimer un élément d’un tableau, utilisez la méthode splice() de l’objet Tableau.

• Pour remplacer un élément d’un tableau, utilisez la méthode splice() de l’objet Tableau.

L’exemple suivant montre comment utiliser la méthode des éléments à un tableau, les supprimer du tableau ou les remplacer.

// Syntaxe JavaScript var monTableau = new Array("1", "2"); trace(monTableau); affiche 1,2

splice() de l’objet Tableau pour ajouter

myArray.push("5"); // ajoute la valeur "5" à la fin de monTableau trace(monTableau); // affiche 1,2,5

myArray.splice(3, 0, "4"); // ajoute la valeur "4" après la valeur "5" trace(monTableau); // affiche 1,2,5,4

myArray.sort(); // trie monTableau trace(monTableau); // affiche 1,2,4,5

myArray.splice(2, 0, "3"); trace(monTableau); // affiche 1,2,3,4,5

Tableaux de la syntaxe JavaScript 51

myArray.splice(3, 2); // supprime deux valeurs aux positions d’index 3 et 4 trace(monTableau); // affiche 1,2,3

myArray.splice(2, 1, "7"); // remplace une valeur à la position d’index 2 par

"7"

trace(monTableau); affiche 1,2,7

Copie de tableaux

L’affectation d’un tableau à une variable, puis l’affectation de cette variable à une autre variable ne crée pas une copie séparée de ce tableau.

Par exemple, la première instruction ci-dessous crée un tableau contenant les noms de deux continents puis affecte le tableau à la variable même liste à une nouvelle variable

listeContinents. Dans la troisième instruction, l’ajout

listeTerres. La seconde instruction affecte la

d’Australie à listeTerres ajoute automatiquement l’élément Australie au tableau

listeContinents. En effet, les deux noms de variables font référence au même objet Tableau

en mémoire.

// Syntaxe JavaScript var listeTerres = new Array("Asie", "Afrique"); var listeContinents = listeTerres; listeTerres.push("Australie"); // ceci ajoute également "Australie" à

listeContinents

Pour créer la copie d’un tableau indépendant d’un autre tableau :

• Utilisez la méthode slice() de l’objet Tableau.

Par exemple, les instructions suivantes créent un tableau puis utilisent copie indépendante du tableau.

// Syntaxe JavaScript var ancienTableau = ["a", "b", "c"]; var nouveauTableau = ancienTableau.slice(); // crée une copie indépendante de

ancienTableau

Une fois nouveauTableau créé, la modification de ancienTableau ou de nouveauTableau n’a aucun effet sur l’autre tableau.

slice() pour créer une

Tri des tableaux

Les tableaux sont triés dans l’ordre alphanumérique, les nombres étant triés avant les chaînes. Les chaînes sont triées en fonction de la première lettre, quel que soit le nombre de caractères qu’elles contiennent.

Pour trier un tableau :

• Utilisez la méthode sort() de l’objet Tableau.

Les instructions suivantes trient un Tableau alphabétique non trié.

// Syntaxe JavaScript var ancienTableau = ["d", "a", "c", "b"]; ancienTableau.sort(); // renvoie a, b, c, d

52 Chapitre 2 : Principes de base du scripting dans Director

Les instructions suivantes trient un tableau alphanumérique non trié

// Syntaxe JavaScript var ancienTableau = [6, "f", 3, "b"]; ancienTableau.sort(); // renvoie 3, 6, b, f

Le tri d’un tableau renvoie un nouveau tableau trié.

Création de tableaux multidimensionnels

Vous pouvez également créer des tableaux multidimensionnels qui vous permettront d’utiliser les valeurs de plusieurs tableaux à la fois.

Dans l’exemple suivant, les deux premières instructions créent les tableaux distincts

tableau2. La troisième instruction crée un tableau multidimensionnel et l’affecte à tableauMd.

tableau1 et

Pour accéder aux valeurs d’un tableau multidimensionnel, les instructions quatre et cinq utilisent des crochets ; le premier crochet donne accès à un tableau précis, le second donnant accès à une valeur située à une position d’index spécifiée dans le tableau.

// Syntaxe JavaScript var tableau1 = nouveau Tableau(5,10); var tableau2 = [15,20]; var tableauMd = nouveau Tableau(tableau1, tableau2); trace(tableauMd[0][1]); // affiche 10 trace(tableauMd[1][0]); // affiche 15

Tableaux de la syntaxe JavaScript 53

54 Chapitre 2 : Principes de base du scripting dans Director

CHAPITRE 3

Rédaction de scripts dans Director

Les scripts de Macromedia Director MX 2004 prennent en charge toutes sortes de fonctionnalités pour des animations qui seraient impossibles à réaliser sans eux. Au fur et à mesure de la rédaction des scripts, vous vous rendrez probablement compte que des scripts de plus en plus compliqués sont nécessaires pour prendre en charge l’interactivité complexe de vos animations Director. Nous vous présentons ici les concepts et techniques de scripting intermédiaires et avancés, notamment des informations concernant le scripting orienté objet dans Director.

Si vous êtes un novice en matière de scripting dans Director, assurez-vous de lire le Chapitre 2,

Principes de base du scripting dans Director, page 9 en plus des rubriques suivantes.

Choisir entre Lingo et la syntaxe JavaScript

Lingo et JavaScript donnent tous deux accès aux mêmes objets, événements et API de scripting. Le langage dans lequel vous choisissez de rédiger vos scripts importe donc peu. Il vous suffit de décider du langage qui vous convient le mieux.

Voici quelques idées générales concernant le fonctionnement des langages de scripting avec un objet et modèle d’événement donnés dans Director :

• En général, un langage de scripting tel que Lingo ou JavaScript entoure un modèle d’objet et

d’événement donné et donne accès à ces objets et événements.

• JavaScript est une implémentation de ECMAScript qui entoure le modèle d’objet et

d’événement d’un navigateur web et donne accès aux objets et événements du navigateur.

• ActionScript est une implémentation de ECMAScript qui entoure le modèle d’objet et

d’événement de Macromedia Flash et donne accès aux objets et événements de Flash.

• L’implémentation Director de JavaScript est une implémentation de ECMAScript qui entoure

le modèle d’objet et d’événement de Director et donne accès aux objets et événements de Director.

• Lingo est une syntaxe personnalisée qui entoure le modèle d’objet et d’événement de Director

et donne accès aux objets et événements de Director.

Lingo et JavaScript sont tout simplement les deux langages que vous pouvez utiliser pour accéder au même modèle d’objet etévénement dans Director. Les scripts rédigés dans l’un des langages ont les mêmes capacités que ceux rédigés dans l’autre.

Une fois que vous avez donc décidé de la manière d’accéder aux API de scripting dans un langage, vous saurez comment y accéder dans l’autre. Par exemple, le code de la syntaxe JavaScript peut accéder à des types de données Lingo tels que les symboles, les listes linéaires, les listes de propriétés et ainsi de suite, créer et invoquer des scripts et comportements parents de Lingo, créer et invoquer des Xtras et utiliser des expressions de sous-chaînes Lingo. De plus, les scripts de la syntaxe JavaScript et Lingo peuvent être utilisés au sein d’une animation ; toutefois, un acteur script ne peut contenir qu’un type de syntaxe.

Il existe deux différences principales entre Lingo et la syntaxe JavaScript :

• Chaque langage comprend des conventions de syntaxe et de terminologie qui leur sont

propres. Par exemple, la syntaxe d’un gestionnaire d’événement dans Lingo est différente de celle de JavaScript.

-- Syntaxe Lingo on mouseDown

... end

// Syntaxe JavaScript function mouseDown() {

... }

Pour plus d’informations concernant les conventions de syntaxe et de terminologie utilisées pour chaque langage, veuillez consulter Terminologie de scripting, page 10 et Syntaxe de

scripting, page 13.

• L’accès à certains API de scripting varie légèrement d’un langage à l’autre. Par exemple,

vous utiliseriez des constructions différentes pour accéder au deuxième mot du premier paragraphe d’un acteur texte :

-- Syntaxe Lingo member("Nouvelles du jour").paragraph[1].word[2]

// Syntaxe JavaScript member("Nouvelles du jour").getPropRef("paragraph", 1).getProp("word", 2);

Format de scripting à syntaxe à points

Que vous rédigiez des scripts avec Lingo ou en utilisant la syntaxe JavaScript, vous le faites à l’aide du format de scripting à syntaxe à points. Vous utilisez la syntaxe à points pour accéder aux propriétés ou méthodes liées à un objet. Une instruction utilisant la syntaxe à points commence par le nom de l’objet, suivi d’un point, puis du nom de la propriété, de la méthode ou de la souschaîne de texte que vous souhaitez spécifier. Chaque point d’une instruction représente un mouvement allant d’un niveau plus élevé et plus général de la hiérarchie des objets à un niveau inférieur et plus précis.

Par exemple, l’instruction suivante crée d’abord une référence à la bibliothèque de distribution appelée « Nouvelles du jour » puis utilise la syntaxe à points pour accéder au nombre d’acteurs compris dans cette bibliothèque.

-- Syntaxe Lingo castLib("Nouvelles du jour").member.count

// Syntaxe JavaScript castLib("Nouvelles du jour").member.count;

56 Chapitre 3 : Rédaction de scripts dans Director

Pour identifier les sous-chaînes, les termes suivant le point servent à indiquer des éléments spécifiques du texte. Par exemple, la première instruction ci-dessous concerne le premier paragraphe de l’acteur texte appelé « Nouveaux Eléments ». La seconde instruction concerne le deuxième mot du premier paragraphe.

-- Syntaxe Lingo member("Nouveaux Eléments").paragraph[1] member("Nouveaux Eléments").paragraph[1].word[2]

// Syntaxe JavaScript member("Nouveaux Eléments").getPropRef("paragraph", 1); member("Nouveaux Eléments").getPropRef("paragraph", 1).getProp("word", 2);

Pour certains objets prenant en charge l’accès des propriétés en cascade à des données ou à un type d’acteur précis, comme indiqué dans les deux instructions précédentes, la syntaxe JavaScript normale ne supporte pas ce genre d’accès. Vous devez donc utiliser les méthodes et

getProp() pour accéder aux propriétés de cascade dans la syntaxe JavaScript.

getPropRef()

Voici quelques remarques concernant cette exception dans la syntaxe JavaScript :

• Vous devez appliquer cette technique aux objets 3D, aux acteurs texte, aux acteurs champ et

aux Xtras XML Parser auxquels vous avez accédé à l’aide de la syntaxe JavaScript.

• Vous devez utiliser la méthode getPropRef() pour stocker une référence à l’un des objets

précédemment mentionnés ou à ses propriétés à l’aide de la syntaxe JavaScript.

• Vous devez utiliser la méthode getProp() pour récupérer une valeur de propriété de l’un des

objets précédemment mentionnés ou de ses propriétés à l’aide la syntaxe JavaScript.

• Vous devez accéder aux objets 3D et propriétés en utilisant leurs noms complets dans la

syntaxe JavaScript. Dans Lingo par exemple, la propriété raccourci de la propriété

shaderList[1] doit être utilisée tout le temps.

shaderList[1]. Toutefois, dans la syntaxe JavaScript, la propriété

shader peut être utilisée comme un

Introduction aux objets de Director

Les objets sont généralement des groupes logiques de données nommées pouvant également contenir des méthodes agissant sur ces données. Dans cette version de Director, les API de scripting ont été groupés en objets et sont accessibles à travers ces objets. Chaque objet donne accès à un ensemble précis de données nommées et de types de fonctionnalités. Par exemple, l’objet Image-objet donne accès aux données et fonctionnalités d’une image-objet, l’objet Animation donne accès aux données et fonctionnalités d’une animation, et ainsi de suite.

Les objets utilisés dans Director appartiennent aux quatre catégories suivantes. Selon la fonctionnalité que vous voulez ajouter et la partie d’une animation à laquelle vous l’ajoutez, vous utiliserez les objets d’une ou plusieurs de ces catégories :

• Objets principaux

• Types de médias

• Objets de scripting

• Objets 3D

Introduction aux objets de Director 57

Objets principaux

Cette catégorie d’objets donne accès aux principales fonctionnalités et fonctions de Director, telles que le moteur du lecteur de Director, les fenêtres des animations, les images-objets, les sons, etc. Ces objets représentent la couche de base à travers laquelle on accède à tous les API et autres catégories d’objets.

Il existe également un groupe de méthodes et propriétés de haut niveau qui vous permettent d’accéder directement à tous les objets principaux au lieu d’avoir à passer par la hiérarchie des objets.

Pour plus d’informations sur les objets principaux et leurs API, consultez le Chapitre 5, Objets

principaux de Director, page 113.

Types de médias

Cette catégorie d’objets donne accès aux fonctionnalités des divers types de médias (RealMedia, DVD, GIF animé, etc.) ajoutés aux animations en tant qu’acteurs.

Les médias ne sont pas strictement des objets mais plutôt des acteurs qui se rapportent à un type de média précis. Lorsqu’un type de média est ajouté à une animation en tant qu’acteur, il hérite de la fonctionnalité de l’objet Acteur principal et étend l’objet Acteur en fournissant des fonctionnalités supplémentaires qui ne sont disponibles que pour le type de média spécifié. Par exemple, un acteur RealMedia a accès aux méthodes et propriétés de l’objet Acteur, et possède également d’autres méthodes et propriétés propres à RealMedia. Les autres types de médias affichent tous ce comportement.

Pour plus d’informations sur les types de médias disponibles et leurs API, consultez le Chapitre 6,

Types de médias, page 131.

Objets de scripting

Cette catégorie d’objets, également connus sous le nom de Xtras, donne accès aux fonctionnalités des composants logiciels tels que XML Parser, Fileio et SpeechXtra qui sont installés dans Director et étendent les fonctionnalités principales de Director. Les Xtras existants fournissent certaines fonctions telles que l’importation de filtres et la connexion à Internet. Vous pouvez créer vos propres Xtras si vous savez programmer en langage C.

Pour plus d’informations sur les objets de scripting et leurs API, consultez le Chapitre 7, Objets de

scripting, page 149.

Objets 3D

Cette catégorie d’objets donne accès aux fonctionnalités d’acteurs et de texte utilisées pour créer des animations 3D.

Pour plus d’informations sur les animations 3D, veuillez voir la rubrique Utilisation de Director dans le panneau d’aide de Director.

Pour plus d’informations sur les objets 3D et leurs API, consultez le Chapitre 8, Objets 3D,

page 153.

58 Chapitre 3 : Rédaction de scripts dans Director

Diagramme de modèles d’objets

Les diagrammes suivants illustrent les principales relations de haut niveau entre les groupes d’objets et leurs hiérarchies dans Director. Pour toute information sur la création d’objets, les propriétés et méthodes et les autres API, veuillez consulter les rubriques consacrées à chaque API.

Diagramme de modèles d’objets 59

Fonctions et propriétés de haut niveau

Il existe également un groupe de méthodes et propriétés de haut niveau qui vous permettent d’accéder directement à tous les objets principaux et fonctionnalités au sein de Director. Ces fonctions et propriétés sont très utiles pour créer des références aux objets principaux, aux nouvelles images, aux listes et ainsi de suite. Par exemple, la propriété directement référence à l’objet principal Animation et la fonction liste linéaire.

Les tableaux suivants dressent la liste des fonctions et propriétés de haut niveau.

Propriétés de haut niveau

_global _player

_key _sound

_mouse _system

_movie

Fonctions de haut niveau

castLib() rect()

channel() (niveau supérieur) script()

color() showLocals()

date() (formats), date() (Système) sound()

image() isBusy()

list() sprite()

member() symbol()

point() timeout()

propList() trace()

put() vector()

random() window()

randomVector() xtra()

_movie de haut niveau fait

list() de haut niveau crée une

60 Chapitre 3 : Rédaction de scripts dans Director

Introduction à la programmation orientée objet dans Director

Vous pouvez appliquer les principes de la programmation orientée objet à vos scripts avec Lingo ou JavaScript. Cette opération facilite en général la programmation puisqu’elle vous permet de rédiger moins de codes et d’utiliser la logique pour effectuer des tâches, tout en améliorant la réutilisation et la modularité de vos codes.

En fonction du langage utilisé, vous appliquez ces principes à l’aide de deux types de paradigmes :

• Dans Lingo, vous utilisez les scripts parents, les scripts ancêtres et les objets enfants pour

simuler la programmation orientée objet.

• Dans la syntaxe JavaScript, vous utilisez les techniques de programmation orientée objet de

style JavaScript standard pour créer des classes et des sous-classes.

Chaque paradigme vous permet d’appliquer les avantages apportés par la programmation orientée objet à vos scripts. Ainsi, le langage de scripting que vous utilisez importe peu. Il vous suffit tout simplement d’appliquer les principes différemment.

Vu que chaque langage de scripting utilise un paradigme différent pour appliquer les principes orientés objet, les techniques valables pour un langage ne seront pas valables pour l’autre. Il vous suffit donc de consulter le contenu qui s’applique au langage de scripting que vous utilisez :

• Pour plus d’informations sur la simulation de la programmation orientée objet dans Lingo,

consultez Programmation orientée objet avec Lingo sur cette page.

• Pour plus d’informations sur la simulation de la programmation orientée objet dans JavaScript,

consultez Programmation orientée objet avec la syntaxe JavaScript, page 72.

Programmation orientée objet avec Lingo

Dans Lingo, les scripts parents offrent les avantages de la programmation orientée objet. Vous pouvez utiliser des scripts parents pour générer des objets scripts qui ont une réponse et un comportement similaires tout en fonctionnant indépendamment les uns des autres.

Lingo peut créer plusieurs copies (ou instances) d’un script parent. Chaque instance d’un script parent est un objet enfant. Vous pouvez créer des objets enfants sur demande au fur et à mesure de la lecture de l’animation. Director ne limite pas le nombre d’objets enfants que vous pouvez créer depuis un même script parent. Vous pouvez créer autant d’objets enfants que la mémoire de l’ordinateur peut en supporter.

Director peut créer plusieurs objets enfants depuis un même script parent de la même façon qu’il peut créer plusieurs instances d’un comportement pour différentes images-objets. Un script parent pourrait être assimilé à un modèle et un objet enfant à une implémentation du modèle parent.

Cette section présente les concepts de base concernant la rédaction des scripts parents, ainsi que la création et l’utilisation des objets enfants, et propose des exemples de script. Vous n’y trouverez pas les concepts de la programmation orientée objet, mais devrez cependant en comprendre les principes afin d’utiliser efficacement les scripts parents et les objets enfants. Vous trouverez dans le commerce de nombreux ouvrages présentant les notions de base de la programmation orientée objet.

Programmation orientée objet avec Lingo 61

Similarité avec les autres langages orientés objet

Si vous connaissez déjà un langage de programmation orienté objet tel que Java ou C++, vous comprenez probablement ces concepts, même s’il se peut que vous les connaissiez en d’autres termes.

Les termes par lesquels Director décrit les scripts parents et les objets enfants correspondent aux termes couramment utilisés dans la programmation orientée objet :

Les scripts parents de Director correspondent aux classes dans la programmation orientée objet. Les objets enfants de Director correspondent aux instances dans la programmation orientée

objet.

Les variables de propriétés de Director correspondent aux variables d’instances ou d’acteurs

dans la programmation orientée objet.

Les gestionnaires de Director correspondent aux méthodes dans la programmation orientée

objet.

Les scripts ancêtres de Director correspondent à la Super classe ou classe de base dans la

programmation orientée objet.

Scripts parents et objets enfants : notions de base

Dans Lingo, un script parent contient un ensemble de gestionnaires et de propriétés définissant un objet enfant ; il ne constitue pas un objet enfant en lui-même. Un objet enfant est une instance autonome et indépendante d’un script parent. Les objets enfants du même parent possèdent des gestionnaires et des propriétés identiques, les objets enfants d’un même groupe pouvant donc avoir des réponses similaires aux événements et aux messages.

Les scripts parents sont généralement utilisés pour construire des objets enfants facilitant l’organisation de l’animation. Ces objets enfants sont particulièrement utiles lorsqu’une animation nécessite plusieurs exécutions simultanées d’une même logique avec des paramètres différents. Vous pouvez aussi ajouter un objet enfant à la propriété ou la propriété

actorList de l’objet Animation pour contrôler les animations.

scriptInstanceList d’un objet Image-objet

Tous les objets enfants d’un même script parent possédant des gestionnaires identiques, ces objets enfants répondent de façon semblable aux événements. Par contre, chaque objet enfant conserve ses propres valeurs pour les propriétés définies dans le script parent. Il s’en suit que chaque objet enfant peut avoir un comportement différent de celui des objets enfants apparentés tout en provenant du même script parent.

Par exemple, vous pouvez créer un script parent définissant des objets enfants de champs texte modifiables, possédant chacun leurs propres paramètres de propriété, texte et couleur, quels que soient les réglages des autres champs texte. En modifiant les valeurs des propriétés d’objets enfants précis, vous pouvez modifier ces caractéristiques pendant la lecture de l’animation, sans influer sur les autres objets enfants basés sur le même script parent.

De même, un objet enfant peut également contenir une propriété réglée sur

TRUE ou FALSE, quel

qu’en soit le réglage pour les objets enfants apparentés. Un script parent se rapporte au nom d’un acteur script contenant les variables de propriétés et

les gestionnaires. Un objet enfant créé à partir d’un script parent est essentiellement une nouvelle instance de l’acteur script.

62 Chapitre 3 : Rédaction de scripts dans Director

Différences entre les objets enfants et les comportements

Bien que les objets enfants et les comportements soient similaires en ce sens qu’ils peuvent tous deux posséder plusieurs instances, ils présentent également plusieurs différences importantes. La principale différence entre les objets enfants et les comportements est que les comportements sont associés à des emplacements du scénario puisqu’ils sont affectés à des images-objets. Les objets comportement sont automatiquement créés à partir d’initialisateurs dans le scénario lorsque la tête de lecture passe d’une image à une autre et rencontre des images-objets possédant des comportements. Les objets enfants de scripts parents, eux, doivent être explicitement créés par un gestionnaire.

Les comportements et les objets enfants diffèrent dans la façon dont ils deviennent associés aux images-objets. Director associe automatiquement un comportement à l’image-objet à laquelle il est associé, alors que vous devez explicitement associer un objet enfant à une image-objet. Les objets enfants ne requièrent pas de références d’images-objets et n’existent que dans la mémoire.

Ancêtres : principes de base

Les scripts parents peuvent déclarer des ancêtres, des scripts supplémentaires dont un script enfant peut appeler et utiliser les gestionnaires et les propriétés.

La création de scripts ancêtres vous permet de créer un ensemble de gestionnaires et propriétés que vous pouvez utiliser et réutiliser pour plusieurs scripts parents.

Un script parent fait d’un autre script parent son ancêtre en affectant le script à sa propriété

ancestor. Par exemple, l’instruction suivante transforme le script Ce_que_chacun_fait en

ancêtre du script parent dans lequel l’instruction survient :

-- Syntaxe Lingo ancestor = new(script "Ce_que_chacun_fait")

Lorsque les gestionnaires et les propriétés ne sont pas définis dans un objet enfant, Director recherche la propriété ou le gestionnaire requis dans les ancêtres de l’enfant, en commençant par son script parent. Si un gestionnaire est appelé ou qu’une propriété est testée et que le script parent ne contient aucune définition correspondante, Director recherche une définition dans le script ancêtre. Si ce script ancêtre contient une définition, celle-ci est utilisée.

Un objet enfant ne peut avoir qu’un ancêtre à la fois, mais ce script ancêtre peut posséder à son tour un ancêtre, qui peut également en avoir un, et ainsi de suite. Cela vous permet de créer des générations de scripts parents dont les gestionnaires sont accessibles à un objet enfant.

Rédaction d’un script parent

Un script parent contient le code nécessaire à la création d’objets enfants et en définit les actions et propriétés possibles. Vous devez d’abord décider du comportement envisagé des objets enfants. Rédigez ensuite un script parent qui effectue les opérations suivantes :

• Déclare les éventuelles variables de propriétés requises ; ces variables représentant des propriétés

pour lesquelles chaque objet enfant peut contenir une valeur indépendamment des autres objets enfants.

• Définit les valeurs initiales des propriétés et des variables de l’objet enfant dans le gestionnaire

on new.

• Contient des gestionnaires supplémentaires contrôlant les actions de l’objet enfant.

Programmation orientée objet avec Lingo 63

Déclaration de variables de propriétés

Chaque objet enfant créé à partir du même script parent contient, dans un premier temps, les mêmes valeurs pour ses variables de propriété. La valeur d’une variable de propriété n’appartient qu’à l’objet enfant auquel elle est associée. Chaque variable de propriété et sa valeur persistent tant que l’objet enfant existe. La valeur initiale d’une variable de propriété est généralement définie dans le gestionnaire

VOID.

Pour déclarer une variable de propriété :

on new. Si la propriété n’est pas initialement définie, sa valeur initiale est

• Utilisez le mot-clé property au début du script parent.

Pour définir et tester des variables de propriétés en dehors de l’objet enfant :

• Définissez et testez les variables de propriétés de la même façon que toute autre propriété dans

vos scripts à l’aide de la syntaxe réfDObjet.nomDePropriété.

Par exemple, l’instruction suivante définit la propriété

voiture1.vitesse = 55

Création du nouveau gestionnaire

Chaque script parent utilise généralement un gestionnaire objet enfant lorsqu’un autre script émet une commande ordonne au script parent défini de créer un objet enfant basé sur lui-même. Si nécessaire, le gestionnaire

on new du script parent peut aussi définir les valeurs initiales des propriétés de l’objet

enfant. Le gestionnaire

on new commence toujours par l’expression on new,, suivie de la variable me et

de tout paramètre communiqué au nouvel objet enfant. Le gestionnaire

la propriété

aSpriteNum. L’instruction return me renvoie l’objet enfant vers le gestionnaire qui a appelé

initialement le gestionnaire

-- Syntaxe Lingo property spriteNum

on new suivant crée un nouvel objet enfant à partir du script parent et initialise

spriteNum de l’enfant à l’aide de la valeur qui lui est associée dans le paramètre

on new.

vitesse d’un objet voiture1 :

on new. Ce gestionnaire crée le nouvel

new(script nomDuScriptParent) qui

on new me, aSpriteNum

spriteNum = aSpriteNum return me

end

Pour plus d’informations sur l’appel des gestionnaires on new, veuillez consulter Création d’un

objet enfant, page 66.

64 Chapitre 3 : Rédaction de scripts dans Director

Ajout de gestionnaires supplémentaires

Le comportement de l’objet enfant est déterminé par l’inclusion des gestionnaires produisant le comportement escompté dans le script parent. Par exemple, vous pouvez ajouter un gestionnaire pour changer la couleur de l’image-objet.

Le script parent suivant définit une valeur pour la propriété gestionnaire qui modifie la propriété

-- Syntaxe Lingo property spriteNum

on new me, aSpriteNum

spriteNum = aSpriteNum return me

end

on changeColor me

spriteNum.foreColor = random(255)

end

foreColor de l’image-objet.

spriteNum et contient un second

Référence à l’objet actuel

D’une manière générale, les objets enfants multiples sont créés à partir du même script parent et chacun d’eux utilise plus d’un gestionnaire. La variable de paramètre spéciale

me indique aux

gestionnaires de l’objet enfant qu’ils doivent agir sur les propriétés de cet objet, et non sur celles d’autres objets enfants. De cette façon, lorsqu’un gestionnaire dans un objet enfant se rapporte à des propriétés, il emploie les valeurs de son propre objet enfant pour ces propriétés.

Le terme de gestionnaire d’un script parent. Il est toujours important de définir

me doit toujours être la première variable de paramètre indiquée dans chaque définition

me comme premier para-

mètre pour les scripts parents et de passer le même paramètre si vous devez appeler d’autres gestionnaires dans le même script parent. Ceux-ci seront en effet les gestionnaires de chacun des objets enfants du script.

Lorsque vous faites référence à des propriétés définies dans des scripts ancêtres, vous devez utiliser le paramètre

me comme source de la référence. En effet, la propriété, bien qu’elle soit définie dans

le script ancêtre, n’en reste pas moins une propriété de l’objet enfant. Par exemple, l’instruction suivante utilise

me pour désigner un objet et accéder aux propriétés définies dans un de ses

ancêtres :

-- Syntaxe Lingo x = me.y – accéder à la propriété y de l’ancêtre

La variable me étant présente dans chaque gestionnaire de l’objet enfant, elle indique que tous les gestionnaires contrôlent ce même objet enfant.

Programmation orientée objet avec Lingo 65

Création d’un objet enfant

Toute l’existence des objets enfants se déroule dans la mémoire ; ils ne sont pas enregistrés avec une animation. Seuls les scripts parents et ancêtres sont enregistrés sur disque.

Pour créer un nouvel objet enfant, utilisez la méthode

new() et affectez à cet objet enfant un nom

de variable ou une position dans une liste afin de pouvoir l’identifier et l’utiliser plus tard. Pour créer un objet enfant et l’affecter à une variable, utilisez la syntaxe suivante :

-- Syntaxe Lingo NomDeVariable = new(script "NomDeScript", paramètre1, paramètre2, ...)

Le paramètre NomDeScript est le nom du script parent, et paramètre1, paramètre2, ... représentent tout paramètre que vous passez au gestionnaire méthode

new() crée un objet enfant dont l’ancêtre est NomDeScript. Elle appelle ensuite le

on new de l’objet enfant. La

gestionnaire on new de l’objet enfant, avec les paramètres indiqués. L’instruction

new() peut provenir de n’importe quel endroit de l’animation. Vous pouvez

personnaliser les paramètres initiaux de l’objet enfant en modifiant les valeurs des paramètres transmis avec l’instruction

new().

Chaque objet enfant n’utilise que la mémoire nécessaire à l’enregistrement des valeurs courantes de ses propriétés et variables ainsi qu’une référence au script parent. Par conséquent, vous pouvez généralement créer et gérer autant d’objets enfants que vous le souhaitez.

Des instructions

new() supplémentaires permettent de produire d’autres objets enfants à partir

du même script parent. Pour créer des objets enfants sans initialiser immédiatement leurs variables de propriété, utilisez

la méthode sans appeler le gestionnaire enfants seraient requises,

rawNew(). La méthode rawNew() effectue cette opération en créant l’objet enfant

on new du script parent. Au cas où de grandes quantités d’objets

rawNew() permet de créer les objets à l’avance et de reporter l’affectation

des valeurs de propriété jusqu’à ce que chaque objet soit requis. L’instruction suivante crée un objet enfant à partir du script parent Véhicule sans initialiser ses

variables de propriétés et l’attribue à la variable

-- Syntaxe Lingo voiture1 = script("Voiture").rawNew()

voiture1 :

Pour initialiser les propriétés de l’un de ces objets enfants, appelez son gestionnaire voiture1 :

voiture1.new

66 Chapitre 3 : Rédaction de scripts dans Director

Vérification des propriétés d’un objet enfant

Vous pouvez vérifier les valeurs de variables de propriétés spécifiques dans des objets enfants à l’aide de la syntaxe à la variable

voiture1 :

-- Syntaxe Lingo x = voiture1.vitesseVoiture

NomObjet.NomDePropriété syntax. Par exemple, l’instruction suivante affecte

x la valeur de la propriété vitesseVoiture de l’objet enfant dans la variable

La consultation des propriétés d’un objet depuis l’extérieur de cet objet peut s’avérer utile pour obtenir des informations sur des groupes d’objets, comme la vitesse moyenne de tous les véhicules d’un jeu de course automobile. Vous pouvez également utiliser les propriétés d’un objet afin de déterminer le comportement d’autres objets qui en dépendent.

En plus de vérifier les propriétés que vous affectez, vous pouvez déterminer si un objet enfant contient un gestionnaire spécifique ou rechercher le script parent d’où provient un objet. Cette fonction est très pratique si des objets proviennent de scripts parents similaires mais présentant des différences très subtiles.

Par exemple, vous pouvez créer un scénario dans lequel un script parent parmi d’autres pourrait servir à créer un objet enfant. Vous pouvez ensuite déterminer de quel script parent un objet enfant déterminé provient à l’aide de la fonction

script(), qui renvoie le nom du script parent

d’un objet. Les instructions suivantes vérifient si l’objet

Voiture :

-- Syntaxe Lingo if voiture1.script = script("Voiture") then

_sound.beep()

end if

voiture1 a été créé depuis le script parent appelé

Vous pouvez également obtenir une liste de gestionnaires d’un objet enfant en utilisant la méthode utilisant la méthode

L’instruction suivante place une liste des gestionnaires de l’objet enfant

maListeDeGestionnaire :

-- Syntaxe Lingo maListeDeGestionnaire = voiture1.handlers()

handlers() ou vérifier si un gestionnaire particulier existe dans un objet enfant en

handler().

voiture1 dans la variable

Cette liste pourrait se présenter comme suit :

[#démarrer, #accélérer, #arrêter]

Les instructions suivantes utilisent la méthode handler() pour vérifier si le gestionnaire

on accélérer existe dans l’objet enfant voiture1 :

-- Syntaxe Lingo if voiture1.handler(#accélérer) then

put("L’objet enfant voiture1 contient le gestionnaire indiqué sur accélérer.")

end if

Programmation orientée objet avec Lingo 67

Suppression d’un objet enfant

Vous pouvez supprimer un objet enfant d’une animation en modifiant la valeur de toutes les variables qui contiennent une référence à cet objet enfant. Si l’objet enfant a été affecté à une liste, comme

Pour supprimer un objet enfant et les variables qui y font référence :

actorList, vous devez également supprimer l’objet en question de la liste.

• Affectez VOID à chaque variable.

Director supprime l’objet enfant lorsque plus rien ne lui fait référence. Dans l’exemple suivant,

balle1 contient la seule référence à un objet enfant particulier, et la définit comme étant VOID

pour supprimer l’objet de la mémoire.

-- Syntaxe Lingo balle1 = VOID

Pour supprimer un objet de actorList :

• Utilisez la méthode delete() pour supprimer l’élément de la liste.

Utilisation de scriptInstanceList

Vous pouvez utiliser la propriété nouveaux comportements à une image-objet. Normalement, des instances de comportements créées à partir des initialisateurs de comportements définis dans le scénario. Si vous ajoutez des objets enfants créés à partir de scripts parents à la liste, les objets enfants reçoivent les messages envoyés à d’autres comportements.

Par exemple, l’instruction suivante ajoute un objet enfant à la propriété de l’image-objet 10 :

-- Syntaxe Lingo add(sprite(10).scriptInstanceList, new(script "rotation", 10))

Le script suivant est le script parent éventuel auquel l’instruction précédente fait référence :

-- Syntax Lingo pour script parent "rotation" property spriteNum

scriptInstanceList pour ajouter dynamiquement de

scriptInstanceList est la liste

scriptInstanceList

on new me, aSpriteNum

spriteNum = aSpriteNum return me

end

on prepareFrame me

sprite(spriteNum).rotation = sprite(spriteNum).rotation + 1

end

Lorsqu’un objet enfant est ajouté à scriptInstanceList, vous devez initialiser la propriété

spriteNum de l'objet enfant. Cette opération est généralement effectuée à partir d’un paramètre

passé au gestionnaire

Remarque : Le message beginSprite n’est pas envoyé aux objets enfants ajoutés dynamiquement.

on new.

Pour obtenir des informations concernant scriptInstanceList, consultez scriptInstanceList,

page 1030.

68 Chapitre 3 : Rédaction de scripts dans Director

Utilisation de actorList

Vous pouvez établir une liste spéciale d’objets enfants (ou de tout autre objet) qui reçoivent un message personnel à chaque fois que la tête de lecture entre dans une image ou que la méthode

updateStage() met la scène à jour.

La liste spéciale est

actorList, qui ne contient que les objets ayant été explicitement ajoutés à

la liste. Le message est le message

image ou que la commande Les objets de

actorList reçoivent un message stepFrame au lieu d’un message enterFrame à

chaque image. Si les objets disposent d’un gestionnaire

stepFrame qui n’est émis que lorsque la tête de lecture entre dans une

updateStage() est utilisée.

on stepFrame, le script du gestionnaire

est exécuté à chaque fois que la tête de lecture entre dans une nouvelle image ou que la méthode

updateStage() met la scène à jour.

Parmi les applications possibles de

actorList et stepFrame figurent l’animation d’objets enfants

utilisés en tant qu’images-objets ou la mise à jour d’un compteur qui suit le nombre de fois que la tête de lecture entre dans une image.

Un gestionnaire

actorList et le gestionnaire stepFrame sont conçus pour des performances optimales dans

Director. Les objets de

enterFrame ou aux messages personnalisés émis après une méthode updateStage().

Pour ajouter un objet dans actorList :

on enterFrame pourrait produire les mêmes résultats, mais la propriété

actorList répondent mieux aux messages stepFrame qu’aux messages

• Utilisez la propriété actorList comme suit, objetEnfant faisant référence à l’objet enfant à

ajouter :

-- Syntaxe Lingo _movie.actorList.add(objetEnfant)

Le gestionnaire stepFrame de l’objet, défini dans son script parent ou ancêtre est alors exécuté automatiquement à chaque fois que la tête de lecture avance. L’objet est transmis en tant que premier paramètre

Director n’efface pas le contenu de provoquer un comportement imprévisible dans cette dernière. Pour éviter le transfert des objets enfants de l’animation actuelle dans la nouvelle animation, insérez une instruction qui efface

actorList dans le gestionnaire on prepareMovie de la nouvelle animation.

me au gestionnaire on stepFrame.

actorList lorsqu’il passe à une autre animation, ce qui peut

Pour effacer les objets enfants de actorList :

• Donnez à actorList la valeur [ ], qui représente une liste vide.

Pour obtenir des informations concernant

actorList, veuillez consulter actorList, page 667.

Programmation orientée objet avec Lingo 69

Création d’objets de temporisation

Un objet de temporisation est un objet script qui agit comme un minuteur et qui envoie un message à la fin du délai. Ce type d’objet est utile pour les scénarios qui nécessitent l’exécution de certains événements à intervalles réguliers ou après un certain délai.

Les objets de temporisation peuvent envoyer des messages appelant des gestionnaires dans des objets enfants ou des scripts d’animation. Vous pouvez créer un objet de temporisation en utilisant le mot de passe

new(). Vous devez spécifier le nom de l’objet, le gestionnaire à appeler

et la fréquence avec laquelle le gestionnaire doit être appelé. Lorsqu’un objet de temporisation est créé, Director maintient une liste des objets de temporisation actuellement actifs, nommée

timeOutList.

Pour créer des objets de temporisation :

• Utilisez l’une des deux syntaxes ci-dessous :

--Syntaxe Lingo

NomDeVariable = timeOut(NomObjTemp).new(intMillisecondes, #NomGestionnaire \

{, ObjetCible})

NomDeVariable = new timeOut(NomObjTemp, intMillisecondes, #NomGestionnaire \

{, ObjetCible})

Cette instruction utilise les éléments suivants :

• NomDeVariable est la variable dans laquelle vous placez l’objet de temporisation.

• timeOut indique le type d’objet Lingo que vous créez.

• NomObjTemp est le nom que vous donnez à l’objet de temporisation. Ce nom figurera dans la

liste

timeOutList. C’est la propriété #name de l’objet.

• new crée un nouvel objet.

• intMillisecondes indique la fréquence avec laquelle l’objet de temporisation doit appeler le

gestionnaire indiqué. C’est la propriété appelle le gestionnaire indiqué toutes les 2 secondes.

#period de l’objet. Une valeur de 2000, par exemple,

• #NomGestionnaire est le nom du gestionnaire que l’objet doit appeler. C’est la propriété

#GestionnaireTemporisation de l’objet. Vous la représentez sous la forme d’un symbole en

précédant le nom du signe

#accélérer.

#. Par exemple, un gestionnaire nommé on accélérer serait noté

• ObjetCible indique le gestionnaire de l’objet enfant à appeler. C’est la propriété #cible de

l’objet. Ce paramètre permet d’être spécifique si plusieurs objets enfants contiennent les mêmes gestionnaires. Si vous omettez ce paramètre, Director recherche le gestionnaire indiqué dans le script d’animation.

L’instruction suivante crée un objet de temporisation appelé gestionnaire on accélérer dans l’objet enfant voiture1 toutes les 2 secondes :

-- Syntaxe Lingo monMinuteur = timeOut("minuteur1").new(2000, #accélérer, voiture1)

minuteur1 qui appellera un

70 Chapitre 3 : Rédaction de scripts dans Director

Pour déterminer le moment auquel le message de temporisation suivant est envoyé par un objet de temporisation déterminé, consultez sa propriété #time. La valeur renvoyée est le moment, en millièmes de secondes, auquel le message de temporisation suivant sera envoyé. Par exemple, l’instruction suivante détermine le moment auquel le prochain message de temporisation sera envoyé de l’objet de temporisation

-- Syntaxe Lingo put timeout("minuteur1").time)

minuteur1 et l’affiche dans la fenêtre Message :

Utilisation de timeOutList

Lorsque vous commencez à créer des objets de temporisation, vous pouvez utiliser

timeOutList

pour déterminer le nombre d’objets de temporisation actifs à un moment particulier. L’instruction suivante attribue la variable

utilisant la propriété

-- Syntaxe Lingo x = _movie.timeoutList.count

count.

x au nombre d’objets se trouvant dans timeOutList en

Vous pouvez également faire référence à un objet de temporisation en employant son numéro dans la liste.

L’instruction suivante supprime le second objet de temporisation dans la méthode

-- Syntaxe Lingo timeout(2).forget()

forget().

timeOutList en utilisant

Relais d’événements système au moyen d’objets de temporisation

Lorsque vous créez des objets de temporisation qui font référence à des objets enfants précis, vous permettez à ces derniers de recevoir des événements système. Les objets de temporisation relayent ces événements vers leurs objets enfants cibles. Les événements système qui peuvent être reçus par des objets enfants sont, par exemple,

exitFrame. En incluant des gestionnaires pour ces événements dans les objets enfants, vous

prepareMovie, startMovie, stopMovie, prepareFrame et

pouvez ordonner aux objets enfants de leur répondre en fonction de vos besoins. Les événements système reçus par les objets enfants sont également reçus par les scripts d’animation, les scripts d’image et les autres scripts définis comme devant leur répondre.

Le script parent suivant contient un gestionnaire pour l’événement système qu’un gestionnaire personnalisé

-- Syntaxe Lingo propriété vitesse

slowDown.

exitFrame ainsi

on new me

vitesse = random(55)

end

on exitFrame

vitesse = vitesse + 5

end

on slowDown mph

vitesse = vitesse - mph

end

Programmation orientée objet avec Lingo 71

Association de propriétés personnalisées avec des objets de temporisation

Si vous souhaitez associer des propriétés personnalisées avec un objet de temporisation, vous devez créer un objet de temporisation dont la cible n’est pas une référence à un objet instance de script. Lorsque vous utilisez cette technique, les données cibles deviennent des données associées à l’objet de temporisation pouvant être utilisées dans votre gestionnaire de temporisation.

L’exemple suivant vous montre comment utiliser cette technique.

-- Syntaxe Lingo

-- initialisation d’un objet de temporisation et transmission dans une liste de propriété de données (tDonnées)

-- au lieu de faire référence à un objet d’instance de script.

tDonnées = [#beta: 0] tTO = timeout("betaData").new(50,#gestionnaireCible,tDonnées)

-- au sein d’un script d’animation, créer le gestionnaire gestionnaireCible

on gestionnaireCible (aData)

-- incrémentation et affichage de la propriété bêta tDonnées.beta = tDonnées.beta + 1 put(tDonnées.beta)

end gestionnaireCible

Dans l’exemple précédent, la propriété beta continue d’être incrémentée. Cela signifie que vous pouvez initialiser plusieurs objets de temporisation qui appellent le même gestionnaire de script d’animation. Chaque objet de temporisation peut posséder sa propre liste de données.

En général, sachez que :

• Lors de l’utilisation d’instances de script en tant que cible, le gestionnaire cible de cette

instance de script en particulier est appelé. Vous ne pouvez pas utiliser des propriétés personnalisées avec cette technique.

• Lors de l'utilisation d'une référence autre qu'une instance de script (une liste de propriété par

exemple) en tant que cible, le gestionnaire cible dans un script d’animation est appelé. Vous pouvez utiliser des propriétés personnalisées avec cette technique.

Programmation orientée objet avec la syntaxe JavaScript

La programmation orientée objet dans la syntaxe JavaScript est quelque peu différente de celle d’autres langages orientés objet tels que Java et C++. Alors que certains langages orientés objet sont basés sur les classes, la syntaxe JavaScript est basée sur les prototypes.

Les deux sections qui suivent comparent à un niveau élevé les langages basés sur les classes aux langages basés sur les prototypes tels que la syntaxe JavaScript.

• Dans les langages basés sur les scripts, vous créez des définitions de classes se rapportant aux

propriétés et méthodes initiales qui caractérisent toutes les instances créées dans ces classes. Une définition de classe contient des méthodes spéciales appelées méthodes de construction et utilisées pour créer des instances de cette classe. Une instance créée à l’aide de l’opérateur en association avec une méthode de construction particulière hérite de toutes les propriétés de sa classe parent. Cette instance peut également effectuer toute autre tâche de traitement qui lui est propre en fonction du constructeur qui a été appelé.

Dans une définition de classe, vous procédez à l’opération d’héritage en créant une sous-classe qui hérite de toutes les propriétés de sa classe parent, en plus de définir les nouvelles propriétés et de modifier les propriétés héritées. La classe parent à partir de laquelle une sous-classe a été créée est aussi appelée super classe.

72 Chapitre 3 : Rédaction de scripts dans Director

new

• Dans les langages basés sur les prototypes tels que la syntaxe JavaScript, il n’existe pas de

distinction entre les classes, les instances, les sous-classes, etc. Tous ces éléments sont considérés comme des objets. Dans la syntaxe JavaScript, au lieu d’utiliser des définitions de classes, vous utilisez des « objets prototype » en tant que modèle à partir duquel de nouveaux objets sont créés. Tout comme dans les langages basés sur les classes, dans la syntaxe JavaScript, vous créez un nouvel objet en utilisant l’opérateur

Au lieu d’utiliser les super classes et les sous-classes, vous associez les objets prototype à des fonctions de construction pour effectuer l’héritage dans la syntaxe JavaScript. Ce procédé est très similaire à celui qui consiste à utiliser les super classes et les sous-classes, à l’exception de la terminologie qui est différente.

Contrairement aux langages basés sur les classes, la syntaxe JavaScript vous permet aussi d’ajouter et de supprimer des propriétés à un objet ou une série d’objets à l’exécution. Par exemple, si vous ajoutez une propriété à un objet prototype à l’exécution, les objets apparentés héritent également de cette propriété.

Terminologie orientée objet

Dans la syntaxe JavaScript, étant donné que tous les types correspondent à des objets, les termes basés sur les classes tels que superclass (super-classe), subclass (sous-classe), class (classe), instance, etc. n’ont aucune signification technique littérale. Cependant, ces termes correspondent essentiellement à des objets dans la syntaxe JavaScript et peuvent être utilisés pour illustrer les différents concepts d’objets de syntaxe JavaScript. Ainsi, ces termes basés sur les classes sont synonymes d’object en ce qui concerne la programmation orientée objet dans la syntaxe JavaScript et signifient ceci :

new en association avec une fonction de construction.

• superclass (super-classe) ; Toute classe à partir de laquelle les sous-classes (objets) sont créées ;

une classe parent.

• subclass (sous-classe) ; Toute classe ayant été créée à partir d’une super classe (objet) ; une classe

enfant.

• class (classe) ; Terme générique signifiant super classe ou sous-classe ; une classe parent ou

enfant.

• instance ou object instance (object d’instance) ; Objet unique ayant été créé à partir d’une super

classe.

Programmation orientée objet avec la syntaxe JavaScript 73

Classes personnalisées

L’un des principaux avantages de la programmation orientée objet est la possibilité de créer des classes personnalisées donnant accès à des fonctionnalités personnalisées à vos scripts. Les classes prédéfinies, telles que Objet, String et Math, de la syntaxe JavaScript sont utiles, mais les fonctionnalités qu’elles offrent peuvent ne pas s’appliquer à la tâche que vous souhaitez accomplir. Supposons, par exemple, que vous souhaitez que certains objets de votre animation représentent des types de transports, tels que des voitures, des bateaux, des avions, et que vous souhaitez que chaque catégorie affiche des caractéristiques et fonctionnalités uniques. Ni les classes de syntaxe JavaScript prédéfinies, ni les objets Director prédéfinis ne pourront directement vous fournir la fonctionnalité dont vous avez besoin. C’est pourquoi vous devez créer une nouvelle classe pour chaque type de transport afin de pouvoir définir des caractéristiques uniques pour chaque type.

Retenez que lorsque vous créez des classes personnalisées de la syntaxe JavaScript, vous avez toujours accès à toutes les fonctions et fonctionnalités des objets Director prédéfinis. Cela signifie que même si les objets Director prédéfinis ne vous fournissent pas directement les fonctionnalités dont vous avez besoin, vous pouvez toujours les utiliser dans vos classes personnalisées pour accéder à leurs valeurs et à leurs fonctionnalités prédéfinies.

Fonctions de construction

Dans la syntaxe JavaScript, une fonction de construction représente la classe qui contient le modèle à partir duquel les nouvelles instances d’objets sont créées. Les fonctions de construction créent et initialisent (définissent l'état par défaut) les propriétés des nouveaux objets.

Le format des fonctions de construction est fondamentalement identique à celui des fonctions de méthode standard de syntaxe JavaScript. Cependant, la fonction de construction utilise un mot de passe spécial

this pour représenter une référence à un nouvel objet initialisé. En règle générale,

une fonction de méthode effectue des actions sur un ensemble de données d’un objet. L’exemple suivant vous montre une manière de créer une fonction de construction Rectangle qui

pourrait être utilisée pour initialiser la hauteur et la largeur de nouveaux objets Rectangle.

function Rectangle(l, h) {

this.width = l; this.height = h;

}

Vous pouvez également créer une fonction de construction en utilisant la syntaxe « fonction littérale ». La syntaxe fonction littérale fournit les mêmes fonctionnalités que la syntaxe précédente et correspond à une autre manière de rédiger une construction. L'exemple suivant vous montre comment utiliser la syntaxe fonction littérale pour créer une fonction de construction Rectangle identique à la précédente.

Rectangle = function(l, h) {

this.width = l; this.height = h;

}

Remarque : Lorsque vous définissez des fonctions de construction à appliquer à une animation, assurez-vous de les placer dans un script d’animation afin qu’elles soient disponibles tout le temps.

Il est recommandé de donner des noms qui correspondent aux fonctionnalités des fonctions de construction et d’utiliser leur initiale dans le nom, tel que

74 Chapitre 3 : Rédaction de scripts dans Director

Rectangle ou Cercle.

En général, les fonctions de construction sont utilisées pour initialiser de nouveaux objets, mais peuvent également renvoyer le nom de l’objet le cas échéant. Si vous retournez l’objet initialisé, l’objet retourné devient la valeur de l’expression

new.

Instances d’objet

La manière la plus commune de créer une nouvelle instance d’objet est d’utiliser l'opérateur suivi du nom de la fonction de construction. Les exemples suivants créent de nouvelles instances d’objet.

var objAléatoire = new Object(); // affecte une référence à un objet Objet var objChaîne = new String(); // affecte une référence à un objet Chaîne

Une fonction de construction peut parfois définir des paramètres qu’une nouvelle instance d’objet passe afin d’initialiser l’état de l’instance d’objet. Si une fonction de construction définit les paramètres utilisés lors de l’initialisation de nouvelles instances d’objet, les valeurs de propriétés sont initialisées ainsi :

• Si vous passez les valeurs à la fonction de construction lors de l’initialisation, les propriétés qui

ont reçu les valeurs sont définies selon ces valeurs.

• Si vous ne passez pas ces valeurs à la fonction de construction lors de l’initialisation, les

propriétés qui n’ont pas reçu les valeurs sont définies sur

Lorsque vous créez de nouvelles instances d’objet, le mot de passe la fonction de construction associée afin de faire référence à une nouvelle instance d’objet. Par conséquent, la nouvelle instance d’objet est initialisée avec toutes les propriétés définies à l’aide de la syntaxe

this.NomDePropriété.

Dans l’exemple suivant, une fonction de construction spécifier les noms des trois propriétés qui seront associées aux nouvelles instances d’objet. L’instruction suivant la construction initialise une nouvelle instance d'objet en passant les valeurs à la construction. Ces valeurs sont utilisées en tant que valeurs initiales des propriétés spécifiées par le mot de passe

// Fonction de construction Cercle function Cercle(x, y, r) {

this.xCoord = x; this.yCoord = y; this.radius = r;

}

this.

undefined.

this est utilisé dans le corps de

Cercle utilise le mot de passe this pour

new

// xCoord = 10, yCoord = 15, radius = 5 var objCercle = new Cercle(10, 15, 5);

Une fois objCercle initialisé, vous pouvez accéder à ses propriétés. A l’aide de l’instance

objCercle créée précédemment, vous pouvez définir certaines variables sur les valeurs de ses

propriétés.

var laCoordX = objCercle.xCoord; // affecte la valeur 10 à laCoordX var laCoordY = objCercle.yCoord; // affecte la valeur 15 à laCoordY var leRayon = objCercle.radius; // affecte la valeur 5 à leRayon

Remarque : Pour plus d’informations concernant l’utilisation de la syntaxe à points pour accéder aux propriétés et méthodes d’un objet, veuillez consulter Format de scripting à syntaxe à points, page 56.

Il est recommandé de donner aux nouveaux objets des noms qui correspondent à leur fonctionnalité et d’utiliser des minuscules, tel que objRectangle ou objCercle.

Programmation orientée objet avec la syntaxe JavaScript 75

Vous pouvez également créer une instance d’objet en utilisant la syntaxe « objet littéral ». Ainsi, vous n’avez pas besoin d’utiliser l’opérateur new et de fonction de construction. Utilisez cette technique uniquement lorsque vous n’avez besoin que d’une instance d’un objet n'ayant pas été défini dans une fonction de construction. Dans l’exemple suivant, une instance d’objet est créée avec

x = 1, y = 2 et radius = 2.

var ObjPetitCercle = { x:1, y:2, radius:2 };

Héritage d’objets

Non seulement la programmation orientée objet est capable de créer vos propres classes personnalisées, mais grâce à elle, les sous-classes peuvent également hériter des propriétés et méthodes des super classes à partir desquelles elles ont été créées. L’héritage vous facilite la création d’objets aux propriétés et fonctionnalités intégrées.

Dans la syntaxe JavaScript, une super classe correspond à la classe de base à partir de laquelle toutes les autres sous-classes sont créées : la super classe Objet. La super classe Objet comprend quelques propriétés et méthodes de base. Les sous-classes qui sont créées à l’aide du modèle Objet héritent toujours de ces propriétés et méthodes de base et définissent leurs propres propriétés et méthodes. Les sous-classes provenant de ces classes héritent de l’objet Objet, de leurs super classes et ainsi de suite. Tous les autres objets que vous créez prolongent cette chaîne d’héritage.

Par exemple, l’objet Objet contient la propriété créez une nouvelle classe nommée hérite ainsi de la propriété si vous créez une autre classe nommée

SousObj2 héritera également de la propriété constructor et de la méthode toString() de

SousObj1, elle correspond à une sous-classe de l’objet Objet et

constructor et de la méthode toString() de l’objet Objet. Ensuite,

SousObj2 en utilisant SousObj1 en tant que super classe,

constructor et la méthode toString(). Si vous

l’objet Objet, en plus de toutes les autres propriétés et méthodes personnalisées que vous avez définies dans

SousObj1.

Deux des propriétés importantes dont vos fonctions de constructions personnalisées héritent de la super classe Objet sont

prototype et constructor. La propriété prototype représente l’objet

prototype de la classe, qui vous permet d’ajouter des variables (propriétés) et des méthodes aux instances d’objet. C’est le moyen par lequel l'héritage est en général implémenté dans la syntaxe JavaScript. La propriété

constructor représente la fonction de construction en elle-même. Dans

les sections suivantes, on vous explique l’utilisation de ces propriétés.

Objets prototype

Lorsque vous créez une sous-classe, cette dernière hérite automatiquement des propriétés et méthodes de la super classe à laquelle elle se rapporte. Dans la syntaxe JavaScript, l’héritage est en général implémenté par les objets prototype. En réalité, une sous-classe hérite des propriétés et méthodes de l’objet prototype de sa super classe et non de la super classe en elle-même. Ce point important apporte une avantage sérieux : Toutes les propriétés et méthodes ne doivent pas être obligatoirement copiées d’une classe à une instance d’objet de cette classe, ce qui peut considérablement réduire la quantité de mémoire nécessaire à la création de nouvelles instances d’objet.

Dans la syntaxe JavaScript, chaque classe, y compris la classe prédéfinie Objet, contient uniquement un objet prototype. Chaque instance d’objet créée à partir d’une classe a accès aux propriétés et méthodes dans l’objet prototype de cette classe. Par conséquent, l’objet prototype d’une classe est en général le seul objet qui stocke les propriétés et méthodes pour cette classe ; une instance d’objet contient uniquement les propriétés nécessaires à l'initialisation de cette instance.

76 Chapitre 3 : Rédaction de scripts dans Director

Dans votre code, il semble que chaque instance d’objet comprend réellement ces propriétés et méthodes parce que vous y avez accès directement à partir de l’instance d’objet. Mais en réalité, l’instance utilise l’objet prototype pour y accéder. L’objet prototype d’une classe est automatiquement créé lorsque vous créez la classe. Vous pouvez accéder à l'objet prototype à l'aide de la propriété

prototype de la classe.

Etant donné que l’objet prototype d’une classe stocke les propriétés partagées par toutes les instances d’objet, il peut définir correctement les propriétés et méthodes donc les valeurs seront partagées parmi toutes les instances d’objet. Le fait de partager les propriétés et les méthodes parmi les instances d’objet vous facilite la création d’instances qui affichent un comportement défini par défaut et la personnalisation de toutes les instances associées au comportement par défaut.

En revanche, les objets prototype ne pourront pas définir correctement les propriétés et méthodes dont les valeurs peuvent varier selon les instances d’objet. Dans ces cas-là, vous pouvez définir ces propriétés et méthodes au sein de la classe elle-même.

Pour spécifier l’étendue d’une propriété ou méthode personnalisée, vous pouvez la définir selon l’un des quatre types suivants :

• Variables d’instances

• Méthodes d’instances

• Variables de classes

• Méthodes de classe

Variables d’instances

Les variables d’instances correspondent à toutes les variables (propriétés) définies dans une fonction de construction et copiées dans chaque instance d’objet de cette construction. Toutes les instances d’objet possèdent leurs propres copies de variables d’instances. Cela signifie que s’il existe cinq instances d’objet pour une classe sont définies dans la classe. Etant donné que chaque instance d’objet possède sa propre copie de variable d’instance, chaque instance d’objet peut affecter une valeur unique à une variable d’instance sans pour autant modifier les valeurs des autres copies de la variable d’instance. Vous pouvez accéder aux variables d’instance directement à partir des instances d’objet qui leur sont propres.

Dans l’exemple suivant, quatre variables d’instance – définies dans une fonction de construction. Ces quatre variables d’instances sont directement disponibles à partir de toutes les instances d’objet de la construction

function Voiture(marque, modèle, couleur) { // définit une classe Voiture

this.marque = marque; this.modèle = modèle; this.couleur = couleur; this.vitesse = 0;

}

Cercle, cinq copies de chaque variable d'instance

marque, modèle, couleur et vitesse– sont

Voiture.

Programmation orientée objet avec la syntaxe JavaScript 77

L’instance d’objet suivante objVoiture contient les quatre variables d’instances. Bien que la valeur de la variable d’instance vitesse ne soit pas passée à la construction Voiture,

objVoiture possède toujours une propriété vitesse dont la valeur initiale est 0 parce que

la variable

// objVoiture.marque="Subaru", objVoiture.modèle="Forester", // objVoiture.couleur="gris", objVoiture.vitesse = 0 var objVoiture = new Voiture("Subaru", "Forester", "gris");

vitesse est définie dans la construction Voiture.

Méthodes d’instances

Les méthodes d’instances correspondent à toute méthode accessible via une instance d’objet. Les instances d’objet ne possèdent pas leurs propres copies de méthodes d'instances. En revanche, les méthodes d’instances sont les premières définies en tant que fonctions, et ensuite les propriétés de l’objet prototype de la fonction de construction sont définies sur les valeurs de la fonction. Les méthodes d’instances utilisent le mot de passe

this dans le corps de la fonction de construction

définie afin de faire référence à l'instance d'objet sur laquelle elles opèrent. Bien qu’une instance d’objet donné ne possède pas une copie d’une méthode d’instance, vous pouvez toujours accéder aux méthodes d’instances directement à partir des instances d’objet qui y sont associées.

Dans l’exemple suivant, une fonction nommée nom de la fonction est ensuite affecté à la propriété classe

Voiture.

// augmente la vitesse de la voiture function Voiture_augmenterVitesse(x) {

this.vitesse += x; return this.vitesse;

} Voiture.prototype.augmenterVitesse = Voiture_augmenterVitesse;

Voiture_augmenterVitesse() est définie. Le

augmenterVitesse de l’objet prototype de la

Une instance d'objet de Voiture peut ensuite accéder à la méthode augmenterVitesse() et affecter sa valeur à la variable à l’aide de la syntaxe suivante.

var objVoiture = new Voiture("Subaru", "Forester", "gris"); var nouvelleVitesse = objVoiture.augmenterVitesse(30);

Vous pouvez également créer une méthode d’instance à l’aide de la syntaxe de fonction littérale. En utilisant la syntaxe de fonction littérale, il n’est plus nécessaire ni de définir une fonction, ni d’affecter un nom de propriété au nom de fonction.

Dans l’exemple suivant, la syntaxe de fonction littérale est utilisée pour définir une méthode

augmenterVitesse() définie précédemment.

// augmente la vitesse d'une voiture Voiture.prototype.augmenterVitesse = function(x) {

}

augmenterVitesse() qui contient les mêmes fonctionnalités que la fonction

this.vitesse += x; return this.vitesse;

78 Chapitre 3 : Rédaction de scripts dans Director

Variables de classes

Egalement appelées variables static, elles correspondent à toutes les variables (propriétés) associées à une classe et non à une instance d’objet. Il n’existe qu’une copie de variable de classe, quel que soit le nombre d’instances d’objet créées dans cette classe. Les variables de classe n’utilisent pas l’objet prototype pour implémenter l’héritage. Vous pouvez accéder à une variable de classe directement via la classe et non via une instance d’objet ; vous devez définir une classe dans une fonction de construction avant de pouvoir définir les variables de classe.

Dans l’exemple suivant, deux variables de classe sont définies–

function Voiture() { // définit une classe de voiture

...

}

Voiture.VITESSE_ = 165; Voiture.VITESSE_MIN = 45;

VITESSE_MAX et VITESSE_MIN.

Vous avez accès aux variables de classe MAX_SPEED et MIN_SPEED directement à partir de la classe

Voiture.

var VitesseMaxVoiture = Voiture.VITESSE_MAX; // VitesseMaxVoiture = 165 var VitesseMinVoiture = Voiture.VITESSE_MIN; // VitesseMinVoiture = 45

Méthodes de classe

Egalement appelées méthodes static, elles correspondent à toutes les méthodes associées à une classe et non à une instance d’objet. Certaines des méthodes ou propriétés suivantes s’appliquent uniquement aux images-objets ayant été créées à partir d’un acteur RealMedia. Les méthodes de classe n'utilisent pas l'objet prototype pour implémenter l'héritage. Vous avez accès à une méthode directement via la classe et non via une instance d’objet ; vous devez définir une classe dans une fonction de construction avant de pouvoir définir les méthodes de classe.

Dans l’exemple suivant, on définit une fonction nommée

définirVitesseInitiale() qui peut

modifier la vitesse par défaut des nouvelles instances de voiture. Le nom de la fonction est affecté à la propriété

function Voiture(marque, modèle, couleur) { // définit une classe de voiture

this.marque = marque; this.modèle = modèle; this.couleur = coleur; this.vitesse = Voiture.vitesseParDéfaut;

} Voiture.vitesseParDéfaut = 10; // vitesse initiale des nouvelles instances de

voiture

// augmente la vitesse d'une voiture function Voiture_définirVitesseInitiale(x) {

Voiture.VitesseParDéfaut = x;

} Voiture.définirVitesseInitiale = Voiture_définirVitesseInitiale;

définirVitesseInitiale de la classe Voiture.

Vous pouvez accéder à la méthode de classe définirVitesseInitiale() directement à partir de la classe

var nouvelleVitesse = Voiture.définirVitesseInitiale(30);

Voiture.

Programmation orientée objet avec la syntaxe JavaScript 79

Vous pouvez également créer une méthode de classe à l'aide de la syntaxe de fonction littérale. Dans l’exemple suivant, la syntaxe de fonction littérale est utilisée pour définir une méthode

définirVitesseInitiale() contenant les mêmes fonctionnalités que la fonction définirVitesseInitiale() définie précédemment.

// augmente la vitesse d’une voiture Voiture.définirVitesseInitiale = function(x) {

Voiture.VitesseParDéfaut = x;

}

Etapes recommandées de définition d’une classe

La liste suivante décrit les étapes que nous vous recommandons de suivre lorsque vous définissez une classe.

1 Définissez une fonction de construction utilisée en tant que modèle à partir duquel les instances

d’objets sont initialisées. Vous pouvez également définir toute variable d'instance de la fonction de construction en utilisant le mot de passe

2 Définissez toute méthode d’instance, ainsi que toute variable d’instance, stockées dans l’objet

this pour faire référence à une instance d’objet.

prototype d’une classe. Ces méthodes et variables d’instances sont disponibles pour toutes les instances d’objet et vous pouvez y accéder via l’objet prototype de la classe.

3 Définissez toute méthode de classe, variable de classe et constante stockées dans la classe elle-

même. Vous pouvez accéder à ces méthodes et variables de classe via la classe elle-même.

Dans votre code, lorsque vous accédez à une propriété d’une instance d'objet, la syntaxe JavaScript recherche l’instance d’objet pour cette propriété. Si l’instance ne contient pas de propriété, la syntaxe JavaScript recherche alors l’objet prototype de la super classe à partir de laquelle l’instance a été créée. Etant donné qu’une instance d’objet est recherchée avant l’objet prototype de la classe à partir de laquelle il a été créé, l’instance d’objet masque les propriétés à l’objet prototype de leurs super classes. Cela signifie qu'une instance d’objet et sa super classe peuvent réellement définir une propriété si elles portent le même nom mais avec des valeurs différentes.

Suppression de variables

Vous pouvez supprimer une variable de classe ou une variable d’instance à l’aide de l’opérateur

delete. L’exemple suivant illustre ce processus.

function Voiture() { // définit la fonction de construction d'une voiture

...

} Voiture.couleur = "bleu"; // définit la propriété couleur de la classe de

voiture

Voiture.prototype.moteur = "V8"; // définit une propriété de moteur du

prototype

var objVoiture = new Voiture();

trace(Voiture.couleur); // affiche « bleu » trace(objVoiture.moteur); // affiche « V8 »

delete Voiture.couleur; delete Voiture.prototype.moteur;

trace(Voiture.couleur); // affichage non défini trace(objVoiture.moteur); // affichage non défini

80 Chapitre 3 : Rédaction de scripts dans Director

Pour accéder à la propriété de construction d’un objet prototype

Lorsque vous définissez une classe en créant une fonction de construction, la syntaxe JavaScript crée un objet prototype pour cette classe. Lorsque l’objet prototype est créé, il comprend au départ une propriété

constructor qui se rapporte à la fonction de construction elle-même. Vous

pouvez utiliser la propriété constructor d’un objet prototype pour déterminer le type de tout objet.

Dans l’exemple suivant, la propriété construction utilisée pour créer l’instance d’objet. La valeur de la propriété

constructor contient une référence à la fonction de

constructor est en

réalité une référence à la construction elle-même et n'est pas une chaîne qui contient le nom de la construction.

function Voiture() { // définit la classe d’une voiture

// code d’initialisation ici

}

var maVoiture = new Voiture(); // maVoiture.constructor == function Voiture()

{}

Création dynamique de propriétés

Un des autres avantages dont vous pouvez bénéficier en utilisant un objet prototype pour implémenter l’héritage est que les propriétés et méthodes ajoutées à un objet prototype sont automatiquement disponibles pour les instances d’objets. Cela est vrai même si une instance d’objet a été créée avant que les propriétés ou les méthodes ne soient ajoutées.

Dans l’exemple suivant, la propriété après qu’une instance d’objet de

function Voiture(marque, modèle) { // définit la classe d’une voiture

this.marque = marque; this.modèle = modèle;

}

couleur est ajoutée à l’objet prototype d’une classe Voiture

Voiture ait déjà été créée.

var maVoiture = new Voiture("Subaru", "Forester"); // crée une instance d’objet

trace(maVoiture.couleur); // renvoie undefined

// ajoute la propriété de couleur de la classe voiture après que maVoiture ait

été initialisé

Voiture.prototype.couleur = "blue";

trace(maVoiture.couleur); // renvoie « bleu »

Vous pouvez également ajouter des propriétés aux instances d’objet après que les instances ont été créées. Lorsque vous ajoutez une propriété à une instance d’objet spécifique, cette propriété est disponible uniquement pour cette instance d’objet spécifique. A l’aide de l’instance d’objet

maVoiture précédemment créée, les instructions suivantes ajoutent la propriété couleur à maVoiture après sa création.

trace(maVoiture.couleur); // renvoie undefined

maVoiture.couleur = "bleu"; // ajoute la propriété de couleur à l’instance

maVoiture

trace(maVoiture.couleur); // renvoie « bleu »

Programmation orientée objet avec la syntaxe JavaScript 81

var deuxièmeVoiture = new Voiture("Honda", "Accord"); // crée une deuxième

instance d’objet

trace(deuxièmeVoiture.couleur); // renvoie undefined

Rédaction de scripts dans la fenêtre Script

Lorsque vous rédigez des scripts pour une animation, ces scripts peuvent considérablement augmenter en quantité et en complexité. La décision des méthodes et propriétés à utiliser, de la structuration efficace des scripts et de leur position judicieuse exige un plan d’action rigoureux et de nombreux tests au fur et à mesure que la complexité de l’animation augmente.

Avant de commencer à rédiger des scripts, précisez l’objectif que vous voulez atteindre. Ceci est en fait aussi important et en général aussi laborieux que la création des storyboards de l’animation.

Une fois le plan d’ensemble de votre animation conçu, vous pouvez commencer à rédiger puis à tester les scripts. Attendez-vous à y passer du temps. Il est très rare qu’un script produise le résultat attendu dès la première rédaction, les premiers tests ou les premières opérations de débogage.

Il est donc conseillé de commencer de manière progressive et de tester vos scripts fréquemment. Dès qu’une partie d’un script produit l’effet escompté, rédigez la partie suivante, et ainsi de suite. Cette méthode vous permet d’identifier rapidement les bogues et garantit la précision de vos scripts au fur et à mesure que leur complexité augmente.

Lorsque vous rédigez vos scripts, vous le faites dans la fenêtre Script de l’interface utilisateur de Director. La fenêtre Script propose un certain nombre de fonctionnalités qui vous permettent de créer et modifier vos scripts.

Pour ouvrir la fenêtre Script, effectuez l’une des opérations suivantes :

• Choisissez Fenêtre > Script.

• Double-cliquez sur l’acteur script dans la fenêtre Distribution.

Vous trouverez d’autres façons de créer et d’ouvrir des scripts dans la section Exécution

d’opérations élémentaires, page 88.

82 Chapitre 3 : Rédaction de scripts dans Director

Définition des préférences de la fenêtre Script

Vous pouvez modifier la police du texte de la fenêtre Script et les couleurs des différents éléments du code. Pour modifier la police par défaut du texte de la fenêtre Script et les couleurs des différents éléments du code, vous utilisez les préférences de la fenêtre Script. Director affecte automatiquement une couleur distincte aux différents éléments du code, sauf si vous désactivez Mise en couleur automatique.

Pour définir des préférences dans la fenêtre Script :

1 Choisissez Edition > Préférences > Script. 2 Pour choisir la police par défaut, cliquez sur le bouton Police et sélectionnez les attributs de la

police dans la boîte de dialogue Police.

3 Pour choisir la couleur par défaut du texte affiché dans la fenêtre Script, choisissez une couleur

dans la puce Couleur.

4 Pour choisir la couleur d’arrière-plan de la fenêtre Script, choisissez une couleur dans la puce

Arrière-plan.

5 Pour que la fenêtre Script colorie automatiquement certains éléments du code, sélectionnez

Mise en couleur automatique. Cette option est activée par défaut. Lorsque l’option Mise en couleur automatique est désactivée, le texte a la couleur par défaut.

6 Pour que la nouvelle fenêtre Script formate automatiquement vos scripts avec la mise en retrait,

sélectionnez l’option Format automatique. Cette option est activée par défaut.

Remarque : Les fonctions de coloration automatique et de formatage automatique ne s’appliquent pas aux codes JavaScript. Par conséquent, si vous créez des scripts à l’aide de la syntaxe JavaScript, les boutons Mise en couleur automatique et Formatage automatique sont désactivés dans la fenêtre Script et les termes tels que function, var et this ont la couleur par défaut.

7 Pour que la nouvelle fenêtre Script affiche les numéros de ligne associés à vos scripts, sélec-

tionnez l’option Numérotation des lignes. Cette option est activée par défaut.

8 Si l’option Mise en couleur automatique est activée, choisissez les couleurs des éléments de code

suivants dans les menus couleurs correspondants :

■ Mots-clés

■ Commentaires

■ Constantes

■ Personnalisé (termes que vous définissez dans votre propre code)

9 Pour changer la couleur de fond de la colonne des numéros de ligne, cliquez sur Numérotation

des lignes et choisissez une nouvelle couleur.

10 Pour changer l’emplacement des volets Pile d’appels, Variables et Surveillance dans la fenêtre

Débogueur, sélectionnez Gauche, Droit, Haut ou Bas dans le menu Panneaux de débogage.

Rédaction de scripts dans la fenêtre Script 83

Insertion de termes de scripting communs

La fenêtre Script offre des menus locaux contenant les termes de scripting communs que vous pouvez utiliser pour insérer des instructions dans un script. Les mêmes menus sont également disponibles dans la fenêtre Messages.

Dans les fenêtres Script et Messages, vous pouvez sélectionner la syntaxe de scripting à utiliser pour un script donné.

Pour sélectionner la syntaxe de scripting :

• Dans le menu local Syntaxe de script, sélectionnez Lingo ou JavaScript.

Après avoir sélectionné une syntaxe de scripting, entrez le code dans la syntaxe que vous avez choisie. Si vous essayez de compiler un script dans une syntaxe autre que celle que vous avez choisie, vous obtenez une erreur de script.

Lorsque vous entrez des scripts dans la fenêtre Script, vous pouvez insérer ou supprimer des marques de commentaire sur une seule ou plusieurs lignes de code à l’aide des boutons Insérer une marque de commentaire et Supprimer la marque de commentaire. Selon la syntaxe choisie, les boutons Insérer une marque de commentaires et Supprimer la marque de commentaire affichent les bons repères de commentaire pour cette syntaxe ; Lingo utilisant des tirets doubles (-

-), et la syntaxe JavaScript deux barres obliques (//).

Pour insérer un commentaire dans le code :

• Mettez en surbrillance la ou les lignes auxquelles vous voulez ajouter un commentaire et

cliquez sur Insérer une marque de commentaire.

Remarque : Lorsque vous utilisez le bouton Insérer une marque de commentaire pour ajouter des commentaires sur plusieurs lignes de code en JavaScript, Director place deux barres obliques avant chaque ligne. Vous pouvez également insérer des commentaires sur plusieurs lignes de code en tapant le signe /* avant la première ligne de code et le signe */ après la dernière ligne ; mais vous devez le faire manuellement.

Pour supprimer le commentaire d’un code :

• Mettez en surbrillance la ou les lignes dont vous voulez supprimer les commentaires et cliquez

sur Supprimer la marque de commentaire.

Les fenêtres Script et Messages contiennent toutes deux les menus suivants :

• Le menu alphabétique Lingo est une liste alphabétique de tous les éléments, à l’exception du

Lingo 3D.

84 Chapitre 3 : Rédaction de scripts dans Director

• Le menu par catégorie est une liste des éléments Lingo répertoriés selon leurs fonctions. Il

n’inclut pas les éléments Lingo 3D.

• Le menu alphabétique 3D de Lingo est une liste alphabétique de tous les éléments Lingo 3D.

• Le menu par catégorie 3D de Lingo est une liste de tous les éléments Lingo 3D répertoriés

selon leurs fonctions.

• Le menu local des Xtras de programmation incluent les méthodes et propriétés de tous les

Xtras de programmation trouvés, qu’il s’agisse d’Xtras Macromedia ou autres.

Remarque : Les Xtras de programmation figurant dans le menu local sont limités à ceux qui supportent la méthode interface() et dont les noms apparaissent dans le menu local. Bien que certains types de médias d’acteurs tels 3D et DVD supportent également la méthode interface(), ils ne figurent pas dans le menu local Xtras de programmation parce qu’ils ne sont pas implémentés en tant que Xtras de programmation dans Director.

L’élément sélectionné dans les menus locaux est inséré par Director à l’emplacement du curseur dans la fenêtre Script.

Si un élément nécessite des paramètres supplémentaires, des repères de noms indiquant les informations supplémentaires requises sont insérés. Lorsque plusieurs arguments ou paramètres sont nécessaires, le premier est mis en surbrillance pour vous inviter à le saisir et le remplacer. Vous devez sélectionner et remplacer les autres paramètres vous-même.

Certains types d’acteurs et d’Xtras de programmation offrent des termes qui ne figurent pas dans les menus locaux. Ces types d’acteurs et d’Xtras possèdent généralement leur propre documentation ; vous pouvez également trouver des informations à partir de Director.

Pour afficher la liste des Xtras disponibles :

• Emettez soit put(_player.xtraList) soit trace(_player.xtraList) dans la fenêtre

Message.

Pour afficher la liste des Xtras de programmation disponibles :

• Emettez soit put(_player.scriptingXtraList) soit

trace(_player.scriptingXtraList) dans la fenêtre Message.

Pour afficher la liste des méthodes et propriétés d’un Xtra :

• Dans le menu local Xtras de programmation, placez-vous sur un Xtra et, dans le menu

secondaire, cliquez sur put interface. Les méthodes et propriétés de cet Xtra apparaissent dans la fenêtre Messages.

Saisie et modification de texte

La saisie et la modification de texte dans une fenêtre Script se font de la même manière que dans n’importe quel champ.

Les opérations d’édition les plus communes effectuées dans une fenêtre Script sont les suivantes :

• Pour sélectionner un mot, double-cliquez dessus.

• Pour sélectionner un script entier, choisissez Edition > Tout sélectionner.

• Pour commencer une nouvelle ligne, entrez un retour chariot.

Rédaction de scripts dans la fenêtre Script 85

• Dans Lingo, pour renvoyer une longue ligne de code à la ligne en insérant un symbole de

continuation, appuyez sur Alt+Entrée (Windows) ou sur Option+Retour (Macintosh) à l’endroit où vous voulez insérer un retour à la ligne. Le symbole de continuation (\) qui apparaît indique que l’instruction continue sur la ligne suivante.

Pour renvoyer une longue ligne de code à la ligne dans la syntaxe JavaScript, insérez un saut de ligne en appuyant sur Entrée (Windows) ou Retour (Macintosh). Le symbole de continuation Lingo cause une erreur de script dans les scripts de la syntaxe JavaScript.

• Pour trouver une gestionnaire dans le script actuel, choisissez son nom dans le menu local

Passer au gestionnaire de la fenêtre Script.

• Pour compiler les scripts que vous venez de rédiger, cliquez sur le bouton Recompiler tous les

scripts modifiés de la fenêtre Script ou fermez cette dernière. Lorsque vous éditez un script, un astérisque apparaît dans la barre de titre de la fenêtre Script, indiquant que le script doit être recompilé.

• Pour compiler tous les scripts d’une animation, sélectionnez Recompiler tous les scripts dans le

menu Contrôle.

• Pour reformater un script avec la bonne mise en retrait, appuyez sur Tab dans la fenêtre Script.

Director place automatiquement les instructions en retrait lorsque leur syntaxe est correcte. Si une ligne n’est pas correctement mise en retrait, la syntaxe de cette ligne est incorrecte.

• Pour ouvrir une seconde fenêtre Script, appuyez sur la touche Alt (Windows) ou Option

(Macintosh), tout en cliquant sur le bouton Nouvel acteur dans la fenêtre Script. Cette opération peut s’avérer utile, par exemple lorsque vous éditez simultanément deux sections différentes d’un long script.

• Pour activer ou désactiver la numérotation des lignes, cliquez sur le bouton Numérotation des

lignes.

• Pour activer ou désactiver la mise en couleur automatique, cliquez sur le bouton Mise en

couleur automatique. La mise en couleur automatique affiche chaque type d’élément Lingo (propriétés, commandes, etc.) dans une couleur différente.

• Pour activer ou désactiver le formatage automatique, cliquez sur le bouton Format automa-

tique. L’option Format automatique applique une mise en retrait correcte à vos scripts chaque fois que vous ajoutez un retour chariot ou que vous appuyez sur la touche Tab.

Recherche de gestionnaires et de texte dans les scripts

La commande Rechercher du menu Edition permet de rechercher des gestionnaires ainsi que de rechercher et modifier du texte ou des gestionnaires.

Pour rechercher des gestionnaires dans les scripts :

1 Choisissez Edition > Rechercher > Gestionnaire.

La boîte de dialogue Rechercher un gestionnaire apparaît. La colonne la plus à gauche de la boîte de dialogue Rechercher un gestionnaire affiche les noms

de tous les gestionnaires de l’animation. La colonne du milieu affiche le numéro de l’acteur associé au script du gestionnaire, ainsi que son nom. La colonne la plus à droite affiche la distribution dans laquelle se trouve l’acteur.

86 Chapitre 3 : Rédaction de scripts dans Director

2 Sélectionnez le gestionnaire à rechercher. 3 Cliquez sur Rechercher.

Le gestionnaire apparaît dans la fenêtre Script. La barre de titre en haut de la fenêtre Script indique le type du script.

Pour rechercher du texte dans les scripts :

1 Activez la fenêtre Script. 2 Choisissez Edition > Rechercher > Texte.

La boîte de dialogue Rechercher du texte apparaît.

3 Saisissez le texte à rechercher dans le champ Rechercher, puis cliquez sur Rechercher.

La recherche ne fait pas de distinction entre les majuscules et les minuscules :

thisHandler et THISHANDLER ne sont pas différenciés lors de la recherche. Cliquez sur la case

ThisHandler,

Respecter la casse pour que la recherche prenne en compte les majuscules et les minuscules.

Pour spécifier les acteurs dans lesquels effectuer la recherche :

• Sélectionnez l’option voulue sous Rechercher.

Pour reprendre la recherche au début une fois qu’elle atteint la fin :

• Sélectionnez l’option En boucle.

Pour ne rechercher que des mots entiers et non des fragments de mots correspondant au mot recherché :

• Sélectionnez l’option Mots entiers seulement.

Pour rechercher l’occurrence suivante du texte spécifié dans le champ Rechercher :

• Choisissez Edition > Poursuivre la recherche.

Pour trouver toutes les occurrences du texte sélectionné :

1 Sélectionnez le texte. 2 Choisissez Edition > Rechercher > Sélection.

Rédaction de scripts dans la fenêtre Script 87

Exécution d’opérations élémentaires

Vous trouverez ci-dessous les opérations élémentaires permettant de créer, associer et ouvrir des scripts.

Pour créer un comportement d’image (script associé à une image) :

• Double-cliquez sur la piste des comportements dans l’image à laquelle vous souhaitez affecter

le comportement.

Piste des comportements

Lorsque vous créez un nouveau comportement, celui-ci reçoit le premier numéro de distribution disponible dans la fenêtre Distribution active.

Lorsque vous créez un nouveau comportement d’image, la fenêtre Script apparaît et contient automatiquement le gestionnaire Lingo

on exitFrame, suivie d’une ligne dans laquelle le curseur clignote puis d’une autre comprenant

le mot

end. Cela vous permet de facilement et rapidement associer un comportement Lingo

commun à l’image. Pour que ce gestionnaire puisse fonctionner avec la syntaxe JavaScript, remplacez

on exitFrame par function exitFrame() { puis end par }.

on exitFrame. La première ligne contient l’expression

Un des comportements d’image les plus fréquents est celui qui maintient la tête de lecture en boucle dans une même image. Il peut s’avérer utile lorsque vous souhaitez que votre animation maintienne la lecture sur une même image en attendant que l’utilisateur clique sur un bouton ou que la lecture d’une vidéo numérique ou d’un fichier audio s’achève.

88 Chapitre 3 : Rédaction de scripts dans Director

Pour maintenir la tête de lecture sur une seule image :

• Dans un comportement d’image, tapez l’instruction suivante sur la ligne qui suit directement

l’instruction seulement) :

-- Syntaxe Lingo _movie.go(_movie.frame)

// Syntaxe JavaScript _movie.go(_movie.frame);

La propriété frame de l’objet Animation se rapporte à l’image actuellement occupée par la tête de lecture. Cette instruction demande essentiellement à la tête de lecture de « revenir au niveau de l’image active ».

Pour créer un comportement d’image-objet (script associé à une image-objet) :

on exitFrame (Lingo) ou function exitFrame()(syntaxe JavaScript

• Dans le scénario ou sur la scène, sélectionnez l’image-objet à laquelle vous souhaitez associer

le comportement. Choisissez ensuite Fenêtre > Inspecteur de comportement et choisissez Nouveau comportement dans le menu local Comportements.

Lorsque vous créez un nouveau comportement d’image-objet, la fenêtre Script apparaît et contient automatiquement le gestionnaire Lingo l’expression comprenant le mot

on mouseUp, suivie d’une ligne dans laquelle le curseur clignote puis d’une autre

end. Cela vous permet de facilement et rapidement associer un comportement

commun à l’image-objet. Pour que ce gestionnaire puisse fonctionner avec la syntaxe JavaScript, remplacez

Pour ouvrir un comportement afin de le modifier :

1 Double-cliquez sur le comportement dans la fenêtre Distribution.

on mouseUp par function mouseUp() { puis end par }.

L’inspecteur de comportement apparaît.

2 Cliquez sur l’icône Script de l’acteur dans l’inspecteur de comportement.

La fenêtre Script de l’acteur affiche le comportement.

Vous pouvez également ouvrir la fenêtre Script et faire défiler les scripts jusqu’à ce que le comportement recherché apparaisse.

on mouseUp. La première ligne contient

Pour supprimer un comportement d’un emplacement dans le scénario :

• Sélectionnez l’emplacement, puis supprimez le script de la liste affichée dans l’inspecteur des

propriétés (volet Comportement).

Pour associer des comportements existants à des images-objets ou à des images, effectuez l’une des opérations suivantes :

• Faites glisser un comportement d’une distribution vers une image-objet ou une image du

scénario ou (pour les images-objets) vers une image-objet de la scène.

• Dans le scénario, sélectionnez les images-objets ou les images auxquelles vous souhaitez associer

le comportement. Choisissez ensuite Fenêtre > Inspecteur de comportement et choisissez le comportement existant dans le menu local Comportements.

Rédaction de scripts dans la fenêtre Script 89

Pour créer un script d’animation (un script associé à une animation), effectuez l’une des opérations suivantes :

• Si le script actuel de la fenêtre Script est un script d’animation, cliquez sur le bouton Nouveau

script de cette fenêtre. (Le bouton Nouveau script crée toujours un script du même type que le script actuel.)

• Si le script actuel de la fenêtre Script n’est pas un script d’animation, cliquez sur le bouton

Nouveau script puis remplacez le type du nouveau script à l’aide du menu local Type du volet Script de l’inspecteur des propriétés.

• Si aucune image-objet ni aucun script n’est sélectionné dans la distribution, dans le scénario ou

sur la scène, ouvrez alors une nouvelle fenêtre Script. Par défaut, un nouveau script d’animation sera créé.

Pour ouvrir un script d’animation ou un script parent afin de le modifier :

• Double-cliquez sur le script dans la fenêtre Distribution.

Pour modifier le type d’un script :

1 Sélectionnez le script dans la fenêtre Distribution ou ouvrez-le dans la fenêtre Script. 2 Cliquez sur l’onglet Script de l’inspecteur des propriétés et choisissez un type de script dans le

menu local Type.

Pour faire défiler les scripts dans la fenêtre Script :

• Utilisez les flèches Acteur précédent et Acteur suivant situées en haut de la fenêtre Script pour

vous déplacer vers l’avant ou l’arrière dans les scripts.

Pour dupliquer un script :

• Sélectionnez le script dans la fenêtre Distribution, puis choisissez Dupliquer dans le menu

Edition.

Pour créer un script automatiquement associé à chaque image-objet créée à partir d’un acteur spécifique, associez le script à l’acteur proprement dit.

Pour créer un script associé à un acteur ou pour en ouvrir un, effectuez l’une des opérations suivantes :

• Cliquez sur le bouton droit de la souris (Windows) ou cliquez en maintenant la touche Ctrl

enfoncée (Macintosh) sur un acteur dans la fenêtre Distribution, puis choisissez Script dans le menu contextuel.

• Sélectionnez un acteur dans la fenêtre Distribution et cliquez ensuite sur le bouton Script de

l’acteur dans la fenêtre Distribution.

90 Chapitre 3 : Rédaction de scripts dans Director

Utilisation de scripts liés

En plus des scripts stockés sous la forme d’acteurs internes, vous pouvez placer des scripts dans des fichiers texte externes et les lier à votre animation Director. Ces scripts liés sont similaires aux fichiers d’images ou de vidéo numérique que vous pouvez importer dans une animation Director.

Parmi les avantages de l’emploi de scripts liés, citons les suivants :

• Une personne peut travailler sur le fichier Director alors qu’une autre travaille sur le script.

• Il est facile d’échanger des scripts avec d’autres personnes.

• Vous pouvez contrôler les scripts séparément du fichier Director, dans une application de

contrôle de code source telle que Microsoft Visual SourceSafe ou Perforce de Perforce Software. Ce type d’application évite que les différents programmeurs qui travaillent ensemble sur un projet Director écrasent le travail des autres.

Les scripts liés ne sont utilisés par Director qu’en cours de création. A l’exécution, les projections Director et le lecteur Macromedia Shockwave utilisent une copie interne spéciale des données du script stockée dans l’animation. De cette façon, il n’est pas nécessaire de distribuer vos scripts liés avec vos animations, et il est impossible à l’utilisateur final de les copier.

Pour importer un script sous la forme d’un fichier texte lié :

1 Choisissez Fichier > Importer. 2 Choisissez Script comme type de fichier à importer. 3 Sélectionnez le ou les fichiers de script que vous souhaitez importer.

Vous pouvez importer des fichiers possédant les extensions .txt, .ls ou .js. L’extension .ls est l’extension désignant les scripts liés de Director.

Pour créer une liste des fichiers à importer, vous pouvez utiliser les boutons Ajouter et Tout ajouter. Une telle liste est notamment utile si vous souhaitez importer des scripts de plusieurs endroits différents.

4 Choisissez Lier au fichier externe dans le menu local Médias. 5 Cliquez sur Importer.

Vous pouvez modifier les scripts liés de manière normale dans la fenêtre Script de Director. Les modifications que vous apportez sont écrites dans les fichiers externes à chaque fois que vous enregistrez l’animation Director. (Si vous avez importé le script lié depuis un serveur UNIX, les fins de ligne UNIX sont préservées.) Si vous importez un script dont le fichier texte est verrouillé, il vous sera impossible de le modifier dans Director.

Il est impossible d’appliquer des couleurs de texte personnalisées aux scripts liés dans la fenêtre Script. Par contre, la fonction de coloration automatique des scripts est activée pour les scripts liés.

Pour transformer un acteur script interne en acteur script lié externe :

1 Sélectionnez l’acteur interne et cliquez sur l’onglet Script de l’inspecteur des propriétés. 2 Cliquez sur Lier le script sous. 3 Entrez le nom du fichier dans la boîte de dialogue Enregistrer le script sous. 4 Cliquez sur Enregistrer.

Rédaction de scripts dans la fenêtre Script 91

Pour recharger un script lié après sa modification :

• Utilisez la propriété unload() de l'objet Image-objet.

Si un script lié est modifié en dehors de Director, vous pouvez le recharger avec la méthode

unload() dans la fenêtre Messages. L’instruction suivante déchargera puis rechargera l’acteur

script

monScript :

-- Syntaxe Lingo

member("monScript").unload()

// Syntaxe JavaScript member("monScript").unload();

92 Chapitre 3 : Rédaction de scripts dans Director

CHAPITRE 4

Débogage de scripts dans Director

Les scripts ne répondent pas toujours immédiatement aux instructions. Le script présente souvent une erreur de syntaxe : il s’agit généralement d’un mot mal écrit ou d’une partie du script absente. Il arrive aussi que le script fonctionne mais ne produise pas le résultat escompté. Des erreurs ou des bogues survenant presque toujours lors de la rédaction de scripts, il est recommandé de prévoir le temps nécessaire au débogage lors du développement des projets multimédia.

Au fur et à mesure de votre apprentissage, vous rencontrerez probablement d’autres types de problèmes, car lorsque vous maîtriserez un sujet, vous commencerez seulement à découvrir les autres. Toutefois, les principales techniques de dépannage présentées dans cette section sont destinées à la fois aux utilisateurs débutants et expérimentés.

Le meilleur moyen de corriger une erreur dans vos scripts varie d’une situation à l’autre. Il n’existe pas de procédure standard permettant de résoudre un problème. Vous devrez utiliser plusieurs des outils et techniques présentés plus bas :

• Présentation générale et détaillée de l’interaction des scripts dans une animation

• Expérimentation et pratique des principales méthodes de débogage

Les outils suivants sont destinés à vous aider à identifier les problèmes dans les scripts :

• Lorsque la fonction de suivi est activée, la fenêtre Messages affiche un enregistrement des

images lues et des gestionnaires en cours d’exécution dans l’animation.

• La fenêtre Débogueur affiche les valeurs des variables globales, les propriétés du script actuelle-

ment en cours d’exécution, la séquence de gestionnaires exécutée pour parvenir au niveau actuel, ainsi que la valeur des variables et des expressions que vous avez sélectionnées.

• La fenêtre Script vous permet de saisir des commentaires, d’insérer des points d’arrêt dans le

script et de sélectionner des variables dont la valeur apparaît dans l’inspecteur d’objet.

• L’inspecteur d’objet vous permet d’afficher et de définir les valeurs des objets et des propriétés

que vous avez sélectionnés.

Bonnes habitudes de rédaction de scripts

De bonnes habitudes vous permettront d’éviter, dès le départ, bon nombre de problèmes dans la rédaction de scripts.

• Veillez à rédiger les scripts par petits lots et testez directement chacun de vos scripts, au fur et à

mesure que vous les créez. Cette procédure permettra d’isoler les éventuels problèmes afin de les identifier plus facilement.

• Insérez des commentaires expliquant l’objectif des instructions et des valeurs du script.

Le script sera alors plus facile à comprendre, lorsque vous y reviendrez ultérieurement ou lorsqu’un autre utilisateur devra l’utiliser. Par exemple, les commentaires des instructions suivantes indiquent l’objectif de la structure

-- Syntaxe Lingo

-- Boucle jusqu’à ce que la touche "s" soit enfoncée repeat while not(_key.keyPressed("s"))

_sound.beep()

end repeat

// Syntaxe JavaScript // Boucle jusqu’à ce que la touche "s" soit enfoncée while(!_key.keyPressed("s")) {

_sound.beep()

}

if…then et clarifient la répétition de la boucle :

• Vérifiez si la syntaxe du script est correcte. Utilisez les menus locaux de la fenêtre Script pour

insérer des versions préformatées des éléments de scripting. Consultez les rubriques des API de ce référentiel pour vérifier si les instructions sont rédigées correctement.

• Utilisez des noms de variable qui indiquent l’objectif d’une variable. Par exemple, une variable

contenant un nombre devrait porter un nom tel que

nouveauNombre plutôt que ABC.

Opérations de débogage de base

Le processus de débogage implique des étapes de stratégie et d’analyse, et non une procédure standard rigoureuse. Cette section décrit les opérations de débogage fondamentales servant à déboguer tous les types de code, et pas uniquement le code Lingo ou JavaScript.

Avant d’apporter une modification majeure à une animation, veillez à toujours en faire une copie de sauvegarde. Il est recommandé de nommer les copies par incréments (par exemple nomFichier_01.dir, nomFichier_02.dir, nomFichier_03.dir, et ainsi de suite) afin de pouvoir suivre les diverses étapes d’une animation.

94 Chapitre 4 : Débogage de scripts dans Director

Identification du problème

Cela peut paraître évident, mais rappelons que la première chose à faire, lors d’une procédure de débogage, est d’identifier le problème. La fonction d’un bouton est-elle faussée ? L’animation accède-t-elle à une autre image que celle prévue ? L’édition d’un champ s’avère-t-elle impossible ?

Essayez aussi de comparer la fonction escomptée d’un script donné à sa fonction réelle. Cette opération vous aidera à déterminer clairement votre objectif et les parties de cet objectif qui n’ont pas été réalisées.

Si vous avez copié un script ou une partie de ce script à partir d’une autre animation ou d’un exemple écrit, vérifiez si ce script a été conçu pour des conditions bien spécifiques. Il était peutêtre nécessaire de programmer une piste d’image-objet. Il se peut également que les noms d’acteur doivent suivre une convention stylistique spécifique.

Localisation du problème

Pour localiser un problème, procédez comme suit :

• Remontez la chaîne et essayez de localiser l’emplacement auquel le problème semble

avoir commencé.

• Utilisez la fenêtre Messages pour suivre les images parcourues par l’animation et identifier les

gestionnaires exécutés par vos scripts.

• Déterminez le comportement présumé des scripts et ce qui, dans ces instructions, est associé

au problème. Par exemple, si un acteur texte ne peut pas être édité alors qu’il devrait l’être, localisez l’emplacement de la propriété

editable de l’acteur dans votre script.

• Si vous ne parvenez pas à modifier comme vous le souhaitiez une image-objet sur la scène,

vérifiez si la méthode

updateStage n’est pas requise à un emplacement précis.

• Vérifiez si le problème survient sur tous les ordinateurs ou sur un seul. Tâchez de définir si le

problème survient uniquement lorsque l’affichage est réglé sur millions de couleurs. Il se peut qu’un élément de l’ordinateur interfère avec l’application.

Concentrez-vous sur des lignes de script précises en insérant un point d’arrêt, c’est-à-dire un point où le script interrompt son exécution et appelle la fenêtre Débogueur, dans une ligne. Ceci vous permettra d’analyser les conditions à ce point précis, avant de poursuivre l’opération du script. Pour plus d’informations sur l’insertion de points d’arrêt dans un script, consultez Débogage dans

la fenêtre Débogueur, page 105.

Résolutions de problèmes simples

Lorsque vous découvrez un bogue, consultez tout d’abord les résolutions de problèmes simples. Le premier test de débogage s’effectue lorsque vous compilez votre script. Pour compiler votre

script, utilisez l’un des méthodes suivantes :

• Dans la fenêtre Script, cliquez sur Recompiler tous les scripts modifiés.

• Cliquez sur le bouton Recompiler tous les scripts dans le menu Contrôle.

• Appuyez sur Maj+F8.

• Fermez la fenêtre Script.

Il est généralement recommandé de compiler des scripts en utilisant l’une des trois premières méthodes. Pour pouvoir utiliser la quatrième option, vous devez fermer la fenêtre Script à chaque fois que vous voulez compiler un script.

Opérations de débogage de base 95

Lorsque vous compilez votre script, Macromedia Director MX 2004 présente un message d’erreur si le script contient une syntaxe incorrecte. Le message affiche généralement la ligne dans laquelle le problème a été détecté initialement. Un point d’interrogation apparaît au point précis où Director a initialement détecté le problème.

Par exemple, la première ligne du message précédent vous indique que l’erreur en question est une erreur de syntaxe et vous donne une explication. La deuxième ligne du message d’erreur affiche la ligne de code contenant l’erreur de syntaxe.

Recherche d’erreurs de syntaxe

Les erreurs de syntaxe sont certainement à l’origine des bogues les plus courants dans le scripting. Lorsqu’un script échoue, il est recommandé de vérifier immédiatement les points suivants :

• Les termes sont écrits correctement, les espaces sont placés aux endroits appropriés et la

ponctuation correcte est utilisée. Director ne peut pas interpréter une syntaxe incorrecte.

• Des guillemets sont placés de part et d’autre des noms d’acteurs, des libellés et des chaînes

dans l’instruction.

• Tous les paramètres requis sont présents. A chaque élément doivent être associés des para-

mètres spécifiques. Consultez les informations sur les API de ce référentiel pour savoir si un élément nécessite d’autres paramètres.

Recherche de bogues simples

Si votre script se compile sans afficher de message d’erreur, il risque de contenir un bogue. Si votre script ne produit pas les résultats escomptés, vérifiez les points suivants :

• Les valeurs des paramètres sont-elles correctes ? Par exemple, l’utilisation d’une valeur incor-

recte pour le nombre de bips sonores que doit générer la méthode beep produit un autre nombre de bips.

• Les valeurs sujettes à modifications, telles que les variables et le contenu d’acteurs texte, ont-

elles les valeurs escomptées ? Vous pouvez afficher leurs valeurs dans l’inspecteur d’objet en sélectionnant le nom de l’objet et en cliquant sur Inspecteur d’objet dans la fenêtre Script, ou dans la fenêtre Messages en utilisant les fonctions

put() ou trace().

• Les éléments de scripting se comportent-ils normalement ? Vous pouvez vérifier leur

comportement dans les rubriques consacrées aux API, dans ce référentiel.

• Si le script est rédigé dans la syntaxe JavaScript, il risque de contenir une erreur de casse. La

syntaxe JavaScript est sensible à la casse, ce qui signifie que les méthodes, fonctions, propriétés et variables doivent être saisies en respectant l’emploi des majuscules et minuscules.

Si vous appelez une méthode ou fonction en ne respectant pas la casse, vous obtenez une erreur de script.

96 Chapitre 4 : Débogage de scripts dans Director

Si vous essayez d’accéder à une variable ou une propriété en utilisant une casse incorrecte, il est possible que vous ne receviez pas d’erreur, mais votre script risque de ne pas avoir le comportement voulu. Par exemple, le gestionnaire d’accéder à la propriété

étiquetteElement en utilisant une casse incorrecte. Ce script ne ren-

mouseUp suivant contient une instruction qui essaie

verra pas d’erreur, mais créera automatiquement une nouvelle variable contenant une casse incorrecte. La valeur de la nouvelle variable est

// Syntaxe JavaScript fonction beginSprite() {

this.étiquetteElement = "Plans";

}

function mouseUp() {

trace(this.étiquetteElement); // crée la propriété étiquetteElement

}

undefined.

Débogage dans la fenêtre Script

La fenêtre Script propose un certain nombre de fonctionnalités qui vous permettent de déboguer vos scripts.

Pour ouvrir la fenêtre Messages :

• Choisissez Fenêtre > Script.

Pour rédiger un commentaire associé à la ligne de code courante :

• Cliquez sur Insérer une marque de commentaire.

Pour supprimer le commentaire de la ligne de code courante :

• Cliquez sur Supprimer la marque de commentaire.

Pour activer ou désactiver les points d’arrêt dans la ligne de code courante :

• Cliquez sur Activer/désactiver le point d’arrêt.

Pour désactiver tous les points d’arrêt :

• Cliquez sur Ignorer les points d’arrêt.

Pour ajouter l’expression ou la variable sélectionnée à l’inspecteur d’objet :

• Cliquez sur Inspecteur d’objet.

Débogage dans la fenêtre Script 97

Débogage dans la fenêtre Messages

La fenêtre Messages vous permet de tester les commandes de scripting et d’en contrôler le processus lors de la lecture d’une animation.

Pour ouvrir la fenêtre Messages :

• Choisissez Fenêtre > Messages.

Gestion de la fenêtre Messages

La fenêtre Messages contient un volet de saisie et un volet de résultat. Le contenu du volet de saisie est modifiable. Le contenu du volet de résultat est en lecture seule. Le seul moyen d’afficher le texte dans le volet de résultat est d’appeler la fonction

put() ou trace().

Vous pouvez ajuster la taille des volets de saisie et de résultat en faisant glisser le séparateur horizontal situé entre les deux volets.

Pour redimensionner le volet de résultat :

• Faites glisser le séparateur horizontal vers un nouvel emplacement.

Pour masquer complètement le volet de résultat :

• Cliquez sur le bouton Réduire/Agrandir, au centre du séparateur horizontal.

Lorsque le volet de résultat est masqué, les sorties des scripts en cours d’exécution sont affichées dans le volet de saisie.

Pour afficher le volet de résultat lorsqu’il est masqué :

• Cliquez de nouveau sur le bouton Réduire/Agrandir.

Pour effacer le contenu de la fenêtre Messages :

• Cliquez sur le bouton Effacer.

Si le volet de résultat est visible, son contenu est effacé. Si le volet de résultat n’est pas visible, le contenu du volet de saisie est effacé.

Pour effacer une partie du contenu du volet de résultat :

1 Sélectionnez le texte à effacer. 2 Appuyez sur la touche Retour arrière ou Suppr.

Pour copier du texte dans le volet de saisie ou de résultat :

1 Sélectionnez le texte. 2 Choisissez Edition > Copier.

98 Chapitre 4 : Débogage de scripts dans Director

Test de scripts dans la fenêtre Messages

Vous pouvez tester les instructions Lingo et JavaScript pour vérifier leur fonctionnement en les saisissant dans la fenêtre Messages et en observant les résultats. Lorsque vous saisissez une commande dans la fenêtre Messages, Director l’exécute immédiatement, qu’une animation soit ou non en cours d’exécution.

Avant de saisir les instructions que vous voulez tester, vous devez d’abord sélectionner la syntaxe de scripting (Lingo ou JavaScript) à tester.

Pour sélectionner la syntaxe de scripting :

1 Dans le menu déroulant Syntaxe de script, sélectionnez Lingo ou JavaScript.

Pour tester une instruction d’une ligne :

1 Saisissez directement l’instruction dans la fenêtre Messages. 2 Appuyez sur Entrée (Windows) ou sur Retour (Macintosh). Director exécute l’instruction.

Si l’instruction est valide, la fenêtre Messages affiche le résultat de l’instruction dans le volet de résultat, en bas de l’écran. Si le script n’est pas valide, un message d’erreur apparaît.

Par exemple, si vous saisissez l’instruction suivante dans la fenêtre Messages :

-- Syntaxe Lingo

put 50+50

// Syntaxe JavaScript put 50+50

puis que vous appuyez sur la touche Entrée (Windows) ou Retour (Macintosh), le résultat apparaît dans le volet de résultat :

-- Syntaxe Lingo

-- 100

// Syntaxe JavaScript // 100

Si vous saisissez l’instruction suivante dans la fenêtre Messages :

-- Syntaxe Lingo

_movie.stage.bgColor = 255

// Syntaxe JavaScript _movie.stage.bgColor = 255;

puis que vous appuyez sur la touche Entrée (Windows) ou Retour (Macintosh), la scène apparaît en noir.

Vous pouvez tester plusieurs lignes de code en une seule opération en copiant et collant des instructions dans la fenêtre Messages ou en appuyant simultanément sur les touches Maj et Retour (Entrée) après chaque ligne de code.

Pour exécuter plusieurs lignes de code par copier/coller :

1 Copiez les lignes de code dans le Presse-papiers. 2 Entrez une ligne vierge dans la fenêtre Messages. 3 Collez le code dans le volet de saisie de la fenêtre Messages. 4 Placez le point d’insertion à la fin de la dernière ligne de code.

Débogage dans la fenêtre Messages 99

5 Appuyez sur Ctrl+Entrée (Windows) ou Ctrl+Retour (Macintosh). Director trouve la première

ligne vierge au-dessus du point d’insertion et exécute successivement chaque ligne de code après la ligne vierge.

Pour saisir plusieurs lignes de code manuellement :

1 Entrez une ligne vierge dans la fenêtre Messages. 2 Entrez la première ligne de code. 3 Appuyez sur Maj+Retour (Entrée) à la fin de la ligne. 4 Répétez les étapes 2 et 3 jusqu’à la dernière ligne de code. 5 Appuyez sur Ctrl+Entrée (Windows) ou Ctrl+Retour (Macintosh). Director trouve la première

ligne vierge au-dessus du point d’insertion et exécute successivement chaque ligne de code après la ligne vierge.

Vous pouvez tester un gestionnaire sans exécuter l’animation, en écrivant le gestionnaire dans une fenêtre de script d’animation ou de script de comportement, puis en l’appelant depuis la fenêtre Messages.

Pour tester un gestionnaire :

1 Copier et collez ou saisissez manuellement un gestionnaire à plusieurs lignes dans la fenêtre

Messages, comme indiqué dans les deux procédures précédentes.

2 Placez le point d’insertion à la fin de la dernière ligne de code. 3 Appuyez sur Entrée (Windows) ou sur Retour (Macintosh). Le gestionnaire est exécuté.

Toutes les sorties provenant de l’instruction

put() ou trace()dans le gestionnaire sont

affichées dans la fenêtre Messages.

Tout comme la fenêtre Script, la fenêtre Messages contient des menus locaux des commandes de scripting. Lorsque vous sélectionnez une commande dans l’un de ces menus locaux, la commande apparaît automatiquement dans la fenêtre Messages, en présentant le premier argument fourni. Plusieurs menus sont disponibles et permettent un accès rapide au catalogue complet des termes de scripting.

Les menus locaux comprennent les options suivantes :

• Lingo par ordre alphabétique : toutes les commandes, à l’exception de Lingo 3D, présentées

par ordre alphabétique.

• Lingo par catégorie : toutes les commandes, à l’exception de Lingo 3D, présentées par

catégorie.

• Lingo 3D par ordre alphabétique : tous les termes Lingo 3D, présentés par ordre alphabétique.

• Lingo 3D par catégorie : tous les termes Lingo 3D, présentés par catégorie.

• Les Xtras de programmation incluent les méthodes et propriétés de tous les Xtras de program-

mation trouvés, qu’il s’agisse d’Xtras Macromedia ou autres.

Remarque : Les Xtras de programmation figurant dans le menu local sont limités à ceux qui supportent la méthode interface() et dont les noms apparaissent effectivement dans le menu local. Bien que certains types de médias d’acteurs tels 3D et DVD prennent également en charge la méthode interface(), ils ne figurent pas dans le menu local Xtras de programmation parce qu’ils ne sont pas implémentés en tant que Xtras de programmation dans Director.

100 Chapitre 4 : Débogage de scripts dans Director

ADOBE Director MX 2004 Référence de scripting de Director [fr]

Specifications and Main Features

Frequently Asked Questions

User Manual