Manuel du propriétaire | MACROMEDIA DIRECTOR MX 2004-RFRENCE DE SCRIPTING DE DIRECTOR Manuel utilisateur

DIRECTOR MX
®
2004
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é . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Nouveautés concernant le scripting de Director. . . . . . . . . . . . . . . . . . . . . . . . . . . .
Nouveautés dans cette documentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Recherche d’informations en matière de scripting dans Director . . . . . . . . . . . . . . .
CHAPITRE 2 : Principes de base du scripting dans Director
5
6
7
7
................. 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
3
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
CHAPITRE 6 : Types de médias
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
CHAPITRE 7 : Objets de scripting . . . . . . .
CHAPITRE 8 : Objets 3D
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
CHAPITRE 10 : Evénements et messages
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
CHAPITRE 13 : Opérateurs .
CHAPITRE 14 : Propriétés
4
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
CHAPITRE 12 : Méthodes .
INDEX
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
CHAPITRE 9 : Constantes
CHAPITRE 11 : Mots-clés
. . . . . . . . . . . . . . . . . . . . . . . . . . . 113
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 635
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 659
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1165
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 comportements 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.
5
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 :
fournit des informations sur les concepts et
composants de base que vous utilisez lorsque vous rédigez des scripts dans Director.
Principes de base du scripting 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
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
Propriétés
8
fournit une liste des événements disponibles dans Director.
fournit une liste des opérateurs disponibles dans Director.
fournit une liste des propriétés disponibles dans Director.
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.
9
•
•
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 orientée objet avec la syntaxe JavaScript, page 72.
Les scripts associés aux acteurs sont des scripts directement associés à un acteur, indépendamment 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
•
10
Lingo, les constantes telles que TAB, EMPTY et RETURN ont toujours les mêmes valeurs et ne
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.
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.
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() en utilisant la syntaxe
list(). Comme c’est le cas pour une fonction, une méthode ordonne également à une
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 composé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 se produit et Director envoie un message
enterFrame. Si un script contient un gestionnaire enterFrame, les instructions de ce gestionnaire 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.
Terminologie de scripting
11
• Les méthodes sont des termes entraînant une action pendant la lecture de l’animation ou le
•
•
•
•
•
12
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é var indique que le
terme suivant est une variable.
Les opérateurs calculent une nouvelle valeur à partir d’une ou de plusieurs valeurs. Par
exemple, l’opérateur d’addition (+) additionne deux valeurs ou plus pour produire une
nouvelle valeur.
Pour plus d’informations sur les opérateurs, consultez Opérateurs, page 27.
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 (_) ou le signe dollar ($). Les
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.
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 (--). Chaque ligne d’un commentaire 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 (//). Les commentaires à plusieurs lignes sont précédés du signe /* suivi du signe */.
// Ceci est un commentaire JavaScript d’une seule ligne.
/* Ceci est un
commentaire JavaScript de plusieurs lignes.*/
•
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.
Les parenthèses sont nécessaires après chaque nom de méthode et de fonction. Par exemple,
lorsque vous appelez la méthode beep() de l’objet Son, vous devez insérer des parenthèses
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 modifierImage-objet() contient
un appel de gestionnaire image-objetCliquée. Si l’appel du gestionnaire imageobjetCliquée ne contient pas de parenthèses, vous obtenez une erreur de script.
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 on nomDeGestionnaire. En JavaScript, les gestionnaires sont
considérés comme des fonctions et utilisent la syntaxe function nomDeGestionnaire(). Par
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();
}
• 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 additionParam suivant reçoit les deux paramètres a
et b.
--Syntaxe Lingo
on additionParam a, b -- sans parenthèses
c = a + b
end
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 valeurDébut.
// Syntaxe JavaScript
var valeurDébut = 0;
Remarque : Bien que l’utilisation de var dans la syntaxe JavaScript soit facultative, il est recommandé 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.
• 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",
maListe2 = [" 1
", "
"2",
"3"] -- renvoie ["1", "2", "3"]
2 ", " 3 "] -- renvoie [" 1 ", " 2
", "
Syntaxe de scripting
3
"]
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
member("chat").hiLite
MEMBER("CHAT").HILITE
Member("Chat").Hilite
=
=
=
=
true
True
TRUE
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 entX le nombre entier 14. La variable entX est donc du type de données
nombre entier. Dans la seconde instruction, il a été attribué à la variable chaîneX une séquence
de valeurs de caractères, c’est-à-dire une chaîne. La variable 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.
Par exemple, #list ou #word.
Array
(Syntaxe JavaScript seulement) Bien qu’il ne s’agisse pas exactement
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.
Boolean
Une valeur TRUE (1) ou FALSE (0). En Lingo, toutes les valeurs TRUE ou FALSE
sont de simples constantes de nombres entiers, 1 pour TRUE, 0 pour FALSE.
Dans la syntaxe JavaScript, toutes les valeurs true ou false sont, par
défaut, les vraies valeurs booléennestrue ou false, mais sont automatiquement converties, le cas échéant, en simples constantes de nombres
entiers dans Director.
En Lingo, TRUE et FALSE peuvent être en majuscules ou minuscules. Dans la
syntaxe JavaScript, true et false doivent toujours être en minuscules.
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
peut être utilisé avec les dates en JavaScript. En Lingo, utilisez la méthode
date() pour travailler avec les dates.
Float
(Lingo seulement) Nombre à virgule flottante. Par exemple, 2,345 ou
45,43.
Function
(Syntaxe JavaScript seulement) Bien qu’il ne s’agisse pas exactement
d’un type de données, un objet Function peut être utilisé pour préciser une
chaîne ou un code à exécuter.
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
valeurs ou de propriétés, et de valeurs.
Math
(Syntaxe JavaScript seulement) Bien qu’il ne s’agisse pas exactement
d’un type de données, un objet Math peut être utilisé pour effectuer des
opérations mathématiques.
null
(Syntaxe JavaScript seulement) Indique une variable dont la valeur
correspond à 0 dans les contextes numériques et à FALSE dans les
contextes booléens.
Number
(Syntaxe JavaScript seulement) Bien qu’il ne s’agisse pas exactement
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é.
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
Object peut être utilisé pour créer un conteneur personnalisé de données
et des méthodes agissant sur les données.
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
combinaisons de caractères dans des chaînes.
String
Chaîne de symboles clavier ou de valeurs de caractères. Par exemple,
"Director" ou "$5.00".
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.
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 name de l’objet Auteur est une chaîne, et la valeur doit donc
être une chaîne telle que Nouvelle du jour. Si vous essayez d’attribuer une valeur de type de
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 monAnimation est converti automatiquement.
--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
// 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, Bonjour
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 Bonjour et BONJOUR sont des
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 toString() peut convertir une valeur numérique en une chaîne.
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.
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 parseInt() vous permet de convertir une
chaîne ou un nombre décimal en nombre entier. Contrairement à la fonction integer() de
Lingo, parseInt() arrondit au plus petit. Par exemple, l’instruction suivante arrondit le nombre
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 leNombre.
--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
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 symbol().
--Syntaxe Lingo
x = symbol("novice") – renvoie le résultat #novice
// 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 on prepareMovie (Lingo) ou function
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.
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 value() (Lingo) ou de la
méthode parseInt() (syntaxe JavaScript), ou un nombre en chaîne à l’aide de la fonction
string() (Lingo) ou de la méthode toString() (syntaxe JavaScript).
22
Chapitre 2 : Principes de base du scripting dans Director
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é numChannels d’un acteur.
Pour attribuer une valeur à une variable :
• Utilisez l’opérateur égal à (=).
Par exemple, l’instruction suivante attribue une URL à la variable endroitsAvisiter :
// 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 maSomme:
--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é member de l’image-objet, et la place dans la variable
ActeurTexte.
--Syntaxe Lingo
ActeurTexte = sprite(2).member
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.
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 ; put() et trace() proposent des fonctionnalités identiques et sont
disponibles en Lingo et la syntaxe JavaScript.
Par exemple, l’instruction suivante affiche la valeur attribuée à la variable monNuméro dans la
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
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 goToNetMovie(), mais pas dans celles affichées par la méthode
goToNetPage().
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 VOID (Lingo) ou undefined (syntaxe JavaScript).
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.
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é var, cette variable sera disponible pour toutes les fonctions du script qui
la contient.
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 _global.nomVar, cette variable sera disponible pour tous
les scripts d’une animation.
L’exemple suivant utilise la syntaxe _global.gFilm dans un script pour déclarer la variable gFilm
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
// 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 x et y
sont des opérandes et le signe plus (+) l’opérateur. La seconde instruction illustre un opérateur
unaire où la variable i est l’opérande et ++ l’opérateur.
// Syntaxe JavaScript
x + y; // opérateur binaire
i++; // opérateur unaire
Pour plus d’informations sur les opérateurs, consultez le Chapitre 13, Opérateurs, page 635.
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é
( )
Opérations permettant de contrôler la priorité.
5
-
Lorsque placé devant un chiffre, en inverse la valeur.
5
*
Effectue une multiplication.
4
mod
(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.
4
++
(Syntaxe JavaScript seulement) Ajoute un à son opérande.
4
Lorsque utilisé comme opérateur préfixe (++x), renvoie la valeur de
son opérande après avoir ajouté un. Lorsque utilisé comme
opérateur postfixe (x++), renvoie la valeur de son opérande avant
d’ajouter un.
--
(Syntaxe JavaScript seulement) Soustrait un de son opérande. La 4
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
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 4/3 est 1.
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 float() avec une ou
plusieurs des valeurs dans l’expression. Par exemple, le résultat de 4/float(3) est 1.333.
28
Chapitre 2 : Principes de base du scripting dans Director
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.
1
===
(Syntaxe JavaScript seulement) Deux opérandes sont égaux et
du même type.
1
!=
1
(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.
1
<>
(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.
1
=
(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
(Syntaxe JavaScript seulement) x = x % y
1
x %= y
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, && est un opérateur logique qui détermine si deux expressions sont vraies, mais en Lingo, && 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
(Lingo seulement) Détermine si les deux expressions sont vraies. 4
&&
(Syntaxe JavaScript seulement) Détermine si les deux
expressions sont vraies.
ou
(Lingo seulement) Détermine si une ou les deux expressions sont 4
vraies.
||
(Syntaxe JavaScript seulement) Détermine si une ou les deux
expressions sont vraies.
4
not
(Lingo seulement) Inverse une expression
5
!
(JavaScript seulement) Inverse une expression
5
4
L’opérateur not (Lingo) ou ! (Syntaxe JavaScript) est utile lorsqu’il s’agit de faire passer la valeur
ou FALSE à la valeur opposée. Par exemple, l’instruction suivante active le son s’il est
désactivé, ou le désactive s’il est activé :
TRUE
--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, && est un opérateur logique qui détermine si deux expressions sont vraies, mais en Lingo, && 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.
2
+=
(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.
2
&&
(Lingo seulement) Concatène deux chaînes et insère un espace
entre elles.
2
"
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é Réponse, affiché
sur la scène. La seconde instruction n’a pu être placée avant la première parce que la variable x n’a
pas encore été définie.
--Syntaxe Lingo
x = 2 + 2
member("Réponse").text = string(x)
// 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 if...then...else (Lingo) ou if...else (syntaxe
JavaScript). Par exemple, vous pouvez créer une structure 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 ({ }) remplacent l’élément Lingo then et doivent encadrer
chaque instruction if, else ou else if.
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 else if spécifie l’exécution
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
// 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 then. Si vous insérez un retour de chariot, vous devez également placer une instruction end if à la fin de la structure if…then.
Lorsque vous rédigez des structures if dans la syntaxe JavaScript, vous pouvez placer l’instruction
ou les instructions après if sur la même ligne que celle de if, ou les placer sur leur propre ligne en
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 case (Lingo) et switch...case (syntaxe JavaScript) sont des raccourcis permettant d’éviter l’utilisation des structures if...then...else ou if...then dans les structures à
branchements multiples. Les structures case et switch...case sont souvent plus efficaces et
plus lisibles que beaucoup de structures if...then...else ou if...then.
En Lingo, la condition devant être testée suit le terme case dans la première ligne de la structure
La comparaison commence par la première ligne, puis passe à la suivante, etc. jusqu’à ce
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.
case.
Dans la syntaxe JavaScript, la condition devant être testée suit le terme switch dans la première
ligne de la structure. Chaque comparaison du test suit le terme case dans chaque ligne contenant
un test. Vous pouvez mettre fin à une comparaison case en utilisant le terme facultatif break.
Lorsque vous insérez le terme break, vous excluez le programme de la structure switch et
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 case ou switch...case peut utiliser des comparaisons comme conditions de test.
Par exemple, les structures 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 repeat
Spécifiez le nombre de répétitions sous forme de plage après l’instruction repeat with.
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éralement 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
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 mouseDown cesse d’exister.
Pour quitter une boucle en Lingo, utilisez l’instruction exit repeat.
Pour quitter une boucle dans la syntaxe JavaScript, vous pouvez utiliser le terme 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’utilisateur 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 :
•
•
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.
Les événements système
Plusieurs événements système tels que prepareFrame, beginSprite, etc., se produisent automatiquement 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 mouseDown, mouseUp et ainsi de
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 prepareMovie est toujours le premier à
se produire, l’événement prepareFrame toujours le second, etc. Toutefois, les événements
mouseDown et mouseUp peuvent ne jamais se produire dans une animation, à moins qu’un
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.
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 comportement 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’imageobjet.
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’animation 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 gestionnaire pour le message. Si un gestionnaire est trouvé, le message est intercepté et le script du gestionnaire 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 pass() pour ignorer
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.
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 a et b par les deux valeurs qu’il a reçues, stocke le résultat dans la variable locale c puis
utilise le mot-clé 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 gestionnaire. 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é me, mais tout autre terme serait également acceptable.
--Syntaxe Lingo
maHauteur = sprite(2).jump(5)
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 findColor suivant retourne la couleur
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 jump suivant ne renvoie rien si le
paramètre aVal est égal à 5 ; autrement, il renvoie une valeur.
--Syntaxe Lingo
on jump(aVal)
if aVal = 5 then return
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 list(), vous spécifiez que les éléments de la liste
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()
// 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 propList(), vous spécifiez que les éléments de la
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—left, top, right
et 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)
// 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 listeCollaborateurs
contenant une valeur, Françoise, puis ajoute Paul en tant que seconde valeur dans la liste.
--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 :
• 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 listeCollaborateurs puis attribue la seconde
valeur de la liste à la variable nom2.
--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"
// 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é Raymond.
--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()
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 petitdéjeuner et déjeuner.
--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
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()
•
•
•
•
46
(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.
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 append() pour ajouter un élément à la fin d’une liste.
--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"]
// 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 liste1
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
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 ([ ]) soit le constructeur Tableau pour créer un tableau. Les deux
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
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é length puis en renvoyant le type d’objet à l’aide de la propriété
constructor.
// Syntaxe JavaScript
var x = ["1", "2", "3"];
trace(x.length); // affiche 3
trace(x.contructor == Array); // affiche true
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
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.
splice()
•
•
•
L’exemple suivant montre comment utiliser la méthode splice() de l’objet Tableau pour ajouter
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
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 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 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 slice() pour créer une
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.
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 tableau1 et
tableau2. La troisième instruction crée un tableau multidimensionnel et l’affecte à tableauMd.
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.
55
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 getPropRef()
et getProp() pour accéder aux propriétés de cascade dans la syntaxe JavaScript.
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é shader peut être utilisée comme un
raccourci de la propriété shaderList[1]. Toutefois, dans la syntaxe JavaScript, la propriété
shaderList[1] doit être utilisée tout le temps.
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é _movie de haut niveau fait
directement référence à l’objet principal Animation et la fonction list() de haut niveau crée une
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
60
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()
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
Les objets enfants
Director correspondent aux classes dans la programmation orientée objet.
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.
de Director correspondent à la Super classe ou classe de base dans la
programmation orientée objet.
Les scripts ancêtres
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é scriptInstanceList d’un objet Image-objet
ou la propriété actorList de l’objet Animation pour contrôler les animations.
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é
Par exemple, l’instruction suivante transforme le script Ce_que_chacun_fait en
ancêtre du script parent dans lequel l’instruction survient :
ancestor.
-- 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 on new. Si la propriété n’est pas initialement définie, sa valeur initiale est
VOID.
Pour déclarer une variable de propriété :
• 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é vitesse d’un objet voiture1 :
voiture1.vitesse = 55
Création du nouveau gestionnaire
Chaque script parent utilise généralement un gestionnaire on new. Ce gestionnaire crée le nouvel
objet enfant lorsqu’un autre script émet une commande new(script nomDuScriptParent) qui
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 on new suivant crée un nouvel objet enfant à partir du script parent et initialise
la propriété spriteNum de l’enfant à l’aide de la valeur qui lui est associée dans le paramètre
aSpriteNum. L’instruction return me renvoie l’objet enfant vers le gestionnaire qui a appelé
initialement le gestionnaire on new.
-- Syntaxe Lingo
property spriteNum
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é spriteNum et contient un second
gestionnaire qui modifie la propriété foreColor de l’image-objet.
-- Syntaxe Lingo
property spriteNum
on new me, aSpriteNum
spriteNum = aSpriteNum
return me
end
on changeColor me
spriteNum.foreColor = random(255)
end
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 me doit toujours être la première variable de paramètre indiquée dans chaque définition
de gestionnaire d’un script parent. Il est toujours important de définir me comme premier paramè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 on new de l’objet enfant. La
méthode new() crée un objet enfant dont l’ancêtre est NomDeScript. Elle appelle ensuite le
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 rawNew(). La méthode rawNew() effectue cette opération en créant l’objet enfant
sans appeler le gestionnaire on new du script parent. Au cas où de grandes quantités d’objets
enfants seraient requises, 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 voiture1 :
-- Syntaxe Lingo
voiture1 = script("Voiture").rawNew()
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 NomObjet.NomDePropriété syntax. Par exemple, l’instruction suivante affecte
à la variable x la valeur de la propriété vitesseVoiture de l’objet enfant dans la variable
voiture1 :
-- Syntaxe Lingo
x = voiture1.vitesseVoiture
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 voiture1 a été créé depuis le script parent appelé
Voiture :
-- Syntaxe Lingo
if voiture1.script = script("Voiture") then
_sound.beep()
end if
Vous pouvez également obtenir une liste de gestionnaires d’un objet enfant en utilisant la
méthode handlers() ou vérifier si un gestionnaire particulier existe dans un objet enfant en
utilisant la méthode handler().
L’instruction suivante place une liste des gestionnaires de l’objet enfant voiture1 dans la variable
:
maListeDeGestionnaire
-- Syntaxe Lingo
maListeDeGestionnaire = voiture1.handlers()
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 actorList, vous devez également supprimer l’objet en question de la liste.
Pour supprimer un objet enfant et les variables qui y font référence :
• Affectez VOID à chaque variable.
Director supprime l’objet enfant lorsque plus rien ne lui fait référence. Dans l’exemple suivant,
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.
balle1
-- 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é scriptInstanceList pour ajouter dynamiquement de
nouveaux comportements à une image-objet. Normalement, scriptInstanceList est la liste
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é scriptInstanceList
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
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 on new.
Remarque : Le message beginSprite n’est pas envoyé aux objets enfants ajoutés dynamiquement.
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 stepFrame qui n’est émis que lorsque la tête de lecture entre dans une
image ou que la commande updateStage() est utilisée.
Les objets de actorList reçoivent un message stepFrame au lieu d’un message enterFrame à
chaque image. Si les objets disposent d’un gestionnaire 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 on enterFrame pourrait produire les mêmes résultats, mais la propriété
et le gestionnaire stepFrame sont conçus pour des performances optimales dans
Director. Les objets de actorList répondent mieux aux messages stepFrame qu’aux messages
enterFrame ou aux messages personnalisés émis après une méthode updateStage().
actorList
Pour ajouter un objet dans actorList :
• 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 me au gestionnaire on stepFrame.
Director n’efface pas le contenu de actorList lorsqu’il passe à une autre animation, ce qui peut
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.
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 :
•
•
•
•
•
•
•
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é #period de l’objet. Une valeur de 2000, par exemple,
appelle le gestionnaire indiqué toutes les 2 secondes.
#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 #. Par exemple, un gestionnaire nommé on accélérer serait noté
#accélérer.
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.
NomDeVariable
L’instruction suivante crée un objet de temporisation appelé minuteur1 qui appellera un
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)
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 minuteur1 et l’affiche dans la fenêtre Message :
-- Syntaxe Lingo
put timeout("minuteur1").time)
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 x au nombre d’objets se trouvant dans timeOutList en
utilisant la propriété count.
-- Syntaxe Lingo
x = _movie.timeoutList.count
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 timeOutList en utilisant
la méthode forget().
-- Syntaxe Lingo
timeout(2).forget()
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, prepareMovie, startMovie, stopMovie, prepareFrame et
exitFrame. En incluant des gestionnaires pour ces événements dans les objets enfants, vous
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 exitFrame ainsi
qu’un gestionnaire personnalisé slowDown.
-- Syntaxe Lingo
propriété vitesse
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 new
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
• 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 new en association avec une fonction de construction.
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 :
• 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 Rectangle ou Cercle.
74
Chapitre 3 : Rédaction de scripts dans Director
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 new
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 undefined.
Lorsque vous créez de nouvelles instances d’objet, le mot de passe this est utilisé dans le corps de
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 Cercle utilise le mot de passe this pour
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 this.
// Fonction de construction Cercle
function Cercle(x, y, r) {
this.xCoord = x;
this.yCoord = y;
this.radius = r;
}
// 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é constructor et la méthode toString(). Si vous
créez une nouvelle classe nommée SousObj1, elle correspond à une sous-classe de l’objet Objet et
hérite ainsi de la propriété constructor et de la méthode toString() de l’objet Objet. Ensuite,
si vous créez une autre classe nommée SousObj2 en utilisant SousObj1 en tant que super classe,
SousObj2 héritera également de la propriété constructor et de la méthode toString() de
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 Cercle, cinq copies de chaque variable d'instance
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 –marque, modèle, couleur et vitesse– sont
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 Voiture.
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;
}
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 vitesse est définie dans la construction Voiture.
// objVoiture.marque="Subaru", objVoiture.modèle="Forester",
// objVoiture.couleur="gris", objVoiture.vitesse = 0
var objVoiture = new Voiture("Subaru", "Forester", "gris");
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 Voiture_augmenterVitesse() est définie. Le
nom de la fonction est ensuite affecté à la propriété augmenterVitesse de l’objet prototype de la
classe Voiture.
// augmente la vitesse de la voiture
function Voiture_augmenterVitesse(x) {
this.vitesse += x;
return this.vitesse;
}
Voiture.prototype.augmenterVitesse = Voiture_augmenterVitesse;
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() qui contient les mêmes fonctionnalités que la fonction
augmenterVitesse() définie précédemment.
// augmente la vitesse d'une voiture
Voiture.prototype.augmenterVitesse = function(x) {
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–VITESSE_MAX et VITESSE_MIN.
function Voiture() { // définit une classe de voiture
...
}
Voiture.VITESSE_ = 165;
Voiture.VITESSE_MIN = 45;
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é définirVitesseInitiale de la classe Voiture.
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;
Vous pouvez accéder à la méthode de classe définirVitesseInitiale() directement à partir de
la classe Voiture.
var nouvelleVitesse = Voiture.définirVitesseInitiale(30);
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 this pour faire référence à une instance d’objet.
2 Définissez toute méthode d’instance, ainsi que toute variable d’instance, stockées dans l’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 ellemê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
L’exemple suivant illustre ce processus.
delete.
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é constructor contient une référence à la fonction de
construction utilisée pour créer l’instance d’objet. La valeur de la propriété 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é couleur est ajoutée à l’objet prototype d’une classe Voiture
après qu’une instance d’objet de Voiture ait déjà été créée.
function Voiture(marque, modèle) { // définit la classe d’une voiture
this.marque = marque;
this.modèle = modèle;
}
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 automatique. 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.
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.
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,
thisHandler et THISHANDLER ne sont pas différenciés lors de la recherche. Cliquez sur la case
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. La première ligne contient l’expression
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 }.
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 on exitFrame (Lingo) ou function exitFrame()(syntaxe JavaScript
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) :
• 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 on mouseUp. La première ligne contient
l’expression on mouseUp, 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
commun à l’image-objet. Pour que ce gestionnaire puisse fonctionner avec la syntaxe JavaScript,
remplacez on mouseUp par function mouseUp() { puis end par }.
Pour ouvrir un comportement afin de le modifier :
1 Double-cliquez sur le comportement dans la fenêtre Distribution.
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.
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
•
90
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.
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.
93
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 if…then et clarifient la répétition de la boucle :
-- 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()
}
• 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 paramè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•
•
•
96
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, ontelles 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.
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 mouseUp suivant contient une instruction qui essaie
d’accéder à la propriété étiquetteElement en utilisant une casse incorrecte. Ce script ne renverra pas d’erreur, mais créera automatiquement une nouvelle variable contenant une casse
incorrecte. La valeur de la nouvelle variable est undefined.
// Syntaxe JavaScript
fonction beginSprite() {
this.étiquetteElement = "Plans";
}
function mouseUp() {
trace(this.étiquetteElement); // crée la propriété étiquetteElement
}
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 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 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
Gestion de scripts dans la fenêtre Messages
Vous pouvez régler le volet de résultat de la fenêtre Messages de manière à afficher un enregistrement des instructions qu’une animation exécute lors de sa lecture. Ceci s’avère utile pour faire
le suivi du flux de votre code et examiner le résultat d’instructions spécifiques. Il existe deux
manières d’effectuer cette opération.
Pour afficher des instructions dans le volet de résultat, procédez comme suit :
• Dans la fenêtre Messages, cliquez sur Trace.
• Donnez à la propriété traceScript de l’objet Animation la valeur TRUE.
Les entrées placées après un double signe égal (==) indiquent ce qui s’est produit dans l’animation, par exemple la dernière image ouverte, le script en cours d’exécution ou le résultat d’une
méthode ou de la définition d’une valeur.
Par exemple, la ligne suivante contient plusieurs renseignements :
== Frame: 39 Script: 1 Handler: mouseUp
• L’animation a accédé à l’image 39.
• L’animation a exécuté le script 1, le premier script associé à l’image.
• L’animation a exécuté le gestionnaire mouseUp dans le script 1 après que l’animation a accédé à
l’image.
Les entrées situées après une flèche constituée d’un double tiret et d’un signe supérieur à (-->)
indiquent les lignes de votre code qui ont été exécutées. Par exemple, les lignes Lingo suivantes :
---> if leftSide < 10 then
--> if leftSide < 200 then
--> _movie.go("Début du jeu")
indiquent que ces instructions Lingo ont été exécutées. Supposons que vous souhaitiez déterminer
la raison pour laquelle la tête de lecture n’a pas accédé à l’image appelée « Début du jeu ». Si la
ligne --> _movie.go("Début du jeu") ne s’est pas affichée dans la fenêtre Messages, il se peut
que la condition de l’instruction précédente ne soit pas celle escomptée.
Le volet de résultat de la fenêtre Messages peut contenir une grande quantité de texte lorsque la
fonction de suivie est activée. Pour supprimer le contenu du volet de résultat, cliquez sur le
bouton Effacer. Si le volet de résultat n’est pas visible, le contenu du volet de saisie est effacé.
Débogage dans la fenêtre Messages
101
Vous pouvez retracer le suivi des valeurs de variables et d’autres objets en sélectionnant le nom de
l’objet dans la fenêtre Messages et en cliquant sur le bouton Inspecteur d’objet. L’objet est ajouté
à l’inspecteur d’objet, où sa valeur sera affichée et actualisée lors de la lecture de l’animation. Pour
plus d’informations sur l’inspecteur d’objet, veuillez consulter Débogage de l’inspecteur d’objet,
page 102.
Lorsque vous êtes en mode de débogage, vous pouvez retracer le suivi des modifications d’une
variable en la sélectionnant dans la fenêtre Messages et en cliquant sur le bouton Surveiller
l’expression. Director ajoute ensuite la variable au volet Surveillance dans la fenêtre Débogueur,
dans laquelle sa valeur est affichée et actualisée pendant que vous travaillez dans la fenêtre
Débogueur. Pour plus d’informations sur le volet Surveillance, veuillez consulter Débogage dans la
fenêtre Débogueur, page 105.
Débogage de l’inspecteur d’objet
L’inspecteur d’objet permet d’afficher et de définir les propriétés d’un grand nombre d’objets ne
s’affichant pas dans l’inspecteur des propriétés. Il s’agit notamment des objets de scripting tels
que les variables globales, les listes, les objets enfants de scripts parents, toutes les propriétés
d’acteur 3D, les propriétés d’images-objets, les expressions de script, etc. En outre, l’inspecteur
d’objet affiche les modifications apportées aux propriétés d’objet lors de la lecture de l’animation,
par exemple les modifications dues aux scripts ou apportées aux propriétés de scénario de l’imageobjet. Ces types de modifications ne sont pas affichés dans l’inspecteur des propriétés lors de la
lecture de l’animation.
Pour ouvrir l’Inspecteur d’objet :
• Choisissez Fenêtre > Inspecteur d’objet.
102
Chapitre 4 : Débogage de scripts dans Director
Présentation détaillée des structures d’objets
L’inspecteur d’objet est très utile pour comprendre la structure d’objets complexes. Par exemple,
les acteurs 3D contiennent un grand nombre de couches de propriétés. L’inspecteur d’objet
affichant une représentation visuelle de la structure imbriquée de ces propriétés, il vous aide à
comprendre l’organisation de ces propriétés, ainsi que leurs interactions. Il est important de
comprendre la structure des propriétés des objets dans Director lors de la rédaction des scripts.
La possibilité d’examiner le changement de valeur des propriétés lors de la lecture d’une
animation est pratique pour comprendre le fonctionnement de l’animation. Cela s’avère
particulièrement utile lors des procédures de test et de débogage des scripts, car vous pouvez
constater les changements de valeurs en fonction des scripts que vous avez rédigés.
La fenêtre Débogueur de Director affiche également ces informations, mais uniquement en mode
de débogage. Pour plus d’informations sur le débogage, veuillez consulter Débogage avancé,
page 111.
Objets visibles
Voici quelques exemples d’objets que vous pouvez entrer dans l’inspecteur d’objet :
•
•
•
•
•
•
Images-objets, telles que sprite(3)
Acteurs, tels que member("3d")
Variables globales, telles que gMaListe
Objets enfants, tels que gMonEnfant
Objets Macromedia Flash, tels que gMonObjetFlash ; pour plus d’informations sur l’utilisation d’objets Flash dans Director, veuillez consulter la rubrique Utilisation de Director dans
le panneau d’aide de Director.
Expressions de script, telles que sprite(7).blend
Affichage d’objets
Vous pouvez afficher un objet dans l’inspecteur d’objet de trois manières. Vous pouvez faire
glisser les éléments directement dans l’inspecteur d’objet, saisir manuellement le nom d’un de
ses éléments ou utiliser le bouton Inspecteur d’objet dans les fenêtres Messages et Script.
Pour faire glisser un élément dans l’inspecteur d’objet, effectuez l’une des opérations
suivantes :
• Sélectionnez une image-objet dans la fenêtre Scénario et faites-la glisser dans l’inspecteur
•
•
d’objet.
Sélectionnez un acteur dans la fenêtre Acteur et faites-le glisser dans l’inspecteur d’objet.
Sélectionnez le nom d’un objet dans les fenêtres Script, Messages ou Texte et faites-le glisser
dans l’inspecteur d’objet.
Pour entrer manuellement un objet dans l’inspecteur d’objet :
1 Double-cliquez dans la première cellule vide de la colonne Objet de l’inspecteur d’objet.
2 Tapez le nom de l’objet dans la cellule. Utilisez le même nom que celui utilisé pour cet objet
dans vos scripts.
3 Appuyez sur Entrée (Windows) ou sur Retour (Macintosh). Si l’objet possède des souspropriétés, un signe plus (+) est affiché sur sa gauche.
Débogage de l’inspecteur d’objet
103
4 Cliquez sur le signe plus. Les propriétés de l’objet s’affichent en dessous de celui-ci. Les
propriétés contenant des sous-propriétés sont affichées avec un signe plus sur leur gauche.
Cliquez sur chaque signe plus pour afficher les sous-propriétés.
Pour voir un objet à l’aide du bouton Inspecteur d’objet :
1 Dans la fenêtre Script, mettez en surbrillance la partie d’une instruction se rapportant à un objet.
2 Dans la fenêtre Script, cliquez sur Inspecteur d’objet. Si l’objet possède des sous-propriétés, un
signe plus (+) est affiché sur sa gauche.
3 Cliquez sur le signe plus. Les propriétés de l’objet s’affichent en dessous de celui-ci. Les
propriétés contenant des sous-propriétés sont affichées avec un signe plus sur leur gauche.
Cliquez sur chaque signe plus pour afficher les sous-propriétés.
Remarque : Si vous examinez beaucoup d’objets ou de gros objets individuels dans l’Inspecteur
d’objet, vous risquez de causer des problèmes de performances durant la programmation, particulièrement lorsque l’option Interrogation automatique est activée. Par exemple, lorsque vous examinez
une liste contenant 10 000 entrées, l’affichage de Director peut sembler lent.
Parcourir des objets
Vous pouvez également accéder au contenu de l’inspecteur d’objet à l’aide des touches fléchées de
votre clavier.
Pour monter ou descendre dans la liste des éléments :
• Utilisez les touches fléchées Haut et Bas.
Pour visualiser les sous-propriétés d’un élément :
• Sélectionnez l’élément et appuyez sur la touche fléchée Droite.
Pour masquer les sous-propriétés d’un élément :
• Sélectionnez l’élément et appuyez sur la touche fléchée Gauche.
Utilisation de Interrogation automatique
Les propriétés système, telles que milliseconds et colorDepth ne sont actualisées dans l’inspecteur d’objet que lorsque l’option Interrogation automatique est activée. L’utilisation de l’interrogation automatique augmente la charge de travail du processeur, ce qui risque de ralentir les
performances de votre animation lorsque vous ajoutez un certain nombre de propriétés système à
l’inspecteur d’objet.
Pour activer l’option Interrogation automatique :
1 Cliquez du bouton droit de la souris (Windows) ou cliquez en maintenant la touche Ctrl
enfoncée (Macintosh) dans l’inspecteur d’objet. Le menu contextuel de l’inspecteur d’objet
apparaît.
2 Sélectionnez Interrogation automatique dans le menu contextuel. Lorsque l’option
Interrogation automatique est activée, une coche apparaît à côté de l’option correspondante
dans le menu.
Pour désactiver l’option Interrogation automatique :
• Sélectionnez à nouveau Interrogation automatique dans le menu contextuel.
104
Chapitre 4 : Débogage de scripts dans Director
Modification des valeurs d’un objet ou d’une propriété :
Vous pouvez définir la valeur d’un objet ou d’une propriété dans l’inspecteur d’objet en saisissant
une nouvelle valeur dans le champ situé à droite du nom de l’objet ou de la propriété.
Pour définir la valeur d’un objet ou d’une propriété :
1 Double-cliquez sur la valeur, à droite du nom de l’élément.
2 Saisissez la nouvelle valeur de l’élément.
3 Appuyez sur Entrée (Windows) ou sur Retour (Macintosh). La nouvelle valeur est définie et est
immédiatement reflétée dans l’animation.
Vous pouvez saisir une expression de script comme valeur pour un élément. Par exemple, vous
pouvez définir la valeur de sprite(3).locH sur l’expression sprite(8).locH + 20.
Suppression d’objets
Vous pouvez également retirer des éléments de l’inspecteur d’objet.
Pour retirer un élément de l’inspecteur d’objet :
• Sélectionnez l’élément et appuyez sur la touche Retour arrière (Windows) ou Suppr
(Macintosh).
Pour effacer tout le contenu de l’inspecteur d’objet :
• Cliquez du bouton droit de la souris (Windows) ou cliquez en maintenant la touche Ctrl
enfoncée (Macintosh) dans l’inspecteur d’objet et choisissez Effacer tout dans le menu local.
Lorsque vous ouvrez une animation différente de celle sur laquelle vous travaillez actuellement, les
objets précédemment entrés dans l’inspecteur d’objet y sont conservés. Ceci facilite la comparaison de différentes versions d’une même animation. Lorsque vous quittez Director, les éléments de
l’inspecteur d’objet ne sont pas conservés.
Débogage dans la fenêtre Débogueur
La fenêtre Débogueur constitue un mode spécial de la fenêtre Script. Elle fournit plusieurs outils
permettant de localiser la cause de vos problèmes dans les scripts. Le Débogueur vous permet
de localiser rapidement les éléments de votre code qui sont à l’origine du problème. La fenêtre
Débogueur permet de rédiger des scripts ligne par ligne, d’ignorer les gestionnaires imbriqués, de
modifier le texte des scripts et de visualiser les valeurs des variables et d’autres objets au fur et à
mesure de leur modification. L’apprentissage des outils de la fenêtre Débogueur permet
d’accroître l’efficacité de votre programmation.
La fenêtre Débogueur permet également de localiser et de corriger les erreurs dans vos scripts.
Elle comprend plusieurs outils qui vous permettront d’effectuer les opérations suivantes :
•
•
•
•
•
Afficher la partie du script contenant la ligne de code courante.
Retracer la séquence des gestionnaires appelés avant le gestionnaire courant.
Exécuter certaines parties du gestionnaire courant.
Exécuter certaines parties des gestionnaires appelés depuis le gestionnaire courant.
Afficher la valeur d’une variable locale, d’une variable globale ou d’une propriété associée au
code qui fait l’objet de la recherche.
Débogage dans la fenêtre Débogueur
105
Saisie du mode de débogage
La fenêtre Débogueur ne s’affiche que lorsqu’un script est interrompu. Cette interruption
survient lorsque Director détecte une erreur ou un point d’arrêt dans un script.
La boîte de dialogue Erreur de script apparaît lorsqu’une erreur de script survient. Cette boîte de
dialogue affiche les informations associées à l’erreur détectée, vous demande si vous souhaitez
corriger le bogue dans le script, modifier le script dans la fenêtre Script ou annuler.
Pour passer en mode de débogage, effectuez l’une des opérations suivantes :
• Cliquez sur Déboguer dans la boîte de dialogue Erreur de script.
• Placez un point d’arrêt dans un script.
Lorsque Director détecte un point d’arrêt en cours d’exécution, l’exécution du script est interrompue et la fenêtre Script passe en mode de débogage. La lecture de l’animation se poursuit,
mais l’exécution de vos scripts est interrompue jusqu’à ce que vous utilisiez la fenêtre Débogueur
pour indiquer la procédure que Director doit suivre. Si plusieurs fenêtres Script sont ouvertes,
Director recherche celle contenant le script dans lequel le point d’arrêt a été détecté et fait passer
cette fenêtre en mode de débogage.
Pour ajouter un point d’arrêt afin de provoquer l’ouverture de la fenêtre Débogueur :
1 Dans la fenêtre Script, ouvrez le script qui devrait contenir le point d’arrêt.
2 Cliquez sur la marge gauche de la fenêtre Script, à côté de la ligne de code dans laquelle le point
d’arrêt doit apparaître ou placez un point d’insertion sur la ligne de code et cliquez sur Activer/
désactiver le point d’arrêt. L’exécution du code sera interrompue au début de cette ligne et la
fenêtre Script passera en mode de débogage. Si la fenêtre Script est ouverte lorsque Director
détecte une erreur de script ou un point d’arrêt, la fenêtre Débogueur remplacera automatiquement la fenêtre Script.
106
Chapitre 4 : Débogage de scripts dans Director
Pour mettre fin au débogage, effectuez l’une des opérations suivantes :
• Cliquez sur le bouton Relancer le script dans la fenêtre Débogueur. Cette opération rétablit
•
l’exécution normale du script.
Cliquez sur le bouton Arrêter le débogage dans la fenêtre Débogueur. Cette opération met fin
à la session de débogage et à l’animation.
La fenêtre Script apparaît à nouveau, à la place de la fenêtre Débogueur.
Lorsque la fenêtre Débogueur apparaît, elle présente la ligne de code courante et vous propose
plusieurs choix pour la suite de l’exécution.
Pour connaître la ligne de code courante :
• Dans le volet Script, recherchez la flèche verte affichée près d’une ligne de code.
La flèche verte pointe vers la ligne courante. Vous ne pouvez pas sélectionner une autre ligne de
code en cliquant dessus dans le volet Script.
Affichage de la pile d’appels dans la fenêtre Débogueur
Le volet Pile d’appels présente la séquence des gestionnaires imbriqués exécutés avant la ligne de
code courante. Cette séquence est appelée « pile d’appels ». Utilisez la pile d’appels pour retracer
la structure de votre code lors de la procédure de débogage. Vous pouvez visualiser les variables
associées à un gestionnaire spécifique en cliquant sur le nom du gestionnaire dans le volet Pile
d’appels. Les variables sont affichées dans le volet des variables.
Affichage des variables dans la fenêtre Débogueur
Le volet des variables de la fenêtre Débogueur affiche les variables associées au gestionnaire
courant. Le gestionnaire courant est celui qui est affiché dans le volet Script et le dernier gestionnaire affiché dans le volet Pile d’appels. Vous pouvez également afficher les variables associées aux
gestionnaires précédents dans la pile d’appels. Les modifications apportées aux valeurs des variables d’un script sont affichées en rouge. Pour plus d’informations sur la progression dans les
scripts, veuillez consulter Progression dans les scripts dans la fenêtre Débogueur, page 109.
Pour afficher les variables associées à un gestionnaire dans la pile d’appels :
• Cliquez sur le nom du gestionnaire dans le volet Pile d’appels. Les variables sont affichées dans
le volet des variables.
Le volet des variables contient quatre onglets vous permettant de visualiser les variables :
Le volet Toutes affiche
les variables globales et locales associées au gestionnaire courant.
Le volet Locales affiche
Le volet Propriétés
uniquement les variables locales associées au gestionnaire courant.
affiche les propriétés déclarées dans le script courant.
Le volet Globales affiche
uniquement les variables globales associées au gestionnaire courant.
Vous pouvez trier les variables dans le volet des variables :
• Pour trier les variables par nom, cliquez sur le mot Nom qui apparaît au-dessus des noms de
variable.
• Pour trier les variables en ordre alphabétique inversé, cliquez une seconde fois sur le mot Nom.
Débogage dans la fenêtre Débogueur
107
Vous pouvez modifier les valeurs des variables locales du gestionnaire courant et des variables
globales dans le volet des variables. Vous ne pouvez pas modifier les valeurs des variables locales
qui ne sont pas situées dans le gestionnaire courant.
Pour changer la valeur d’une variable dans le volet des variables :
1 Double-cliquez sur la valeur de la variable dans la colonne Valeur.
2 Saisissez la nouvelle valeur de la variable.
3 Appuyez sur Entrée (Windows) ou sur Retour (Macintosh).
Affichage des objets dans la fenêtre Débogueur
Le volet Surveillance de la fenêtre Débogueur permet de visualiser les variables et autres objets
associés au gestionnaire courant, ainsi que les objets associés aux autres gestionnaires. L’ajout
d’objets dans le volet Surveillance vous permet de suivre leurs valeurs au fur et à mesure de leur
modification grâce aux scripts. Lorsque la valeur d’un objet change en raison de l’exécution d’une
ligne de code, Director affiche la couleur du nom de l’objet en rouge dans le volet Surveillance.
Le volet Surveillance affiche uniquement les objets que vous avez ajoutés. Vous pouvez utiliser
chacun des quatre onglets du volet Surveillance pour organiser les objets en groupes.
Pour ajouter au volet Surveillance un objet dont le nom est affiché dans le volet Script :
1 Cliquez sur le nom de l’objet dans le volet Script.
2 Cliquez sur le bouton Surveiller l’expression.
Pour ajouter au volet Surveillance un objet dont le nom n’est pas affiché dans le volet
Script :
1 Double-cliquez sur la première cellule vide de la colonne Nom du volet Surveillance.
2 Saisissez le nom de l’objet dans la cellule et appuyez sur Entrée (Windows) ou sur Retour
(Macintosh).
Si l’objet possède des propriétés, un signe plus (+) est affiché en regard du nom de l’objet.
Pour afficher les propriétés d’un objet :
• Cliquez sur le signe plus (+) à côté du nom de l’objet.
Le volet Surveillance permet d’organiser les objets de plusieurs façons.
Pour organiser les objets dans le volet Surveillance, effectuez l’une des opérations
suivantes :
• Pour trier les objets dans le volet Surveillance, cliquez sur l’en-tête de colonne Nom affiché
•
•
•
108
en haut de la colonne de gauche. Les noms d’objets de la colonne sont présentés par ordre
alphabétique.
Pour trier les objets en ordre alphabétique inversé, cliquez une seconde fois sur l’en-tête de
colonne Nom.
Pour organiser les objets en groupes, utilisez les onglets du volet Surveillance. Pour ajouter un
objet à un volet spécifique, cliquez sur l’onglet de votre choix avant d’ajouter l’objet.
Pour effacer le contenu d’un onglet dans le volet Surveillance, sélectionnez le volet, puis cliquez
du bouton droit (Windows) ou en maintenant la touche Ctrl enfoncée (Macintosh) dans le
volet Surveillance et sélectionnez Effacer tout.
Chapitre 4 : Débogage de scripts dans Director
Progression dans les scripts dans la fenêtre Débogueur
La fenêtre Débogueur fournit un ensemble d’outils permettant une exécution lente des scripts, ce
qui vous permet de visualiser l’effet de chaque ligne de code dans votre animation. Vous pouvez
exécuter une ligne de code à la fois et décider si vous souhaitez exécuter les gestionnaires ligne par
ligne ou pour l’ensemble des lignes.
Pour exécuter uniquement la ligne de code courante indiquée par la flèche verte :
• Cliquez sur le bouton Exécuter le script pas à pas.
La plupart des gestionnaires comprennent des instructions d’appel des autres gestionnaires. Vous
pouvez centrer votre attention sur ces gestionnaires imbriqués, ou les ignorer et vous limiter au
code du gestionnaire courant.
Lorsque vous savez que les gestionnaires sont exécutés comme prévu et que vous souhaitez vous
concentrer sur le code dans le gestionnaire courant, la fenêtre Débogueur peut ignorer les gestionnaires imbriqués et accéder directement à la prochaine ligne de code dans le gestionnaire courant.
Lorsque le débogueur ignore un gestionnaire imbriqué, il exécute le gestionnaire, mais n’affiche
pas le code du gestionnaire et ne marque pas de pause dans le gestionnaire imbriqué.
Pour ignorer les gestionnaires imbriqués :
• Cliquez sur le bouton Exécuter le script pas à pas dans la fenêtre Débogueur.
Ce bouton exécute la ligne de code courante, ainsi que les gestionnaires imbriqués appelés par
la ligne, puis s’arrête sur la ligne suivante du gestionnaire.
Si vous suspectez un dysfonctionnement des gestionnaires imbriqués et souhaitez examiner leur
comportement, la fenêtre Débogueur vous permet également d’exécuter les gestionnaires imbriqués ligne par ligne.
Pour exécuter les gestionnaires imbriqués ligne par ligne :
• Cliquez sur le bouton Exécuter le script en détail dans la fenêtre Débogueur.
Un clic sur le bouton Exécuter le script en détail lance l’exécution de la ligne de code courante
et poursuit le flux normal dans les gestionnaires imbriqués appelés par l’intermédiaire de cette
ligne. Une fois le traitement d’un gestionnaire imbriqué terminé, la fenêtre Débogueur s’arrête
sur la prochaine ligne de code dans le gestionnaire de niveau supérieur.
Lorsque la procédure de débogage est terminée, vous pouvez quitter le Débogueur à tout
moment :
Pour reprendre l’exécution normale de code et quitter la fenêtre Débogueur :
• Cliquez sur le bouton Relancer le script.
Pour quitter le Débogueur et arrêter la lecture de l’animation :
• Cliquez sur le bouton Arrêter le débogage.
Débogage dans la fenêtre Débogueur
109
Edition de scripts en mode de débogage
Lorsque vous êtes en mode de débogage, vous pouvez éditer vos scripts directement dans la
fenêtre Débogueur. Ceci vous permet de corriger les erreurs dès que vous les rencontrez, puis
de poursuivre la procédure de débogage.
Pour éditer un script dans la fenêtre Débogueur :
1 Cliquez dans le volet Script et placez le point d’insertion à l’endroit où vous souhaitez
commencer à taper.
2 Apportez les modifications au script.
Vous pouvez passer directement à un gestionnaire spécifique en sélectionnant son nom et en
cliquant sur le bouton Passer au gestionnaire.
3 Lorsque la procédure de débogage et d’édition des scripts est terminée, cliquez sur le bouton
Arrêter le débogage. La fenêtre Script repasse en mode Script.
4 Cliquez sur le bouton Recompiler tous les scripts modifiés.
Débogage de projections et d’animations Shockwave
Cette section traite du débogage durant l’exécution dans les projections et les animations Director
qui comprennent un contenu Macromedia Shockwave. Vous pouvez utiliser la fenêtre Messages
ou activer les dialogues d’erreurs de script pour déboguer les projections et les animations
Shockwave.
Pour déboguer à l’aide de la fenêtre Messages :
• Donnez à la propriété debugPlaybackEnabled de l'objet Lecteur la valeur TRUE.
Lorsque cette propriété possède la valeur TRUE, la lecture d’une projection ou d’une animation
Shockwave ouvre une fenêtre Messages (Microsoft Windows) ou un fichier texte Messages
(Macintosh), et les résultats des appels de fonction put() ou trace() sont insérés dans ces
formats.
Si, à tout moment durant l’animation, vous donnez à la propriété debugPlaybackEnabled la
valeur FALSE, la fenêtre ou le fichier texte Messages se ferme et ne peut être rouverte durant
cette session de lecture, même si vous redonnez à la propriété debugPlaybackEnabled la
valeur TRUE plus tard.
Pour déboguer en activant les dialogues d’erreurs de script :
• Dans le fichier .ini d’une projection ou d’une animation Shockwave, donnez à la propriété
la valeur 1.
Vous créez ainsi, dans la boite de dialogue, un texte d’erreurs plus descriptif que le texte
d’erreurs générique. Par exemple, un message d’erreur générique peut avoir l’aspect suivant :
DisplayFullLingoErrorText
Erreur de script : Continuer ?
L’attribution de la valeur 1 à la propriété the DisplayFullLingoErrorText pourrait générer
le message d’erreur suivant :
Erreur de script : liste attendue
Pour obtenir des informations sur la création et la modification d’un fichier .ini pour une
projection ou une animation Shockwave, consultez le fichier modèle .ini de Director se
trouvant dans le dossier d’installation racine de Director.
110
Chapitre 4 : Débogage de scripts dans Director
Débogage avancé
Si le problème n’est pas facile à identifier, tentez les approches suivantes :
• Déterminez la section dans laquelle se situe le problème. Par exemple, si un clic sur un bouton
•
•
•
•
•
•
ne produit pas le résultat escompté, vérifiez le script affecté à ce bouton.
Si une image-objet exécute une action erronée, vérifiez les valeurs de propriété attachées à
l’image-objet. Sont-elles définies sur les valeurs souhaitées ?
Recherchez la séquence d’exécution du script. Lorsqu’une section de l’animation ne réagit pas
comme vous l’espériez, tâchez tout d’abord de retracer la séquence des événements de l’animation. Consultez les autres scripts dans la hiérarchie des messages pour vous assurer que Director
exécute le bon gestionnaire.
Consultez les informations de suivi dans la fenêtre Messages, qui présentent les images parcourues par l’animation, ainsi que les gestionnaires appelés au cours de la lecture de l’animation.
Essayez d’utiliser les fonctions Exécuter le script pas à pas et Exécuter le script en détail dans la
fenêtre Débogueur et voyez si les résultats diffèrent de ce que vous attendiez.
Vérifiez les variables et les expressions. Analysez le changement des valeurs lors de la lecture
de l’animation. Observez si elles changent au mauvais moment ou si elles ne changent pas du
tout. Si la même variable est utilisée dans plusieurs gestionnaires, assurez-vous que chaque
gestionnaire qui utilise la variable a défini cette variable comme globale.
Vous pouvez suivre les variables et les expressions en affichant leurs valeurs dans le volet
Surveillance de la fenêtre Débogueur ou dans l’inspecteur d’objet.
N’apportez qu’une modification à la fois. N’hésitez pas à apporter des modifications dans un
gestionnaire pour vérifier si les changements peuvent résoudre le problème ou produire des
résultats qui aident à le localiser.
Veillez toutefois à ne pas résoudre un problème en en créant un autre. Apportez une modification à la fois et annulez-la si le problème n’est pas résolu. Si vous apportez trop de modifications avant de résoudre un problème, vous risquez de ne plus pouvoir déterminer quel était le
problème initial, voire même d’en créer de nouveaux.
Recréez la section. Si vous ne trouvez pas de solution, tâchez de recréer la section depuis le
début. Par exemple, si une image-objet ne réagit pas correctement lorsque le pointeur la survole, créez une simple animation contenant uniquement cette image-objet et le gestionnaire,
avec la méthode rollOver().
Si vous copiez/collez simplement les scripts, cela risque de copier le problème. En revanche, si
vous recréez la section, vous serez amené à reconstruire la logique depuis son premier niveau, et
vous pourrez alors vérifier si Director réagit comme vous le souhaitez. Si la section que vous
avez recréée ne fonctionne toujours pas comme prévu, il se peut que l’erreur provienne de la
logique de la section.
Si la section que vous avez recréée fonctionne correctement, comparez-la avec l’animation
d’origine pour noter leurs différences. Vous pouvez également copier la section dans l’originale
et vérifier si le problème est résolu.
Débogage avancé
111
112
Chapitre 4 : Débogage de scripts dans Director
CHAPITRE 5
Objets principaux de Director
Les objets principaux de Macromedia Director MX 2004 donnent accès aux fonctionnalités et
options disponibles dans Director, les projections et Macromedia Shockwave Player. Les objets
principaux incluent le moteur du lecteur de Director, les fenêtres des animations, les imagesobjets, les sons, etc. Ils représentent la couche de base à travers laquelle on accède à tous les API et
autres catégories d’objets, à l’exception des objets de scripting qui étendent les fonctionnalités de
base de Director.
Pour voir comment les objets principaux sont liés entre eux et à d’autres objets de Director,
consultez Diagramme de modèles d’objets, page 59.
Acteur
Représente un acteur au sein d’une bibliothèque de distribution. Les acteurs sont les médias et les
éléments de script d’une animation. Les acteurs média peuvent être du texte, des bitmaps, des
formes, etc. Les acteurs script incluent les comportements, les scripts d’animation, etc.
Un acteur peut être référencé soit par numéro soit par nom.
• Lorsque vous faites référence à un acteur en utilisant son numéro, Director le recherche dans
•
une bibliothèque précise et en extrait les données. Cette méthode est plus rapide que celle qui
consiste à faire référence à l’acteur par son nom. Toutefois, vu que Director ne met pas à jour
automatiquement les références aux numéros d’acteurs dans le script, toute référence par
numéro à un acteur qui a changé de position dans sa bibliothèque de distribution sera rompue.
Lorsque vous faites référence à un acteur en utilisant son nom, Director effectue des recherches
dans toutes les bibiliothèques de distribution d’une animation, de la première à la dernière, et
extrait les données de l’acteur lorsqu’il trouve son nom. Cete méthode est plus lente que celle
qui consiste à faire référence au numéro de l’acteur, surtout lorsqu’il s’agit d’animations
contenant plusieurs bibliothèques de distribution et acteurs. Toutefois, une référence à un
nom d’acteur permet à cette dernière de rester intacte, même si l’acteur change de position
dans sa bibliothèque de distribution.
Vous pouvez créer une référence à une bibliothèque de distribution en utilisant la fonction de
haut niveau member() ou la propriété member de l’objet Distribution, Animation ou Image-objet.
113
Les exemples suivants illustrent la création d’une référence à un acteur.
• Utilisez la fonction de haut niveau member().
-- Syntaxe Lingo
objTree = member("arbreBmp")
// Syntaxe JavaScript
var objTree = member("arbreBmp");
• Utilisez la propriété member de l’objet Image-objet.
-- Syntaxe Lingo
objTree = sprite(1).member;
// Syntaxe JavaScript
var objTree = sprite(1).member;
Résumé des méthodes pour l’objet Acteur
Méthode
copyToClipBoard()
duplicate() (acteur)
erase()
importFileInto()
move()
pasteClipBoardInto()
preLoad() (acteur)
unLoad() (acteur)
Résumé des propriétés pour l’objet Acteur
Propriété
castLibNum
modifiedDate
comments
name
creationDate
number (acteur)
fileName (acteur)
purgePriority
height
rect (acteur)
hilite
regPoint
linked
scriptText
loaded
size
media
thumbNail
mediaReady
type (acteur)
modified
width
modifiedBy
114
Chapitre 5 : Objets principaux de Director
Voir aussi
Types de médias, member(), member (distribution), member (animation), member
(image-objet), Animation, Lecteur, Objets de scripting, Image-objet, Fenêtre
Animation
Représente une animation en cours d’exécution dans le lecteur de Director.
Le lecteur de Director peut contenir une ou plusieurs animations. Une animation peut contenir
une ou plusieurs bibliothèques. Une bibliothèque de distribution peut consister en un ou
plusieurs acteurs qui représentent des médias et des scripts dans une animation. Les acteurs média
peuvent être du texte, des bitmaps, des formes, etc. Les acteurs script incluent les comportements,
les scripts d’animation, etc. Les images-objets sont créées à partir d’acteurs et utilisées sur la scène
d’une animation.
Vous pouvez désigner l’animation en cours d’exécution en utilisant la propriété de haut niveau
une animation quelconque du lecteur en utilisant la propriété
_movie. Vous pouvez désigner
movie de l’objet Fenêtre.
• Désignez l’animation en cours d’exécution.
-- Syntaxe Lingo
objAnimation = _movie
// Syntaxe JavaScript
var objAnimation = _movie;
• Utilisez la propriété movie de l’objet Fenêtre pour accéder à l’animation d’une fenêtre donnée.
-- Syntaxe Lingo
objAnimation = _player.window[2].movie
// Syntaxe JavaScript
var objAnimation = _player.window[2].movie;
Dans Director MX 2004, vous pouvez non seulement utiliser une référence à une animation pour
accéder aux méthodes et propriétés de l’animation même, mais aussi appeler des gestionnaires
Lingo et JavaScript et accéder aux acteurs et images-objets de l’animation, y compris leurs
méthodes et propriétés. Cette procédure est différente des versions précédentes de Director dans
lesquelles vous deviez utiliser la commande tell pour accéder aux animations. L’objet Animation
constitue une manière simple de travailler sur les animations.
Remarque : La commande tell est obsolète dans Director MX 2004.
Résumé des méthodes pour l’objet Animation
Méthode
beginRecording()
newMember()
cancelIdleLoad()
preLoad() (animation)
clearFrame()
preLoadMember()
constrainH()
preLoadMovie()
constrainV()
printFrom()
delay()
puppetPalette()
deleteFrame()
puppetSprite()
115
Méthode (suite)
duplicateFrame()
puppetTempo()
endRecording()
puppetTransition()
finishIdleLoad()
ramNeeded()
frameReady() (animation)
rollOver()
go()
saveMovie()
goLoop()
sendAllSprites()
goNext()
sendSprite()
goPrevious()
stopEvent()
idleLoadDone()
unLoad() (animation)
insertFrame()
unLoadMember()
label()
unLoadMovie()
marker()
updateFrame()
mergeDisplayTemplate()
updateStage()
beginRecording()
newMember()
Résumé des propriétés pour l’objet Animation
Propriété
116
aboutInfo
frameTransition
active3dRenderer
idleHandlerPeriod
actorList
idleLoadMode
allowCustomCaching
idleLoadPeriod
allowGraphicMenu
idleLoadTag
allowSaveLocal
idleReadChunkSize
allowTransportControl
imageCompression
allowVolumeControl
imageQuality
allowZooming
keyboardFocusSprite
beepOn
lastChannel
buttonStyle
lastFrame
castLib
markerList
centerStage
member (animation)
copyrightInfo (animation)
name
displayTemplate
paletteMapping
dockingEnabled
path (animation)
editShortCutsEnabled
preferred3dRenderer
enableFlashLingo
preLoadEventAbort
Chapitre 5 : Objets principaux de Director
Propriété (suite)
exitLock
score
fileFreeSize
scoreSelection
fileSize
script
fileVersion
sprite (animation)
fixStageSize
stage
frame
timeoutList
frameLabel
traceLoad
framePalette
traceLogFile
frameScript
traceScript
frameSound1
updateLock
frameSound2
useFastQuads
frameTempo
xtraList (animation)
Voir aussi
_movie, Bibliothèque de distribution, Acteur, movie, Lecteur, Image-objet,
Fenêtre
Bibliothèque de distribution
Représente une seule bibliothèque de distribution dans une animation.
Une animation peut contenir une ou plusieurs bibliothèques. Une bibliothèque de distribution
peut consister en un ou plusieurs acteurs qui représentent des médias dans une animation, tels
que les sons, textes, graphiques et autres.
Vous pouvez créer une référence à une bibliothèque de distribution en utilisant la fonction de
haut niveau castLib() ou la propriété castLib de l’objet Animation. Par exemple, si une
animation contient une bibliothèque de distribution appelée scripts, vous pouvez créer une
référence à cette bibliothèque en procédant comme suit :
• Utilisez la méthode de haut niveau castLib().
-- Syntaxe Lingo
scriptBibli = castLib("scripts")
// Syntaxe JavaScript
var scriptBibli = castLib("scripts");
• Utilisez la propriété castLib de l’objet Animation.
-- Syntaxe Lingo
scriptBibli = _movie.castLib["scripts"]
// Syntaxe JavaScript
var scriptBibli = _movie.castLib["scripts"];
117
Résumé des méthodes pour l’objet Bibliothèque de distribution
Méthode
findEmpty()
Résumé des propriétés pour l’objet Bibliothèque de distribution
Propriété
fileName (distribution)
member (distribution)
name
number (distribution)
preLoadMode
selection
Voir aussi
castLib, castLib(), Acteur, Animation, Lecteur, Image-objet, Fenêtre
Fenêtre
Représente une fenêtre dans laquelle une animation est en cours d’exécution, dont la fenêtre
Scène et toute autre animation dans une fenêtre (MIAW) couramment utilisée.
Vous pouvez créer une référence à un objet Fenêtre en utilisant la fonction de haut niveau
window(), la propriété window de l’objet Lecteur ou la propriété windowList de l’objet Lecteur.
• Utilisez la méthode de haut niveau window().
-- Syntaxe Lingo
objFenêtre = window("Soleil")
// Syntaxe JavaScript
var objFenêtre = window("Soleil");
• Utilisez la propriété window de l’objet Lecteur.
-- Syntaxe Lingo
objFenêtre = _player.window["Soleil"]
// Syntaxe JavaScript
var objFenêtre = _player.window["Soleil"];
• Utilisez la propriété windowList de l’objet Lecteur.
-- Syntaxe Lingo
objFenêtre = _player.windowList[1]
// Syntaxe JavaScript
var objFenêtre = _player.windowList[1];
Remarque : Lorsque vous créez une référence au nom d’une fenêtre en utilisant soit la fonction de
haut niveau window() soit la propriété window de l’objet Lecteur, cette référence n’est créée que si une
fenêtre portant ce nom existe. Si une fenêtre de ce nom n’existe pas, la référence contient VOID
(Lingo) ou null (syntaxe JavaScript).
118
Chapitre 5 : Objets principaux de Director
Résumé des méthodes pour l’objet Fenêtre
Méthode
close()
moveToBack()
forget() (fenêtre)
moveToFront()
maximize()
open() (fenêtre)
mergeProps()
restore()
minimize()
Résumé des propriétés pour l’objet Fenêtre
Propriété
appearanceOptions
resizable
bgColor (fenêtre)
sizeState
dockingEnabled
sourceRect
drawRect
title (fenêtre)
fileName (fenêtre)
titlebarOptions
image (fenêtre)
type (fenêtre)
movie
visible
name
windowBehind
picture (fenêtre)
windowInFront
rect (fenêtre)
Voir aussi
Bibliothèque de distribution, Acteur, Animation, Lecteur, Image-objet,
window(), window, windowList
Global
Fournit un emplacement de stockage de variables globales. Ces variables sont disponibles dans
Lingo et la syntaxe JavaScript.
Vous pouvez accéder à l’objet Global en utilisant la propriété de haut niveau _global. Vous
pouvez soit affecter _global à une variable soit utiliser directement la propriété _global pour
accéder aux méthodes de l’objet Global et à toute variable globale définie.
• Affectez
_global
à une variable.
-- Syntaxe Lingo
objGlobal = _global
// Syntaxe JavaScript
var objGlobal = _global;
119
• Utilisez la propriété _global directement.
-- Syntaxe Lingo
_global.showGlobals()
// Syntaxe JavaScript
_global.showGlobals();
• Accédez à une variable globale.
-- Syntaxe Lingo
global gSuccess
...
on mouseDown
gSuccess = "Félicitations !"
put(_global.gSuccess) -- affiche
end"
"Félicitations!"
// Syntaxe JavaScript
_global.gSuccess = "Félicitations !";
...
function mouseDown() {
trace(_global.gSuccess); // affiche
}
"Félicitations !"
Résumé des méthodes pour l’objet Global
Méthode
clearGlobals()
showGlobals()
Voir aussi
_global
Image-objet
Représente une occurrence d’un acteur dans une piste d’image-objet du scénario.
Un objet Image-objet couvre une plage d’images-objets, c’est-à-dire la gamme d’images d’une
piste d’image-objet donnée. Un objet Piste d’image-objet représente une piste d’image-objet toute
entière, quel que soit le nombre d’images-objets qu’elle contient.
Une image-objet peut être référencée soit par numéro soit par nom.
• Lorsque vous faites référence à une image-objet par numéro, Director effectue une recherche
dans toutes les images-objets qui existent dans l’image courante du scénario, en commençant
par la piste dont le numéro est le plus bas, et extrait les données de l’image-objet lorsqu’il la
trouve. Cette méthode est plus rapide que celle qui consiste à faire référence à une image-objet
par son nom. Toutefois, vu que Director ne met pas à jour automatiquement les références aux
numéros d’images-objets dans le script, toute référence par numéro à une image-objet qui a
changé de position dans la scène sera rompue.
120
Chapitre 5 : Objets principaux de Director
• Lorsque vous désignez une image-objet par son nom, Director fait une recherche dans toutes
les images-objets qui existent dans l’image courante du scénario, en commençant par la piste
portant le numéro le plus bas, et extrait les données de l’image-objet lorsqu’il la trouve. Cete
méthode est plus lente que celle qui consiste à faire référence au numéro de l’image-objet,
surtout lorsqu’il s’agit d’animations contenant plusieurs bibliothèques de distribution, acteurs
et images-objets. Toutefois, une référence à un nom d’image-objet permet à cette référence de
rester intacte, même si l’image-objet change de position sur la scène.
Vous pouvez créer une référence à un objet Image-objet en utilisant la fonction de haut niveau
la propriété sprite de l’objet Animation ou la propriété sprite de l’objet Piste
d’image-objet.
sprite(),
• Utilisez la fonction de haut niveau sprite().
-- Syntaxe Lingo
objImageObjet = sprite(1)
// Syntaxe JavaScript
var objImageObjet = sprite(1);
• Utilisez la propriété sprite de l’objet Animation.
-- Syntaxe Lingo
objImageObjet = _movie.sprite["saule"]
// Syntaxe JavaScript
var objImageObjet = _movie.sprite["saule"];
• Utilisez la propriété sprite de l’objet Piste d’image-objet.
-- Syntaxe Lingo
objImageObjet = channel(3).sprite
// Syntaxe JavaScript
var objImageObjet = channel(3).sprite;
Vous pouvez utiliser une référence à un objet Image-objet pour accéder à l’acteur à partir duquel
l’image-objet a été créée. Toute modification effectuée sur l’acteur à partir duquel une imageobjet a été créée est également reflétée dans l’image-objet. L’exemple suivant illustre la
modification du texte d’un acteur texte à partir duquel l’image-objet 5 a été créée. Ce changement
apporté à l’acteur sera également reflété dans l’image-objet 5.
-- Syntaxe Lingo
labelText = sprite(5)
labelText.member.text = "Saule pleureur"
// Syntaxe JavaScript
var labelText = sprite(5);
labelText.member.text = "Saule pleureur";
121
Résumé des propriétés pour l’objet Image-objet
Propriété
backColor
locV
blend (image-objet)
locZ
bottom
member (image-objet)
constraint
name (image-objet)
cursor
quad
editable
rect (image-objet)
endFrame
right
flipH
rotation
flipV
skew
foreColor
spriteNum
height
startFrame
ink
top
left
width
locH
Voir aussi
Bibliothèque de distribution, Acteur, Animation, Lecteur, sprite (animation),
sprite (piste d’image-objet), sprite(), Piste d’image-objet, Fenêtre
Lecteur
Représente le moteur de lecture principal utilisé pour gérer et exécuter l’environnement auteur,
les animations dans une fenêtre (MIAW), les projections et Shockwave Player.
L’objet Lecteur donne accès à toutes les animations et fenêtres qu’il gère, en plus des Xtras
disponibles.
Vous pouvez créer une référence à l’objet Lecteur en utilisant la propriété de haut niveau
_player.
• Affectez_player à une variable.
-- Syntaxe Lingo
objLecteur = _player
// Syntaxe JavaScript
var objLecteur = _player;
• Utilisez la propriété _player directement.
-- Syntaxe Lingo
_player.alert("L’animation est terminée.")
// Syntaxe JavaScript
_player.alert("L’animation est terminée.");
122
Chapitre 5 : Objets principaux de Director
Résumé des méthodes pour l’objet Lecteur
Méthode
alert()
getPref()
appMinimize()
halt()
cursor()
open() (lecteur)
externalParamName()
quit()
externalParamValue()
setPref()
flushInputEvents()
windowPresent()
Résumé des propriétés pour l’objet Lecteur
Propriété
activeCastLib
netThrottleTicks
activeWindow
organizationName
alertHook
productName
applicationName
productVersion
applicationPath
safePlayer
currentSpriteNum
scriptingXtraList
debugPlaybackEnabled
searchCurrentFolder
digitalVideoTimeScale
searchPathList
disableImagingTransformation
serialNumber
emulateMultibuttonMouse
sound (lecteur)
externalParamCount
switchColorDepth
frontWindow
toolXtraList
inlineImeEnabled
transitionXtraList
lastClick
userName
lastEvent
window
lastKey
window
lastRoll
xtra
mediaXtraList
xtraList (lecteur)
netPresent
Voir aussi
_player, Bibliothèque de distribution, Acteur, Animation, Image-objet, Fenêtre
123
Piste audio
Représente une piste audio individuelle au sein de l’objet Son.
Les pistes audio disponibles sont au nombre de huit. Vous pouvez utiliser un objet Piste audio
dans un script pour accéder à l’une des huit pistes audio et la modifier.
Remarque : Vous ne pouvez modifier que les deux premières pistes audio dans le scénario de
l’interface utilisateur de Director.
Vous pouvez créer une référence à un objet Piste audio en utilisant la méthode de haut niveau
sound(), la propriété sound de l’objet Lecteur ou la méthode channel() de l’objet Son. Par
exemple, vous pouvez faire référence à la piste audio 2 comme suit :
• Utilisez la méthode de haut niveau sound().
-- Syntaxe Lingo
objPisteAudio = sound(2)
// Syntaxe JavaScript
var objPisteAudio = sound(2);
• Utilisez la propriété sound de l’objet Lecteur.
-- Syntaxe Lingo
objPisteAudio = _player.sound[2]
// Syntaxe JavaScript
var objPisteAudio = _player.sound[2];
• Utilisez la méthode channel() de l’objet Son.
-- Syntaxe Lingo
objPisteAudio = _sound.channel(2)
// Syntaxe JavaScript
var objPisteAudio = _sound.channel(2);
Résumé des méthodes pour l’objet Piste audio
Méthode
breakLoop()
playFile()
fadeIn()
playNext() (piste audio)
fadeOut()
queue()
fadeTo()
rewind() (piste audio)
getPlayList()
setPlayList()
pause() (piste audio)
stop() (piste audio)
play() (piste audio)
Résumé des propriétés pour l’objet Piste audio
Propriété
124
channelCount
member (piste audio)
elapsedTime
pan
Chapitre 5 : Objets principaux de Director
Propriété (suite)
endTime
sampleCount
loopCount
sampleRate
loopEndTime
startTime
loopsRemaining
status
loopStartTime
volume (piste audio)
Voir aussi
channel() (audio), sound (lecteur), sound(), Son
Piste d’image-objet
Représente une piste d’image-objet individuelle dans le scénario.
Un objet Image-objet couvre une plage d’images-objets, c’est-à-dire la gamme d’images d’une
piste d’image-objet donnée. Un objet Piste d’image-objet représente une piste d’images-objets
toute entière, quel que soit le nombre d’images-objets qu’elle contient.
Les pistes d’images-objets sont contrôlées par le scénario par défaut. Utilisez l’objet Piste d’imageobjet pour faire passer le contrôle d’une piste d’image-objet au script lors d’une séance d’enregistrement de scénario.
Une piste d’image-objet peut être référencée soit par numéro soit par nom.
• Lorsque vous désignez une piste d’image-objet par son numéro, vous accédez directement à la
•
piste. Cette méthode est plus rapide que celle qui consiste à faire référence à une piste d’imageobjet par son nom. Toutefois, vu que Director ne met pas à jour automatiquement les références aux numéros des piste d’images-objets dans le script, toute référence par numéro à une piste
d’image-objet qui a changé de position dans la scène sera rompue.
Lorsque vous désignez une piste d’image-objet par son nom, Director fait une recherche dans
toutes les pistes, en commençant par la piste portant le numéro le plus bas, et extrait les données de la piste d’image-objet lorsqu’il la trouve. Cete méthode est plus lente que celle qui consiste à faire référence au numéro de la piste d’image-objet, surtout lorsqu’il s’agit d’animations
contenant plusieurs bibliothèques de distribution, acteurs et images-objets. Toutefois, une
référence à une piste d’image-objet permet à cette référence de rester intacte, même si la piste
d’image-objet change de position dans le scénario.
Vous pouvez créer une référence à une piste d’image-objet en utilisant la méthode de haut niveau
channel().
• Utilisez la méthode de haut niveau channel().
-- Syntaxe Lingo
objPisteImageObjet = channel(2)
// Syntaxe JavaScript
var objPisteImageObjet = channel(2);
125
Vous pouvez utiliser une référence à un objet Piste d’image-objet pour accéder à l’image-objet
couramment utilisée dans une piste d’image-objet particulière. L’exemple suivant illustre l’accès à
la couleur de fond de l’image-objet couramment utilisée dans la piste d’image-objet 2.
-- Syntaxe Lingo
libelléImageObjet = channel(2).sprite.backColor
// Syntaxe JavaScript
var libelléImageObjet = channel(2).sprite.backColor;
Résumé des méthodes pour l’objet Piste d’image-objet
Méthode
makeScriptedSprite()
removeScriptedSprite()
Résumé des propriétés pour l’objet Piste d’image-objet
Propriété
name (piste d’image-objet)
number (piste d'image-objet)
scripted
sprite (piste d’image-objet)
Voir aussi
Bibliothèque de distribution, channel() (niveau supérieur), Acteur, Animation,
Lecteur, Image-objet, Fenêtre
Son
Contrôle la lecture audio dans les huit pistes audio disponibles.
L’objet Son consiste en huit objets Piste audio représentant des pistes audio individuelles.
Vous pouvez créer une référence à l’objet Son en utilisant la propriété de haut niveau _sound.
• Affectez_sound à une variable.
-- Syntaxe Lingo
objSon = _sound
// Syntaxe JavaScript
var objSon = _sound;
• Utilisez la propriété _sound pour accéder à la propriété soundDevice de l’objet Son.
-- Syntaxe Lingo
objPériph = _sound.soundDevice
// Syntaxe JavaScript
var objPériph = _sound.soundDevice;
126
Chapitre 5 : Objets principaux de Director
Résumé des méthodes pour l’objet Son
Méthode
beep()
channel() (audio)
Résumé des propriétés pour l’objet Son
Propriété
soundDevice
soundDeviceList
soundEnabled
soundKeepDevice
soundLevel
soundMixMedia
Voir aussi
_sound, Piste audio
Souris
Permet d’accéder à l’activité d’un utilisateur liée à la souris, y compris les mouvements et les clics
de souris.
Vous pouvez accéder à l’objet Souris en utilisant la propriété de haut niveau _mouse. Vous pouvez
soit affecter _mouse à une variable soit utiliser directement la propriété _mouse pour accéder aux
propriétés de l’objet Souris.
• Affectez
_mouse
à une variable.
-- Syntaxe Lingo
objSouris = _mouse
// Syntaxe JavaScript
var objSouris = _mouse;
• Utilisez la propriété _mouse directement.
-- Syntaxe Lingo
doubleClic = _mouse.doubleClick
// Syntaxe JavaScript
var doubleClic = _mouse.doubleClick;
Résumé des propriétés pour l’objet Souris
Propriété
clickLoc
mouseLoc
clickOn
mouseMember
doubleClick
mouseUp
127
Propriété (suite)
mouseChar
mouseV
mouseDown
mouseWord
mouseH
rightMouseDown
mouseItem
rightMouseUp
mouseLine
stillDown
Voir aussi
_mouse
Système
Donne accès aux informations sur le système et l’environnement, à commencer par les méthodes
de niveau du système.
Vous pouvez créer une référence à l’objet Système en utilisant la propriété de haut niveau
_system.
• Affectez _system à une variable.
-- Syntaxe Lingo
objSystème = _system
// Syntaxe JavaScript
var objSystème = _system;
• Utilisez la propriété _system directement.
-- Syntaxe Lingo
dateSystème = _system.date()
// Syntaxe JavaScript
var dateSystème = _system.date();
Résumé des méthodes pour l’objet Système
Méthode
date() (Système)
restart()
shutDown()
time() (Système)
128
Chapitre 5 : Objets principaux de Director
Résumé des propriétés pour l’objet Système
Propriété
colorDepth
deskTopRectList
environmentPropList
milliseconds
Voir aussi
_system
Touche
Utilisé pour contrôler l’activité d’un utilisateur au clavier.
Vous pouvez accéder à l’objet Touche en utilisant la propriété de haut niveau _key. Vous pouvez
soit affecter _key à une variable soit utiliser directement la propriété _key pour accéder aux
méthodes et propriétés de l’objet Touche.
• Affectez
_key
à une variable.
-- Syntaxe Lingo
objTouche = _key
// Syntaxe JavaScript
var objTouche = _key;
• Utilisez directement la propriété _key.
-- Syntaxe Lingo
ctrlEnfoncée = _key.controlDown
// Syntaxe JavaScript
var ctrlEnfoncée = _key.controlDown;
Résumé des méthodes pour l’objet Touche
Méthode
keyPressed()
129
Résumé des propriétés pour l’objet Touche
Propriété
commandDown
controlDown
key
keyCode
optionDown
shiftDown
Voir aussi
_key
130
Chapitre 5 : Objets principaux de Director
CHAPITRE 6
Types de médias
Les types de médias de Director MX 2004 de Macromedia donnent accès aux fonctionnalités des
divers types de médias (RealMedia, DVD, GIF animé, etc.), qui sont ajoutés aux animations en
tant qu’acteurs.
Les médias ne sont pas réellement 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 voir comment les types de médias d’acteurs sont liés entre eux et à d’autres objets de
Director, consultez Diagramme de modèles d’objets, page 59.
Animation Flash
Représente un acteur ou une image-objet renfermant un contenu Flash.
Vous pouvez ajouter un acteur d’animation Flash à une animation en utilisant la méthode
newMember() de l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#flash)
// Syntaxe JavaScript
_movie.newMember("flash");
Un acteur ou une image-objet Flash peut également contenir des composants Flash. Les
composants Flash fournissent des fonctionnalités qui étendent les fonctionnalités existantes des
acteurs ou des images-objets Flash. Pour plus d’informations sur les composants Flash pris en
charge par Director, consultez Composant Flash, page 136.
Certaines des méthodes ou propriétés suivantes s’appliquent uniquement aux images-objets créées
à partir d’un acteur d’animation Flash.
131
Résumé des méthodes pour le type de média Animation Flash
Méthode
callFrame()
printAsBitmap()
clearAsObjects()
rewind() (GIF animé, Flash)
clearError()
setCallback()
findLabel()
setFlashProperty()
flashToStage()
settingsPanel()
getFlashProperty()
setVariable()
getVariable()
showProps()
goToFrame()
stageToFlash()
hitTest()
stop() (Flash)
hold()
stream()
newObject()
tellTarget()
print()
Résumé des propriétés pour le type de média Animation Flash
Propriété
actionsEnabled
originPoint
broadcastProps
originV
bufferSize
playBackMode
buttonsEnabled
playing
bytesStreamed
posterFrame
centerRegPoint
quality
clickMode
rotation
defaultRect
scale (acteur)
defaultRectMode
scaleMode
eventPassMode
sound (lecteur)
fixedRate
static
flashRect
streamMode
frameCount
streamSize
imageEnabled
viewH
linked
viewPoint
mouseOverButton
viewScale
originH
viewV
originMode
132
Chapitre 6 : Types de médias
Voir aussi
Composant Flash, Acteur
Animation liée
Représente un acteur d’animation liée.
Vous pouvez ajouter un acteur d’animation liée à une animation en utilisant la méthode
newMember() de l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#movie)
// Syntaxe JavaScript
_movie.newMember("movie");
Résumé des propriétés pour le type de média Animation liée
Propriété
scriptsEnabled
Voir aussi
Acteur
Bitmap
Représente un acteur bitmap.
Utilisez les objets image bitmaps pour effectuer de simples opérations affectant le contenu d’un
acteur bitmap telles que le changement des couleurs de fond et de premier plan de l’acteur ou
pour effectuer une délicate manipulation des pixels d’une image telle que le recadrage, le dessin et
la copie de pixels.
Vous pouvez ajouter un acteur bitmap à une animation en utilisant la méthode newMember() de
l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#bitmap)
// Syntaxe JavaScript
_movie.newMember("bitmap");
Certaines des méthodes ou propriétés suivantes s’appliquent uniquement aux images-objets créées
à partir d’un acteur bitmap.
Résumé des méthodes pour le type de média Bitmap
Méthode
crop() (Image)
pictureP()
133
Résumé des propriétés pour le type de média Bitmap
Propriété
alphaThreshold
imageCompression
backColor
imageQuality
blend (image-objet)
palette
depth (Bitmap)
picture (acteur)
dither
rect (image)
foreColor
trimWhiteSpace
image (image)
useAlpha
Voir aussi
Acteur
Boucle d’animation
Représente un acteur boucle d’animation.
Vous pouvez ajouter un acteur boucle d’animation à une animation en utilisant la méthode
newMember() de l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#filmloop)
// Syntaxe JavaScript
_movie.newMember("filmloop");
Résumé des propriétés pour le type de média Boucle d’animation
Propriété
media
regPoint
Voir aussi
Acteur
Bouton
Représente un acteur bouton ou case à cocher.
Vous pouvez ajouter un acteur bouton à une animation en utilisant la méthode newMember() de
l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#button)
// Syntaxe JavaScript
_movie.newMember("button");
134
Chapitre 6 : Types de médias
Résumé des propriétés pour le type de média Bouton
Propriété
hilite
Voir aussi
Acteur
Champ
Représente un acteur champ.
Vous pouvez ajouter un acteur champ à une animation en utilisant la méthode newMember() de
l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#field)
// Syntaxe JavaScript
_movie.newMember("field");
Résumé des méthodes pour le type de média Champ
Méthode
charPosToLoc()
pointToItem()
lineHeight()
pointToLine()
linePosToLocV()
pointToParagraph()
locToCharPos()
pointToWord()
locVToLinePos()
scrollByLine()
pointToChar()
scrollByPage()
Résumé des propriétés pour le type de média Champ
Propriété
alignment
fontStyle
autoTab
lineCount
border
margin
boxDropShadow
pageHeight
boxType
scrollTop
dropShadow
selEnd
editable
selStart
font
text
fontSize
wordWrap
Voir aussi
Acteur
135
Composant Flash
Représente un composant Macromedia Flash imbriqué dans un acteur ou une image-objet
comprenant un contenu Flash.
Un composant Flash offre des fonctionnalités qui étendent les fonctionnalités existantes des
acteurs ou des images-objets comprenant du contenu Flash. Ils sont créés et supportés entièrement par la communauté de développement de Director.
Director prend en charge les composants Flash suivants :
Composant Flash
Description
Button
Bouton d’interface utilisateur rectangulaire redimensionnable.
CheckBox
Partie importante de toute forme d’application ; vous pouvez l’utiliser à chaque
fois que vous avez besoin de rassembler un ensemble de valeurs true ou
false qui ne sont pas mutuellement exclusives.
DateChooser
Calendrier permettant à un utilisateur de choisir une date.
label
Une ligne de texte.
List
Liste défilante à un ou plusieurs choix.
NumericStepper
Permet à un utilisateur de parcourir un ensemble de numéros ordonnés.
RadioButton
Composante essentielle de toute forme d’application web : vous pouvez
l’utiliser à chaque fois que vous voulez faire un choix parmi un groupe
d’options.
ScrollPane
Affiche des clips, des fichiers JPEG et des fichiers SWF dans une zone à
défilement.
TextArea
Champ de texte à plusieurs lignes.
TextInput
Composant à une seule ligne qui entoure l’objet TextField natif d’ActionScript.
Tree
Permet à un utilisateur de visualiser des données hiérarchiques.
Un composant Flash a accès aux mêmes API que ceux auxquels accède un acteur ou une imageobjet Flash normal, en plus des fonctionnalités se rapportant à ce composant. Pour plus
d’informations sur l’utilisation de ces composants Flash, consultez les rubriques Utilisation
de Director dans le panneau d’aide de Director.
Vous pouvez ajouter un acteur de composant Flash à une animation en utilisant la méthode
newMember() de l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#flashcomponent)
// Syntaxe JavaScript
_movie.newMember("flashcomponent");
Voir aussi
Animation Flash, Acteur
136
Chapitre 6 : Types de médias
Curseur
Représente un acteur curseur.
Vous pouvez ajouter un acteur curseur à une animation en utilisant la méthode newMember() de
l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#cursor)
// Syntaxe JavaScript
_movie.newMember("cursor");
Résumé des propriétés pour le type de média Curseur
Propriété
castMemberList
cursorSize
hotSpot
interval
Voir aussi
Acteur
DVD
Représente un acteur DVD.
Vous pouvez ajouter un acteur DVD à une animation en utilisant la méthode newMember() de
l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#dvd)
// Syntaxe JavaScript
_movie.newMember("dvd");
Certaines des méthodes ou propriétés suivantes s’appliquent uniquement aux images-objets créées
à partir d’un acteur DVD.
Résumé des événements pour le type de média DVD
Les événements DVD suivants sont toujours pris en charge par un gestionnaire d’événement
DVDeventNotification. Lorsque l’un de ces événements se produit, le gestionnaire d’événement
DVDeventNotification le reçoit sous forme de paramètre. Certains de ces événements contiennent également d’autres informations qui sont transmises sous forme de deuxième ou troisième
paramètre à DVDeventNotification. Pour plus d’informations sur l’utilisation des événements
suivants avec le gestionnaire DVDeventNotification, consultez on DVDeventNotification,
page 179.
Evénement
angleChange
noFirstPlayChain
audioStreamChange
parentalLevelChange
137
Evénement (suite)
buttonChange
playbackStopped
chapterAutoStop
playPeriodAutoStop
chapterStart
rateChange
diskEjected
stillOff
diskInserted
stillOn
domainChange
titleChange
error
UOPchange
karaokeMode
warning
Résumé des méthodes pour le type de média DVD
Méthode
activateAtLoc()
selectAtLoc()
activateButton()
selectButton()
frameStep()
selectButtonRelative()
pause() (DVD)
stop() (DVD)
play() (DVD)
subPictureType()
returnToTitle()
titleMenu()
rootMenu()
Résumé des propriétés pour le type de média DVD
Propriété
138
angle (DVD)
duration (DVD)
angleCount
folder
aspectRatio
frameRate (DVD)
audio (DVD)
fullScreen
audioChannelCount
mediaStatus (DVD)
audioExtension
playRate (DVD)
audioFormat
resolution (DVD)
audioSampleRate
selectedButton
audioStream
startTimeList
audioStreamCount
stopTimeList
buttonCount
subPicture
chapter
subPictureCount
chapterCount
title (DVD)
closedCaptions
titleCount
Chapitre 6 : Types de médias
Propriété (suite)
currentTime (DVD)
videoFormat
domain
volume (DVD)
Voir aussi
Acteur
Forme vectorielle
Représente un acteur forme vectorielle.
Vous pouvez ajouter un acteur forme vectorielle à une animation en utilisant la méthode
newMember() de l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#vectorshape)
// Syntaxe JavaScript
_movie.newMember("vectorshape");
Certaines des méthodes ou propriétés suivantes s’appliquent uniquement aux images-objets créées
à partir d’un acteur forme vectorielle.
Résumé des méthodes pour le type de média Forme vectorielle
Méthode
addVertex()
deleteVertex()
moveVertex()
moveVertexHandle()
newCurve()
showProps()
Résumé des propriétés pour le type de média Forme vectorielle
Propriété
antiAlias
imageEnabled
backgroundColor
originH
broadcastProps
originMode
centerRegPoint
originPoint
closed
originV
curve
regPointVertex
defaultRect
scale (acteur)
defaultRectMode
scaleMode
endColor
strokeColor
139
Propriété (suite)
fillColor
strokeWidth
fillCycles
vertex
fillDirection
vertexList
fillMode
viewH
fillOffset
viewPoint
fillScale
viewScale
flashRect
viewV
gradientType
Voir aussi
Acteur
GIF animé
Représente un acteur GIF animé.
Vous pouvez ajouter un acteur GIF animé à une animation en utilisant la méthode newMember()
de l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#animgif)
// Syntaxe JavaScript
_movie.newMember("animgif");
Certaines des méthodes ou propriétés suivantes s’appliquent uniquement aux images-objets créées
à partir d’un acteur GIF animé.
Résumé des méthodes pour le type de média GIF animé
Méthode
resume()
rewind() (GIF animé, Flash)
Résumé des propriétés pour le type de média GIF animé
Propriété
directToStage
frameRate
linked
path (animation)
playBackMode
Voir aussi
Acteur
140
Chapitre 6 : Types de médias
Palette de couleurs
Représente la palette de couleurs associée à un acteur bitmap.
Une acteur palette de couleurs n’a aucune méthode ou propriété à laquelle il est possible d’accéder
directement. Les méthodes et propriétés suivantes sont simplement associées aux palettes de
couleurs.
Vous pouvez ajouter un acteur palette de couleurs à une animation en utilisant la méthode
newMember() de l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#palette)
// Syntaxe JavaScript
_movie.newMember("palette");
Vous pouvez associer un acteur bitmap à un acteur palette de couleurs à l’aide de la propriété
palette de l’acteur bitmap. L’exemple suivant attribut la propriété palette de l’acteur bitmap
acteurBmp à l’acteur palette de couleurs acteurPaletteDeCouleurs. La valeur de la propriété
palette reflète le numéro de l’acteur palette de couleurs.
-- Syntaxe Lingo
member("acteurBmp").palette = member("acteurPaletteDeCouleurs")
// Syntaxe JavaScript
member("acteurBmp").palette = member("acteurPaletteDeCouleurs");
Après avoir associé un acteur bitmap à un acteur palette de couleurs, vous ne pouvez pas
supprimer l’acteur palette de couleurs avant d’avoir supprimé son association à l’acteur bitmap.
Résumé des méthodes pour le type de média Palette de couleurs
Méthode
color()
Résumé des propriétés pour le type de média Palette de couleurs
Propriété
depth (Bitmap)
palette
paletteMapping
Voir aussi
Bitmap, Acteur, palette
141
Police
Représente un acteur police.
Vous pouvez ajouter un acteur police à une animation en utilisant la méthode newMember() de
l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#font)
// Syntaxe JavaScript
_movie.newMember("font");
Résumé des propriétés pour le type de média Police
Propriété
bitmapSizes
characterSet
fontStyle
originalFont
recordFont
Voir aussi
Acteur
QuickTime
Représente un acteur QuickTime.
Vous pouvez ajouter un acteur QuickTime à une animation en utilisant la méthode newMember()
de l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#quicktimemedia)
// Syntaxe JavaScript
_movie.newMember("quicktimemedia");
Certaines des méthodes ou propriétés suivantes s’appliquent uniquement aux images-objets créées
à partir d’un acteur QuickTime.
Résumé des méthodes pour le type de média QuickTime
Méthode
142
enableHotSpot()
trackEnabled
getHotSpotRect()
trackNextKeyTime
nudge()
trackNextSampleTime
ptToHotSpotID()
trackPreviousKeyTime
quickTimeVersion()
trackPreviousSampleTime
qtRegisterAccessKey()
trackStartTime (acteur)
Chapitre 6 : Types de médias
Méthode (suite)
qtUnRegisterAccessKey()
trackStopTime (acteur)
setTrackEnabled()
trackText
swing()
trackType (acteur)
trackCount (acteur)
Résumé des propriétés pour le type de média QuickTime
Propriété
fieldOfView
nodeType
hotSpotEnterCallback
pan (propriété QTVR)
hotSpotExitCallback
percentStreamed (acteur)
invertMask
preLoad (acteur)
isVRMovie
rotation
loopBounds
scale (acteur)
mask
staticQuality
motionQuality
tilt
mouseLevel
translation
node
triggerCallback
nodeEnterCallback
warpMode
nodeExitCallback
Voir aussi
Acteur
RealMedia
Représente un acteur RealMedia.
Vous pouvez ajouter un acteur RealMedia à une animation en utilisant la méthode newMember()
de l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#realmedia)
// Syntaxe JavaScript
_movie.newMember("realmedia");
Certaines des méthodes ou propriétés suivantes s’appliquent uniquement aux images-objets créées
à partir d’un acteur RealMedia.
143
Résumé des méthodes pour le type de média RealMedia
Méthode
pause() (RealMedia, SWA, Windows Media)
play() (RealMedia, SWA, Windows Media)
realPlayerNativeAudio()
realPlayerPromptToInstall()
realPlayerVersion()
seek()
stop() (RealMedia, SWA, Windows Media)
Résumé des propriétés pour le type de média RealMedia
Propriété
audio (RealMedia)
password
currentTime (RealMedia)
pausedAtStart (RealMedia, Windows Media)
displayRealLogo
percentBuffered
duration (RealMedia, SWA)
soundChannel (RealMedia)
image (RealMedia)
state (RealMedia)
lastError
userName (RealMedia)
mediaStatus (RealMedia, Windows Media)
video (RealMedia, Windows Media)
Voir aussi
Acteur
Shockwave 3D
Représente un acteur Macromedia Shockwave 3D.
Un acteur Shockwave 3D (ou, tout simplement, 3D) est différent des autres acteurs car il contient
un univers 3D complet. Un univers 3D contient un ensemble d’objets propres aux acteurs 3D
vous permettant d’ajouter des fonctionnalités 3D à une animation.
Vous pouvez ajouter un acteur 3D à une animation en utilisant la méthode newMember() de
l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#shockwave3d)
// Syntaxe JavaScript
_movie.newMember("shockwave3d");
Pour plus d’informations sur les objets et API dont disposent les acteurs 3D, consultez le
Chapitre 8, Objets 3D, page 153.
Voir aussi
Acteur
144
Chapitre 6 : Types de médias
Shockwave Audio
Représente un acteur Shockwave Audio.
Vous pouvez ajouter un acteur Shockwave Audio à une animation en utilisant la méthode
newMember() de l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#swa)
// Syntaxe JavaScript
_movie.newMember("swa");
Résumé des événements pour le type de média Shockwave Audio
Evénements
on cuePassed
Résumé des méthodes pour le type de média Shockwave Audio
Méthode
getError() (Flash, SWA)
getErrorString()
isPastCuePoint()
pause() (RealMedia, SWA, Windows Media)
play() (RealMedia, SWA, Windows Media)
preLoadBuffer()
stop() (RealMedia, SWA, Windows Media)
Résumé des propriétés pour le type de média Shockwave Audio
Propriété
bitRate
percentStreamed (acteur)
bitsPerSample
preLoadTime
channelCount
sampleRate
copyrightInfo (SWA)
sampleSize
cuePointNames
soundChannel (SWA)
cuePointTimes
state (Flash, SWA)
duration (RealMedia, SWA)
streamName
loop (acteur)
URL
mostRecentCuePoint
volume (acteur)
numChannels
Voir aussi
Acteur
145
Son
Représente un acteur utilisé pour stocker et faire référence à des échantillons de sons.
Les échantillons de sons sont contrôlés par les objets de base Son et Piste audio. Un acteur son ne
possède pas d’API et utilise les API des objets Son et Piste audio pour contrôler son
comportement.
Vous pouvez ajouter un acteur son à une animation en utilisant la méthode newMember() de
l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#sound)
// Syntaxe JavaScript
_movie.newMember("sound");
Pour plus d’informations sur les objets et API que vous pouvez utiliser pour contrôler des
échantillons de sons, consultez Son, page 126 et Piste audio, page 124.
Voir aussi
Acteur
Texte
Représente un acteur texte.
Vous pouvez ajouter un acteur texte à une animation en utilisant la méthode newMember() de
l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#text)
// Syntaxe JavaScript
_movie.newMember("text");
Résumé des événements pour le type de média Texte
Evénement
on hyperlinkClicked
Résumé des méthodes pour le type de média Texte
Méthode
count()
pointInHyperlink()
pointToChar()
pointToItem()
pointToLine()
pointToParagraph()
pointToWord()
146
Chapitre 6 : Types de médias
Résumé des propriétés pour le type de média Texte
Propriété
antiAlias
hyperlink
antiAliasThreshold
hyperlinkRange
bottomSpacing
hyperlinks
charSpacing
hyperlinkState
firstIndent
kerning
fixedLineSpace
kerningThreshold
font
RTF
fontStyle
selectedText
HTML
useHypertextStyles
Voir aussi
Acteur
Windows Media
Représente un acteur Windows Media.
Vous pouvez ajouter un acteur Windows Media à une animation en utilisant la méthode
newMember() de l’objet Animation.
-- Syntaxe Lingo
_movie.newMember(#windowsmedia)
// Syntaxe JavaScript
_movie.newMember("windowsmedia");
Certaines des méthodes ou propriétés suivantes s’appliquent uniquement aux images-objets créées
à partir d’un acteur Windows Media.
Résumé des méthodes pour le type de média Windows Media
Méthode
pause() (RealMedia, SWA, Windows Media)
play() (RealMedia, SWA, Windows Media)
playFromToTime()
rewind() (Windows Media)
stop() (RealMedia, SWA, Windows Media)
147
Résumé des propriétés pour le type de média Windows Media
propriété
audio (Windows Media)
pausedAtStart (RealMedia, Windows Media)
directToStage
playRate (Windows Media)
duration (acteur)
video (RealMedia, Windows Media)
height
volume (image-objet)
loop (Windows Media)
width
mediaStatus (RealMedia, Windows Media)
Voir aussi
Acteur
148
Chapitre 6 : Types de médias
CHAPITRE 7
Objets de scripting
Les objets de scripting, également connus sous le nom d'extensions Xtra dans Macromedia
Director MX 2004 fournissent l’accès à la fonctionnalité des composants du logiciel qui sont
installés avec Director et étendent la fonctionnalité principale de celui-ci. 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 voir comment les objets de scripting sont liés les uns aux autres, ainsi qu'aux autres objets
de Director, veuillez consulter Diagramme de modèles d’objets, page 59.
Fileio
Permet d’effectuer des opérations d’entrée et de sortie de fichier.
Vous pouvez créer une référence à un objet Fileio à l’aide de l’opérateur new.
-- Syntaxe Lingo
objFileio = new xtra("fileio")
// Syntaxe JavaScript
var objFileio = new xtra("fileio");
Résumé des méthodes pour l’objet Fileio
Méthode
closeFile()
readFile()
createFile()
readLine()
delete()
readToken()
displayOpen()
readWord()
displaySave()
setFilterMask()
error()
setFinderInfo()
fileName()
setNewLineConversion()
getFinderInfo()
setPosition()
getLength()
status()
getOSDirectory()
version()
149
Méthode (suite)
getPosition()
writeChar()
openFile()
writeReturn()
readChar()
writeString()
NetLingo
Permet d’effectuer des opérations de réseau comme par exemple, obtenir ou lire en continu
un support à partir d’un réseau, vérifier la disponibilité du réseau, vérifier la progression d’une
opération de réseau, etc.
Vous pouvez créer une référence à un objet NetLingo à l’aide de l’opérateur new.
-- Syntaxe Lingo
objNetLingo = new xtra("netlingo")
// Syntaxe JavaScript
var objNetLingo = new xtra("netlingo");
Résumé des méthodes pour l’objet NetLingo
Méthode
browserName()
netDone()
cacheDocVerify()
netError()
cacheSize()
netLastModDate()
clearCache
netMIME()
downloadNetThing
netStatus
externalEvent()
netTextResult()
getLatestNetID
postNetText
getNetText()
preloadNetThing()
getStreamStatus()
proxyServer
gotoNetMovie
tellStreamStatus()
gotoNetPage
URLEncode
netAbort
SpeechXtra
Permet d’ajouter à une animation la fonctionnalité de synthèse de parole à partir du texte.
Vous pouvez créer une référence à un objet SpeechXtra à l’aide de l’opérateur new.
-- Syntaxe Lingo
objSpeech = new xtra("speechxtra")
// Syntaxe JavaScript
var objSpeech = new xtra("speechxtra");
150
Chapitre 7 : Objets de scripting
Résumé des méthodes pour l’objet SpeechXtra
Méthode
voiceCount()
voiceSet()
voiceGet()
voiceSetPitch()
voiceGetAll()
voiceSetRate()
voiceGetPitch()
voiceSetVolume()
voiceGetRate()
voiceSpeak()
voiceGetVolume()
voiceState()
voiceInitialize()
voiceStop()
voicePause()
voiceWordPos()
voiceResume()
XML Parser
Permet d’effectuer des analyses XML.
Vous pouvez créer une référence à un objet XML Parser à l’aide de l’opérateur new.
-- Syntaxe Lingo
objXml = new xtra("xmlparser")
// Syntaxe JavaScript
var objXml = new xtra("xmlparser");
Résumé des méthodes pour l’objet XML Parser
Méthode
count()
doneParsing()
getError() (XML)
ignoreWhiteSpace()
makeList()
makeSubList()
parseString()
parseURL()
Résumé des propriétés pour l’objet XML Parser
Propriété
attributeName
attributeValue
child (XML)
name (XML)
151
152
Chapitre 7 : Objets de scripting
CHAPITRE 8
Objets 3D
Les objets 3D permettent d’ajouter la fonctionnalité 3D à une animation. Ces objets sont à la fois
exposés à la syntaxe Lingo et à la syntaxe JavaScript au sein de Macromedia Director MX 2004,
des projections et du lecteur Macromedia Shockwave.
Vous avez accès à ces objets 3D par le biais des acteurs Shockwave 3D (ou 3D uniquement).
Vous pouvez également créer des images-objets 3D à partir des acteurs 3D. Les acteurs 3D ainsi
que les images-objets 3D comportent des fonctionnalités qui leur sont propres. Ils ont également
accès aux fonctionnalités des acteurs et images-objets non 3D dont les API sont respectivement
indiqués par les objets principaux Member et Sprite.
Un acteur 3D est différent des autres acteurs dans le sens où un acteur 3D contient tout un
monde en 3D. Un monde en 3D comprend des objets qui permettent l’accès à la fonctionnalité
3D. Tous les objets d’un monde en 3D se fondent sur un objet de base appelé noeud. La forme
la plus simple d’un nœud dans un monde en 3D est un objet Groupe ; cet objet Group est
fondamentalement le nœud de base. Tous les autres objets d’un monde en 3D se fondent sur un
objet Groupe, ce qui signifie que les autres objets héritent de la fonctionnalité d’un objet Groupe
en plus de posséder la fonctionnalité propre à ces objets.
Pour voir comment les objets 3D sont liés les uns aux autres, ainsi qu'aux autres objets de
Director, veuillez consulter Diagramme de modèles d’objets, page 59.
Director est livré avec deux Xtras vous donnant accès aux objets 3D :
• Xtra 3D (3DAuth.x32 sous Windows, 3D Auth Xtra sous Macintosh) prend en charge la
•
fenêtre média 3D dans Director.
Xtra 3D Media (Shockwave 3D Asset.x32 sous Windows, 3D Asset Xtra sur Macintosh) prend
en charge le média 3D proprement dit.
Pour accéder aux objets 3D lors de la programmation ou de l’exécution, votre animation doit
comprendre un Xtra 3D.
153
Acteur
Représente un acteur Shockwave 3D.
Un acteur Shockwave 3D (ou 3D uniquement) comprend tout un monde en 3D. Un monde
en 3D comprend un ensemble d’objets vous permettant d’ajouter un fonctionnalité 3D à une
animation.
Vous pouvez créer une référence à un acteur 3D soit à l’aide de la fonction member(), soit à l’aide
de la propriété member de l’objet Animation ou Image-objet. Vous pouvez utiliser les mêmes
techniques que pour créer une référence à un acteur qui n’est pas en 3D.
• Utilisez la fonction member() de haut niveau.
-- Syntaxe Lingo
acteur3d = member("magie")
// Syntaxe JavaScript
var acteur3d = member("magie");
• Utilisez la propriété member de l'objet Image-objet.
-- Syntaxe Lingo
acteur3d = sprite(1).member;
// Syntaxe JavaScript
var acteur3d = sprite(1).member;
Résumé des méthodes pour l’objet Acteur
Méthode
154
camera()
model
cloneModelFromCastmember
modelResource
cloneMotionFromCastmember
motion()
deleteCamera
newCamera
deleteGroup
newGroup
deleteLight
newLight
deleteModel
newMesh
deleteModelResource
newModel
deleteMotion
newModelResource
deleteShader
newShader
deleteTexture
newTexture
extrude3D
resetWorld
group()
revertToWorldDefaults
light()
shader()
loadFile()
texture()
Chapitre 8 : Objets 3D
Résumé des propriétés pour l’objet Acteur
Propriété
ambientColor
loop (3D)
animationEnabled
model
bevelDepth
modelResource
bevelType
motion
bytesStreamed (3D)
percentStreamed (3D)
camera
preLoad (3D)
cameraPosition
reflectivity
cameraRotation
shader
diffuseColor
smoothness
directionalColor
specularColor
directionalPreset
state (3D)
directToStage
streamSize (3D)
displayFace
texture
displayMode
textureMember
group
textureType
light
tunnelDepth
Voir aussi
Caméra, Groupe, Lumière, Modèle, Ressource modèle, Mouvement, Matériau, Imageobjet, Texture
Caméra
Représente un objet Caméra.
Une caméra contrôle la manière dont une image-objet 3D visualise le monde en 3D. Une imageobjet 3D affiche une vue de caméra particulière dans le monde.
Vous pouvez créer une référence à une caméra à l’aide de la propriété camera de l’objet 3D
Member. La propriété camera choisit la caméra située à un endroit précis de l’index dans la liste
des caméras. Avec Lingo, vous pouvez directement utiliser la propriété camera de l’objet 3D
Member afin de créer une référence. Dans la syntaxe JavaScript, vous devez utiliser la méthode
getPropRef() pour créer une référence.
Dans l’exemple suivant, une référence à la deuxième caméra de la « chambre familiale » de l’acteur
3D est créée et affectée à la variable maCaméra.
-- Syntaxe Lingo
maCaméra = member("chambre familiale").camera[2]
// Syntaxe JavaScript
var maCaméra = member("chambre familiale").getPropRef("camera", 2);
155
Résumé des méthodes pour l’objet Caméra
Méthode
addBackdrop
addOverlay
insertBackdrop
insertOverlay
removeBackdrop
removeOverlay
Résumé des propriétés pour l’objet Caméra
Propriété
backdrop
fog.far (brouillard)
backdrop[].blend (3D)
fog.near (brouillard)
backdrop[].loc (fond et recouvrement)
hither
backdrop[].regPoint (3D)
orthoHeight
backdrop[].rotation (fond et recouvrement)
overlay
backdrop[].scale (3D)
overlay[].blend (3D)
backdrop[].source
overlay[].loc (fond et recouvrement)
backdrop.count (3D)
overlay[].regPoint (3D)
child (3D)
overlay[].rotation (fond et recouvrement)
colorBuffer.clearAtRender
overlay[].scale (3D)
colorBuffer.clearValue
overlay[].source
fieldOfView (3D)
overlay.count (3D)
fog.color()
projection
fog.decayMode
rootNode
fog.enabled (brouillard)
yon
Voir aussi
Groupe, Lumière, Modèle, Ressource modèle, Mouvement, Matériau, Texture
156
Chapitre 8 : Objets 3D
Groupe
Représente un modèle n’ayant ni ressource ni matériaux.
Un groupe est un nœud de base et correspond tout simplement à un point dans l’espace représenté par une transformation. Vous pouvez affecter des enfants et des parents à ce nœud afin de
regrouper des modèles, des lumières, des caméras ou d’autres groupes.
Le groupe de base est appelé monde, ce qui revient fondamentalement au même qu’acteur 3D.
Vous pouvez créer une référence à un groupe à l'aide de la propriété group de l’objet 3D Member.
La propriété group choisit le groupe situé à un endroit précis de l’index dans la liste de groupes.
En Lingo, vous pouvez directement utiliser la propriété group de l’objet 3D Member pour créer
une référence. Dans la syntaxe JavaScript, vous devez utiliser la méthode getPropRef() pour
créer une référence.
Dans l’exemple suivant, une référence au premier groupe de l’acteur 3D espace est créée et
affectée à la variable monGroupe.
-- Syntaxe Lingo
monGroupe = member("espace").group[1]
// Syntaxe JavaScript
var monGroupe = member("espace").getPropRef("group", 1);
Résumé des méthodes pour l’objet Groupe
Méthode
addChild
pointAt
addToWorld
registerScript()
clone
removeFromWorld
cloneDeep
rotate
getWorldTransform()
scale (commande)
isInWorld()
translate
Résumé des propriétés pour l’objet Groupe
Propriété
name (3D)
parent
pointAtOrientation
transform (propriété)
userData
worldPosition
Voir aussi
Caméra, Lumière, Modèle, Ressource modèle, Mouvement, Matériau, Texture
157
Image-objet
Représente une image-objet 3D créée à partir d’un acteur Shockwave 3D.
Vous pouvez créer une référence à une image-objet 3D à l’aide de la fonction sprite() de haut
niveau, de la propriété sprite de l’objet Animation ou bien de la propriété sprite de l’objet
Piste d’images-objets. Vous pouvez utiliser les mêmes techniques que pour créer une référence
à une image-objet qui n’est pas 3D.
• Utilisez la fonction sprite() de haut niveau.
-- Syntaxe Lingo
imageObjet3d = sprite(1)
// Syntaxe JavaScript
var imageObjet3d = sprite(1);
• Utilisez la propriété sprite de l’objet Animation.
-- Syntaxe Lingo
imageObjet3d = _movie.sprite["saule"]
// Syntaxe JavaScript
var imageObjet3d = _movie.sprite["saule"];
• Utilisez la propriété sprite de l’objet Piste d’images-objets.
-- Syntaxe Lingo
imageObjet3d = channel(3).sprite
// Syntaxe JavaScript
var imageObjet3d = channel(3).sprite;
Résumé des méthodes pour l’objet Image-objet
Méthode
addCamera
cameraCount()
deleteCamera
Résumé des propriétés pour l’objet Image-objet
Propriété
antiAliasingEnabled
backColor
camera
directToStage
Voir aussi
Caméra, Acteur
158
Chapitre 8 : Objets 3D
Lumière
Représente une lumière dans un monde en 3D.
Les lumières sont utilisées pour éclairer un monde en 3D. Sans les lumières, on ne peut pas voir
les objets de ce monde.
Vous pouvez créer une référence à une lumière à l’aide de la propriété light de l’objet 3D
Member. La propriété light choisit une lumière à un endroit précis de l’index dans la liste
des lumières. En Lingo, vous pouvez directement utiliser la propriété light de l’objet 3D
Member pour créer une référence. Dans la syntaxe JavaScript, vous devez utiliser la méthode
getPropRef() pour créer une référence.
Dans l’exemple suivant, une référence à la troisième lumière de la « salle d'animation » de l’acteur
3D est créée et affectée à la variable maLumière.
-- Syntaxe Lingo
maLumière = member("salle d’animation").light[3]
// Syntaxe JavaScript
var maLumière = member("salle d’animation").getPropRef("light", 3);
Résumé des propriétés pour l’objet Lumière
Propriété
attenuation
color (lumière)
specular (lumière)
spotAngle
spotDecay
type (lumière)
Voir aussi
Caméra, Groupe, Modèle, Ressource modèle, Mouvement, Matériau, Texture
Matériau
Représente la couleur de la surface d’un modèle.
Vous pouvez dessiner des images à la surface d’un modèle en appliquant une ou plusieurs textures
à chaque matériau.
Vous pouvez créer une référence à un matériau à l’aide de la propriété shader de l’objet 3D
Member. La propriété shader choisit la nuance située à un endroit précis de l’index dans la liste
des matériaux. En Lingo, vous pouvez directement utiliser la propriété shader de l’objet 3D
Member afin de créer une référence. Dans la syntaxe JavaScript, vous devez utiliser la méthode
getPropRef() pour créer une référence.
159
Dans l’exemple suivant, une référence à la deuxième nuance de l’acteur 3D triangle est créée et
affectée à la variable monMatériau.
-- Syntaxe Lingo
monMatériau = member("triangle").shader[2]
// Syntaxe JavaScript
var monMatériau = member("triangle").getPropRef("shader", 2);
Modèle
Représente un objet visible qu’un utilisateur peut voir dans un monde en 3D.
Un modèle utilise une ressource modèle et occupe une orientation et un emplacement précis dans
un monde en 3D. Une ressource modèle est un élément de la géométrie 3D que vous pouvez
utiliser pour dessiner des modèles 3D. Un modèle définit également l’apparence d’une ressource
modèle, telle que les textures et les matériaux qui sont utilisés. Pour plus d’informations sur la
relation entre les modèles et les ressources modèles, veuillez consulter la rubrique Utilisation de
Director dans le panneau d’aide de Director.
Vous pouvez créer une référence à un modèle à l’aide de la propriété model de l’objet 3D Member.
La propriété model choisit un modèle situé à un endroit précis de l’index dans la liste des modèles.
En Lingo, vous pouvez directement utiliser la propriété model de l’objet 3D Member afin de créer
une référence. Dans la syntaxe JavaScript, vous devez utiliser la méthode getPropRef() pour
créer une référence.
Dans l’exemple suivant, une référence au deuxième modèle de l’acteur 3D Transportation est
créée et affectée à la variable monModèle.
-- Syntaxe Lingo
monModèle = member("Transportation").model[2]
// Syntaxe JavaScript
var monModèle = member("Transportation").getPropRef("model", 2);
Un modèle comprend également des modificateurs qui contrôlent le rendu du modèle et le
comportement de l’animation. Les modificateurs sont liés au modèle à l’aide de la méthode
addModifier(). Une fois un modificateur lié à un modèle, ses propriétés peuvent être
manipulées par le script.
Les modificateurs suivants sont disponibles avec un modèle :
160
Modificateur
Description
BonesPlayer
Modifie la forme d’un modèle après l’exécution.
Collision
Permet à un modèle d’être prévenu en cas de collision et d’agir en
fonction.
Inker
Ajoute une silhouette, des plis et des bords à un modèle existant.
KeyframePlayer
Modifie les propriétés transform du modèle après l’exécution.
LOD
Permet de contrôler le nombre de polygones utilisés par modèle
pour le rendu d’un modèle, en fonction de la distance du modèle par
rapport à la caméra.
Le modificateur LOD est également disponible pour les ressources
modèles.
Chapitre 8 : Objets 3D
Modificateur
Description
MeshDeform
Modifie la forme d’une ressource modèle existante lors de
l’exécution.
SDS
Le rendu du modèle comporte des détails géométriques
supplémentaires dans la zone du modèle que la caméra est en train
de fixer.
Toon
Modifie le rendu du modèle afin d’imiter le style des bandes
dessinées.
Pour plus d’informations sur les méthodes, propriétés et événements disponibles pour les
modificateurs, veuillez consulter la rubrique Utilisation de Director dans le panneau d’aide de
Director.
Mouvement
Représente une séquence d’animation prédéfinie qui implique le mouvement d’un modèle ou
d’un composant d’un modèle.
Vous pouvez définir les mouvements individuels de manière à ce qu'ils se lisent d'eux-mêmes ou
avec d'autres mouvements. Par exemple, une course peut être combinée à un saut afin de simuler
le saut d’une personne au-dessus d’une flaque d'eau.
Vous pouvez créer une référence à un mouvement à l’aide de la propriété motion de l’objet 3D
Member. La propriété motion choisit le mouvement situé à un endroit précis de l’index dans la
liste des mouvements. En Lingo, vous pouvez utiliser directement la propriété motion de l’objet
3D Member pour créer une référence. Dans la syntaxe JavaScript, vous devez utiliser la méthode
getPropRef() pour créer une référence.
Dans l’exemple suivant, une référence au quatrième mouvement de l’acteur 3D athlète est créée
et affectée à la variable monMouvement.
-- Syntaxe Lingo
monMouvement = member("athlète").motion[4]
// Syntaxe JavaScript
var monMouvement = member("athlète").getPropRef("motion", 4);
Ressource modèle
Représente un élément de la géométrie 3D utilisé pour dessiner des modèles 3D.
Un modèle utilise une ressource modèle et occupe une orientation et emplacement précis dans
un monde en 3D. Un modèle définit également l’apparence d’une ressource modèle, telle que
les textures et matériaux utilisés.
Pour plus d’informations sur la relation entre les modèles et les ressources modèles, ainsi que sur
l’utilisation des modèles et des ressources modèles, veuillez consulter la rubrique Utilisation de
Director dans le panneau d’aide de Director.
161
Vous pouvez créer une référence à une ressource modèle à l’aide de la propriété modelResource
de l’objet 3D Member. La propriété modelResource choisit la ressource modèle située à un
endroit précis de l’index dans la liste des ressources modèles. En Lingo, vous pouvez utiliser
directement la propriété modelResource de l’objet 3D Member pour créer une référence. Dans
la syntaxe JavaScript, vous devez utiliser la méthode getPropRef() pour créer une référence.
Dans l'exemple suivant, une référence à la deuxième ressource modèle de l’acteur 3D roues est
créée et affectée à la variable maRessourceModèle.
-- Syntaxe Lingo
maRessourceModèle = member("roues").modelResource[2]
// Syntaxe JavaScript
var maRessourceModèle = member("roues").getPropRef("modelResource", 2);
Services de rendu
Représente l’objet global qui comprend une liste de propriétés dont les valeurs influencent
les propriétés communes de rendu de tous les acteurs et images-objets 3D.
Vous pouvez accéder à l’objet services de rendu global à l’aide de la fonction
getRendererServices() de haut niveau.
Dans l’exemple suivant, on accède à la propriété de rendu de l’objet services de rendu global et
la valeur est affectée à la variable monRendu.
-- Syntaxe Lingo
monRendu = getRendererServices().renderer
// Syntaxe JavaScript
var monRendu = getRendererServices().renderer;
Résumé des méthodes pour l’objet Services de rendu
Méthode
getHardwareInfo()
Résumé des propriétés pour l’objet Services de rendu
Propriété
modifiers
primitives
renderer
rendererDeviceList
textureRenderFormat
Voir aussi
Acteur, Image-objet
162
Chapitre 8 : Objets 3D
Texture
Représente la texture appliquée à un matériau.
Vous pouvez créer une référence à une texture à l’aide de la propriété texture de l’objet 3D
Member. La propriété texture choisit la texture située à un endroit précis de l’index dans la liste
des textures. En Lingo, vous pouvez utiliser directement la propriété texture de l’objet 3D
Member afin de créer une référence. Dans la syntaxe JavaScript, vous devez utiliser la méthode
getPropRef() pour créer une référence.
Dans l’exemple suivant, une référence à la première texture de l’acteur 3D triangle est créée et
affectée à la variable maTexture.
-- Syntaxe Lingo
maTexture = member("triangle").texture[1]
// Syntaxe JavaScript
var maTexture = member("triangle").getPropRef("texture", 1);
163
164
Chapitre 8 : Objets 3D
CHAPITRE 9
Constantes
Cette section propose une liste alphabétique de toutes les constantes disponibles dans
Macromedia Director MX 2004.
La plupart de ces constantes ne s’appliquent qu’à Lingo. La syntaxe JavaScript contient des
constantes qui sont similaires aux constantes Lingo énumérées ici ; nous vous fournirons donc
des explications sur l’usage de la Syntaxe JavaScript ainsi que des exemples pour vous aider à
associer les fonctionnalités des constantes Lingo à leurs équivalents les plus proches dans la
syntaxe JavaScript. Pour plus d’informations sur les constantes de la syntaxe JavaScript, consultez
les nombreuses autres ressources consacrées à ce sujet.
" (chaîne)
Utilisation
-- Syntaxe Lingo
"
// Syntaxe JavaScript
"
Description
Constante de chaîne ; lorsqu’ils sont utilisés avant et après une chaîne, les guillemets droits
signifient que la chaîne est une chaîne littérale, et non une variable, une valeur numérique ou un
élément de script. Les guillemets droits doivent toujours encadrer les noms littéraux des acteurs,
des distributions, des fenêtres et des fichiers externes.
Exemple
L’instruction suivante utilise les guillemets droits pour indiquer que la chaîne « San Francisco »
est une chaîne littérale, le nom d’un acteur :
-- Syntaxe Lingo
put member("San Francisco").loaded
// Syntaxe JavaScript
put(member("San Francisco").loaded);
Voir aussi
QUOTE
165
BACKSPACE
Utilisation
-- Syntaxe Lingo
BACKSPACE
// Syntaxe JavaScript
51 // value of _key.keyCode
Description
Constante; représente la touche Suppression/Retour Arrière. Cette touche est appelée Retour
Arrière sur un clavier Windows et Suppr sur un clavier Macintosh.
Exemple
Le gestionnaire on keyDown suivant vérifie si l’utilisateur a appuyé sur la touche Retour Arrière et,
le cas échéant, appelle le gestionnaire effacerEntrée:
-- Syntaxe Lingo
on keyDown
if (_key.key = BACKSPACE) then effacerEntrée
_movie.stopEvent()
end keyDown
// Syntaxe JavaScript
function keyDown() {
if (_key.keyCode == 51) {
clearEntry();
_movie.stopEvent();
}
}
EMPTY
Utilisation
-- Syntaxe Lingo
VIDES
// Syntaxe JavaScript
""
Description
Constante de caractères ; représente la chaîne vide, "", une chaîne sans caractères.
Exemple
L’instruction suivante efface tous les caractères de l’acteur champ Notice en donnant au champ la
valeur EMPTY :
-- Syntaxe Lingo
member("Notice").text = EMPTY
// Syntaxe JavaScript
member("Notice").text = "";
166
Chapitre 9 : Constantes
ENTER
Utilisation
-- Syntaxe Lingo
ENTER
// Syntaxe JavaScript
3 // value of _key.keyCode
Description
Constante de caractères ; représente la touche Entrée (Windows) ou Retour (Macintosh) pour un
retour de chariot.
Sur les claviers PC, l’élément ENTER ne se rapporte qu’à la touche Entrée du clavier numérique.
Pour une animation lue comme applet, utilisez RETURN pour spécifier la touche Retour sous
Windows et la touche Entrée sur le Macintosh.
Exemple
Cette instruction vérifie si la touche Entrée est enfoncée et, le cas échéant, envoie la tête de lecture
sur l’image ajouterLaSomme :
-- Syntaxe Lingo
on keyDown
if (_key.key = ENTER) then _movie.go("ajouterLaSomme")
end
// Syntaxe JavaScript
function keyDown() {
if (_key.keyCode == 3) {
_movie.go("ajouterLaSomme");
}
}
Voir aussi
RETURN (constante)
FALSE
Utilisation
-- Syntaxe Lingo
FALSE
// Syntaxe JavaScript
FALSE
Description
Constante ; s’applique à une expression qui est logiquement fausseFALSE, telle que 2 > 3. Lorsque
traitée comme un nombre, FALSE a la valeur numérique de 0. Inversement, 0 est traité comme
FALSE.
167
Exemple
L’instruction suivante désactive la propriété soundEnabled en lui donnant la valeur FALSE :
-- Syntaxe Lingo
_sound.soundEnabled = FALSE
// Syntaxe JavaScript
_sound.soundEnabled = false;
Voir aussi
if, not, TRUE
PI
Utilisation
-- Syntaxe Lingo
PI
// Syntaxe JavaScript
Math.PI
Description
Constante ; renvoie la valeur de pi (π), le rapport de la circonférence d’un cercle et de son
diamètre, sous la forme d’un nombre à virgule flottante. La valeur est arrondie au nombre de
décimales défini par la propriété floatPrecision.
Exemple
L’instruction suivante utilise la constante PI dans une équation destinée à calculer la surface d’un
cercle :
-- Syntaxe Lingo
vRadius = 3
vArea = PI*power(vRadius, 2)
trace(vArea) – résultats dans 28.2743
// Syntaxe JavaScript
var vRadius = 3;
vArea = Math.PI*Math.pow(vRadius, 2);
trace(vArea); // résultats dans 28.274333882308138
QUOTE
Utilisation
-- Syntaxe Lingo
QUOTE
// Syntaxe JavaScript
\"
Description
Constante; représente le caractère guillemet dans une chaîne puisque ce caractère est lui-même
utilisé dans les scripts Lingo pour délimiter les chaînes.
168
Chapitre 9 : Constantes
Exemple
L’instruction suivante insère des guillemets dans une chaîne :
-- Syntaxe Lingo
put("Comment épelez-vous" && QUOTE & "Macromedia" & QUOTE & "?")
// Syntaxe JavaScript
put("Comment épelez-vous \"Macromedia\"?");
Le résultat est un jeu de guillemets placés autour du mot Macromedia :
Comment épelez-vous "Macromedia" ?
RETURN (constante)
Utilisation
-- Syntaxe Lingo
RETURN
// Syntaxe JavaScript
36 // value of _key.keyCode
\n // lorsqu’il est utilisé dans une chaîne
Description
Constante ; représente un retour de chariot.
Exemple
L’instruction suivante reprend la lecture d’une animation en pause lorsque l’utilisateur appuie sur
le retour de chariot :
-- Syntaxe Lingo
if (_key.key = RETURN) then _movie.go(_movie.frame + 1)
// Syntaxe JavaScript
if (_key.keyCode == 36) {
_movie.go(_movie.frame+1);
}
L’instruction suivante utilise la constante de caractère RETURN pour insérer un retour de chariot
entre deux lignes d’un message d’alerte :
-- Syntaxe Lingo
_player.alert("Dernière ligne du fichier." & RETURN & "Cliquer sur OK pour
fermer.")
// Syntaxe JavaScript
_player.alert("Dernière ligne du fichier.\nCliquez sur OK pour fermer");
Sous Windows, vous devez normalement placer un caractère additionnel de saut de ligne à la fin
de chaque ligne. L’instruction suivante crée une chaîne de deux caractères nommée CRLF
fournissant le saut de ligne additionnel :
CRLF = RETURN & numToChar(10)
169
SPACE
Utilisation
-- Syntaxe Lingo
SPACE
// Syntaxe JavaScript
49 // value of _key.keyCode
Description
Constante ; valeur en lecture seule représentant une espace.
Exemple
L’instruction suivante affiche Age de bronze dans la fenêtre Messages :
-- Syntaxe Lingo
put("Age"&SPACE&"de"&SPACE&"bronze")
TAB
Utilisation
-- Syntaxe Lingo
TAB
// Syntaxe JavaScript
48 // value of _key.keyCode
Description
Constante ; représente la touche Tab.
Exemple
L’instruction suivante vérifie si le caractère saisi est le caractère de tabulation et, le cas échéant,
appelle le gestionnaire champSuivant :
-- Syntaxe Lingo
if (_key.key = TAB) then champSuivant
// Syntaxe JavaScript
if (_key.keyCode == 48) {
doNextField();
}
Ces instructions font avancer ou reculer la tête de lecture selon que l’utilisateur appuie sur les
touches Tab ou Majuscule-Tab :
-- Syntaxe Lingo
if (_key.key = TAB) then
if (_key.shiftDown) then
_movie.go(_movie.frame - 1)
else
_movie.go(_movie.frame +1)
end if
end if
170
Chapitre 9 : Constantes
// Syntaxe JavaScript
if (_key.keyCode == 48) {
if (_key.shiftDown) {
_movie.go(_movie.frame-1);
} else {
_movie.go(_movie.frame+1);
}
}
Voir aussi
BACKSPACE, EMPTY, RETURN (constante)
TRUE
Utilisation
-- Syntaxe Lingo
TRUE
// Syntaxe JavaScript
true
Description
Constante ; représente la valeur d’une expression logique, telle que 2 < 3. Elle est traditionnellement une valeur numérique de 1, mais tout chiffre entier non nul donne TRUE dans une comparaison.
Exemple
L’instruction suivante active la propriété soundEnabled en lui donnant la valeur TRUE :
-- Syntaxe Lingo
_sound.soundEnabled = TRUE
// Syntaxe JavaScript
_sound.soundEnabled = true;
Voir aussi
FALSE, if
171
VOID
Utilisation
-- Syntaxe Lingo
VOID
// Syntaxe JavaScript
null
Description
Constante ; indique la valeur VOID.
Exemple
L’instruction suivante vérifie si la variable variableCourante a la valeur VOID :
-- Syntaxe Lingo
if variableCourante = VOID then
put("Cette variable n’a aucune valeur")
end if
// Syntaxe JavaScript
if (currentVariable == null) {
put("Cette variable n’a aucune valeur");
}
Voir aussi
voidP()
172
Chapitre 9 : Constantes
CHAPITRE 10
Evénements et messages
Cette section propose une liste alphabétique de tous les événements et messages disponibles dans
Macromedia Director MX 2004.
on activateApplication
Utilisation
-- Syntaxe Lingo
on activateApplication
instruction(s)
end
// Syntaxe JavaScript
function activateApplication() {
instruction(s);
}
Description
Gestionnaire intégré ; exécuté lorsque la projection passe au premier plan. Ce gestionnaire est
pratique lorsqu’une projection est exécutée dans une fenêtre et que l’utilisateur l’envoie à l’arrièreplan pour travailler dans une autre application. Le gestionnaire est exécuté lorsque la projection
repasse au premier plan. Toutes les MIAW exécutées dans la projection peuvent également
utiliser ce gestionnaire.
En cours de programmation, ce gestionnaire n’est appelé que lorsque l’option Animer en arrièreplan est activée dans les préférences générales.
Sous Windows, ce gestionnaire n’est pas appelé lorsque la projection n’est que réduite et
qu’aucune application n’est passée au premier plan.
Exemple
Le gestionnaire suivant lit un son à chaque fois que l’utilisateur ramène la projection au premier
plan :
-- Syntaxe Lingo
on activateApplication
sound(1).queue(member("sonDouverture"))
sound(1).play()
end
173
// Syntaxe JavaScript
function activateApplication() {
sound(1).queue(member("sonDouverture"));
sound(1).play();
}
Voir aussi
on deactivateApplication, activeCastLib, on deactivateWindow
on activateWindow
Utilisation
-- Syntaxe Lingo
on activateWindow
instruction(s)
end
// Syntaxe JavaScript
function activateWindow()
instruction(s);
}
Description
Message système et gestionnaire d’événements ; contient des instructions exécutées dans une
animation lorsque l’utilisateur clique sur la fenêtre inactive et que la fenêtre passe au premier plan.
Vous pouvez utiliser un gestionnaire on activateWindow dans un script que vous souhaitez
exécuter à chaque fois que l’animation devient active.
Le fait de cliquer sur l’animation principale (la scène principale) ne génère pas de gestionnaire on
activateWindow.
Exemple
Ce gestionnaire lit le son Hourra lorsque la fenêtre dans laquelle l’animation est exécutée devient
active :
-- Syntaxe Lingo
on activateWindow
sound(2).play(member("Hourra"))
end
// Syntaxe JavaScript
function activateWindow() {
sound(2).play(member("Hourra"));
}
Voir aussi
activeWindow, close(), on deactivateWindow, frontWindow, on moveWindow, open()
(fenêtre)
174
Chapitre 10 : Evénements et messages
on beginSprite
Utilisation
-- Syntaxe Lingo
on beginSprite
instruction(s)
end
// Syntaxe JavaScript
function beginSprite() {
instruction(s);
}
Description
Message système et gestionnaire d’événement ; contient des instructions exécutées lorsque la tête
de lecture passe à une image contenant une image-objet jusqu’alors inconnue. A l’instar de
endSprite, cet événement est généré une seule fois, même si la tête de lecture effectue une boucle
sur une image, étant donné que le déclencheur est une image-objet que la tête de lecture n’avait
pas encore rencontrée. L’événement est généré avant prepareFrame.
Director crée des instances de tout script de comportement lié à l’image-objet lorsque le message
beginSprite est envoyé.
La référence d’objet me est transmise à cet événement s’il est utilisé dans un comportement.
Le message est envoyé aux comportements et aux scripts d’images.
Si une image-objet commence à la première image lue dans le cadre de l’animation, le message
beginSprite est envoyé après le message prepareMovie mais avant les messages prepareFrame
et startMovie.
Remarque : N’oubliez pas que certaines propriétés d’image-objet telles que rect ne seront peut-être
pas accessibles dans un gestionnaire beginSprite. En effet, le système doit calculer la propriété, ce
qui ne peut se faire tant que l’image-objet n’a pas été dessinée.
Les commandes go, play et updateStage sont désactivées dans un gestionnaire
on beginSprite.
Exemple
Le gestionnaire suivant lit l’acteur Georges Brassens lorsque l’image-objet commence :
-- Syntaxe Lingo
on beginSprite me
sound(1).play(member("Georges Brassens"))
end
// Syntaxe JavaScript
function beginSprite() {
sound(1).play(member("Georges Brassens"));
}
Voir aussi
on endSprite, on prepareFrame, scriptInstanceList
175
on closeWindow
Utilisation
-- Syntaxe Lingo
on closeWindow
instruction(s)
end
// Syntaxe JavaScript
function closeWindow() {
instruction(s);
}
Description
Message système et gestionnaire d’événements ; contient les instructions exécutées lorsque
l’utilisateur ferme la fenêtre d’une animation en cliquant sur sa case de fermeture.
Le gestionnaire on closeWindow est un bon endroit pour placer les commandes que vous
souhaitez exécuter à chaque fermeture de la fenêtre de l’animation.
Exemple
Le gestionnaire suivant transmet à Director la commande forget pour qu’il libère la fenêtre
courante de la mémoire, lorsque l’utilisateur ferme la fenêtre dans laquelle l’animation est en
cours de lecture :
-- Syntaxe Lingo
on closeWindow
-- opérations de maintenance standard
window(1).forget()
end
// Syntaxe JavaScript
function closeWindow() {
// opérations de maintenance standard
window(1).forget();
}
on cuePassed
Utilisation
-- Syntaxe Lingo
on cuePassed({me,} IDdePiste, numéroDeRepère,nomDeRepère)
instruction(s)
end
// Syntaxe JavaScript
function cuePassed(IDdePiste,numéroDeRepère,nomDeRepère) {
instruction(s);
}
Description
Message système et gestionnaire d’événements ; contient des instructions exécutées à chaque fois
qu’un son ou qu’une image-objet passe par un point de repère sur son média.
176
Chapitre 10 : Evénements et messages
•
•
•
•
Le paramètre facultatif me représente la valeur réfDinstanceDeScript du script appelé.
Vous devez inclure ce paramètre si vous utilisez le message dans un comportement. Si vous
omettez ce paramètre, les autres arguments ne seront pas traités correctement.
IDdePiste Le numéro de la piste audio ou d'image-objet spécifique du fichier où le point de
repère a été franchi.
numéroDeRepère Le nombre ordinal du point de repère qui déclenche l’événement dans la
liste des points de repère de l’acteur.
nomDeRepère Le nom du point de repère rencontré.
me
Le message est transmis, dans l’ordre, aux scripts d’image-objet, d’acteur, d’image et d’animation.
Pour qu’elle reçoive l’événement, l’image-objet doit être la source du son, telle qu’une animation
QuickTime ou un acteur SWA. Utilisez la propriété isPastCuePoint pour vérifier les points de
repère dans les comportements relatifs aux images-objets qui ne génèrent aucun son.
Exemple
Le gestionnaire suivant placé dans un script d’animation ou d’image affiche tous les points de
repère pour la piste audio 1 dans la fenêtre Messages :
-- Syntaxe Lingo
on cuePassed piste, numéro, nom
if (channel = #Sound1) then
put("Le point de repère" && number && "intitulé" && name && "est survenu
dans le son 1")
end if
end
// Syntaxe JavaScript
function cuePassed(piste, numéro, nom) {
if (channel == symbol("Son1")) {
put("Le point de repère" + number + "intitulé" + name + "est survenu dans
le son 1");
}
}
Voir aussi
scriptInstanceList, cuePointNames, cuePointTimes, isPastCuePoint()
177
on deactivateApplication
Utilisation
-- Syntaxe Lingo
on deactivateApplication
instruction(s)
end
// Syntaxe JavaScript
function deactivateApplication() {
instruction(s);
}
Description
Gestionnaire intégré ; exécuté lorsque la projection passe à l’arrière-plan. Ce gestionnaire est
pratique lorsqu’une projection est exécutée dans une fenêtre et que l’utilisateur l’envoie à l’arrièreplan pour travailler dans une autre application. Toutes les MIAW exécutées dans la projection
peuvent également utiliser ce gestionnaire.
En cours de programmation, ce gestionnaire n’est appelé que lorsque l’option Animer en arrièreplan est activée dans les préférences générales.
Sous Windows, ce gestionnaire n’est pas appelé lorsque la projection n’est que réduite et
qu’aucune application n’est passée au premier plan.
Exemple
Le gestionnaire suivant lit un son à chaque fois que l’utilisateur envoie la projection à l’arrièreplan :
-- Syntaxe Lingo
on deactivateApplication
sound(1).queue(member("sonDeFermeture"))
sound(1).play()
end
// Syntaxe JavaScript
function deactivateApplication() {
sound(1).queue(member("sonDeFermeture"));
sound(1).play();
}
Voir aussi
add (texture 3D), activeCastLib, on deactivateWindow
178
Chapitre 10 : Evénements et messages
on deactivateWindow
Utilisation
-- Syntaxe Lingo
on deactivateWindow
instruction(s)
end
// Syntaxe JavaScript
function deactivateWindow() {
instruction(s);
}
Description
Message système et gestionnaire d’événements ; contient des instructions qui sont exécutées
lorsque la fenêtre dans laquelle l’animation est lue, est désactivée. Le gestionnaire d’événements
on deactivate est un bon endroit pour placer le code que vous souhaitez exécuter dès la
désactivation d’une fenêtre.
Exemple
Le gestionnaire suivant lit le son Ronflement lorsque la fenêtre dans laquelle l’animation est lue,
est désactivée :
-- Syntaxe Lingo
on deactivateWindow
sound(2).play(member("Ronflement"))
end
// Syntaxe JavaScript
function deactivateWindow() {
sound(2).play(member("Ronflement"));
}
on DVDeventNotification
Utilisation
-- Syntaxe Lingo
on DVDeventNotification eventArg1 {, eventArg2} {, eventArg3}
instruction(s)
}
// Syntaxe JavaScript
function DVDeventNotification(eventArg1 {, eventArg2} {, eventArg3}) {
instruction(s);
}
Description
Gestionnaire d’événements DVD intégré. Contient des instructions exécutées en réponse aux
événements qui se produisent durant la lecture d’un DVD.
Ce gestionnaire sert à gérer tous les événements DVD. L’événement qui se produit est toujours
transmis en tant que premier paramètre, eventArg1. Certains événements contiennent des
informations qui sont transmises en tant que second paramètre, eventArg2, et, dans certains cas,
en tant que troisième paramètre, eventArg3.
179
Le tableau suivant affiche les événements qui peuvent se produire durant la lecture d’un DVD.
180
Evénements
Description
angleChange
Se produit lorsque le nombre d’angles disponibles ou le nombre d’angles
de l’utilisateur courant a changé.
Les informations supplémentaires suivantes sont transmises à
DVDeventNotification lorsque cet événement se produit :
• eventArg2 - Un nombre entier ou une adresse indiquant le nombre
d’angles disponibles. Lorsque le nombre d’angles disponibles est 1, cela
signifie que la vidéo courante n’est pas multi angle.
• eventArg3 - Un nombre entier ou une adresse indiquant le nombre
d’angles de l’utilisateur courant.
audioStreamChange
Se produit lorsque le numéro de flux audio de l’utilisateur courant passe au
titre principal.
Les informations supplémentaires suivantes sont transmises à
DVDeventNotification lorsque cet événement se produit :
• eventArg2 - Un nombre entier ou une adresse indiquant le numéro du flux
audio du nouvel utilisateur. Stream 0xFFFFFFFF indique qu’aucun flux n’a
été sélectionné.
buttonChange
Se produit lorsque le nombre de boutons disponibles ou le numéro du
bouton actuellement sélectionné a changé.
Les informations supplémentaires suivantes sont transmises à
DVDeventNotification lorsque cet événement se produit :
• eventArg2 - Un nombre entier ou une adresse indiquant le nombre de
boutons disponibles.
• eventArg3 - Un nombre entier ou une adresse indiquant le numéro du
bouton actuellement sélectionné. Le numéro 0 indique qu’aucun bouton
n’a été sélectionné.
chapterAutoStop
Se produit lorsque la lecture s’arrête suite à un appel à
chapterPlayAutoStop().
chapterStart
Se produit lorsque de la lecture d’un nouveau programme dans le domaine
title commence.
Les informations supplémentaires suivantes sont transmises à
DVDeventNotification lorsque cet événement se produit :
• eventArg2 - Un nombre entier ou une adresse indiquant le numéro du
nouveau chapitre.
diskEjected
Se produit lorsqu’un DVD est éjecté.
diskInserted
Se produit lorsqu’un DVD est inséré.
Chapitre 10 : Evénements et messages
Evénements
Description
domainChange
Se produit lorsque le domaine du lecteur DVD change.
Les informations supplémentaires suivantes sont transmises à
DVDeventNotification lorsque cet événement se produit :
• eventArg2. Une valeur indiquant le nouveau domaine. Le nouveau
domaine sera l’une des valeurs suivantes.
firstPlay. Le Navigateur DVD effectue une initialisation par défaut
d’un DVD.
videoManagerMenu. Le Navigateur DVD affiche des menus pour la
totalité du disque.
videoTitleSetMenu. Le Navigateur DVD affiche des menus pour la
série de titres en cours.
title. Le Navigateur DVD affiche le titre courant.
stop. Le Navigateur DVD est dans le domaine stop.
■
■
■
■
■
error
Se produit lorsqu’une condition d’erreur DVD a lieu.
Les informations supplémentaires suivantes sont transmises à
DVDeventNotification lorsque cet événement se produit :
• eventArg2. Une valeur indiquant une condition d’erreur. La condition
d’erreur sera l’une des valeurs suivantes.
copyProtectFail. Echec de l’échange de clé pour la protection de
copie DVD. La lecture est interrompue.
invalidDVD1_0Disc. Le DVD créé ne correspond pas aux
spécifications de la version 1.x. La lecture est interrompue.
invalidDiscRegion. Le DVD ne peut pas être lu parce qu’il n’est pas
compatible avec la région système.
lowParentalLevel. Le niveau parental du lecteur est inférieur au niveau
parental le plus bas qui existe dans le contenu du DVD. La lecture est
interrompue.
macrovisionFail. Echec de la distribution Macrovision. Lecture
interrompue.
incompatibleSystemAndDecoderRegions. Aucun disque ne peut être lu
car la région système ne correspond pas à la région du décodeur.
incompatibleDiscAndDecoderRegions. Le DVD ne peut pas être lu
parce qu’il n’est pas compatible avec la région du décodeur.
unexpected. Une erreur inattendue s’est produite ; il est possible que le
contenu n’ait pas été créé correctement. La lecture est interrompue.
■
■
■
■
■
■
■
■
karaokeMode
A lieu lorsque le mode audio est réglé sur karaoke.
noFirstPlayChain
A lieu lorsque le DVD ne possède pas de FP_PGC (First Play Program
Chain) et que le Navigateur DVD ne charge pas de PGC et ne s’exécute
pas automatiquement.
parentalLevelChange
A lieu lorsque le niveau parental du contenu créé est sur le point de
changer.
Les informations supplémentaires suivantes sont transmises à
DVDeventNotification lorsque cet événement se produit :
• eventArg2. Nombre entier indiquant le nouveau niveau parental défini
dans le lecteur.
181
Evénements
Description
playbackStopped
A lieu lorsque la lecture est interrompue. Le Navigateur DVD a terminé la
lecture du PGC et n’a trouvé aucune instruction concernant la poursuite de
la lecture.
playPeriodAutoStop
rateChange
A lieu lorsque la cadence de lecture change.
Les informations supplémentaires suivantes sont transmises à
DVDeventNotification lorsque cet événement se produit :
• eventArg2. Nombre entier indiquant la nouvelle cadence de lecture.
Une valeur inférieure à (<) 0 indique un mode de lecture inverse. Une
valeur supérieure à (>) 0 indique un mode de lecture avant. Cette valeur
correspond à la cadence de lecture multipliée par 10 000.
stillOff
A lieu à la fin d’une image fixe (PGC, cellule ou VOBU)
stillOn
A lieu à la fin d’une image fixe (PGC, cellule ou VOBU)
Les informations supplémentaires suivantes sont transmises à
DVDeventNotification lorsque cet événement se produit :
• eventArg2 - Une valeur booléenne indiquant la disponibilité des boutons.
Zéro (0) indique que les boutons sont disponibles. Un (1) indique
qu’aucun bouton n’est disponible.
• eventArg3 - Un nombre entier ou une adresse indiquant la durée de
l’image fixe en secondes. 0xFFFFFFFF indique une image fixe infinie.
titleChange
A lieu lorsque le numéro du titre en cours change.
Les informations supplémentaires suivantes sont transmises à
DVDeventNotification lorsque cet événement se produit :
• eventArg2 - Un nombre entier ou une adresse indiquant le nouveau
numéro du titre.
UOPchange
A lieu lorsque l’un des mécanismes de lecture ou de recherche disponibles
a changé.
Les informations supplémentaires suivantes sont transmises à
DVDeventNotification lorsque cet événement se produit :
• eventArg2 - Un nombre entier ou une adresse indiquant les mécanismes
de lecture ou de recherche explicitement désactivés par le DVD.
warning
A lieu lorsqu’une condition d’avertissement DVD est rencontrée.
Les informations supplémentaires suivantes sont transmises à
DVDeventNotification lorsque cet événement se produit :
• eventArg2 - Un nombre entier ou une adresse indiquant la condition
d’avertissement. La condition d’avertissement sera l’une des valeurs
suivantes :
invalidDVD1_0Disc. Le DVD n’a pas été correctement créé. La lecture
peut continuer, mais un comportement inattendu risque de se produire.
formatNotSupported. Un décodeur ne supporte pas le format courant.
La lecture d’un flux risque de ne pas fonctionner.
illegalNavCommand. Le processeur de commande de navigation DVD
interne a essayé de traiter une commande illégale.
open.
seek.
read.
■
■
■
■
■
■
182
Chapitre 10 : Evénements et messages
Voir aussi
DVD
on endSprite
Utilisation
-- Syntaxe Lingo
on endSprite
instruction(s)
end
// Syntaxe JavaScript
function endSprite() {
instruction(s);
}
Description
Message système et gestionnaire d’événement ; contient des éléments Lingo exécutés lorsque la
tête de lecture sort d’une image-objet et passe à une image dans laquelle l’image-objet n’existe pas.
Il est généré après exitFrame.
Placez les gestionnaires on endSprite dans un script de comportement.
Director détruit les instances des scripts de comportement liés à l’image-objet immédiatement
après l’événement endSprite.
Le gestionnaire d’événement reçoit la référence de comportement ou de script d’image me
lorsqu’il est utilisé dans un comportement. Ce message endSprite est envoyé après le message
exitFrame si la tête de lecture continue jusqu’à la fin de l’image.
Les méthodes go(), play() et updateStage() sont désactivées dans un gestionnaire on
endSprite.
Exemple
Le gestionnaire suivant est exécuté lorsque la tête de lecture quitte une image-objet :
-- Syntaxe Lingo
on endSprite me
-- nettoyage
gNombreDeRequins = gNombreDeRequins - 1
sound(5).stop()
end
// Syntaxe JavaScript
function endSprite() {
// nettoyage
gNombreDeRequins--;
sound(5).stop();
}
Voir aussi
on beginSprite, on exitFrame
183
on enterFrame
Utilisation
-- Syntaxe Lingo
on enterFrame
instruction(s)
end
// Syntaxe JavaScript
function enterFrame() {
instruction(s);
}
Description
Message système et gestionnaire d’événement ; contient des instructions exécutées à chaque fois
que la tête de lecture entre dans l’image.
Placez les gestionnaires on enterFrame dans un script de comportement, d’image ou
d’animation, comme suit :
• Pour affecter le gestionnaire à une seule image-objet, placez-le dans un comportement lié
à l’image-objet.
• Pour affecter le gestionnaire à une seule image, placez-le dans le script de l’image.
• Pour affecter le gestionnaire à chaque image (à moins que vous n’indiquiez explicitement
le contraire), placez le gestionnaire on enterFrame dans un script d’animation. Le gestionnaire est exécuté à chaque fois que la tête de lecture entre dans une image à moins que
le script d’image n’ait son propre gestionnaire. Si le script d’image a son propre gestionnaire,
le gestionnaire on enterFrame du script d’image prend priorité sur le gestionnaire
on enterFrame du script d’animation.
L’ordre des événements d’images est stepFrame, prepareFrame, enterFrame et exitFrame.
Cet événement reçoit la référence d’objet me lorsqu’il est utilisé dans un comportement.
Exemple
Le gestionnaire suivant désactive la condition d’asservissement pour les images 1 à 5 à chaque fois
que la tête de lecture entre dans l’image :
-- Syntaxe Lingo
on enterFrame
repeat with i = 1 to 5
_movie.puppetSprite(i, FALSE)
end repeat
end
// Syntaxe JavaScript
function enterFrame() {
for (i=1;i<=5;i++) {
_movie.puppetSprite(i, false);
}
}
184
Chapitre 10 : Evénements et messages
on EvalScript
Utilisation
-- Syntaxe Lingo
on EvalScriptunParamètre
instruction(s)
end
// Syntaxe JavaScript
function EvalScript(unParamètre) {
instruction(s);
}
Description
Message système et gestionnaire d’événement ; dans une animation à contenu Macromedia
Shockwave, renferme des instructions exécutées lorsque le gestionnaire reçoit un message
EvalScript d’un navigateur. Le paramètre est une chaîne reçue du navigateur web.
• Le message EvalScript peut inclure une chaîne que Director peut interpréter comme une
•
instruction Lingo. Lingo n’accepte pas de chaînes imbriquées. Si le gestionnaire que vous
appelez attend une chaîne comme paramètre, passez le paramètre comme symbole.
Le gestionnaire on EvalScript est appelé par la méthode JavaScript ou VBScript
EvalScript() dans un navigateur web.
Seuls les comportements devant être contrôlés par les utilisateurs doivent être inclus dans
pour des raisons de sécurité, ne donnez pas d’accès complet à tous les
comportements.
on EvalScript;
Remarque : Si vous placez un mot-clé return à la fin de votre gestionnaire EvalScript, la valeur
renvoyée peut être utilisée par JavaScript dans le navigateur web.
Exemple
L’exemple suivant indique comment faire passer la tête de lecture à une image spécifique en
fonction de l’image passée comme paramètre :
-- Syntaxe Lingo
on EvalScript unParamètre
_movie.go(unParamètre)
end
// Syntaxe JavaScript
function EvalScript(unParamètre) {
_movie.go(unParamètre);
}
Le gestionnaire suivant exécute l’instruction _movie.go(unParamètre) s’il reçoit un message
EvalScript contenant l’argument chien, chat ou arbre :
-- Syntaxe Lingo
on EvalScript unParamètre
case unParamètre of
"chien", "chat", "arbre": _movie.go(unParamètre)
end case
end
185
// Syntaxe JavaScript
function EvalScript(unParamètre) {
switch(unParamètre) {
case "chien", "chat", "arbre": _movie.go(unParamètre);
}
}
Une instruction d’appel possible dans JavaScript serait EvalScript ("chien").
Le gestionnaire suivant prend un argument qui pourrait être un nombre ou un symbole :
-- Syntaxe Lingo
on EvalScript unParamètre
if word 1 of unParamètre = "monGestionnaire" then
_movie.go(unParamètre)
end if
end
// Syntaxe JavaScript
function EvalScript(unParamètre) {
if (unParamètre.indexOf("monGestionnaire",0)) {
_movie.go(unParamètre);
}
}
Le gestionnaire suivant nécessite normalement une chaîne comme argument. L’argument est
reçu comme un symbole, puis converti en chaîne dans le gestionnaire par la fonction string :
-- Syntaxe Lingo
on monGestionnaire unParamètre
_movie.go(chaîne(unParamètre))
end
// Syntaxe JavaScript
fonction monGestionnaire(unParamètre {
_movie.go(unParamètre.toString());
}
Voir aussi
externalEvent(), return (mot-clé)
on exitFrame
Utilisation
-- Syntaxe Lingo
on exitFrame
instruction(s)
end
// Syntaxe JavaScript
function exitFrame() {
instruction(s);
}
Description
Message système et gestionnaire d’événement ; contient des instructions exécutées à chaque fois
que la tête de lecture quitte l’image à laquelle le gestionnaire on exitFrame est lié. Le gestionnaire on exitFrame est pratique pour placer des instructions permettant de réinitialiser des conditions inutiles une fois sorti de l’image.
186
Chapitre 10 : Evénements et messages
Placez les gestionnaires on exitFrame dans des scripts de comportements, d’image ou
d’animation de la façon suivante :
• Pour affecter le gestionnaire à une seule image-objet, placez-le dans un comportement lié
à l’image-objet.
• Pour affecter le gestionnaire à une seule image, placez-le dans le script de l’image.
• Pour affecter le gestionnaire à chaque image (à moins que vous n’indiquiez explicitement le
contraire), placez le gestionnaire dans un script d’animation. Le gestionnaire on exitFrame est
exécuté à chaque fois que la tête de lecture quitte l’image, à moins que le script d’image n’ait
son propre gestionnaire on exitFrame. Le cas échéant, le gestionnaire on exitFrame du
script d’image prend priorité sur celui du script d’animation.
Lorsque utilisé dans un comportement, cet événement reçoit la référence me du script d’imageobjet ou d’image. L’ordre des événements d’image est prepareFrame, enterFrame et exitFrame.
Exemple
Le gestionnaire suivant désactive toutes les conditions d’asservissement lorsque la tête de lecture
quitte l’image :
-- Syntaxe Lingo
on exitFrame me
repeat with i = 48 down to 1
sprite(i).scripted = FALSE
end repeat
end
// Syntaxe JavaScript
function exitFrame() {
for (i=48; i>=1; i--);
sprite(i).scripted = false;
}
}
Le gestionnaire suivant déplace la tête de lecture vers une image spécifiée si la valeur de la variable
globale vTotal dépasse 1 000 lorsque la tête de lecture quitte l’image :
// Syntaxe JavaScript
function exitFrame() {
if (_global.vTotal > 1000) {
_movie.go("Terminé");
}
}
Voir aussi
on enterFrame
187
on getBehaviorDescription
Utilisation
-- Syntaxe Lingo
on getBehaviorDescription
instruction(s)
end
// Syntaxe JavaScript
function getBehaviorDescription() {
instruction(s);
}
Description
Message système et gestionnaire d’événement; contient des instructions renvoyant la chaîne
apparaissant dans le volet de description de l’inspecteur de comportement lorsque le
comportement est sélectionné.
La chaîne de description est facultative.
Director envoie le message getBehaviorDescription aux comportements liés à une image-objet
à l’ouverture de l’inspecteur de comportement. Placez le gestionnaire on
getBehaviorDescription dans un comportement.
Le gestionnaire peut contenir des caractères de retour de chariot pour formater les descriptions
multilignes.
Exemple
L’instruction suivante affiche « Barre de défilement vertical de champ de texte multiligne » dans
le volet de description :
-- Syntaxe Lingo
on getBehaviorDescription
return "Barre de défilement vertical de champ de texte multiligne"
end
// Syntaxe JavaScript
function getBehaviorDescription() {
return "Barre de défilement vertical de champ de texte multiligne";
}
Voir aussi
on getPropertyDescriptionList, on getBehaviorTooltip, on runPropertyDialog
188
Chapitre 10 : Evénements et messages
on getBehaviorTooltip
Utilisation
-- Syntaxe Lingo
on getBehaviorTooltip
instruction(s)
end
// Syntaxe JavaScript
function getBehaviorTooltip() {
instruction(s);
}
Description
Message système et gestionnaire d’événement ; contient des instructions renvoyant la chaîne
apparaissant dans une info-bulle pour un script de la palette des bibliothèques.
Director envoie le message getBehaviorTooltip au script lorsque le curseur s’arrête au-dessus de
ce dernier dans la palette des bibliothèques. Placez le gestionnaire on getBehaviorTooltip dans
le comportement.
L’utilisation du gestionnaire est facultative. Si aucun gestionnaire n’est fourni, le nom de l’acteur
apparaît dans l’info-bulle.
Le gestionnaire peut contenir des caractères de retour de chariot pour formater les descriptions
multilignes.
Exemple
L’instruction suivante affiche Pièce de puzzle dans le volet de description :
-- Syntaxe Lingo
on getBehaviorTooltip
return "Pièce de puzzle"
end
// Syntaxe JavaScript
function getBehaviorTooltip() {
return "Pièce de puzzle";
}
Voir aussi
on getPropertyDescriptionList, on getBehaviorDescription, on runPropertyDialog
189
on getPropertyDescriptionList
Utilisation
-- Syntaxe Lingo
on getPropertyDescriptionList
instruction(s)
end
// Syntaxe JavaScript
fonction getPropertyDescriptionList() {
instruction(s);
}
Description
Message système et gestionnaire d’événement ; contient des instructions générant une liste de
définitions et de libellés pour les paramètres qui apparaissent dans la boîte de dialogue Paramètres
d’un comportement.
Placez le gestionnaire on getPropertyDescriptionList dans un script de comportement.
Les comportements ne contenant pas de gestionnaire on getPropertyDescriptionList
n’apparaissent pas dans la boîte de dialogue Paramètres et ne peuvent pas être modifiés à partir
de l’interface de Director.
Le message on getPropertyDescriptionList est envoyé lorsqu’une action entraînant l’ouverture de l’inspecteur de comportement a lieu : soit lorsque l’utilisateur fait glisser un comportement sur le scénario, soit lorsqu’il double-clique sur un comportement dans l’inspecteur de
comportement.
Les paramètres #default, #format et #comment sont obligatoires pour chaque paramètre. Les
valeurs possibles de ces paramètres sont :
190
#default
Valeur initiale du paramètre.
#format
#integer #float #string #symbol #member #bitmap #filmloop #field #palette
#picture #sound #button #shape #movie #digitalvideo #script #richtext
#ole #transition #xtra #frame #marker #ink #boolean
#comment
Chaîne descriptive apparaissant à gauche du champ modifiable dans la boîte de
dialogue Paramètres.
#range
Fourchette de valeurs possibles pouvant être affectées à une propriété. Cette
fourchette est spécifiée sous la forme d’une liste linéaire avec plusieurs valeurs ou
comme un minimum et maximum sous la forme d’une liste de propriétés : [#min:
valeurMin, #max: valeurMax].
Chapitre 10 : Evénements et messages
Exemple
Le gestionnaire suivant définit les paramètres d’un comportement apparaissant dans la boîte de
dialogue Paramètres. Chaque instruction commençant par addProp ajoute un paramètre à la liste
appelée Description. Chaque élément ajouté à la liste définit une propriété et ses valeurs
#default, #format et #comment :
on getPropertyDescriptionList
description = [:]
adescription.addProp(#dynamic, [#default:1, #format:#boolean, \
#comment:"Dynamique"])
description.addProp(#fieldNum, [#default:1, #format:#integer, \
#comment:"Image-objet à faire défiler:"])
description.addProp(#extentSprite,[#default:1,#format:#integer, \
#comment: "Etendre l’image-objet:"])
description.addProp(#proportional, [#default:1, #format:#boolean, \
#comment: "Proportionnel:"])
return description
end
Voir aussi
addProp, on getBehaviorDescription, on runPropertyDialog
on hyperlinkClicked
Utilisation
-- Syntaxe Lingo
on hyperlinkClicked me, données, plage
instruction(s)
end
// Syntaxe JavaScript
function hyperlinkClicked(données, plage){
instruction(s);
}
Description
Message système et gestionnaire d’événement ; utilisé pour déterminer si l’utilisateur a cliqué sur
un lien hypertexte.
Ce gestionnaire d’événement comprend les paramètres suivants :
•
•
•
Utilisé dans un comportement pour identifier l’instance d’image-objet.
Les données du lien hypertexte même, la chaîne saisie dans l’inspecteur de texte lors
de la modification de l’acteur texte.
plage La plage de caractères du lien hypertexte dans le texte (il est possible d’obtenir le texte
de la plage même en utilisant la syntaxe réfActeur.char[plage[1]..plage[2]].
me
données
Ce gestionnaire doit être attaché à une image-objet en tant que script de comportement. Evitez de
placer ce gestionnaire dans un script d’acteur.
191
Exemple
Le comportement suivant affiche un lien utilisé pour examiner le lien hypertexte sélectionné,
passer à une URL si nécessaire, puis afficher le texte du lien dans la fenêtre Messages :
-- Syntaxe Lingo
property spriteNum
on hyperlinkClicked(me, données, plage)
if data starts "http://" then
gotoNetPage(données)
end if
acteurCourant = sprite(spriteNum).member
chaîneDancre = acteurCourant.char[plage[1]..plage[2]]
put("Le lien hypertexte"&&chaîneDancre&&"vient d’être activé.")
end
// Syntaxe JavaScript
function hyperlinkClicked(données, plage) {
var st = data.slice(0,7);
var ht = "http://";
if (st = ht) {
gotoNetPage(données) ;
}
var acteurCourant = sprite(this.spriteNum).member;
var r1 = acteurCourant.getPropRef("car", plage[1]).hyperlinkRange;
var a = r1[1] - 1;
var b = r1[2];
var st = new String(acteurCourant.text);
var chaîneDancre = st.slice(a, b);
put("Le lien hypertexte" + chaîneDancre + " vient d’être activé.");
}
on idle
Utilisation
-- Syntaxe Lingo
on idle
instruction(s)
end
// Syntaxe JavaScript
function idle() {
instruction(s);
}
Description
Message système et gestionnaire d’événement ; contient des instructions exécutées lorsque
l’animation n’a pas d’autres événements à traiter et constitue un endroit pratique pour placer
les instructions à exécuter aussi fréquemment que possible, comme celles qui mettent à jour
les valeurs des variables globales et affichent les conditions de l’animation courante.
Les instructions des gestionnaires on idle étant fréquemment exécutées, il est recommandé de
ne pas placer d’instruction Lingo dont le traitement prend trop de temps dans un gestionnaire
on idle.
Il est souvent préférable de placer les gestionnaires on idle dans des scripts d’image plutôt que
dans des scripts d’animation pour tirer parti du gestionnaire on idle uniquement lorsque
nécessaire.
192
Chapitre 10 : Evénements et messages
Director peut charger des acteurs à partir d’une distribution interne ou externe pendant un
événement idle. Cependant, il ne peut pas charger des acteurs liés pendant un événement idle.
Le message idle est envoyé uniquement aux scripts d’image et d’animation.
Exemple
Le gestionnaire suivant met à jour l’heure affichée dans l’animation lorsqu’il n’y a aucun autre
événement à traiter :
-- Syntaxe Lingo
on idle
member("Heure").text = _system.time()
end idle
// Syntaxe JavaScript
function idle() {
member("Heure").text = _system.time();
}
Voir aussi
idleHandlerPeriod
on isOKToAttach
Utilisation
-- Syntaxe Lingo
on isOKToAttach me, typeDimageObjet, numéroDimageObjet
instruction(s)
end
// Syntaxe JavaScript
function isOKToAttach(typeDimageObjet, numéroDimageObjet) {
instruction(s)
}
Description
Gestionnaire intégré ; vous pouvez ajouter ce gestionnaire à un comportement en vue de vérifier
le type d’image-objet auquel le comportement est associé et empêcher que ce comportement soit
attaché à des types d’images-objets non appropriés.
Lorsque le comportement est associé à une image-objet, le gestionnaire est exécuté et Director lui
transmet le type et le numéro de l’image-objet. L’argument me contient une référence au comportement associé à l’image-objet.
Ce gestionnaire est exécuté avant le gestionnaire on getPropertyDescriptionList.
L’auteur Lingo peut vérifier deux types d’images-objets. #graphic inclut tous les acteurs
graphique tels que les formes, les bitmaps, les vidéos numériques, le texte, etc. #script indique
le comportement associé à la piste des scripts. Dans ce cas, numéroDimageObjet est 1.
Pour chacun de ces types d’images-objets, le gestionnaire doit renvoyer la valeur TRUE ou FALSE.
La valeur TRUE indique que le comportement peut être associé à l’image-objet. La valeur FALSE
empêche l’association du comportement à l’image-objet.
Si le comportement ne contient pas de gestionnaire on isOKToAttach, le comportement peut
être associé à n’importe quelle image ou image-objet.
193
Ce gestionnaire est appelé lors de l’association initiale du comportement à l’image-objet ou à la
piste des scripts et lors de l’association d’un nouveau comportement à une image-objet à l’aide de
l’inspecteur de comportement.
Exemple
L’instruction suivante vérifie le type d’image-objet à laquelle le comportement est associé et
renvoie la valeur TRUE pour toutes les images-objets graphique à l’exception des formes et la valeur
FALSE pour la piste des scripts :
-- Syntaxe Lingo
on isOKToAttach me, typeDimageObjet, numéroDimageObjet
case typeDimageObjet of
#graphic: -- tout type d’image-objet graphique
return sprite(numéroDimageObjet).member.type <> #shape
-- fonctionne avec tout, sauf les acteurs forme
#script: --piste des scripts de l’image
return FALSE -- ne fonctionne pas comme script d’image
end case
end
// Syntaxe JavaScript
function isOKToAttach(typeDimageObjet, numéroDimageObjet) {
switch (typeDimageObjet) {
case symbol("graphique"): // tout type d’image-objet graphique
return sprite(numéroDimageObjet).member.type != symbol("forme");
// fonctionne avec tout, sauf les acteurs forme
case symbol("script"): // piste des scripts de l’image
return false; // ne fonctionne pas comme script d’image
}
}
on keyDown
Utilisation
-- Syntaxe Lingo
on keyDown
instruction(s)
end
// Syntaxe JavaScript
function keyDown() {
instruction(s);
}
Description
Message système et gestionnaire d’événement ; contient les instructions exécutées lorsqu’une
touche est enfoncée.
Lorsqu’une touche est enfoncée, Director recherche un gestionnaire on keyDown aux emplacements suivants et dans l’ordre qui suit : gestionnaire d’événement principal, script d’image-objet
champ modifiable, script d’acteur champ, script d’image et script d’animation. Pour les imagesobjets et les acteurs, les gestionnaires on keyDown ne fonctionnent qu’avec les acteurs texte et
champ modifiables. Un événement keyDown n’a aucun effet sur les autres types d’acteurs (acteurs
bitmap, par exemple). Si le fait d’appuyer sur une touche doit produire un résultat identique dans
toute l’animation, définissez keyDownScript.
194
Chapitre 10 : Evénements et messages
Director arrête la recherche dès qu’il rencontre le premier gestionnaire on keyDown, sauf si celuici contient une commande pass exigeant le renvoi du message keyDown à l’emplacement suivant.
Le gestionnaire d’événement on keyDown est idéal pour placer des instructions créant des
raccourcis clavier ou d’autres fonctions d’interface, en fonction des actions que vous souhaitez
déclencher lorsque l’utilisateur appuie sur une touche du clavier.
Lorsque l’animation est lue sous forme d’applet, un gestionnaire on keyDown intercepte toujours
les touches enfoncées, même s’il est vide. Lorsque l’utilisateur saisit du texte dans un champ
modifiable, le gestionnaire on keyDown de ce champ doit inclure la commande pass pour que les
caractères saisis apparaissent dans le champ.
L’endroit où vous placez un gestionnaire on keyDown peut affecter le moment où il est exécuté.
• Pour appliquer le gestionnaire à une image-objet champ modifiable particulière, placez-le dans
•
•
•
un script d’image-objet.
Pour appliquer le gestionnaire à un acteur champ modifiable quelconque, placez-le dans un
script d’acteur.
Pour appliquer le gestionnaire à une image entière, placez-le dans un script d’image.
Pour appliquer le gestionnaire à l’animation entière, placez-le dans un script d’animation.
Vous pouvez annuler un gestionnaire on keyDown en plaçant un autre gestionnaire on keyDown
dans une position qui sera vérifiée par Lingo avant celle du gestionnaire à annuler. Par exemple,
vous pouvez annuler un gestionnaire on keyDown affecté à un acteur en plaçant un gestionnaire
on keyDown dans un script d’image-objet.
Exemple
Le gestionnaire suivant vérifie si la touche Retour a été enfoncée et, le cas échéant, fait passer la
tête de lecture à une autre image :
-- Syntaxe Lingo
on keyDown
if (_key.key = RETURN) then _movie.go("additionnerLaSomme")
end keyDown
// Syntaxe JavaScript
function keyDown() {
if (_key.keyCode == 36) {
_movie.go("additionnerLaSomme");
}
}
Voir aussi
charToNum(), keyDownScript, keyUpScript, key, keyCode, keyPressed()
195
on keyUp
Utilisation
-- Syntaxe Lingo
on keyUp
instruction(s)
end
// Syntaxe JavaScript
function keyUp() {
instruction(s);
}
Description
Message système et gestionnaire d’événement ; contient des instructions exécutées lorsque
l’utilisateur relâche une touche. Le gestionnaire on keyUp est similaire au gestionnaire on
keyDown, à ceci près que l’événement se produit après l’apparition d’un caractère si l’image-objet
champ ou texte est modifiable à l’écran.
Lorsque l’utilisateur relâche une touche, Lingo recherche un gestionnaire on keyUp aux
emplacements suivants et dans l’ordre qui suit : gestionnaire d’événement principal, script
d’image-objet champ modifiable, script d’acteur champ, script d’image et script d’animation.
Pour les images-objets et les acteurs, les gestionnaires on keyUp ne fonctionnent qu’avec les
chaînes modifiables. Un événement keyUp n’a aucun effet sur les autres types d’acteurs (acteurs
bitmap, par exemple). Si le fait de relâcher une touche doit produire un résultat identique dans
toute l’animation, définissez keyUpScript.
Lingo arrête la recherche dès qu’il rencontre le premier gestionnaire on keyUp, sauf si celui-ci
contient une commande pass exigeant le renvoi du message keyUp au gestionnaire ou script
suivant.
Le gestionnaire on keyUp est idéal pour placer des instructions créant des raccourcis clavier ou
d’autres fonctions d’interface, en fonction des actions que vous souhaitez déclencher lorsque
l’utilisateur relâche une touche du clavier.
Lorsque l’animation est lue sous forme d’applet, un gestionnaire on keyUp enregistre toujours
les touches enfoncées, même s’il est vide. Lorsque l’utilisateur saisit du texte dans un champ
modifiable, le gestionnaire on keyUp de ce champ doit inclure la commande pass pour que les
caractères saisis apparaissent dans le champ.
L’endroit où vous placez un gestionnaire on keyUp affecte le moment où il est exécuté, tel que :
• Pour appliquer le gestionnaire à une image-objet champ modifiable spécifique, placez-le dans
•
•
•
un comportement.
Pour appliquer le gestionnaire à un acteur champ modifiable quelconque, placez-le dans un
script d’acteur.
Pour appliquer le gestionnaire à une image entière, placez-le dans un script d’image.
Pour appliquer le gestionnaire à l’animation entière, placez-le dans un script d’animation.
Vous pouvez annuler un gestionnaire on keyUp en plaçant un autre gestionnaire on keyUp dans
une position qui sera vérifiée par Lingo avant celle du gestionnaire à annuler. Par exemple, vous
pouvez annuler le gestionnaire on keyUp affecté à un acteur en plaçant un gestionnaire on keyUp
dans un script d’image-objet.
196
Chapitre 10 : Evénements et messages
Exemple
Le gestionnaire suivant vérifie si la touche Retour a été relâchée et, le cas échéant, fait passer la tête
de lecture à une autre image :
-- Syntaxe Lingo
on keyUp
if (_key.key = RETURN) then _movie.go("additionnerLaSomme")
end keyUp
// Syntaxe JavaScript
function keyUp() {
if (_key.keyCode == 36) {
_movie.go("additionnerLaSomme");
}
}
Voir aussi
on keyDown, keyDownScript, keyUpScript
on mouseDown (gestionnaire d’événement)
Utilisation
-- Syntaxe Lingo
on mouseDown
instruction(s)
end
// Syntaxe JavaScript
function mouseDown() {
instruction(s);
}
Description
Message système et gestionnaire d’événement; contient des instructions exécutées lorsque le
bouton de la souris est enfoncé.
Lorsque le bouton de la souris est enfoncé, Lingo recherche un gestionnaire on mouseDown aux
emplacements suivants et dans l’ordre qui suit : gestionnaire d’événement principal, script
d’image-objet, script d’acteur, script d’image et script d’animation. Lingo arrête la recherche
lorsqu’il atteint le premier emplacement contenant un gestionnaire on mouseDown, sauf si ce
dernier contient une commande pass permettant de passer explicitement le message mouseDown à
l’emplacement suivant.
Pour que l’animation réponde toujours de la même manière lorsque le bouton de la souris est
enfoncé, définissez mouseDownScript ou placez un gestionnaire mouseDown dans un script de
l’animation.
Les gestionnaires d’événements on mouseDown sont pratiques pour placer des instructions faisant
clignoter des images, déclenchant des effets sonores ou provoquant le déplacement d’imagesobjets lorsque l’utilisateur appuie sur le bouton de la souris.
L’endroit où vous placez un gestionnaire on mouseDown peut affecter le moment où il est exécuté.
• Pour appliquer le gestionnaire à une image-objet spécifique, placez-le dans un script d’image•
objet.
Pour appliquer le gestionnaire à un acteur quelconque, placez-le dans un script d’acteur.
197
• Pour appliquer le gestionnaire à une image entière, placez-le dans un script d’image.
• Pour appliquer le gestionnaire à l’animation entière, placez-le dans un script d’animation.
Vous pouvez annuler un gestionnaire on mouseDown en plaçant un autre gestionnaire on
dans une position qui sera vérifiée par Lingo avant celle du gestionnaire à annuler.
Par exemple, vous pouvez annuler un gestionnaire on mouseDown affecté à un acteur en plaçant
un gestionnaire on mouseDown dans le script d’une image-objet.
mouseDown
Lorsqu’il est utilisé dans un comportement, cet événement reçoit en paramètre la référence au
script de l’image-objet ou au script d’image me.
Exemple
Le gestionnaire suivant vérifie si l’utilisateur clique à un endroit quelconque de la scène et, le cas
échéant, fait passer la tête de lecture à une autre image :
-- Syntaxe Lingo
on mouseDown
if (_mouse.clickOn = 0) then _movie.go("additionnerLaSomme")
end
// Syntaxe JavaScript
function mouseDown() {
if (_mouse.clickOn == 0) {
_movie.go("additionnerLaSomme");
}
}
Le gestionnaire suivant, affecté à un script d’image-objet, lit un son lorsque l’utilisateur clique sur
l’image-objet :
-- Syntaxe Lingo
on mouseDown
sound(1).play(member("Grillons"))
end
// Syntaxe JavaScript
function mouseDown() {
sound(1).play(member("Grillons"));
}
Voir aussi
clickOn, mouseDownScript, mouseUpScript
198
Chapitre 10 : Evénements et messages
on mouseEnter
Utilisation
-- Syntaxe Lingo
on mouseEnter
instruction(s)
end
// Syntaxe JavaScript
function mouseEnter() {
instruction(s);
}
Description
Message système et gestionnaire d’événement ; contient les instructions exécutées lorsque le
pointeur de la souris entre en contact avec la zone référencée de l’image-objet. Il n’est pas
nécessaire que le bouton de la souris soit enfoncé.
Si l’image-objet est un acteur bitmap dont l’encre est Dessin seul, sa zone référencée correspond à
la portion d’image affichée. Dans tous les autres cas, elle correspond au rectangle de délimitation
de l’image-objet.
Lorsqu’il est utilisé dans un comportement, cet événement reçoit en paramètre la référence au
script de l’image-objet ou au script d’image me.
Exemple
L’instruction suivante est un comportement de bouton simple qui change l’image bitmap du
bouton lorsque la souris survole, puis sort du bouton :
-- Syntaxe Lingo
property spriteNum
on mouseEnter me
-- détermine l’acteur courant et passe à l’acteur suivant de la
distribution.
acteurCourant = sprite(spriteNum).member.number
sprite(spriteNum).member = acteurCourant + 1
end
on mouseLeave me
-- détermine l’acteur courant et passe à l’acteur suivant de la
distribution.
acteurCourant = sprite(spriteNum).member.number
sprite(spriteNum).member = acteurCourant -1
end
199
// Syntaxe JavaScript
var spriteNum;
function mouseEnter() {
// détermine l’acteur courant et passe à l’acteur suivant de la
distribution.
acteurCourant = sprite(spritenum).member.number;
sprite(spritenum).member = acteurCourant +1;
}
function mouseLeave() {
// détermine l’acteur courant et passe à l’acteur précédent de la
distribution.
acteurCourant = sprite(spritenum).member.number;
sprite(spritenum).member = acteurCourant - 1;
}
Voir aussi
on mouseLeave, on mouseWithin
on mouseLeave
Utilisation
-- Syntaxe Lingo
on mouseLeave
instruction(s)
end
// Syntaxe JavaScript
function mouseLeave() {
instruction(s);
}
Description
Message système et gestionnaire d’événement ; contient les instructions exécutées lorsque la souris
sort de la zone référencée de l’image-objet. Il n’est pas nécessaire que le bouton de la souris soit
enfoncé.
Si l’image-objet est un acteur bitmap dont l’encre est Dessin seul, sa zone référencée correspond à
la portion d’image affichée. Dans tous les autres cas, elle correspond au rectangle de délimitation
de l’image-objet.
Lorsqu’il est utilisé dans un comportement, cet événement reçoit en paramètre la référence au
script de l’image-objet ou au script d’image me.
Exemple
L’instruction suivante est un comportement de bouton simple qui change l’image bitmap du
bouton lorsque la souris survole le bouton, puis en sort :
-- Syntaxe Lingo
property spriteNum
on mouseEnter me
-- détermine l’acteur courant et passe à l’acteur suivant de la
distribution.
acteurCourant = sprite(spriteNum).member.number
sprite(spriteNum).member = acteurCourant + 1
200
Chapitre 10 : Evénements et messages
end
on mouseLeave me
-- détermine l’acteur courant et passe à l’acteur suivant de la
distribution.
acteurCourant = sprite(spriteNum).member.number
sprite(spriteNum).member = acteurCourant -1
end
// Syntaxe JavaScript
var spriteNum;
function mouseEnter() {
// détermine l’acteur courant et passe à l’acteur suivant de la
distribution.
acteurCourant = sprite(spritenum).member.number;
sprite(spritenum).member = acteurCourant +1;
}
function mouseLeave() {
// détermine l’acteur courant et passe à l’acteur précédent de la
distribution.
acteurCourant = sprite(spritenum).member.number;
sprite(spritenum).member = acteurCourant - 1;
}
Voir aussi
on mouseEnter, on mouseWithin
on mouseUp (gestionnaire d’événement)
Utilisation
-- Syntaxe Lingo
on mouseUp
instruction(s)
end
// Syntaxe JavaScript
function mouseUp() {
instruction(s);
}
Description
Message système et gestionnaire d’événement ; contient les instructions exécutées lorsque le
bouton de la souris est relâché.
Lorsque l’utilisateur relâche le bouton de la souris, Lingo recherche un gestionnaire on mouseUp
aux emplacements suivants et dans l’ordre qui suit : gestionnaire d’événement principal, script
d’image-objet, script d’acteur, script d’image et script d’animation. Lingo arrête la recherche dès
qu’il rencontre le premier gestionnaire on mouseUp, sauf si celui-ci contient une commande pass
permettant de passer explicitement le message mouseUp à l’emplacement suivant.
Pour obtenir la même réponse dans toute l’animation lorsque l’utilisateur relâche le bouton de la
souris, définissez the mouseUpScript.
201
Le gestionnaire d’événement on mouseUp est pratique pour appeler un script Lingo modifiant
l’apparence des objets (boutons, par exemple) une fois que l’utilisateur a cliqué dessus. Pour ce
faire, il suffit de changer l’acteur de l’image-objet sur laquelle l’utilisateur a cliqué, dès qu’il
relâche le bouton de la souris.
L’endroit où vous placez un gestionnaire on mouseUp affecte le moment où il est exécuté, de la
manière suivante :
• Pour appliquer le gestionnaire à une image-objet spécifique, placez-le dans un script d’imageobjet.
• Pour appliquer le gestionnaire à un acteur quelconque, placez-le dans un script d’acteur.
• Pour appliquer le gestionnaire à une image entière, placez-le dans un script d’image.
• Pour appliquer le gestionnaire à l’animation entière, placez-le dans un script d’animation.
Vous pouvez annuler un gestionnaire on mouseUp en plaçant un autre gestionnaire on mouseUp
dans une position qui sera vérifiée par Lingo avant celle du gestionnaire à annuler. Par exemple,
vous pouvez annuler un gestionnaire on mouseUp affecté à un acteur en plaçant un gestionnaire
on mouseUp dans un script d’image-objet.
Lorsqu’il est utilisé dans un comportement, cet événement reçoit en paramètre la référence au
script de l’image-objet ou au script d’image me.
Exemple
Le gestionnaire suivant, affecté à l’image-objet 10, change l’acteur associé à cette image-objet à
chaque fois que l’utilisateur relâche le bouton de la souris après avoir cliqué sur l’image-objet :
-- Syntaxe Lingo
on mouseUp
sprite(10).member = member ("Gris")
end
// Syntaxe JavaScript
function mouseUp() {
sprite(10).member = member ("Gris");
}
Voir aussi
on mouseDown (gestionnaire d’événement)
on mouseUpOutside
Utilisation
-- Syntaxe Lingo
on mouseUpOutside me
instruction(s)
end
// Syntaxe JavaScript
function mouseUpOutside() {
instruction(s);
}
Description
Message système et gestionnaire d’événement; envoyé lorsque l’utilisateur clique sur une imageobjet, puis relâche le bouton de la souris en dehors de cette dernière.
202
Chapitre 10 : Evénements et messages
Exemple
L’instruction suivante lit un son lorsque l’utilisateur clique sur une image-objet, puis relâche le
bouton de la souris en dehors du rectangle de délimitation de cette dernière :
-- Syntaxe Lingo
on mouseUpOutside me
sound(1).play(member("Professeur Machin"))
end
// Syntaxe JavaScript
function mouseUpOutside() {
sound(1).play(member("Professeur Machin"));
}
Voir aussi
on mouseEnter, on mouseLeave, on mouseWithin
on mouseWithin
Utilisation
-- Syntaxe Lingo
on mouseWithin
instruction(s)
end
// Syntaxe JavaScript
function mouseWithin() {
instruction(s);
}
Description
Message système et gestionnaire d’événement; contient les instructions exécutées lorsque la souris
est dans la zone référencée de l’image-objet. Il n’est pas nécessaire que le bouton de la souris soit
enfoncé.
Si l’image-objet est un acteur bitmap dont l’encre est Dessin seul, sa zone référencée correspond à
la partie d’image affichée. Dans tous les autres cas, elle correspond au rectangle de délimitation de
l’image-objet.
Lorsqu’il est utilisé dans un comportement, cet événement reçoit en paramètre la référence au
script de l’image-objet ou au script d’image me.
Exemple
L’instruction suivante affiche la position de la souris lorsqu’elle se trouve au-dessus d’une imageobjet :
-- Syntaxe Lingo
on mouseWithin
member("Affichage").text = string(_mouse.mouseH)
end
// Syntaxe JavaScript
function mouseWithin() {
member("Affichage").text = _mouse.mouseH.toString();
}
203
Voir aussi
on mouseEnter, on mouseLeave
on moveWindow
Utilisation
-- Syntaxe Lingo
on moveWindow
instruction(s)
end
// Syntaxe JavaScript
function moveWindow() {
instruction(s);
}
Description
Message système et gestionnaire d’événement; contient les instructions exécutées lorsqu’une
fenêtre est déplacée, par exemple lorsque l’utilisateur fait glisser une animation vers un nouvel
emplacement de la scène. Pratique pour placer le code Lingo qui doit être exécuté à chaque fois
que la fenêtre d’une animation est déplacée.
Exemple
Le gestionnaire suivant affiche un message dans la fenêtre Messages lorsque la fenêtre d’une
animation en cours de lecture est déplacée :
-- Syntaxe Lingo
on moveWindow
put("Déplacement de la fenêtre contenant" && _movie.name)
end
// Syntaxe JavaScript
function moveWindow() {
put "Déplacement de la fenêtre contenant + _movie.name);
}
Voir aussi
activeWindow, name (3D), windowList
204
Chapitre 10 : Evénements et messages
on openWindow
Utilisation
-- Syntaxe Lingo
on openWindow
instruction(s)
end
// Syntaxe JavaScript
function openWindow() {
instruction(s);
}
Description
Message système et gestionnaire d’événements; contient des instructions exécutées lorsque
Director ouvre l’animation en tant qu’animation dans une fenêtre. C’est aussi un endroit idéal
pour placer des instructions à exécuter à chaque fois que l’animation s’ouvre dans une fenêtre.
Exemple
Le gestionnaire suivant exécute le fichier audio Hourra lorsque la fenêtre de l’animation s’ouvre :
-- Syntaxe Lingo
on openWindow
sound(2).play(member("Hourra"))
end
// Syntaxe JavaScript
function openWindow() {
sound(2).play(member("Hourra"));
}
on prepareFrame
Utilisation
-- Syntaxe Lingo
on prepareFrame
instruction(s)
end
// Syntaxe JavaScript
function prepareFrame {
instruction(s);
}
Description
Message système et gestionnaire d’événements; contient des instructions exécutées immédiatement avant le dessin de l’image courante.
Contrairement aux événements beginSprite et endSprite, un événement prepareFrame est
généré à chaque fois que la tête de lecture arrive sur une image.
Le gestionnaire on prepareFrame est un bon endroit pour changer les propriétés de l’image-objet
avant qu’elle ne soit dessinée.
S’il est utilisé dans un comportement, le gestionnaire on prepareFrame reçoit la référence me.
205
Les commandes go, play et updateStage sont désactivées dans un gestionnaire
on prepareFrame.
Exemple
Le gestionnaire suivant définit la propriété locH de l’image-objet à laquelle le comportement est
lié :
-- Syntaxe Lingo
on prepareFrame me
sprite(me.spriteNum).locH = _mouse.mouseH
end
// Syntaxe JavaScript
function prepareFrame() {
sprite(spriteNum).locH = _mouse.mouseH;
}
Voir aussi
on enterFrame
on prepareMovie
Utilisation
-- Syntaxe Lingo
on prepareMovie
instruction(s)
end
// Syntaxe JavaScript
function prepareMovie() {
instruction(s);
}
Description
Message système et gestionnaire d’événements; contient des instructions exécutées après que
l’animation précharge les acteurs, mais avant qu’elle ne :
• crée des instances de comportements liées aux images-objets de la première image lue ;
• prépare la première image lue, y compris son dessin, la lecture des sons et l’exécution des
transitions et des effets de palette.
Les nouvelles variables globales utilisées pour le comportement des images-objets de la première
image doivent être initialisées dans le gestionnaire on prepareMovie. Il est inutile de redéfinir les
variables globales déjà définies par l’animation précédente.
Un gestionnaire on prepareMovie est un bon endroit pour placer un code Lingo ou JavaScript
servant à créer les variables globales, initialiser les variables, lire un son pendant que le reste de
l’animation se charge en mémoire ou vérifier et ajuster les paramètres de l’ordinateur tels que
le nombre de couleurs.
Les commandes go, play
on prepareMovie.
206
et updateStage sont désactivées dans un gestionnaire
Chapitre 10 : Evénements et messages
Exemple
Le gestionnaire suivant crée une variable globale lorsque l’animation débute :
-- Syntaxe Lingo
on prepareMovie
global ScoreActuel
ScoreActuel = 0
end
// Syntaxe JavaScript
function prepareMovie() {
_global.ScoreActuel = 0;
}
Voir aussi
on enterFrame, on startMovie
on resizeWindow
Utilisation
-- Syntaxe Lingo
on resizeWindow
instruction(s)
end
// Syntaxe JavaScript
function resizeWindow() {
instruction(s);
}
Description
Message système et gestionnaire d’événements; contient les instructions activées lorsqu’une
animation est lue dans une fenêtre et que l’utilisateur modifie les dimensions de cette fenêtre
en tirant sur sa case de redimensionnement ou sur l’un de ses bords.
Un gestionnaire d’événement on resizeWindow est idéal pour insérer des instructions se
rapportant aux dimensions de la fenêtre, comme le positionnement des images-objets et le
recadrement des animations de type vidéo numérique.
Exemple
Ce gestionnaire déplace l’image-objet 3 vers les coordonnées stockées dans la variable
emplacementCentral lorsque la fenêtre lue par l’animation est redimensionnée :
-- Syntaxe Lingo
on resizeWindow emplacementCentral
sprite(3).loc = emplacementCentral
end
// Syntaxe JavaScript
function resizeWindow(emplacementCentral) {
sprite(3).loc = emplacementCentral;
}
Voir aussi
drawRect, sourceRect
207
on rightMouseDown (gestionnaire d’événement)
Utilisation
-- Syntaxe Lingo
on rightMousedown
instruction(s)
end
// Syntaxe JavaScript
function rightMouseDown() {
instruction(s);
}
Description
Message système et gestionnaire d’événements; sous Windows, spécifie les instructions exécutées
lorsque l’utilisateur appuie sur le bouton droit de la souris. Sur Macintosh, les instructions sont
exécutées lorsque l’utilisateur appuie simultanément sur le bouton de la souris et la touche Ctrl,
et que la propriété emulateMultiButtonMouse a la valeur TRUE ; si cette propriété a la valeur
FALSE, ce gestionnaire d’événement n’a aucun effet sur Macintosh.
Exemple
Le gestionnaire suivant ouvre la fenêtre Aide lorsque l’utilisateur appuie sur le bouton droit de la
souris sous Windows :
-- Syntaxe Lingo
on rightMousedown
window("Aide").open()
end
// Syntaxe JavaScript
function rightMouseDown() {
window("Aide").open();
}
on rightMouseUp (gestionnaire d’événements)
Utilisation
-- Syntaxe Lingo
on rightMouseUp
instruction(s)
end
// Syntaxe JavaScript
function rightMouseUp() {
instruction(s);
}
Description
Message système et gestionnaire d’événements; sous Windows, spécifie les instructions exécutées
lorsque l’utilisateur relâche le bouton droit de la souris. Sur Macintosh, les instructions sont
exécutées lorsque l’utilisateur relâche le bouton de la souris tout en maintenant la touche Ctrl
enfoncée et que la propriété emulateMultiButtonMouse a la valeur TRUE ; si cette propriété a la
valeur FALSE, ce gestionnaire d’événement n’a aucun effet sur Macintosh.
208
Chapitre 10 : Evénements et messages
Exemple
Le gestionnaire suivant ouvre la fenêtre Aide lorsque l’utilisateur relâche le bouton droit de la
souris sous Windows :
-- Syntaxe Lingo
on rightMouseUp
window("Aide").open()
end
// Syntaxe JavaScript
function rightMouseUp() {
window("Aide").open();
}
on runPropertyDialog
Utilisation
-- Syntaxe Lingo
on runPropertyDialog me, listeDinitialisationCourante
instruction(s)
end
// Syntaxe JavaScript
function runPropertyDialog(ListeDinitialisationCourante) {
instruction(s);
}
Description
Message système et gestionnaire d’événements ; contient un code Lingo ou JavaScript définissant
des valeurs spécifiques pour les paramètres d’un comportement dans la boîte de dialogue Paramètres. Le message runPropertyDialog est envoyé à chaque fois que le comportement est lié à une
image-objet ou que l’utilisateur modifie les valeurs initiales de la propriété du comportement
d’une image-objet.
Les paramètres courants des propriétés initiales d’un comportement sont passés au gestionnaire
sous forme de liste de propriétés. Si le gestionnaire on runPropertyDialog n’est pas défini dans
le comportement, Director affiche une boîte de dialogue de personnalisation de comportement
basée sur la liste de propriétés renvoyée par le gestionnaire on getPropertyDescriptionList.
Exemple
Le gestionnaire suivant annule les valeurs des paramètres de la boîte de dialogue Paramètres
du comportement. Les nouvelles valeurs sont contenues dans la liste listeDinitialisationCourante. Normalement, la boîte de dialogue Paramètres permet à l’utilisateur de définir les
constantes de masse et de gravité. Cependant, le gestionnaire suivant affecte ces valeurs constantes
de paramètres sans afficher de boîte de dialogue :
-- Syntaxe Lingo
property masse
property constanteGravité
on runPropertyDialog me, listeDinitialisationCourante
-- forcer la masse à 10
ListeDinitialisationCourante.setaProp(#masse, 10)
-- forcer la constanteGravité à 9.8
ListeDinitialisationCourante.setaProp(#constanteGravité, 9.8)
return listeDinitialisationCourante
209
end
// Syntaxe JavaScript
function runPropertyDialog(ListeDinitialisationCourante) {
//forcer la masse à 10
ListeDinitialisationCourante.setaProp("masse", 10)
//forcer la constanteGravité à 9.8
ListeDinitialisationCourante.setaProp("constanteGravité", 9.8)
return(listeDinitialisationCourante)
}
Voir aussi
on getBehaviorDescription, on getPropertyDescriptionList
on savedLocal
Utilisation
-- Syntaxe Lingo
on savedLocal
instruction(s)
end
// Syntaxe JavaScript
function savedLocal() {
instruction(s);
}
Description
Message système et gestionnaire d’événements. Cette propriété est fournie pour permettre des
améliorations dans de futures versions de Shockwave Player.
Voir aussi
allowSaveLocal
on sendXML
Utilisation
-- Syntaxe Lingo
on sendXML "sendxmlstring", "fenêtre", "données"
instruction(s)
end
// Syntaxe JavaScript
function sendXML(sendxmlstring, fenêtre, données) {
instruction(s);
}
Description
Gestionnaire d’événement; fonctionne de manière similaire à la méthode de scripting getURL
également disponible avec l’Xtra Macromedia Flash Asset. Le gestionnaire on sendXML est appelé
en Lingo lorsque la méthode ActionScript objetXML.send est exécutée dans une image-objet
Flash ou dans un objet Flash XML.
210
Chapitre 10 : Evénements et messages
Dans ActionScript, la méthode objetXML.send transmet deux paramètres, en plus des données
XML, dans l’objet XML. Ces paramètres sont les suivants :
•
•
url – L’URL à laquelle envoyer les données XML. En règle générale, c’est l’URL d’un script
serveur qui attend de traiter les données XML.
fenêtre – la fenêtre de navigateur dans laquelle afficher la réponse du serveur.
La méthode ActionScript objetXML.send peut être appelée dans Director, soit par une imageobjet Flash, soit par un objet Flash XML global créé en Lingo. Dans ce cas, le gestionnaire Lingo
on sendXML est appelé, et les mêmes paramètres sont transmis au gestionnaire.
L’instruction Lingo suivante illustre le mode de réception des paramètres par le gestionnaire
on sendXML :
on sendXML me, Lurl, fenêtreCible, donnéesXml
Ces paramètres sont en corrélation avec le paramètre objetXML.send, comme suit :
•
•
•
– L’URL à laquelle envoyer les données XML.
– la fenêtre de navigateur dans laquelle afficher la réponse du serveur.
donnéesXML – Les données XML de l’objet XML Flash.
Lurl
fenêtreCible
En créant un gestionnaire on sendXML dans votre animation Director, vous lui permettez de
traiter les événements objetXML.send générés dans une image-objet Flash ou un objet Flash
global.
Les images-objets Flash peuvent également charger des données XML externes ou analyser des
données XML internes. L’Xtra Flash Asset gère ces fonctions de la même manière qu’un contenu
Flash 5 ou Flash MX dans votre navigateur.
Exemple
La commande Lingo suivante obtient les informations de méthode objetXML.send d’une imageobjet Flash, redirige le navigateur vers l’URL et transmet les données XML à l’URL :
-- Syntaxe Lingo
on sendXML me, Lurl, fenêtreCible, donnéesXml
gotoNetPage(Lurl, fenêtreCible)
postNetText(Lurl, donnéesXml)
end
// Syntaxe JavaScript
function sendXML(Lurl, fenêtreCible, donnéesXml) {
gotoNetPage(Lurl, fenêtreCible);
postNetText(Lurl, donnéesXml);
}
211
on startMovie
Utilisation
-- Syntaxe Lingo
on startMovie
instruction(s)
end
// Syntaxe JavaScript
function startMovie() {
instruction(s);
}
Description
Message système et gestionnaire d’événement; contient des instructions exécutées avant que la tête
de lecture n’atteigne la première image de l’animation. L’événement startMovie se produit après
l’événement prepareFrame et avant l’événement enterFrame.
Un gestionnaire on startMovie est idéal pour placer les éléments Lingo initialisant les imagesobjets de la première image de l’animation.
Exemple
Le gestionnaire suivant rend les images-objets invisibles au démarrage de l’animation :
-- Syntaxe Lingo
on startMovie
repeat with compteur = 10 to 50
sprite(compteur).visible = 0
end repeat
end startMovie
// Syntaxe JavaScript
function startMovie() {
for(compteur=10;compteur<=50;compteur++) {
sprite(compteur).visible = 0;
}
}
Voir aussi
on prepareMovie
212
Chapitre 10 : Evénements et messages
on stepFrame
Utilisation
-- Syntaxe Lingo
on stepFrame
instruction(s)
end
// Syntaxe JavaScript
function stepFrame() {
instruction(s);
}
Description
Message système et gestionnaire d’événement ; fonctionne avec les scripts présents dans la liste
actorList puisque ce sont les seuls à recevoir des messages on stepFrame. Ce gestionnaire
d’événement est exécuté lorsque la tête de lecture arrive sur une image ou que la scène est mise à
jour.
Un gestionnaire on stepFrame est un emplacement utile pour les instructions que vous souhaitez
exécuter fréquemment pour une série d’objets particulière. Affectez les objets à la liste actorList
lorsque vous souhaitez que les éléments Lingo du gestionnaire on stepFrame soient exécutés;
inversement, retirez ces objets de la liste actorList pour éviter l’exécution de ces éléments Lingo.
Lorsque les objets sont dans actorList, leurs gestionnaires on stepFrame sont exécutés à chaque
fois que la tête de lecture arrive sur une image ou que la commande updateStage est émise.
Le message stepFrame est envoyé avant le message prepareFrame.
Affectez des objets à actorList pour qu’ils puissent répondre aux messages stepFrame. Les
objets doivent disposer d’un gestionnaire on stepFrame pour utiliser cette fonctionnalité interne
avec actorList.
Les commandes go, play et updateStage sont désactivées dans un gestionnaire on stepFrame.
Exemple
Si l’objet enfant est affecté à actorList, le gestionnaire on stepFrame de ce script parent met à
jour la position de l’image-objet stockée dans la propriété monImageObjet à chaque fois que la
tête de lecture arrive sur une image :
-- Syntaxe Lingo
property monImageObjet
on new me, LimageObjet
monImageObjet = LimageObjet
return me
end
on stepFrame me
sprite(monImageObjet).loc = point(random(640),random(480))
end
213
// Syntaxe JavaScript
// définir une classe de construction contenant la propriété monImageObjet
function Frame(LimageObjet) {
this.monImageObjet = LimageObjet;
}
function stepFrame() {
var monImage = new Frame(sprite(spriteName).spriteNum);
sprite(monImage.monImageObjet).loc = point(random(640),random(480));
end
on stopMovie
Utilisation
-- Syntaxe Lingo
on stopMovie
instruction(s)
end
// Syntaxe JavaScript
function stopMovie() {
instruction(s);
}
Description
Message système et gestionnaire d’événement; contient des instructions exécutées à l’arrêt de
l’animation.
Un gestionnaire on stopMovie est l’emplacement idéal pour les éléments Lingo destinés à
éliminer les données superflues, comme la fermeture des fichiers ressource, l’élimination des
variables globales ou la suppression de champs et d’objets, lorsque l’animation est terminée.
Lorsque le gestionnaire on stopMovie figure dans une animation dans une fenêtre, il n’est appelé
que lorsque l’animation est lue jusqu’à la fin ou débouche sur une autre animation. Il n’est pas
appelé lorsque la fenêtre est fermée ou supprimée par le biais de la commande forget window.
Exemple
Le gestionnaire suivant supprime une variable globale lorsque l’animation s’arrête :
-- Syntaxe Lingo
global gScoreActuel
on stopMovie
gScoreActuel = 0
end
// Syntaxe JavaScript
_global.gScoreActuel;
function stopMovie() {
_global gScoreActuel = 0;
}
Voir aussi
on prepareMovie
214
Chapitre 10 : Evénements et messages
on streamStatus
Utilisation
-- Syntaxe Lingo
on streamStatus URL, état, octetsTéléchargés, totalDesoctets, erreur
instruction(s)
end
// Syntaxe JavaScript
function streamStatus(URL, état, octetsTéléchargés, totalDesoctets, erreur{
instruction(s);
}
Description
Message système et gestionnaire d’événements; appelé régulièrement pour déterminer la
quantité d’un objet déjà téléchargée depuis Internet. Ce gestionnaire n’est appelé que si
tellStreamStatus (TRUE) a été appelé et qu’il a été ajouté à un script d’animation.
Le gestionnaire on streamStatus possède les paramètres suivants :
URL
Affiche l’adresse Internet des données en cours de récupération.
état
Affiche l’état du flux en cours de téléchargement. Les valeurs possibles sont
Connecting (connexion), Started (commencé), InProgress (en cours), Complete
(terminé) et Error (erreur).
octets
Téléchargés
Affiche le nombre d’octets récupérés depuis le réseau.
totalDes
Octets
Affiche le nombre total d’octets transférés , si ce chiffre est connu. Cette valeur peut
être 0 si le serveur HTTP ne fait pas figurer la longueur du contenu dans l’en-tête
MIME.
erreur
Affiche une chaîne vide ("") si le téléchargement n’est pas terminé, OK (OK) si le
téléchargement a abouti ou un code d’erreur s’il a échoué.
Ces paramètres sont automatiquement remplis par Director avec des informations concernant
l’évolution du téléchargement. Ce gestionnaire est appelé automatiquement par Director et il n’y
a aucun moyen de contrôler quand il sera appelé la fois suivante. Si des informations relatives à
une opération particulière sont requises, appelez getStreamStatus().
Vous pouvez lancer un téléchargement réseau à l’aide de commandes Lingo, en liant les médias
avec une URL ou en utilisant un acteur externe à partir d’une URL. Un gestionnaire
streamStatus sera appelé pour fournir des informations sur tous les transferts à partir du réseau.
Placez le gestionnaire streamStatus dans les scripts d’animation.
215
Exemple
Le gestionnaire suivant détermine l’état d’un objet transféré et affiche son URL :
-- Syntaxe Lingo
on streamStatus URL, état, octetsTéléchargés, totalDesOctets
if état = "Complete" then
put(URL && "Téléchargement terminé");
end if
end streamStatus
// Syntaxe JavaScript
function streamStatus(URL, état, octetsTéléchargés, totalDesOctets) {
if (état == "Terminé") {
put(URL + " Téléchargement terminé");
}
}
Voir aussi
getStreamStatus(), tellStreamStatus()
on timeOut
Utilisation
-- Syntaxe Lingo
on timeOut
instruction(s)
end
// Syntaxe JavaScript
function timeOut() {
instruction(s);
}
Description
Message système et gestionnaire d’événement; contient des instructions exécutées lorsque la souris
ou le clavier n’a pas été utilisé pendant la durée spécifiée par timeOutLength. Placez toujours un
gestionnaire on timeOut dans un script d’animation.
Pour que la temporisation produise la même réponse pendant toute l’animation, utilisez
afin de contrôler le comportement du délai d’inactivité de façon centralisée.
timeoutScript
Exemple
Le gestionnaire suivant lit l’animation Boucle lorsque les utilisateurs sont restés inactifs pendant
l’intervalle de temps défini dans la propriété timeoutLength. Il peut être utilisé pour répondre
lorsque les utilisateurs quittent l’ordinateur.
-- Syntaxe Lingo
on timeOut
_movie.play("Boucle")
end timeOut
// Syntaxe JavaScript
function timeOut() {
_movie.play("Boucle");
}
216
Chapitre 10 : Evénements et messages
trayIconDoubleClick
Utilisation
-- Syntaxe Lingo
on trayIconDoubleClick
instruction(s)
end
// Syntaxe JavaScript
function trayIconDoubleClick() {
instruction(s);
}
Description
Gestionnaire d’événements d’animations et fenêtres (Microsoft Windows seulement). Contient
des instructions qui sont exécutées lorsqu’un utilisateur double clique sur l’icône de la barre
d’applications.
L’événement trayIconDoubleClick n’est envoyé au gestionnaire que si la propriété
systemTrayIcon est définie comme étant TRUE.
Exemple
Le gestionnaire suivant met une animation en pause quand un utilisateur double-clique sur
l’icône de la barre d’état système.
-- Syntaxe Lingo
on trayIconDoubleClick
_movie.delay(500)
end
// Syntaxe JavaScript
function trayIconDoubleClick() {
_movie.delay(500);
}
Voir aussi
Animation, systemTrayIcon, trayIconMouseDown, trayIconRightMouseDown, Fenêtre
trayIconMouseDown
Utilisation
-- Syntaxe Lingo
on trayIconMouseDown
instruction(s)
end
// Syntaxe JavaScript
function trayIconMouseDown() {
instruction(s);
}
Description
Gestionnaire d’événements d’animations et fenêtres (Microsoft Windows seulement). Contient
des instructions qui sont exécutées lorsqu’un utilisateur clique une fois sur l’icône de la barre
d’applications.
217
L’événement trayIconMouseDown n’est envoyé au gestionnaire que si la propriété
systemTrayIcon est définie comme étant TRUE.
Exemple
Le gestionnaire suivant met une animation en pause quand un utilisateur clique avec la souris
alors que le pointeur se trouve au-dessus de l’icône de la barre d’état système.
-- Syntaxe Lingo
on trayIconMouseDown
_movie.delay(500)
end
// Syntaxe JavaScript
function trayIconMouseDown() {
_movie.delay(500);
}
Voir aussi
Animation, systemTrayIcon, trayIconDoubleClick, trayIconRightMouseDown,
Fenêtre
trayIconRightMouseDown
Utilisation
-- Syntaxe Lingo
on trayIconRightMouseDown
instruction(s)
end
// Syntaxe JavaScript
function trayIconRightMouseDown() {
instruction(s);
}
Description
Gestionnaire d’événements d’animations et fenêtres (Microsoft Windows seulement). Contient
des instructions qui sont exécutées lorsqu’un utilisateur clique avec le bouton droit de la souris sur
l’icône de la barre d’applications.
L’événement trayIconRightMouseDown n’est envoyé au gestionnaire que si la propriété
systemTrayIcon est définie comme étant TRUE.
Exemple
Le gestionnaire suivant met une animation en pause quand un utilisateur clique sur l’icône de la
barre d’état système avec le bouton droit.
-- Syntaxe Lingo
on trayIconRightMouseDown
_movie.delay(500)
end
// Syntaxe JavaScript
function trayIconRightMouseDown() {
_movie.delay(500);
}
218
Chapitre 10 : Evénements et messages
Voir aussi
Animation, systemTrayIcon, trayIconDoubleClick, trayIconMouseDown, Fenêtre
on zoomWindow
Utilisation
-- Syntaxe Lingo
on zoomWindow
instruction(s)
end
// Syntaxe JavaScript
function zoomWindow() {
instruction(s);
}
Description
Message système et gestionnaire d’événement ; contient des instructions exécutées lorsqu’une
animation dans une fenêtre est redimensionnée. Cela se produit lorsque l’utilisateur clique sur
le bouton Réduction ou Agrandissement (Windows) ou sur le bouton Zoom (Macintosh).
Le système d’exploitation détermine les dimensions après avoir redimensionné la fenêtre.
Un gestionnaire d’événement on zoomWindow est un emplacement idéal pour insérer des
éléments Lingo permettant de réorganiser les images-objets lorsque les dimensions de la
fenêtre évoluent.
Exemple
Ce gestionnaire déplace l’image-objet 3 vers les coordonnées stockées dans la variable
emplacementCentral lorsque la fenêtre lue par l’animation est redimensionnée :
-- Syntaxe Lingo
on zoomWindow
emplacementCentral = point(10, 10)
sprite(3).loc = emplacementCentral
end
// Syntaxe JavaScript
function zoomWindow() {
var emplacementCentral = point(10, 10);
sprite(3).loc = emplacementCentral;
}
Voir aussi
drawRect, sourceRect, on resizeWindow
219
220
Chapitre 10 : Evénements et messages
CHAPITRE 11
Mots-clés
Cette section propose une liste alphabétique de tous les mots-clés disponibles dans Macromedia
Director MX 2004.
Ces mots-clés ne s’appliquent qu’à Lingo. La syntaxe JavaScript contient des mots-clés et des
expressions dont la fonction est similaire aux mots-clés Lingo suivants, mais qui ne sont pas traités
ici. Pour plus d’informations au sujet des mots-clés et expressions de la syntaxe JavaScript,
consultez le Chapitre 2, Principes de base du scripting dans Director, page 9.
\ (continuation)
Utilisation
-- Syntaxe Lingo
première partie d’une instruction sur cette ligne \
deuxième partie de l’instruction \
troisième partie de l’instruction
Description
Symbole de continuation; lorsqu’il est utilisé comme dernier caractère d’une ligne, indique que
l’instruction continue à la ligne suivante. Lingo interprète alors ces lignes comme une seule
instruction.
Exemple
L’instruction suivante utilise le caractère \ pour diviser l’instruction en deux lignes :
-- Syntaxe Lingo
if sprite("monImageObjet").member = member("monActeur") then \
_player.alert("L’image-objet a été créée à partir de monActeur")
221
case
Utilisation
-- Syntaxe Lingo
case expression of
expression1 : instruction
expression2 : Instruction(s)
expression3, expression4 : instruction
{otherwise: Instruction(s)}
end case
Description
Mot-clé ; lance une structure de branchements multiples plus facile à rédiger qu’une suite
d’instructions if...then.
Lingo compare la valeur de case expression aux expressions des lignes suivantes. Cette
comparaison commence au début de ces lignes et continue dans l’ordre jusqu’à ce que Lingo
rencontre une expression identique à case expression.
Le cas échéant, Lingo exécute la ou les instructions correspondantes suivant les deux points placés
après l’expression identique. Si une seule instruction suit l’expression identique, l’instruction peut
être placée sur la même ligne. Les instructions multiples doivent apparaître sur des lignes
immédiatement en retrait après l’expression identique.
Lorsque plusieurs correspondances possibles pourraient entraîner Lingo à exécuter les mêmes
instructions, les expressions doivent être séparées par des virgules. (La ligne contenant
expression3 et expression4 est un exemple de ce genre de situation.)
Lingo suspend sa recherche de correspondance dès qu’il rencontre la première expression
correspondant à celle recherchée.
Si l’instruction facultative otherwise figure à la fin de la structure case, les instructions qui
suivent otherwise sont exécutées si Lingo ne rencontre aucune expression identique.
Exemple
Le gestionnaire suivant teste la touche que l’utilisateur vient d’enfoncer 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.
• Si l’utilisateur a appuyé sur n’importe quelle autre touche, l’ordinateur émet un bip sonore.
on keyDown
case (_key.key) of
"a" : _movie.go("Pomme")
"b", "c":
_movie.puppetTransition(99)
_movie.go("Oranges")
otherwise: _sound.beep()
end case
end keyDown
222
Chapitre 11 : Mots-clés
L’instruction case suivante vérifie si le curseur se trouve sur l’image-objet 1, 2 ou 3 et exécute
l’élément Lingo approprié :
case _movie.rollOver() of
1: sound(1).play(member("Clarinette"))
2: sound(1).play(member("Tambour"))
3: sound(1).play(member("Bongos"))
end case
char...of
Utilisation
-- Syntaxe Lingo
expressionActeurTexte.char[quelCaractère]
charquelCaractèreof variableChaîneouChamp
expressionActeurTexte.char[premierCaractère..dernierCaractère]
char premierCaractère to dernierCaractère of variableChaîneouChamp
Description
Mot-clé ; identifie un caractère ou une plage de caractères dans une sous-chaîne. Une expression
de sous-chaîne peut être n’importe quel caractère, mot, élément ou ligne dans n’importe quelle
source de texte (telle que des acteurs champ et des variables) contenant une chaîne.
• Une expression utilisant quelCaractère identifie un caractère spécifique.
• Une expression utilisant premierCaractère et dernierCaractère identifie une plage
de caractères.
Ces expressions doivent être des nombres entiers spécifiant un caractère ou une plage de caractères
dans une sous-chaîne. Les caractères peuvent être des lettres, des nombres, des signes de ponctuation, des espaces et des caractères de contrôle comme Tab ou Retour.
Le mot-clé char...of peut être testé, mais pas défini. Utilisez la commande put...into pour
modifier les caractères d’une chaîne.
Exemple
L’instruction suivante affiche le premier caractère de la chaîne 9,00 euros :
put(("9,00 euros").char[1..1])
-- "$"
L’instruction suivante affiche la chaîne 9,00 euros entière :
put(("9,00 euros").char[1.0.5])
-- "$9.00"
L’instruction suivante modifie les cinq premiers caractères du deuxième mot de la troisième ligne
d’un acteur texte :
member("question").line[3].word[2].char[1..5] = "?????"
Voir aussi
mouseMember, mouseItem, mouseLine, mouseWord
223
end
Utilisation
-- Syntaxe Lingo
end
Description
Mot-clé ; marque la fin des gestionnaires et des structures de contrôle à plusieurs lignes.
Exemple
Le gestionnaire mouseDown suivant se termine par une instruction end mouseDown.
on mouseDown
_player.alert("Le bouton de la souris a été enfoncé")
end mouseDown
end case
Utilisation
-- Syntaxe Lingo
end case
Description
Mot-clé ; termine une instruction case.
Exemple
Le gestionnaire suivant utilise le mot-clé end case pour terminer l’instruction case :
on keyDown
case (_key.key) of
"a" : _movie.go("Pomme")
"b", "c":
_movie.puppetTransition(99)
_movie.go("Oranges")
otherwise: _sound.beep()
end case
end keyDown
Voir aussi
case
exit
Utilisation
-- Syntaxe Lingo
exit
Description
Mot-clé ; indique à Lingo de quitter un gestionnaire et de retourner où le gestionnaire a été
appelé. Si le gestionnaire est imbriqué dans un autre gestionnaire, Lingo retourne au gestionnaire
principal.
224
Chapitre 11 : Mots-clés
Exemple
La première instruction du script suivant vérifie si le moniteur est en noir et blanc et, le cas
échéant, sort du gestionnaire :
on définitionDesCouleurs
if _system.colorDepth = 1 then exit
sprite(1).forecolor = 35
end
Voir aussi
abort, halt(), quit(), pass, return (mot-clé)
exit repeat
Utilisation
-- Syntaxe Lingo
exit repeat
Description
Mot-clé ; indique à Lingo de quitter une boucle et de passer à l’instruction suivant l’instruction
end repeat, sans toutefois quitter la méthode ou le gestionnaire courant.
Le mot-clé exit repeat est pratique pour sortir d’une boucle lorsqu’une condition spécifiée,
telle que l’égalité de deux valeurs ou la présence d’une valeur donnée dans une variable, existe.
Exemple
Le gestionnaire suivant cherche la position de la première voyelle dans une chaîne représentée par
la variable chaîneDeTest. Dès que la première voyelle est trouvée, la commande exit repeat
indique à Lingo de quitter la boucle et de passer à l’instruction return i :
on rechercheDeVoyelle chaîneDeTest
repeat with i = 1 to chaîneDeTest.char[chaîneDeTest.char.count]
if "aeiou" contains chaîneDeTest.char[i] then exit repeat
end repeat
return i
end
Voir aussi
repeat while, repeat with
field
Utilisation
field( quelChamp)
Description
Mot-clé ; fait référence à l’acteur champ spécifié par quelChamp.
• Lorsque quelChamp est une chaîne, il est utilisé comme nom d’acteur.
• Lorsque quelChamp est un nombre entier, il est utilisé comme numéro d’acteur.
Les chaînes de caractères et expressions de sous-chaînes peuvent être lues ou placées dans le
champ.
225
Le terme field était utilisé dans les versions précédentes de Director et est conservé pour une
compatibilité amont. Pour les nouvelles animations, utilisez member pour faire référence aux
acteurs champs.
Exemple
L’instruction suivante place les caractères 5 à 10 du champ nommé Entrée dans la variable
monMotClé :
monMotClé = field("Entrée").char[5..10]
L’instruction suivante vérifie si l’utilisateur a saisi le mot bureau et, le cas échéant, passe à l’image
devisBureau :
if member("devis") contains "bureau" then _movie.go("devisBureau")
Voir aussi
char...of, item...of, line...of, word...of
global
Utilisation
global variable1 {, variable2} {, variable3}...
Description
Mot-clé ; définit une variable comme variable globale pour que les autres gestionnaires ou
animations puissent la partager.
Chaque gestionnaire qui examine ou change le contenu d’une variable globale doit utiliser le motclé global pour identifier la variable comme une variable globale. Autrement, le gestionnaire
traite la variable comme une variable locale, même si un autre gestionnaire l’a déclarée comme
globale.
Remarque : Pour assurer que les variables globales soient disponibles dans l’ensemble d’une
animation, déclarez et initialisez-les dans le gestionnaire prepareMovie. Ensuite, si vous quittez
l’animation et revenez à celle-ci à partir d’une autre animation, vos variables globales reprendront
leurs valeurs initiales à moins que vous ne vérifiiez d’abord qu’elles ne sont pas déjà définies.
Une variable globale peut être déclarée dans n’importe quel gestionnaire ou script. Sa valeur peut
être utilisée par d’autres gestionnaires ou scripts qui déclarent également la variable comme
globale. Si le script change la valeur de la variable, la nouvelle valeur est disponible pour tous les
autres gestionnaires traitant la variable comme globale.
Une variable globale est disponible dans n’importe quel script ou animation, quel que soit
l’endroit où elle a été d’abord déclarée; elle n’est pas automatiquement supprimée lorsque vous
naviguez vers une autre image, animation ou fenêtre.
Les variables manipulées dans la fenêtre Messages sont automatiquement globales, même si elles
ne sont pas explicitement déclarées comme telles.
Les animations à contenu Macromedia Shockwave exécutées sur Internet ne peuvent pas accéder
aux variables globales d’autres animations, y compris les animations exécutées sur la même page
HTML. Les animations peuvent uniquement partager des variables globales si une animation
intégrée navigue vers une autre animation et est remplacée par le biais des commandes
goToNetMovie ou go movie.
226
Chapitre 11 : Mots-clés
Exemple
L’exemple suivant donne à la variable globale PointDeDépart/ sa valeur initiale de 1 si elle ne
contient pas déjà une valeur. Cela permet une navigation vers l’animation et aussi à partir de celleci, sans perte des données enregistrées.
global gPointDeDépart
on prepareMovie
if voidP(gPointDeDépart) then gPointDeDépart = 1
end
Voir aussi
showGlobals(), property, gotoNetMovie
if
Utilisation
ifexpressionLogique then instruction
if expressionLogique then instruction
else instruction
end if
if expressionLogique then
instruction(s)
end if
if expressionLogique then
instruction(s)
else
instruction(s)
end if
if expressionLogique1 then
instruction(s)
else if expressionLogique2 then
instruction(s)
else if expressionLogique3 then
instruction(s)
end if
if expressionLogique1 then
instruction(s)
else expressionLogique2
end if
Description
Mot-clé ; la structure if...then évalue l’expression logique spécifiée par expressionLogique.
• Si la condition a la valeur TRUE, Lingo exécute les instructions suivant then.
• Si la condition a la valeur FALSE, Lingo exécute les instructions suivant else. Si aucune
•
instruction ne suit else, Lingo quitte la structure if...then.
Toutes les parties de la condition doivent être évaluées, l’exécution ne s’arrêtant pas à la
première condition remplie ou non remplie. Un code plus rapide peut donc être créé en
imbriquant des instructions if...then sur des lignes séparées au lieu de toutes les placer sur
la première ligne à évaluer.
Lorsque la condition est une propriété, Lingo vérifie automatiquement si elle a la valeur TRUE.
Vous n’avez pas besoin d’ajouter explicitement la phrase = TRUE après la propriété.
227
La partie else de l’instruction est facultative. Pour utiliser plus
statement ou else, vous devez conclure par la forme end if.
d’une instruction then-
La partie else correspond toujours à l’instruction if précédente ; vous devez donc parfois inclure
une instruction else nothing pour associer un mot-clé else au mot-clé if approprié.
Remarque : Une façon rapide de déterminer dans la fenêtre Script si le script est correctement lié est
d’appuyer sur la touche Tab. Cela force Director à vérifier la fenêtre Script ouverte et afficher la
présentation en retrait du contenu. Les différences seront immédiatement visibles.
Exemple
L’instruction suivante vérifie si l’utilisateur a appuyé sur un retour chariot et, le cas échéant,
continue :
if the key = RETURN then go the frame + 1
Le gestionnaire suivant vérifie si les touches Cmd et Q ont été enfoncées simultanément et, le cas
échéant, exécute les instructions suivantes :
on keyDown
if (_key.commandDown) and (_key.key = "q") then
nettoyage
quit
end if
end keyDown
Comparez les deux constructions suivantes et les résultats en matière de performance. La première
construction évalue les deux conditions et doit déterminer la mesure du temps, ce qui peut
prendre un moment. La seconde construction évalue la première condition; la seconde condition
étant vérifiée uniquement si la première condition a la valeur TRUE.
imageObjetSousLeCurseur = rollOver()
if (imageObjetSousLeCurseur > 25) and MesureDuTempsDepuisLeDépart() then
_player.alert("Vous avez trouvé le trésor caché !")
end if
La construction plus rapide serait :
imageObjetSousLeCurseur = rollOver()
if (imageObjetSousLeCurseur > 25) then
if MesureDuTempsDepuisLeDépart() then
_player.alert("Vous avez trouvé le trésor caché !")
end if
end if
Voir aussi
case
INF
Utilisation
-- Syntaxe Lingo
INF
Description
Valeur renvoyée ; indique qu’une expression Lingo spécifiée est évaluée comme un nombre infini.
Voir aussi
NAN
228
Chapitre 11 : Mots-clés
item...of
Utilisation
-- Syntaxe Lingo
texpressionActeurTexte.item[quelElément]
item quelElément of variableChaîneOuChamp
expressionActeurTexte.item[premierElément..dernierElément]
item premierElément to dernierElément of variableChaîneOuChamp
Description
Mot-clé ; spécifie un élément ou une série d’éléments d’une sous-chaîne. Un élément est une
série de caractères délimités par le séparateur défini dans la propriété itemDelimiter.
Les termes quelElément, premierElément et dernierElément doivent être des nombres entiers
ou des expressions entières faisant référence à la position des éléments dans la sous-chaîne.
Les sous-chaînes permettent de faire référence à tout caractère, mot, élément ou ligne de
n’importe quelle chaîne de texte. Les chaînes possibles sont les acteurs champ et texte et les
variables contenant des chaînes.
Lorsque le nombre spécifiant le dernier élément est supérieur à celui correspondant à la position
de cet élément dans la sous-chaîne, le dernier élément est spécifié à la place.
Exemple
L’instruction suivante détermine le troisième élément d’une sous-chaîne composée de noms de
couleurs et affiche le résultat dans la fenêtre Messages :
put("rouge,jaune,bleu vert,orange".item[3])
-- "bleu vert"
Le résultat est la sous-chaîne « bleu vert » car tous les caractères placés entre virgules sont pris en
compte.
L’instruction suivante détermine les éléments du troisième au cinquième élément de la souschaîne. Puisque celle-ci ne contient que quatre éléments, seuls le troisième et le quatrième sont
renvoyés. Le résultat apparaît dans la fenêtre Messages.
put("rouge,jaune,bleu vert,orange".item[3..5])
-- "bleu vert, orange"
put item 5 of "rouge, jaune, bleu vert, orange"
-- ""
L’instruction suivante insère l’élément Bureau en quatrième position dans la deuxième ligne de
l’acteur champ Tous les devis :
member("Tous les devis").line[2].item[4] = "Bureau"
Voir aussi
char...of, itemDelimiter, number of members, word...of
229
line...of
Utilisation
-- Syntaxe Lingo
expressionActeurTexte.line[quelleLigne]
line quelleLigne of ChampOuVariableChaîne
expressionActeurTexte.line[premièreLigne..dernièreLigne]
line premièreLigne to dernièreLigne of ChampOuVariableChaîne
Description
Mot-clé ; identifie une ligne ou une série de lignes d’une sous-chaîne. Une ligne est constituée
d’une série de caractères délimités par des retours de chariot et non par des retours à la ligne
automatiques.
Les expressions quelleLigne, premièreLigne et dernièreLigne doivent être des nombres
entiers spécifiant une ligne de la sous-chaîne.
Les sous-chaînes peuvent représenter n’importe quel caractère, mot, élément ou ligne d’un groupe
de caractères. Les sources de texte peuvent être des acteurs champ et des variables contenant des
chaînes.
Exemple
L’instruction suivante affecte les quatre premières lignes de la variable Action à l’acteur champ
Tâches :
member("Tâches").text = Action.line[1..4]
L’instruction suivante insère le mot et après le deuxième mot de la troisième ligne de la chaîne
affectée à la variable Notes :
put "et" after Notes.line[3].word[2]
Voir aussi
char...of, item...of, word...of, number of members
loop (mot-clé)
Utilisation
-- Syntaxe Lingo
_movie.goLoop()
Description
Mot-clé ; fait référence au repère.
Exemple
Le gestionnaire suivant fait boucler l’animation entre le repère précédent et l’image courante :
on exitFrame
_movie.goLoop()
end exitFrame
230
Chapitre 11 : Mots-clés
me
Utilisation
-- Syntaxe Lingo
me
Description
Variable spéciale; s’utilise à l’intérieur de scripts parents et de comportements pour faire référence
à l’objet courant lorsqu’il est une instance du script parent, du comportement ou d’une variable
contenant l’adresse mémoire de l’objet.
Ce terme n’a aucune signification prédéfinie en Lingo. Le terme me est utilisé par convention.
Vous pourrez voir un exemple de me dans une animation en consultant l’animation Parent Scripts
du dossier Learning/Lingo, lui-même dans le dossier de Director.
Exemple
L’instruction suivante affecte l’objet monOiseau1 au script Oiseau. Le mot-clé me accepte le script
Oiseau et sert à renvoyer ce paramètre.
monOiseau1 = new script ("Oiseau")
Voici le gestionnaire on new du script Oiseau :
on new me
return me
end
Les deux ensembles de gestionnaires suivants forment un script parent. Le premier ensemble
utilise me pour faire référence à l’objet enfant. Le second ensemble utilise la variable monAdresse
pour faire référence à l’objet enfant. Pour ce qui est du reste, les scripts parents sont les mêmes.
Premier ensemble :
property mesDonnées
on new me, lesDonnées
mesDonnées = lesDonnées
return me
end
on stepFrame me
traiterLesDonnées me
end
Second ensemble :
property mesDonnées
on new monAdresse, lesDonnées
mesDonnées = lesDonnées
return monAdresse
end
on stepFrame monAdresse
traiterLesDonnées monAdresse
end
Voir aussi
new(), ancestor
231
menu
Utilisation
-- Syntaxe Lingo
menu: nomDeMenu
nomDélément | script
nomDélément | script
...
or
menu: nomDeMenu
nomDélément | script
nomDélément | script
...
[plus de menus]
Description
Mot-clé ; utilisé avec la commande installMenu, spécifie le contenu des menus personnalisés.
Les acteurs champ contiennent des définitions de menus. Faites référence à ces définitions en
utilisant le nom ou le numéro de l’acteur.
Le mot-clé menu est immédiatement suivi d’un deux-points, d’un espace et du nom du menu.
Spécifiez les éléments de ce menu sur les lignes suivantes. Vous pouvez définir un script qui sera
exécuté lorsque l’utilisateur choisit un élément du menu en plaçant le script après le symbole barre
verticale (|). Un nouveau menu est défini par les occurrences suivantes du mot-clé menu.
Remarque : Les menus ne sont pas disponibles dans Shockwave Player.
Sur Macintosh, vous pouvez utiliser des caractères spéciaux pour définir des menus personnalisés.
Ces caractères spéciaux sont sensibles à la casse. Par exemple, pour qu’un élément de menu
apparaisse en gras, la lettre B doit être en majuscules.
Des symboles spéciaux doivent suivre le nom de l’élément de menu et précéder le symbole barre
verticale (|). Vous pouvez également utiliser plus d’un caractère spécial pour définir un élément de
menu. L’utilisation de <B<U, par exemple, définit le style Gras et Souligné.
Evitez de formater les caractères spéciaux des animations qui seront lues sur des plates-formes
différentes, Windows ne supportant pas toujours ce formatage.
232
Symbole Exemple
Description
@
menu: @
*Sur Macintosh, crée le symbole Pomme et active les éléments de la
barre des menus lorsque vous définissez un menu Pomme.
!Ã
!ÃSélection
rapide
*Sur Macintosh, place une coche (Option+v) près du menu.
<B
Gras<B
*Sur Macintosh, donne à l’élément de menu le style Gras.
<I
Italique<I
*Sur Macintosh, définit le style Italique.
<U
Souligné<U
*Sur Macintosh, définit le style Souligné.
<O
Relief<O
*Sur Macintosh, définit le style Relief.
<S
Ombré<S
*Sur Macintosh, définit le style Ombré.
Chapitre 11 : Mots-clés
Symbole Exemple
Description
|
Ouvrir/O | go
to frame
"Ouvrir"
Associe un script à l’élément de menu.
/
Quitter/Q
Définit un équivalent commande-touche.
(
Enregistrer(
Désactive l’élément de menu.
(-
Crée une ligne désactivée dans le menu.
(*
identifie les symboles de formatage qui ne fonctionnent que sur Macintosh.
Exemple
Voici le texte d’un acteur champ appelé menuPersonnalisé2 qui permet d’indiquer le
contenu d’un menu Fichier personnalisé. Pour installer ce menu, utilisez installMenu
member("menuPersonnalisé2") pendant la lecture de l’animation. L’élément de menu
Convertir exécute le gestionnaire personnalisé convertirCeci.
menu: Fichier
Open/O | _movie.go("Ouvrir")
Close/W | _movie.go("Fermer")
Convertir/C | convertirCeci
(Quit/Q | _movie.go("Quitter")
Voir aussi
installMenu, name, number (éléments de menu), checkMark, enabled, script
NAN
Utilisation
-- Syntaxe Lingo
NAN
Description
Valeur renvoyée ; indique que l’expression Lingo spécifiée n’est pas un nombre.
L’instruction suivante tente d’afficher la racine carrée de -1, qui n’est pas un nombre, dans la
fenêtre Messages :
-- Syntaxe Lingo
put((-1).sqrt) -- NAN
Voir aussi
INF
next
Utilisation
-- Syntaxe Lingo
next
Description
Mot-clé ; fait référence au repère suivant de l’animation et revient à utiliser la phrase the marker
(+ 1).
233
Exemple
L’instruction suivante envoie la tête de lecture sur le repère suivant de l’animation :
go next
Le gestionnaire suivant fait passer la tête de lecture au repère suivant du scénario lorsque l’utilisateur appuie sur la touche flèche vers la droite et au repère précédent lorsqu’il appuie sur la touche
flèche vers la gauche :
on keyUp
if (_key.keyCode = 124) then _movie.goNext()
if (_key.keyCode = 123) then _movie.goPrevious()
end keyUp
Voir aussi
loop (mot-clé), goPrevious()
next repeat
Utilisation
-- Syntaxe Lingo
next repeat
Description
Mot-clé ; fait passer Lingo à l’étape suivante d’une boucle d’un script. Cette fonction est
différente de celle du mot-clé exit repeat.
Exemple
La boucle suivante n’affiche que les nombres impairs dans la fenêtre Messages :
repeat with i = 1 to 10
if (i mod 2) = 0 then next repeat
put(i)
end repeat
on
Utilisation
-- Syntaxe Lingo
on nomDeGestionnaire {argument1}, {argument2}, {argument3} ...
instruction(s)
end nomDeGestionnaire
Description
Mot-clé ; indique le début d’un gestionnaire, une suite d’instructions Lingo que vous pouvez
exécuter en utilisant le nom du gestionnaire. Un gestionnaire peut accepter des arguments comme
valeurs d’entrée et renvoyer une valeur comme résultat d’une fonction.
Les gestionnaires peuvent être définis dans les comportements, les scripts d’animations et les
scripts d’acteurs. Le gestionnaire d’un script d’acteur ne peut être appelé que par les autres
gestionnaires du même script. Le gestionnaire d’un script d’animation peut être appelé de
partout.
Vous pouvez utiliser le même gestionnaire dans plusieurs animations en plaçant son script dans
une distribution partagée.
234
Chapitre 11 : Mots-clés
otherwise
Utilisation
-- Syntaxe Lingo
otherwise instruction(s)
Description
Mot-clé ; précède les instructions que Lingo exécute si aucune des conditions précédentes d’une
instruction case n’est remplie.
Ce mot-clé peut s’utiliser pour avertir les utilisateurs d’une entrée hors limites ou d’un type non
valide. Il peut aussi s’avérer très utile pour les opérations de débogage pendant le développement.
Exemple
Le gestionnaire suivant détermine la dernière touche sur laquelle l’utilisateur a appuyé et répond
en conséquence :
• Si l’utilisateur a appuyé sur A, B ou C, l’animation exécute l’action correspondante qui suit le
•
mot-clé of.
Si l’utilisateur a appuyé sur une autre touche, l’animation exécute l’instruction qui suit le motclé otherwise. Le cas échéant, l’instruction est un simple message d’alerte.
on keyDown
case (_key.key) of
"a" : _movie.go("Pomme")
"b", "c":
_movie.puppetTransition(99)
_movie.go("Oranges")
otherwise: _player.alert("Cette touche n’est pas valide.")
end case
end keyDown
property
Utilisation
-- Syntaxe Lingo
property {propriété1}{, propriété2} {,propriété3} {...}
Description
Mot-clé ; déclare que les propriétés indiquées par propriété1, propriété2 etc,. sont des
variables de propriétés.
Declarez les variables de propriétés au début du script parent ou du script comportement.
L’opérateur the permet d’y accéder en dehors de ces scripts.
Remarque : La propriété spriteNum est disponible à tous les comportements et il suffit de la déclarer
pour y accéder.
Vous pouvez faire référence à une propriété dans un script parent ou de comportement sans
utiliser le mot-clé me. Cependant, pour faire référence à une propriété de l’ancêtre d’un script
parent, utilisez la forme me.propriété.
Pour les comportements, les propriétés définies dans un script de comportement sont disponibles
aux autres comportements associés à la même image-objet.
235
Vous pouvez manipuler la propriété d’un objet enfant directement en dehors de ses scripts parents
au moyen d’une syntaxe semblable à celle utilisée pour manipuler d’autres propriétés. Par exemple, l’instruction suivante définit la propriété styleDeDéplacement d’un objet enfant :
set the styleDeDéplacement of monObjet to #frénétique
Utilisez la fonction count pour déterminer le nombre de propriétés contenues dans le script
parent d’un objet enfant. Récupérez le nom de ces propriétés au moyen de getPropAt. Ajoutez
des propriétés à un objet au moyen de setaProp().
Vous pourrez voir un exemple de property dans une animation en consultant l’animation Parent
Scripts du dossier Learning/Lingo, lui-même dans le dossier de Director.
Exemple
L’instruction suivante permet à chaque objet enfant créé à partir d’un script parent unique de
posséder ses propres paramètres de position et de vitesse :
property position, vitesse
Le gestionnaire de script parent suivant déclare une propriété pMonNumDimageObjet pour la
rendre disponible :
-- script Ancien
property pMaPiste
on new me, quelleImageObjet
me.pMaPiste = quelleImageObjet
return me
end
Le script de comportement d’origine définit l’ancêtre et transmet la propriété spriteNum à tous
les comportements :
property spriteNum
property ancestor
on beginSprite me
ancestor = new script("Ancien", spriteNum)
end
Voir aussi
me, ancestor, spriteNum
put...after
Utilisation
-- Syntaxe Lingo
put expression after expressionSousChaîne
Description
Commande ; évalue une expression Lingo, convertit la valeur en chaîne et insère celle-ci à la fin
d’une sous-chaîne spécifiée dans un conteneur, sans remplacer le contenu de ce dernier. Si
expressionSousChaîne spécifie une sous-chaîne cible qui n’existe pas, la valeur de la chaîne est
insérée de manière appropriée dans le conteneur.
Les expressions de sous-chaîne peuvent représenter n’importe quel caractère, mot, élément ou
ligne dans un conteneur quelconque. Les conteneurs peuvent être des acteurs champ, des acteurs
texte et des variables contenant des chaînes, ainsi que des caractères, des mots, des éléments, des
lignes et des plages spécifiés dans des conteneurs.
236
Chapitre 11 : Mots-clés
Exemple
L’instruction suivante ajoute la chaîne « renard chien chat » après le contenu de l’acteur champ
Liste d’animaux :
put("renard chien chat") after member("Liste d’animaux")
Le même résultat peut s’obtenir avec l’instruction suivante :
put "renard chien chat" after member("Liste d’animaux").line[1]
Voir aussi
char...of, item...of, line...of, paragraph, word...of, put...before,
put...into
put...before
Utilisation
-- Syntaxe Lingo
put expression before expressionSousChaîne
Description
Commande ; évalue une expression Lingo, convertit la valeur en chaîne et insère celle-ci avant
une sous-chaîne spécifiée dans un conteneur, sans remplacer le contenu de ce dernier. Si
expressionSousChaîne spécifie une sous-chaîne cible qui n’existe pas, la valeur de la chaîne est
insérée de manière appropriée dans le conteneur.
Les expressions de sous-chaîne peuvent représenter n’importe quel caractère, mot, élément ou
ligne dans un conteneur quelconque. Les conteneurs peuvent être des acteurs champ, des acteurs
texte et des variables contenant des chaînes, ainsi que des caractères, des mots, des éléments, des
lignes et des plages spécifiés dans des conteneurs.
Exemple
L’instruction suivante affecte à la variable listeDanimaux la chaîne « renard chien chat », puis
insère le mot élan avant le deuxième mot de la liste :
put "renard chien chat" into listeDanimaux
put "élan" before word 2 of listeDanimaux
Le résultat correspond à la chaîne « renard élan chien chat ».
Le même résultat peut s’obtenir avec la syntaxe suivante :
put "renard chien chat" into listeDanimaux
put "élan" before listeDanimaux.word[2]
Voir aussi
char...of, item...of, line...of, paragraph, word...of, put...after, put...into
237
put...into
Utilisation
-- Syntaxe Lingo
put expression into expressionSousChaîne
Description
Commande ; évalue une expression Lingo, convertit la valeur en une chaîne et insère celle-ci pour
remplacer une sous-chaîne spécifiée d’un conteneur. Si expressionSousChaîne spécifie une
sous-chaîne cible qui n’existe pas, la valeur de la chaîne est insérée de manière appropriée dans le
conteneur.
Les expressions de sous-chaîne peuvent représenter n’importe quel caractère, mot, élément ou
ligne dans un conteneur quelconque. Les conteneurs peuvent être des acteurs champ, des acteurs
texte et des variables contenant des chaînes, ainsi que des caractères, des mots, des éléments, des
lignes et des plages spécifiés dans des conteneurs.
Lorsqu’une animation est lue en tant qu’applet, la commande put...into remplace tout le texte
d’un conteneur, et non uniquement des sous-chaînes de texte.
Pour affecter des valeurs à des variables, utilisez la commande set.
Exemple
L’instruction suivante change la seconde ligne de l’acteur champ Critiques en Critique par Olivier
Pognon :
put "Critique par Olivier Pognon" into line 2 of member("Critiques")
Le même résultat peut s’obtenir avec un acteur texte au moyen de la syntaxe suivante :
put "Critique par Olivier Pognon" into member("Critiques").line[2]
Voir aussi
char...of, item...of, line...of, paragraph, word...of, put...before,
put...after, set...to, set...=
repeat while
Utilisation
-- Syntaxe Lingo
repeat whileconditionTest
instruction(s)
end repeat
Description
Mot-clé ; exécute les instructions tant que la condition spécifiée par conditionTest a la
valeur TRUE. Cette structure peut servir pour des instructions Lingo qui lisent des chaînes jusqu’à
ce que la fin d’un fichier soit atteinte, qui vérifient des éléments jusqu’à la fin d’une liste, ou qui
effectuent une action en boucle jusqu’à ce que l’utilisateur clique sur le bouton de la souris ou le
relâche.
Tant qu’il est dans une boucle, Lingo ignore les autres événements. Pour déterminer la touche
courante dans une boucle, utilisez la propriété keyPressed.
238
Chapitre 11 : Mots-clés
Un seul gestionnaire peut être exécuté à la fois. Si Lingo reste dans une boucle d’une façon
prolongée, d’autres événements s’empilent en attente d’évaluation. Les boucles sont donc
préférables pour les opérations courtes et rapides ou lorsque vous ne prévoyez aucune action de
l’utilisateur.
Si vous devez traiter quelque chose pendant au moins plusieurs secondes, évaluez la fonction dans
une boucle avec un compteur quelconque ou testez sa progression.
Si la condition d’arrêt n’est jamais atteinte ou s’il n’existe aucune sortie de la boucle, vous pouvez
forcer Director à s’arrêter avec Ctrl+Alt+point (Windows) ou Cmd+point (Macintosh).
Exemple
Le gestionnaire suivant lance le compteur en le remettant à 0 et le fait compter jusqu’à 60
millisecondes :
on countTime
_system.milliseconds
repeat while _system.milliseconds < 60
-- en attente
end repeat
end countTime
Voir aussi
exit, exit repeat, repeat with, keyPressed()
repeat with
Utilisation
-- Syntaxe Lingo
repeat with compteur = début to fin
instruction(s)
end repeat
Description
Mot-clé ; exécute le Lingo spécifié par instruction(s) autant de fois que spécifié par compteur.
La valeur de compteur est la différence entre la valeur indiquée par début et celle indiquée par
fin. Le compteur augmente de 1 à chaque fois que Lingo parcourt la boucle.
La structure repeat with sert à appliquer en continu le même effet à un ensemble d’imagesobjets ou à calculer une série de nombres à une certaine puissance.
Tant qu’il est dans une boucle, Lingo ignore les autres événements. Pour déterminer la touche
courante dans une boucle, utilisez la propriété keyPressed.
Un seul gestionnaire peut être exécuté à la fois. Si Lingo reste dans une boucle d’une façon
prolongée, d’autres événements s’empilent en attente d’évaluation. Les boucles sont donc
préférables pour les opérations courtes et rapides ou lorsque vous ne prévoyez aucune action
de l’utilisateur.
Si vous devez traiter quelque chose pendant au moins plusieurs secondes, évaluez la fonction dans
une boucle avec un compteur ou testez sa progression.
Si la condition d’arrêt n’est jamais atteinte ou s’il n’existe aucune sortie de la boucle, vous pouvez
forcer Director à s’arrêter avec Ctrl+Alt+point (Windows) ou Cmd+point (Macintosh).
239
Exemple
Le gestionnaire suivant transforme les images-objets 1 à 30 en esclaves :
on esclaves
repeat with channel = 1 to 30
_movie.puppetSprite(channel, TRUE)
end repeat
end esclaves
Voir aussi
exit, exit repeat, repeat while, repeat with...down to, repeat with...in list
repeat with...down to
Utilisation
-- Syntaxe Lingo
repeat with variable = valeurInitiale down to valeurFinale
Description
Mot-clé ; décompte par incréments de 1 à partir de valeurInitiale jusqu’à valeurFinale.
Un seul gestionnaire peut être exécuté à la fois. Si Lingo reste dans une boucle d’une façon
prolongée, d’autres événements s’empilent en attente d’évaluation. Les boucles sont donc
préférables pour les opérations courtes et rapides ou lorsque vous ne prévoyez aucune action
de l’utilisateur.
Tant qu’il est dans une boucle, Lingo ignore les autres événements. Pour déterminer la touche
courante dans une boucle, utilisez la propriété keyPressed.
Si vous devez traiter quelque chose pendant au moins plusieurs secondes, évaluez la fonction dans
une boucle avec un compteur ou testez sa progression.
Si la condition d’arrêt n’est jamais atteinte ou s’il n’existe aucune sortie de la boucle, vous pouvez
forcer Director à s’arrêter avec Ctrl+Alt+point (Windows) ou Cmd+point (Macintosh).
Exemple
Le gestionnaire suivant contient une boucle qui décompte de 20 à 15 :
on countDown
repeat with i = 20 down to 15
sprite(6).member = 10 + i
_movie.updateStage()
end repeat
end
repeat with...in list
Utilisation
-- Syntaxe Lingo
repeat with variable in uneListe
Description
Mot-clé ; affecte à la variable les valeurs successives issues de la liste spécifiée.
240
Chapitre 11 : Mots-clés
Tant qu’il est dans une boucle, Lingo ignore les autres événements, à l’exception des touches.
Pour déterminer la touche courante dans une boucle, utilisez la propriété keyPressed.
Un seul gestionnaire peut être exécuté à la fois. Si Lingo reste dans une boucle d’une façon
prolongée, d’autres événements s’empilent en attente d’évaluation. Les boucles sont donc
préférables pour les opérations courtes et rapides ou lorsque vous ne prévoyez aucune action
de l’utilisateur.
Si vous devez traiter quelque chose pendant au moins plusieurs secondes, évaluez la fonction dans
une boucle avec un compteur ou testez sa progression.
Si la condition d’arrêt n’est jamais atteinte ou s’il n’existe aucune sortie de la boucle, vous pouvez
forcer Director à s’arrêter avec Ctrl+Alt+point (Windows) ou Cmd+point (Macintosh).
Exemple
L’instruction suivante affiche quatre valeurs dans la fenêtre Messages :
repeat with i in [1, 2, 3, 4]
put(i)
end repeat
return (mot-clé)
Utilisation
-- Syntaxe Lingo
return expression
Description
Mot-clé; renvoie la valeur expression et quitte le gestionnaire. L’argument expression
peut être une valeur Lingo quelconque.
Lorsque vous appelez un gestionnaire qui sert de fonction définie par l’utilisateur et possède une
valeur de renvoi, vous devez entourer de parenthèses les listes d’arguments, même lorsque ces
listes sont vides, comme dans le cas du gestionnaire de fonction lancerLesDés illustré sous la
fonction result.
La fonction du mot-clé return est similaire à celle de la commande exit, à l’exception près que
renvoie également une valeur à l’instruction qui a appelé le gestionnaire. La commande
dans un gestionnaire entraîne la sortie immédiate de ce gestionnaire, mais peut renvoyer
une valeur au Lingo l’ayant appelé.
return
return
L’utilisation de return dans des scripts orientés objet peut être difficile à comprendre. Il est plus
aisé de commencer par utiliser return pour créer des fonctions et sortir de gestionnaires. Vous
verrez ensuite que la ligne return me dans un gestionnaire on new fournit un moyen de passer
une référence à un objet créé de façon qu’il puisse être affecté à un nom de variable.
Le mot-clé return n’est pas identique à la constante de caractère RETURN, qui correspond à un
retour de chariot. La fonction dépend du contexte.
Pour récupérer une valeur renvoyée, utilisez des parenthèses après le nom du gestionnaire dans
l’instruction d’appel pour indiquer que ce nom de gestionnaire est une fonction.
Vous pourrez voir un exemple de return (mot-clé) dans une animation en consultant
l’animation Parent Scripts du dossier Learning/Lingo, lui-même dans le dossier de Director.
241
Exemple
Le gestionnaire suivant renvoie un multiple aléatoire de cinq compris entre 5 et 100 :
on scoreAléatoire
score = 5 * random(20)
return score
end scoreAléatoire
Vous appelez ce gestionnaire avec une instruction semblable à la suivante :
score = scoreAléatoire()
Dans cet exemple, la variable score reçoit la valeur renvoyée par la fonction scoreAléatoire().
Un script parent remplit la même fonction : en renvoyant la référence de l’objet, le nom de la
variable du code d’appel fournit un pointeur pour références ultérieures à cet objet.
Voir aussi
result, RETURN (constante)
set...to, set...=
Utilisation
-- Syntaxe Lingo
propriétéLingo = expression
variable = expression
Description
Commande ; évalue une expression et affecte le résultat à la propriété spécifiée par
propriétéLingo ou à la variable spécifiée par variable.
Exemple
L’instruction suivante donne à l’acteur 3 le nom de Coucher de soleil :
member(3).name = "Coucher de soleil"
L’instruction suivante inverse l’état de la propriété soundEnabled. Si la propriété soundEnabled
a la valeur TRUE (son activé), cette instruction le désactive. Si la propriété soundEnabled a la
valeur FALSE (son désactivé), cette instruction l’active.
_sound.soundEnabled = not (_sound.soundEnabled)
L’instruction suivante affecte à la variable voyelles la chaîne « aeiou » :
voyelles = "aeiou"
Voir aussi
property
242
Chapitre 11 : Mots-clés
sprite...intersects
Utilisation
-- Syntaxe Lingo
sprite(image-objet1).intersects(image-objet2)
spriteimageObjet1).intersects imageObjet2
Description
Mot-clé ; opérateur comparant la position de deux images-objets pour déterminer si le
quadrilatère de l’imageObjet1 est en contact avec celui de l’imageObjet2 (TRUE) ou non (FALSE).
Si l’encre Dessin seul est appliquée aux deux images-objets, la comparaison porte sur leurs
contours, non sur leurs quadrilatères. Le contour d’une image-objet est défini par l’ensemble des
pixels autres que blanc formant sa bordure.
Il s’agit d’un opérateur de comparaison avec niveau de priorité de 5.
Remarque : L’opérateur point est requis lorsque l’imageObjet1 n’est pas une expression simple – une
expression contenant une opération mathématique.
Exemple
L’instruction suivante vérifie si deux images-objets se croisent et, le cas échéant, modifie le
contenu de l’acteur champ Notice pour qu’il contienne le texte « Position correcte ».
if sprite i intersects j then put("Position correcte") \
into member("Notice")
Voir aussi
sprite...within, quad
sprite...within
Utilisation
-- Syntaxe Lingo
sprite(image-objet1).within(image-objet2)
sprite(imageObjet1withinimageObjet2)
Description
Mot-clé ; opérateur comparant la position de deux images-objets pour déterminer si le
quadrilatère de l’imageObjet1 est complètement à l’intérieur de celui de l’imageObjet2 (TRUE)
ou non (FALSE).
Si l’encre Dessin seul est appliquée aux deux images-objets, la comparaison porte sur leurs
contours, non sur leurs quadrilatères. Le contour d’une image-objet est défini par l’ensemble des
pixels autres que blanc formant sa bordure.
Il s’agit d’un opérateur de comparaison avec niveau de priorité de 5.
Remarque : L’opérateur point est requis lorsque l’imageObjet1 n’est pas une expression simple – une
expression contenant une opération mathématique.
Exemple
L’instruction suivante vérifie si deux images-objets se croisent et, le cas échéant, appelle le
gestionnaire Intérieur :
if sprite(3).within(2) then Intérieur
243
Voir aussi
sprite...intersects, quad
version
Utilisation
-- Syntaxe Lingo
_player.productVersion
Description
Mot-clé ; variable système contenant le numéro de version de Director. La même chaîne apparaît
dans la boîte de dialogue Lire les informations du Finder, sur le Macintosh.
Exemple
L’instruction suivante affiche la version de Director dans la fenêtre Messages :
put(_player.productVersion)
word...of
Utilisation
-- Syntaxe Lingo
member(quelActeur).word[quelMot]
expressionActeurTexte.word[quelMot]
expressionSousChaîne[quelMot]
word quelMot of variableChampOuChaîne
variableChampOuChaîne word[quelMot
expressionActeurTexte.word[premierMot..dernierMot]
member(quelActeur).word[premierMot..dernierMot]
word premierMot to dernierMot of expressionSousChaîne
expressionSousChaîne[quelMot..dernierMot]
Description
Expression de sous-chaîne ; spécifie un mot ou une série de mots dans une sous-chaîne. Une souschaîne de mots est une suite de caractères délimitée par des espaces. (Tout caractère invisible,
comme une tabulation ou un retour de chariot, est considéré comme une espace.)
Les expressions quelMot, premierMot et dernierMot doivent avoir pour valeur un nombre entier
correspondant à un mot de la sous-chaîne.
Les sous-chaînes peuvent représenter n’importe quel caractère, mot, élément ou ligne d’un groupe
de caractères. Les sources de texte peuvent être des acteurs champ et texte et des variables contenant des chaînes.
Vous pouvez voir un exemple de word...of dans une animation en consultant l’animation Text
du dossier Learning/Lingo, lui-même dans le dossier de Director.
Exemple
Les instructions suivantes affectent à la variable listeDanimaux la chaîne « renard chien chat »,
puis insèrent le mot élan avant le deuxième mot de la liste :
listeDanimaux = "renard chien chat"
put "élan" before listeDanimaux.word[2]
Le résultat correspond à la chaîne « renard élan chien chat ».
244
Chapitre 11 : Mots-clés
L’instruction suivante demande à Director d’afficher le cinquième mot de la même chaîne dans la
fenêtre Messages :
put "renard élan chien chat".word[5]
Cette chaîne ne comportant pas de cinquième mot, la fenêtre Messages affiche deux guillemets
droits(""), ce qui indique une chaîne vide.
Voir aussi
char...of, line...of, item...of, count(), number (mots)
245
246
Chapitre 11 : Mots-clés
CHAPITRE 12
Méthodes
Cette section fournit une liste alphabétique de toutes les méthodes disponibles dans Director.
abort
Utilisation
-- Syntaxe Lingo
abort
// Syntaxe JavaScript
abort();
Description
Commande ; indique à Lingo de sortir du gestionnaire courant et de tout autre gestionnaire qui
l’a appelé sans exécuter les instructions restantes du gestionnaire concerné. Elle est différente du
mot-clé exit, qui revient au gestionnaire à partir duquel le gestionnaire courant a été appelé.
La commande abort ne quitte pas Director.
Paramètres
Aucun.
Exemple
L’instruction suivante indique à Lingo de sortir du gestionnaire courant et de tout gestionnaire
l’ayant appelé si la quantité de mémoire disponible est inférieure à 50 Ko :
-- Syntaxe Lingo
if the freeBytes < 50*1024 then abort
// Syntaxe JavaScript
if (_player.freeBytes < 50*1024) {
abort()
}
Voir aussi
exit, halt(), quit()
247
abs()
Utilisation
-- Syntaxe Lingo
abs (expressionNumérique)
// Syntaxe JavaScript
Math.abs (expressionNumérique)
Description
Fonction mathématique (Lingo uniquement) ; calcule la valeur absolue d’une expression
numérique.
La fonction abs() peut être utilisée de différentes façons. Elle permet de simplifier le suivi du
mouvement de la souris et des images-objets en convertissant leurs coordonnées (qu’elles soient
positives ou négatives) en distances (celles-ci sont toujours positives). La fonction abs() permet
également de traiter les fonctions mathématiques telles que sqrt() et log().
Dans la syntaxe JavaScript, utilisez la fonction abs() de l’objet Math.
Paramètres
expressionNumérique Requis. Nombre entier ou à virgule flottante à partir duquel une valeur
absolue est calculée. Si expressionNumérique est un nombre entier, la valeur absolue est
également un nombre entier. Si expressionNumérique est un nombre à virgule flottante, la
valeur absolue est également un nombre à virgule flottante.
Exemple
L’instruction suivante permet de calculer si la valeur absolue de la différence entre la position
actuelle de la souris et la valeur de la variable débutV est supérieure à 30 (puisque vous n’allez pas
utiliser un nombre négatif pour exprimer une distance). Si c’est le cas, la couleur de premier plan
de l’image-objet 6 est modifiée.
-- Syntaxe Lingo
if (the mouseV - débutV).abs > 30 then sprite(6).forecolor = 95
// Syntaxe JavaScript
if ((_mouse.mouseV - Math.abs(_mouse.débutV)) > 30) {
sprite(6).foreColor = 95;
}
activateAtLoc()
Utilisation
-- Syntaxe Lingo
réfObjDvd.activateAtLoc(point(x, y))
// Syntaxe JavaScript
réfObjDvd.activateAtLoc(point(x, y));
Description
Méthode de DVD ; Active la sélection de l’élément de menu DVD intégré qui se trouve sous
l’emplacement spécifié.
Cette méthode renvoie la valeur 0 en cas de réussite.
248
Chapitre 12 : Méthodes
Paramètres
point(x, y)
Requis. Point spécifiant l’emplacement de l’élément de menu DVD intégré.
Exemple
Cette instruction active la sélection de l’élément de menu à un emplacement spécifié :
-- Syntaxe Lingo
member("animation1").activateAtLoc(point(100, 200))
// Syntaxe JavaScript
member("animation1").activateAtLoc(point(100, 200));
Voir aussi
DVD
activateButton()
Utilisation
-- Syntaxe Lingo
réfObjDvd.activateButton()
// Syntaxe JavaScript
réfObjDvd.activateButton();
Description
Méthode de DVD ; Active le bouton de menu actuellement sélectionné.
Cette méthode renvoie la valeur 0 en cas de réussite.
Paramètres
Aucun.
Exemple
Cette instruction active le bouton Menu sur un acteur spécifié :
-- Syntaxe Lingo
sprite(1).member.activateButton()
// Syntaxe JavaScript
sprite(1).member.activateButton();
Voir aussi
DVD
249
add
Utilisation
-- Syntaxe Lingo
listeLinéaire.add(valeur)
// Syntaxe JavaScript
tableau.push(valeur)
Description
Commande de liste (pour les listes linéaires uniquement) ; ajoute une valeur à une liste linéaire.
Dans le cas d’une liste triée, cette valeur est placée dans l’ordre correct. Dans le cas d’une liste non
triée, cette valeur est placée à la fin de la liste.
Cette commande provoque une erreur quand elle est utilisée dans une liste de propriétés.
Remarque : Veillez à ne pas confondre la commande add et l’opérateur + utilisé pour les additions ou
l’opérateur & utilisé pour concaténer les chaînes.
Paramètres
valeur
Requis. Valeur à ajouter à la liste linéaire.
Exemple
Les instructions suivantes ajoutent la valeur 2 à la liste nommée devis. La liste résultante est
[3, 4, 1, 2].
-- Syntaxe Lingo
devis = [3, 4, 1]
devis.add(2)
// Syntaxe JavaScript
devis = new Array(3,4,1);
devis.push(2);
L’instruction suivante ajoute 2 à la liste linéaire triée [1, 4, 5]. Le nouvel élément reste en ordre
alphanumérique, la liste étant une liste triée.
-- Syntaxe Lingo
devis.add(2)
// Syntaxe JavaScript
devis.push(2);
// trier la liste en utilisant la syntaxe JavaScript
devis.sort();
Voir aussi
sort
250
Chapitre 12 : Méthodes
add (texture 3D)
Utilisation
-- Syntaxe Lingo
member(quelActeur).model(quelModèle).meshdeform.mesh[index].\
textureLayer.add()
// Syntaxe JavaScript
member(quelActeur).model(quelModèle).meshdeform.mesh[index].\
textureLayer.add()
Description
Commande de modificateur 3D meshdeform ; ajoute une couche de texture vide à la maille du
modèle.
Vous pouvez copier les coordonnées de texture entre les couches à l’aide du code suivant :
réfDeModèle.meshdeform.texturelayer[a].texturecoordinatelist =
réfDeModèle.meshdeform.texturelayer[b].texturecoordinatelist
Paramètres
Aucun.
Exemple
L’instruction suivante crée une nouvelle couche de texture pour la première maille du modèle
appelé Oreille.
-- Syntaxe Lingo
member("Scène").model("Oreille").meshdeform.mesh[1].textureLayer.add()
// Syntaxe JavaScript
member("Scène").model("Oreille").meshdeform.mesh[1].textureLayer.add();
Voir aussi
meshDeform (modificateur), textureLayer, textureCoordinateList
addAt
Utilisation
liste.AddAt(position, valeur)
Description
Commande de liste (pour les listes linéaires uniquement) ; ajoute une valeur à une position
spécifiée dans la liste.
Cette commande provoque une erreur quand elle est utilisée avec une liste de propriétés.
Paramètres
position Requis. Nombre entier qui indique la position à laquelle la valeur spécifiée par value
est ajoutée à la liste.
valeur
Requis. Valeur à ajouter à la liste.
251
Exemple
L’instruction suivante ajoute la valeur 8 à la quatrième position de la liste devis, qui vaut
[3, 2, 4, 5, 6, 7] :
devis = [3, 2, 4, 5, 6, 7]
devis.addAt(4,8)
La valeur de devis est maintenant [3, 2, 4, 8, 5, 6, 7].
addBackdrop
Utilisation
-- Syntaxe Lingo
sprite(quelleImageObjet).camera{(index)}.addBackdrop(texture,
emplacementDansLimageObjet, rotation)
member(quelActeur).camera(quelleCaméra).addBackdrop(texture,
emplacementDansLimageObjet, rotation)
// Syntaxe JavaScript
sprite(quelleImageObjet).camera{(index)}.addBackdrop(texture,
emplacementDansLimageObjet, rotation);
member(quelActeur).camera(quelleCaméra).addBackdrop(texture,
emplacementDansLimageObjet, rotation);
Description
Commande de caméra 3D ; ajoute un fond à la fin de la liste des fonds de la caméra.
Paramètres
texture
Requis. Texture à appliquer au fond.
emplacementDansLimageObjet Requis. Emplacement 2D dont le fond est affiché dans l’imageobjet 3D. Cet emplacement est mesuré à partir du coin supérieur gauche de l’image-objet.
rotation
Requis. Nombre entier qui définit, en degrés, la rotation à appliquer à la texture.
Exemple
La première ligne de l’instruction suivante crée la texture Rugueuse à partir de l’acteur Cèdre
et l’enregistre dans la variable t1. La deuxième ligne applique la texture comme fond à
l’emplacement (220, 220) dans l’image-objet 5 avec une rotation de zéro degré. La dernière
ligne applique la même texture comme fond pour la caméra 1 de l’acteur Scène à l’emplacement
(20, 20) avec une rotation de 45°.
t1 = member("Scène").newTexture("Rugueuse", #fromCastMember,\
member("Cèdre"))
sprite(5).camera.addBackdrop(t1, point(220, 220), 0)
member("Scène").camera[1].addBackdrop(t1, point(20, 20), 45)
Voir aussi
removeBackdrop
252
Chapitre 12 : Méthodes
addCamera
Utilisation
-- Syntaxe Lingo
sprite(quelleImageObjet).addCamera(quelleCaméra, index)
-- Syntaxe JavaScript
sprite(quelleImageObjet).addCamera(quelleCaméra, index);
Description
Commande 3D ; ajoute une caméra à la liste des caméras de l’image-objet. Les vues des
différentes caméras sont affichées devant celles des caméras en position index inférieures.
Vous pouvez définir la propriété rect de chaque caméra afin d’afficher plusieurs vues au sein
de l’image-objet.
Paramètres
quelleCaméra
Requis. Référence à la caméra à ajouter à la liste des caméras de l’image-objet.
index Requis. Nombre entier spécifiant l’index au niveau duquel la caméra quelleCaméra est
ajoutée à la liste des caméras. Si la valeur index est supérieure à la valeur de cameraCount(), la
caméra est ajoutée à la fin de la liste.
Exemple
L’instruction suivante insère la caméra caméraDeVol en cinquième position de la liste des
caméras de l’image-objet 12 :
-- Syntaxe Lingo
sprite(12).addCamera(member("scène").camera("caméraDeVol"), 5)
// Syntaxe JavaScript
sprite(12).addCamera(member("scène").camera("caméraDeVol"), 5);
Voir aussi
cameraCount(), deleteCamera
addChild
Utilisation
-- Syntaxe Lingo
member(quelActeur).nœud(quelNœudParent).addChild(member\
(quelActeur).nœud(quelNœudEnfant) {,#conserverLunivers})
// Syntaxe JavaScript
member(quelActeur).nœud(quelNœudParent).addChild(member\
(quelActeur).nœud(quelNœudEnfant) {,#conserverLunivers})
Description
Commande 3D ; ajoute un nœud à la liste des enfants d’un autre nœud et le supprime de la liste
des enfants de son parent précédent.
Cette méthode équivaut à définir la propriété parent du nœud enfant sur le nœud parent.
253
Paramètres
quelActeur
Requis. Référence à l’acteur qui contient le nœud à ajouter.
Requis. Référence au nœud à ajouter. Ce nœud peut être un modèle, un groupe, une
caméra ou une lumière.
nœud
Facultatif. Référence à la caméra à ajouter à la liste des caméras de l’imageobjet. Les valeurs correctes sont #preserveWorld et #preserveParent. Lorsque l’enfant est
ajouté et que #preserveParent est spécifié, la transformation relative au parent de l’enfant reste
la même et ce dernier passe à cette transformation dans l’espace de son nouveau parent. La
transformation de l’enfant dans l’univers est recalculée. Lorsque l’enfant est ajouté et que
#preserveWorld est spécifié, la transformation de l’enfant dans l’univers reste la même et ce
dernier ne passe pas à sa transformation dans l’espace de son nouveau parent. Sa transformation
relative au parent est recalculée.
conserverLunivers
Exemple
L’instruction suivante ajoute le modèle Pneu à la liste des enfants du modèle Voiture.
-- Syntaxe Lingo
member("3D").model("Voiture").addChild(member("3D").model("Pneu"))
// Syntaxe JavaScript
member("3D").model("Voiture").addChild(member("3D").model("Pneu"));
L’instruction suivante ajoute le modèle Oiseau à la liste des enfants de la caméra MaCaméra et
utilise l’argument #preserveWorld pour conserver la position du modèle Oiseau dans l’univers.
-- Syntaxe Lingo
member("3D").camera("MaCaméra").addChild(member("3D").model
("Oiseau"), #preserveWorld)
// Syntaxe JavaScript
member("3D").camera("MaCaméra").addChild(member("3D").model
("Oiseau"), symbol("preserveWorld"));
Voir aussi
parent, addToWorld, removeFromWorld
addModifier
Utilisation
-- Syntaxe Lingo
member(quelActeur).model(quelModèle).addModifier\
(#typeDeModificateur)
// Syntaxe JavaScript
member(quelActeur).model(quelModèle).addModifier\
(symbol(typeDeModificateur));
Description
Commande 3D de modèle ; ajoute le modificateur spécifié au modèle. Il n’existe aucune valeur
par défaut pour cette commande.
254
Chapitre 12 : Méthodes
Paramètres
typeDeModificateur Requis. Symbole qui spécifie le modificateur à ajouter. Les modificateurs
possibles sont les suivants :
•
•
•
•
•
•
•
•
#bonesPlayer
#collision
#inker
#keyframePlayer
#lod
(niveau de détail)
#meshDeform
#sds
#toon
Pour plus d’informations, consultez les entrées des différents modificateurs.
Exemple
L’instruction suivante ajoute le modificateur toon au modèle Boîte.
-- Syntaxe Lingo
member("formes").model("Boîte").addModifier(#toon)
// Syntaxe JavaScript
member("formes").model("Boîte").addModifier(symbol("toon"));
Voir aussi
bonesPlayer (modificateur), collision (modificateur), inker (modificateur),
keyframePlayer (modificateur), lod (modificateur), meshDeform
(modificateur), sds (modificateur), toon (modificateur),
getRendererServices(), removeModifier, modifier, modifier[], modifiers
addOverlay
Utilisation
-- Syntaxe Lingo
sprite(quelleImageObjet).camera{(index)}.addOverlay(texture, \
emplacementDansLimageObjet, rotation)
member(quelActeur).camera(quelleCaméra).addOverlay(texture, \
emplacementDansLimageObjet, rotation)
// Syntaxe JavaScript
sprite(quelleImageObjet).camera{(index)}.addOverlay(texture, \
emplacementDansLimageObjet, rotation)
member(quelActeur).camera(quelleCaméra).addOverlay(texture, \
emplacementDansLimageObjet, rotation)
Description
Commande 3D de caméra ; ajoute un recouvrement à la fin de la liste des recouvrements d’une
caméra.
255
Paramètres
texture
Requis. Texture à appliquer au recouvrement.
emplacementDansLimageObjet Requis. Emplacement 2D où le recouvrement est affiché dans
l’image-objet 3D. Cet emplacement est mesuré à partir du coin supérieur gauche de l’imageobjet.
rotation
Requis. Nombre entier qui définit, en degrés, la rotation à appliquer à la texture.
Exemple
La première ligne de l’instruction suivante crée la texture Rugueuse à partir de l’acteur Cèdre et
l’enregistre dans la variable t1. La deuxième ligne applique la texture comme recouvrement à
l’emplacement (220, 220) dans l’image-objet 5 avec une rotation de zéro degré. La dernière ligne
de l’instruction applique la même texture comme recouvrement pour la caméra 1 de l’acteur
Scène, au point (20, 20). Une rotation de 45° est appliquée à la texture.
-- Syntaxe Lingo
t1 = member("Scène").newTexture("Rugueuse", #fromCastMember,\
member("Cèdre"))
sprite(5).camera.addOverlay(t1, point(220, 220), 0)
member("Scène").camera[1].addOverlay(t1, point(20, 20), 45)
// Syntaxe JavaScript
t1 = member("Scène").newTexture("Rugueuse", symbol("fromCastMember"),\
member("Cèdre"));
sprite(5).camera.addOverlay(t1, point(220, 220), 0);
member("Scène").camera[1].addOverlay(t1, point(20, 20), 45);
Voir aussi
removeOverlay
addProp
Utilisation
liste.addProp(propriété, valeur)
addProp list, propriété, valeur
Description
Commande de liste de propriétés ; ajoute, pour les listes de propriétés uniquement, une propriété
spécifiée et sa valeur à une liste de propriétés.
Dans le cas d’une liste non triée, cette valeur est placée à la fin de la liste. Dans le cas d’une liste
triée, cette valeur est placée dans l’ordre correct.
Si la propriété spécifiée existe déjà dans la liste, la syntaxe Lingo et JavaScript en créent une copie.
Afin d’éviter d’avoir des propriétés en double, utilisez la commande setaProp() pour modifier la
propriété correspondant à la nouvelle entrée de liste.
Cette commande provoque une erreur quand elle est utilisée avec une liste linéaire.
Paramètres
propriété
valeur
256
Requis. Propriété à ajouter à la liste.
Requis. Valeur de la propriété à ajouter à la liste.
Chapitre 12 : Méthodes
Exemple
L’instruction suivante ajoute la propriété dupont et sa valeur de 3 à la liste de propriétés devis,
qui contient [#avatar: 4, #soldes: 1]. Cette liste étant triée, la nouvelle entrée est placée par
ordre alphabétique :
devis.addProp(#dupont, 3)
La liste qui en résulte est [#avatar: 4, #dupont: 3, #soldes: 1].
L’instruction suivante ajoute l’entrée dupont: 7 à la liste devis, qui contient maintenant
[#avatar: 4, #dupont: 3, #soldes: 1]. Cette liste contenant déjà la propriété dupont,
le
script en crée une copie :
devis.addProp(#dupont, 7)
La liste qui en résulte est [#avatar: 4, #dupont: 3, #dupont: 7, #soldes: 1].
addToWorld
Utilisation
-- Syntaxe Lingo
member(quelActeur).model(quelModèle).addToWorld()
member(quelActeur).group(quelGroupe).addToWorld()
member(quelActeur).camera(quelleCaméra).addToWorld()
member(quelActeur).light(quelleLumière).addToWorld()
// Syntaxe JavaScript
member(quelActeur).model(quelModèle).addToWorld()
member(quelActeur).group(quelGroupe).addToWorld()
member(quelActeur).camera(quelleCaméra).addToWorld()
member(quelActeur).light(quelleLumière).addToWorld()
Description
Commande 3D ; insère le modèle, le groupe, la caméra ou la lumière, dans l’univers 3D de
l’acteur comme enfant du groupe World.
Lorsqu’un modèle, un groupe, une caméra ou une lumière, est créé ou cloné, il est automatiquement ajouté à l’univers. Utilisez la commande removeFromWorld pour retirer un modèle, un
groupe, une caméra ou une lumière, de l’univers 3D sans le supprimer. Utilisez la commande
isInWorld() pour vérifier si un modèle, un groupe, une caméra ou une lumière, a été ajouté ou
retiré de l’univers.
Paramètres
Aucun.
Exemple
L’instruction suivante ajoute le modèle gbCyl à l’univers 3D de l’acteur Scène.
-- Syntaxe Lingo
member("Scène").model("gbCyl").addToWorld()
// Syntaxe JavaScript
member("Scène").model("gbCyl").addToWorld();
Voir aussi
isInWorld(), removeFromWorld
257
addVertex()
Utilisation
-- Syntaxe Lingo
réfObjActeur.addVertex(indexOùAjouter, pointOùAjouterSommet {,[
emplacementVContrôleHoriz, \
emplacementVContrôleVert ], [ emplacementHContrôleHoriz,
emplacementHContrôleVert ]})
// Syntaxe JavaScript
réfObjActeur.addVertex(indexOùAjouter, pointOùAjouterSommet {,[
emplacementVContrôleHoriz, \
emplacementVContrôleVert ], [ emplacementHContrôleHoriz,
emplacementHContrôleVert ]});
Description
Commande de formes vectorielles ; ajoute un nouveau sommet à un acteur forme vectorielle à la
position spécifiée.
Les positions horizontale et verticale du nouveau sommet sont déterminées par rapport à l’origine
de l’acteur forme vectorielle.
Si vous utilisez les deux derniers paramètres facultatifs, vous pouvez spécifier la position des
poignées de contrôle pour le sommet. La position de ces poignées de contrôle doit être donnée
par rapport à celle du sommet ; par conséquent, si aucune position n’est spécifiée, la poignée sera
placée sans décalage horizontal ou vertical (valeur 0,0).
Paramètres
indexOùAjouter
Requis. Nombre entier qui spécifie l’index au niveau duquel le membre est
ajouté.
pointOùAjouterSommet
Requis. Nombre entier qui spécifie la position à laquelle le membre est
ajouté.
Facultatif. Nombre entier qui spécifie l’emplacement de la partie
horizontale de la poignée de contrôle horizontal.
emplacementHContrôleHoriz
Facultatif. Nombre entier qui spécifie l’emplacement de la partie
verticale de la poignée de contrôle horizontal.
emplacementVContrôleHoriz
Facultatif. Nombre entier qui spécifie l’emplacement de la partie
horizontale de la poignée de contrôle vertical.
emplacementHContrôleVert
Facultatif. Nombre entier qui spécifie l’emplacement de la partie
verticale de la poignée de contrôle vertical.
emplacementVContrôleVert
258
Chapitre 12 : Méthodes
Exemple
La ligne suivante ajoute un point de sommet dans la forme vectorielle Archie entre les deux points
de sommet existants, à la position horizontale 25 et verticale 15 :
-- Syntaxe Lingo
member("Archie").addVertex(2, point(25, 15))
// Syntaxe JavaScript
member("Archie").addVertex(2, point(25, 15));
Voir aussi
vertexList, moveVertex(), deleteVertex(), originMode
alert()
Utilisation
-- Syntaxe Lingo
_player.alert(chaîneAffichée)
// Syntaxe JavaScript
_player.alert(chaîneAffichée);
Description
Méthode de lecteur ; déclenche un bip sonore du système et affiche une boîte de dialogue
d'avertissement contenant une chaîne spécifiée.
Le message d’avertissement doit être une chaîne. Pour inclure une variable numérique dans le
message d’avertissement, convertissez la variable en chaîne avant de la transmettre à alert().
Paramètres
chaîneAffichée Requis. Chaîne qui représente le texte affiché dans la boîte de dialogue
d’avertissement. La chaîne peut contenir jusqu’à 255 caractères.
Exemple
L’instruction suivante crée un message d’alerte indiquant qu’aucun lecteur de CD-ROM n’est
connecté :
-- Syntaxe Lingo
_player.alert("Aucun lecteur de CD-ROM n’est connecté.")
// Syntaxe JavaScript
_player.alert("Aucun lecteur de CD-ROM n’est connecté.");
L’instruction suivante crée un message d’alerte indiquant qu’un fichier est introuvable :
-- Syntaxe Lingo
_player.alert("Le fichier" && QUOTE & nomDuFichier & QUOTE && "est
introuvable.")
// Syntaxe JavaScript
_player.alert("Le fichier \"" + nomDuFichier + "\" est introuvable.");
Voir aussi
Lecteur
259
append
Utilisation
liste.append(valeur)
append liste, valeur
Description
Commande de liste (pour les listes linéaires uniquement) ; ajoute la valeur spécifiée à la fin
d’une liste linéaire. Elle est différente de la commande add, qui insère une valeur à une liste triée
à l’endroit appropriée de cette liste.
Cette commande, utilisée avec une liste de propriétés, provoque une erreur de script.
Propriétés
valeur
Requis. Valeur à ajouter à la fin de la liste linéaire.
Exemple
L’instruction suivante ajoute la valeur 2 à la fin de la liste triée appelée devis, qui contient
[1, 3, 4], alors même que la position ne correspond pas à l'ordre trié de la liste :
set devis = [1, 3, 4]
devis.append(2)
La valeur de devis est maintenant [1, 3, 4, 2].
Voir aussi
add (texture 3D), sort
appMinimize()
Utilisation
-- Syntaxe Lingo
_player.appMinimize()
// Syntaxe JavaScript
_player.appMinimize();
Description
Méthode de lecteur ; dans Microsoft Windows, entraîne la réduction d’une projection en une
icône dans la barre des tâches Windows. Sur Macintosh, entraîne le masquage d’une projection.
Sur Macintosh, ouvre à nouveau une projection masquée depuis le menu des applications du
Macintosh.
Cette méthode est pratique pour les projections et animations MIAW lues sans barre de titre.
Paramètres
Aucun.
260
Chapitre 12 : Méthodes
Exemple
-- Syntaxe Lingo
on mouseUp me
_player.appMinimize()
end
// Syntaxe JavaScript
function mouseUp() {
_player.appMinimize();
}
Voir aussi
Lecteur
atan()
Utilisation
-- Syntaxe Lingo
(nombre).atan
atan (nombre)
// Syntaxe JavaScript
Math.atan(nombre);
Description
Fonction mathématique (Lingo uniquement) ; calcule l’arctangente, qui correspond à l’angle
dont la tangente est un nombre spécifié. Le résultat est une valeur en radians comprise entre pi/2
et +pi/2.
Dans la syntaxe JavaScript, utilisez la fonction atan() de l’objet Math.
Paramètres
Aucun.
Exemple
L’instruction suivante donne l’arctangente de 1 :
(1).atan
Le résultat, à quatre chiffres après la virgule, est 0,7854, soit approximativement pi/4.
La plupart des fonctions trigonométriques utilisent les radians ; vous devrez alors peut-être
convertir les valeurs de degrés en radians.
Le gestionnaire suivant vous permet d’effectuer les conversions de degrés en radians :
-- Syntaxe Lingo
on degrésEnRadians valeurEnDegrés
return valeurEnDegrés * PI/180
end
// Syntaxe JavaScript
function degrésEnRadians (valeurEnDegrés) {
return valeurEnDegrés * PI/180
}
261
Le gestionnaire affiche le résultat de la conversion de 30 degrés en radians dans la fenêtre
Messages :
put degrésEnRadians(30)
-- 0.5236
Voir aussi
cos(), PI, sin()
beep()
Utilisation
-- Syntaxe Lingo
_sound.beep({entNombreDeBits})
// Syntaxe JavaScript
_sound.beep({entNombreDeBits});
Description
Méthode audio ; déclenche l’émission d’un bip sonore sur le haut-parleur de l’ordinateur.
Ce bip se répète autant de fois que spécifié par entNombreDeBips. Si vous n’avez pas spécifié
entNombreDeBips, le bip sonore ne retentit qu’une seule fois.
• Sous Windows, le bip sonore est le son désigné dans la boîte de dialogue des propriétés
sonores.
• Sur Macintosh, le bip sonore est le son sélectionné dans la section Alertes du tableau de bord
Moniteurs et son. Si le volume a la valeur 0, le bip sonore est remplacé par un clignotement
de la barre de menus.
Paramètres
entNombreDeBits Facultatif. Nombre entier qui spécifie combien de fois les haut-parleurs de
l’ordinateur doivent émettre un bip sonore.
Exemple
-- Syntaxe Lingo
on mouseUp me
_sound.beep(1)
end mouseUp
// Syntaxe JavaScript
function mouseUp() {
_sound.beep(1);
}
Voir aussi
Son
262
Chapitre 12 : Méthodes
beginRecording()
Utilisation
-- Syntaxe Lingo
_movie.beginRecording()
// Syntaxe JavaScript
_movie.beginRecording();
Description
Méthode d’animation ; lance une session de création du scénario.
Lorsque vous appelez beginRecording(), la tête de lecture avance automatiquement d’une
image et commence l’enregistrement à partir de cette image. Pour éviter ce comportement
et commencer l’enregistrement dans l’image où beginRecording() est appelée, insérez une
instruction telle que _movie.go(_movie.frame - 1) entre les appels de beginRecording()
et de endRecording().
Dans une animation, vous ne pouvez procéder qu’à une seule session à la fois de mise à jour du
scénario.
A chaque appel de beginRecording() doit correspondre un appel de endRecording(), qui
termine la session de création du scénario.
Paramètres
Aucun.
Exemple
Lorsque vous l’utilisez dans le gestionnaire suivant, le mot-clé beginRecording démarre une
session de création du scénario qui anime l’acteur Balle en l'affectant à la piste d’image-objet 20,
puis en déplaçant l’image-objet horizontalement et verticalement sur une série d’images. Le
nombre des images est déterminé par l'argument nombreDimages.
-- Syntaxe Lingo
on animBalle(nombreDimages)
_movie.beginRecording()
horizontal = 0
vertical = 100
repeat with i = 1 to nombreDimages
_movie.go(i)
sprite(20).member = member("Balle")
sprite(20).locH = horizontal
sprite(20).locV = vertical
sprite(20).forecolor = 255
horizontal = horizontal + 3
vertical = vertical + 2
_movie.updateFrame()
end repeat
_movie.endRecording()
end animBalle
263
// Syntaxe JavaScript
function animBalle(nombreDimages) {
_movie.beginRecording();
var horizontal = 0;
var vertical = 100;
for (var i = 1; i <= nombreDimages; i++) {
_movie.go(1);
sprite(20).member = member("Balle");
sprite(20).locH = horizontal;
sprite(20).locV = vertical;
sprite(20).foreColor = 255;
horizontal = horizontal + 3;
vertical = vertical + 2;
_movie.updateFrame();
}
_movie.endRecording();
}
Voir aussi
endRecording(), Animation
bitAnd()
Utilisation
bitAnd(entier1, entier2)
Description
Fonction (Lingo uniquement) ; convertit les deux nombres entiers spécifiés en nombres binaires
32 bits et renvoie un nombre binaire constitué de 1 aux positions où les deux nombres comportaient un 1 et de 0 à toutes les autres positions. Le résultat est un nouveau nombre binaire, que
Lingo affiche sous la forme d'un entier en base 10.
Entier
Nombre binaire (abrégé)
6
00110
7
00111
Résultat
6
00110
Dans la syntaxe JavaScript, utilisez l’opérateur au niveau du bit « & ».
Paramètres
264
entier1
Requis. Le premier nombre entier.
entier2
Requis. Le second nombre entier.
Chapitre 12 : Méthodes
Exemple
L'instruction suivante compare les versions binaires des entiers 6 et 7 et renvoie le résultat sous la
forme d'un entier :
put bitAnd(6, 7)
-- 6
Voir aussi
bitNot(), bitOr(), bitXor()
bitNot()
Utilisation
(entier).bitNot
bitNot(entier)
Description
Fonction (Lingo uniquement) ; convertit le nombre entier spécifié en nombre binaire 32 bits
et inverse la valeur de chaque chiffre binaire en remplaçant les 1 par des 0 et les 0 par des 1. Le
résultat est un nouveau nombre binaire, que Lingo affiche sous la forme d’un nombre entier en
base 10.
Entier
Nombre binaire
1
00000000000000000000000000000001
Résultat
-2
11111111111111111111111111111110
Dans la syntaxe JavaScript, utilisez l’opérateur au niveau du bit « ~ ».
Paramètres
Aucun.
Exemple
L'instruction suivante inverse la représentation binaire de l'entier 1 et renvoie un nouveau
nombre.
put (1).bitNot
-- -2
Voir aussi
bitAnd(), bitOr(), bitXor()
265
bitOr()
Utilisation
bitOr(entier1, entier2)
Description
Fonction (Lingo uniquement) ; convertit les deux nombres entiers spécifiés en nombres binaires
32 bits et renvoie un nombre binaire constitué de 1 aux positions où l’un ou l’autre nombre
comportait un 1 et de 0 à toutes les autres positions. Le résultat est un nouveau nombre binaire,
que Lingo affiche sous la forme d'un entier en base 10.
Entier
Nombre binaire (abrégé)
5
0101
6
0110
Résultat
7
0111
Dans la syntaxe JavaScript, utilisez l’opérateur au niveau du bit « | ».
Paramètres
entier1
Requis. Le premier nombre entier.
entier2
Requis. Le second nombre entier.
Exemple
L'instruction suivante compare les versions binaires des entiers 5 et 6 et renvoie le résultat sous la
forme d'un entier :
put bitOr(5, 6)
-- 7
Voir aussi
bitNot(), bitAnd(), bitXor()
bitXor()
Utilisation
bitXor(entier1, entier2)
Description
Fonction ; convertit les deux entiers spécifiés en nombres binaires 32 bits et renvoie un nombre
binaire constitué de 1 aux positions où les chiffres des nombres donnés ne correspondent pas et
de 0 aux positions où les chiffres sont les mêmes. Le résultat est un nouveau nombre binaire, que
Lingo affiche sous la forme d'un entier en base 10.
266
Entier
Nombre binaire (abrégé)
5
0101
6
0110
Chapitre 12 : Méthodes
Entier
Nombre binaire (abrégé)
Résultat
3
0011
Dans la syntaxe JavaScript, utilisez l’opérateur au niveau du bit « ^ ».
Paramètres
entier1
Requis. Le premier nombre entier.
entier2
Requis. Le second nombre entier.
Exemple
L'instruction suivante compare les versions binaires des entiers 5 et 6 et renvoie le résultat sous la
forme d'un entier :
put bitXor(5, 6)
-- 3
Voir aussi
bitNot(), bitOr(), bitAnd()
breakLoop()
Utilisation
-- Syntaxe Lingo
réfObjPisteAudio.breakLoop()
// Syntaxe JavaScript
réfObjPisteAudio.breakLoop();
Description
Méthode de canal audio ; interrompt la lecture du son actuellement mis en boucle dans la piste
réfObjPisteAudio et entraîne sa lecture jusqu’à la limite endTime.
Si aucun son n’est actuellement en boucle, cette méthode n’a aucun effet.
Paramètres
Aucun.
267
Exemple
Le gestionnaire suivant arrête la lecture du son mis en boucle dans la piste audio 2 et entraîne sa
lecture jusqu’à la fin.
-- Syntaxe Lingo
on continuerLaMusiqueDeFond
sound(2).breakLoop()
end
// Syntaxe JavaScript
function continuerLaMusiqueDeFond() {
sound(2).breakLoop();
}
Voir aussi
endTime, Piste audio
browserName()
Utilisation
browserName chemin
browserName()
browserName(#enabled, trueOuFalse)
Description
Propriété système, commande et fonction ; spécifie le chemin ou l’emplacement du navigateur
web. Vous pouvez utiliser l’Xtra FileIO pour afficher une boîte de dialogue permettant à
l’utilisateur de rechercher un navigateur. La méthode displayOpen() de l’Xtra FileIO est utile
pour afficher une boîte de dialogue d’ouverture.
La forme browserName() renvoie le nom du navigateur actuellement spécifié. Si vous placez un
nom de chemin, tel celui trouvé au moyen de l’Xtra FileIO, comme argument dans la forme
browserName(CheminCompletVersLapplication), vous pouvez définir la propriété. La forme
browserName(#enabled, trueOuFalse) détermine si le navigateur spécifié est automatiquement lancé par la commande goToNetPage.
Cette commande est utile uniquement lors de la lecture dans une projection ou dans Director et
n’a aucun effet pour la lecture dans un navigateur.
Cette propriété peut être testée et définie.
Exemple
L’instruction suivante indique l’emplacement du navigateur Netscape :
browserName "Mon Disque:Mon Dossier:Netscape"
L’instruction suivante affiche le nom du navigateur dans une fenêtre Messages :
put browserName()
268
Chapitre 12 : Méthodes
build()
Utilisation
-- Syntaxe Lingo
member(quelActeur).modelResource(quelleRessDeMod).build()
// Syntaxe JavaScript
member(quelActeur).modelResource(quelleRessDeMod).build();
Description
Commande 3D de maille ; construit une maille. Cette commande n’est utilisée qu’avec les
ressources de modèle de type #mesh.
Vous devrez utiliser la commande build() pour la construction initiale de la maille, après avoir
modifié l’une de ses propriétés face, et après avoir utilisé la commande generateNormals().
Paramètres
Aucun.
Exemple
Cet exemple crée une simple ressource de modèle de type #mesh, en spécifie les propriétés, puis
l’utilise pour créer un nouveau modèle. Le processus est décrit dans les explications accompagnant
l’exemple suivant :
La ligne 1 crée une maille nommée Plan, qui consiste en une face, trois sommets et un maximum
de trois couleurs. Le nombre de normales et de coordonnées de textures n’est pas défini. Les
normales sont créées par la commande generateNormals.
La ligne 2 définit les vecteurs qui seront utilisés comme sommets de Plan.
La ligne 3 affecte les vecteurs aux sommets de la première face de Plan.
La ligne 4 définit les trois couleurs permises par la commande newMesh.
La ligne 5 affecte les couleurs à la première face de Plan. La troisième couleur de la liste est
appliquée au premier sommet de Plan, la deuxième couleur au deuxième sommet, et la première
couleur au troisième sommet. Les couleurs seront étalées sur la première face de Plan en dégradés.
La ligne 6 crée les normales de Plan avec la commande generateNormals().
La ligne 7 appelle la commande build() pour construire la maille.
-- Syntaxe Lingo
nm = member("Formes").newMesh("Plan",1,3,0,3,0)
nm.vertexList = [vector(0,0,0), vector(20,0,0), vector(20, 20, 0)]
nm.face[1].vertices = [ 1,20,3 ]
nm.colorList = [rgb(255,255,0), rgb(0, 255, 0), rgb(0,0,255)]
nm.face[1].colors = [3,20,1]
nm.generateNormals(#smooth)
nm.build()
nm = member("Formes").newModel("triModèle", nm)
269
// Syntaxe JavaScript
nm = member("Formes").newMesh("Plan",1,3,0,3,0);
nm.vertexList = [vector(0,0,0), vector(20,0,0), vector(20, 20, 0)];
nm.face[1].vertices = [ 1,2,3];
nm.colorList = [rgb(255,255,0), rgb(0, 255, 0), rgb(0,0,255)];
nm.face[1].colors = [3,2,1];
nm.generateNormals(#smooth);
nm.build();
nm = member("Formes").newModel("triModèle", nm);
Voir aussi
generateNormals(), newMesh, face[ ]
cacheDocVerify()
Utilisation
-- Syntaxe Lingo
cacheDocVerify #paramètre
cacheDocVerify()
// Syntaxe JavaScript
cacheDocVerify symbol(paramètre);
cacheDocVerify();
Description
Fonction ; définit la fréquence de rafraîchissement du contenu d’une page web sur la base des
informations contenues dans la mémoire cache de la projection.
La forme cacheDocVerify() renvoie le paramètre courant de la mémoire cache.
La fonction cacheDocVerify n’est valide que pour les animations exécutées dans Director ou
sous forme de projections. Elle n’est pas valide pour les animations avec un contenu Macromedia
Shockwave, qui utilisent les paramètres réseau du navigateur web dans lequel elles sont exécutées.
-- Syntaxe Lingo
on resetCache
valeurCourante = cacheDocVerify()
if valeurCourante = #once then
alert "Vérification du cache activée"
cacheDocVerify #always
end if
end
// Syntaxe JavaScript
function resetCache() {
valeurCourante = cacheDocVerify();
if (valeurCourante == symbol("once")) {
alert ("Vérification du cache activée");
cacheDocVerify(symbol("always"))
}
}
270
Chapitre 12 : Méthodes
Paramètres
Facultatif. Symbole qui spécifie la fréquence de rafraîchissement du contenu
d’une page web. Les valeurs possibles sont #once (une seule fois, valeur par défaut) et #always
(autant de fois que nécessaire). La valeur #once indique à une animation de télécharger une fois
un fichier depuis Internet, puis de l’utiliser depuis la mémoire cache sans rechercher une version
actualisée sur Internet. La valeur #always indique à une animation d’essayer de télécharger une
version actualisée du fichier à chaque fois que l’animation en question appelle une URL.
paramètreCache
Voir aussi
cacheSize(), clearCache
cacheSize()
Utilisation
-- Syntaxe Lingo
cacheSize taille
cacheSize()
// Syntaxe JavaScript
cacheSize(taille);
cacheSize();
Description
Fonction et commande ; définit la taille de la mémoire cache de Director.
La fonction cacheSize n’est valide que pour les animations exécutées sous Director ou sous
forme de projections. Elle n’est pas valide pour les animations avec un contenu Macromedia
Shockwave, qui utilisent les paramètres réseau du navigateur web dans lequel elles sont exécutées.
Paramètres
nouvelleTailleDeCache
Facultatif. Nombre entier qui spécifie la taille de la mémoire cache en
kilo-octets.
Exemple
Le gestionnaire suivant vérifie si le paramètre de cache du navigateur a une valeur inférieure à
1 Mo. Si c’est le cas, il affiche un message d’alerte et définit la taille de la mémoire cache à 1 Mo.
-- Syntaxe Lingo
on checkCache if
cacheSize()<1000 then
alert "augmentation de la mémoire cache à 1Mo"
cacheSize 1000
end if
end
// Syntaxe JavaScript
function checkCache() {
if (cacheSize() < 1000) {
alert ("augmentation de la mémoire cache à 1 Mo");
cacheSize(1000);
}
}
Voir aussi
cacheDocVerify(), clearCache
271
call
Utilisation
call #nomDeGestionnaire, script, {args...}
call (#nomDeGestionnaire, instanceDeScript, {args...})
Description
Commande ; envoie un message qui appelle un gestionnaire dans un script particulier ou une liste
de scripts donnés.
La commande call peut utiliser une variable comme nom de gestionnaire. Les messages transmis
à l’aide de call ne sont pas transmis aux autres scripts liés à l’image-objet, aux scripts d’acteurs,
scripts d’image ou scripts d’animation.
Paramètres
nomDeGestionnaire
Requis. Symbole qui spécifie le gestionnaire à activer.
instanceDeScript Requis. Référence au script ou à la liste de scripts qui contient le gestionnaire. Si instanceDeScript est une instance de script unique, un message d’alerte est envoyé si
le gestionnaire n’est pas défini dans le script ancêtre du script. Si instanceDeScript est une liste
d’instances de scripts, le message est envoyé à chaque élément de la liste tour à tour ; aucune alerte
n’est générée si le gestionnaire n’est pas défini dans le script ancêtre.
args
Facultatif. Tous les paramètres facultatifs à transmettre au gestionnaire.
Exemple
Le gestionnaire suivant envoie le message augmenterLeCompteur au premier script de
comportement lié à l’image-objet 1 :
-- Syntaxe Lingo
on mouseDown me
-- obtenir la référence du premier comportement de l’image-objet 1
set xref = getAt (the scriptInstanceList of sprite 1,1)
-- exécuter le gestionnaire augmenterLeCompteur dans le script référencé,
-- avec un paramètre
call (#augmenterLeCompteur, xref, 2)
end
// Syntaxe JavaScript
function mouseDown() {
// obtenir la référence du premier comportement de l’image-objet 1
xref = getAt(sprite(1).script(1));
// exécuter le gestionnaire augmenterLeCompteur dans le script référencé
call(symbol("augmenterLeCompteur"), xref, 2);
}
272
Chapitre 12 : Méthodes
L’exemple suivant illustre la façon dont une instruction call peut appeler les gestionnaires d’un
comportement ou d’un script parent et ceux de son ancêtre.
• Le script suivant est un script parent :
-- Syntaxe Lingo
-- script Homme
property ancestor
on new me
set ancestor = new(script "Animal", 2)
return me
end
on courir me, nouvelOutil
put "Homme courant sur "&the nombreDePattes of me&" pattes"
end
• Le script suivant est le script ancêtre :
-- script Animal
property nombreDePattes
on new me, nouveauNombreDePattes
set nombreDePattes = nouveauNombreDePattes
return me
end
on courir me
put "Animal courant sur "& nombreDePattes &" pattes"
end
on marcher me
put "Animal marchant sur "& nombreDePattes &" pattes"
end
• Les instructions suivantes utilisent le script parent et le script ancêtre.
L’instruction suivante crée une instance du script parent :
set h = new(script "homme")
L’instruction suivante fait marcher l’homme :
call #marcher, h
-- "Animal marchant sur 2 pattes"
L’instruction suivante fait courir l’homme :
set msg = #courir
call msg, h
-- "Homme courant sur 2 pattes"
L’instruction suivante crée une seconde instance du script parent :
set h2 = new(script "homme")
L’instruction suivante envoie un message aux deux instances du script parent :
call msg, [h, h2]
-- "Homme courant sur 2 pattes "
-- "Homme courant sur 2 pattes "
273
callAncestor
Utilisation
callAncestor nomDeGestionnaire, script, {args...}
Description
Commande ; envoie un message au script ancêtre d’un objet enfant.
Les ancêtres peuvent, à leur tour, avoir leurs propres ancêtres.
Lorsque vous utilisez callAncestor, le nom du gestionnaire peut être une variable et vous
pouvez explicitement contourner les gestionnaires du script principal et accéder directement
au script ancêtre.
Paramètres
nomDeGestionnaire
Requis. Symbole qui spécifie le gestionnaire à activer.
instanceDeScript Requis. Référence au script ou à la liste de scripts qui contient le gestionnaire. Si instanceDeScript est une instance de script unique, un message d’alerte est envoyé si
le gestionnaire n’est pas défini dans le script ancêtre du script. Si instanceDeScript est une liste
d’instances de scripts, le message est envoyé à chaque élément de la liste tour à tour ; aucune alerte
n’est générée si le gestionnaire n’est pas défini dans le script ancêtre.
args
Facultatif. Tous les paramètres facultatifs à transmettre au gestionnaire.
Exemple
L’exemple suivant présente la façon dont une instruction callAncestor peut appeler des
gestionnaires dans l’ancêtre d’un comportement ou d’un script parent.
• Le script suivant est un script parent :
-- script "homme"
property ancestor
on new me, nouvelOutil
set ancestor = new(script "Animal", 2)
return me
end
on courir me
put "Homme courant sur "&the nombreDePattes of me&" pattes"
end
• Le script suivant est le script ancêtre :
-- script "animal"
property nombreDePattes
on new me, nouveauNombreDePattes
set nombreDePattes = nouveauNombreDePattes
return me
end
on courir me
put "Animal courant sur "& nombreDePattes &" pattes"
end
on marcher me
put "Animal marchant sur "& nombreDePattes &" pattes"
end
274
Chapitre 12 : Méthodes
• Les instructions suivantes utilisent le script parent et le script ancêtre.
L’instruction suivante crée une instance du script parent :
set h = new(script "homme")
L’instruction suivante fait marcher l’homme :
call #marcher, h
-- "Animal marchant sur 2 pattes"
L’instruction suivante fait courir l’homme :
set msg = #courir
callAncestor msg, h
-- "Animal courant sur 2 pattes"
L’instruction suivante crée une seconde instance du script parent :
set h2 = new(script "homme")
L’instruction suivante envoie un message au script ancêtre des deux hommes :
callAncestor #courir,[h,h2]
-- "Animal courant sur 2 pattes"
-- "Animal courant sur 2 pattes"
Voir aussi
ancestor, new()
callFrame()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.callFrame(nomOuNumImageFlash)
// Syntaxe JavaScript
réfObjImageObjet.callFrame(nomOuNumImageFlash);
Description
Commande ; utilisée pour appeler une série d’actions résidant dans une image d’une image-objet
d’animation Flash.
Cette commande transmet un message au moteur ActionScript de Flash et déclenche l’exécution
des actions dans l’animation Flash.
Paramètres
nomOuNumImageFlash
Requis. Chaîne ou numéro qui spécifie le nom ou le numéro de l’image à
appeler.
Exemple
Cette instruction lance l’exécution des actions associées à l’image 10 de l’animation Flash dans
l’image-objet 1 :
-- Syntaxe Lingo
sprite(1).callFrame(10)
// Syntaxe JavaScript
sprite(1).callFrame(10);
275
camera()
Utilisation
member(quelActeur).camera(quelleCaméra)
member(quelActeur).camera[index]
member(quelActeur).camera(quelleCaméra).quellePropriétéDeCaméra
member(quelActeur).camera[index].quellePropriétéDeCaméra
sprite(quelleImageObjet).camera{(index)}
sprite(quelleImageObjet).camera{(index)}.quellePropriétéDeCaméra
Description
Elément 3D ; objet à une position de vecteur à partir de laquelle l’univers 3D est observé.
Chaque image-objet possède une liste de caméras. Les vues des différentes caméras de la liste
sont affichées au-dessus de celles des caméras en position index inférieures. Vous pouvez
définir la propriété rect (caméra) de chaque caméra afin d’afficher plusieurs vues au sein de
l’image-objet.
Les caméras sont enregistrées dans la palette des caméras de l’acteur. Utilisez les commandes
newCamera et deleteCamera pour créer et supprimer les caméras d’un acteur 3D.
La propriété camera d’une image-objet est la première caméra de la liste des caméras de l’imageobjet. La caméra référencée par sprite(quelleImageObjet).camera est la même que
sprite(quelleImageObjet).camera(1). Utilisez les commandes addCamera et deleteCamera
pour construire la liste des caméras d’une image-objet 3D.
Exemple
L’instruction suivante affecte à l’image-objet 1 la caméra camArbre de l’acteur Picnic.
sprite(1).camera = member("Picnic").camera("camArbre")
L’instruction suivante affecte à l’image-objet 1 la caméra 2 de l’acteur Picnic.
sprite(1).camera = member("Picnic").camera[2]
Voir aussi
bevelDepth, overlay, modelUnderLoc, spriteSpaceToWorldSpace, fog,
clearAtRender
cameraCount()
Utilisation
-- Syntaxe Lingo
sprite(quelleImageObjet).cameraCount()
// Syntaxe JavaScript
sprite(quelleImageObjet).cameraCount();
Description
Commande 3D ; renvoie le nombre d’éléments de la liste des caméras de l’image-objet.
Paramètres
Aucun.
276
Chapitre 12 : Méthodes
Exemple
L’instruction suivante indique que l’image-objet 5 contient trois caméras.
-- Syntaxe Lingo
put sprite(5).cameraCount()
-- 3
// Syntaxe JavaScript
put(sprite(5).cameraCount());
// 3
Voir aussi
addCamera, deleteCamera
cancelIdleLoad()
Utilisation
-- Syntaxe Lingo
_movie.cancelIdleLoad(entBaliseDeChargement)
// Syntaxe JavaScript
_movie.cancelIdleLoad(entBaliseDeChargement);
Description
Méthode d’animation ; annule le chargement de tous les acteurs portant la balise de chargement
spécifiée.
Paramètres
Requis. Nombre entier qui spécifie un groupe d’acteurs mis en file
d’attente pour être chargé lorsque l’ordinateur est inactif.
entBaliseDeChargement
Exemple
L’instruction suivante annule le chargement des acteurs portant la balise de chargement en
période d’inactivité numéro 20 :
-- Syntaxe Lingo
_movie.cancelIdleLoad(20)
// Syntaxe JavaScript
_movie.cancelIdleLoad(20);
Voir aussi
idleLoadTag, Animation
277
castLib()
Utilisation
-- Syntaxe Lingo
castLib(nomOuNumDeDistribution)
// Syntaxe JavaScript
castLib(nomOuNumDeDistribution);
Description
Fonction du niveau supérieur ; renvoie une référence à une distribution spécifiée.
La distribution par défaut est la distribution numéro 1. Si vous voulez spécifier un acteur dans
une distribution autre que la distribution numéro 1, définissez castLib() pour spécifier l’autre
distribution.
Paramètres
nomOuNumDeDistribution Requis. Chaîne qui spécifie le nom de la distribution ou nombre
entier qui spécifie son numéro.
Exemple
L’instruction suivante affecte à la variable parties la deuxième distribution :
-- Syntaxe Lingo
parties = castLib(2)
// Syntaxe JavaScript
var parties = castLib(2);
Voir aussi
Bibliothèque de distribution, castLibNum
channel() (niveau supérieur)
Utilisation
-- Syntaxe Lingo
channel(nomOuNumDePisteAudio)
// Syntaxe JavaScript
channel(nomOuNumDePisteAudio);
Description
Fonction du niveau supérieur ; renvoie une référence à un objet Piste audio.
Paramètres
Requis. Chaîne qui spécifie le nom d’une piste audio ou nombre entier
qui spécifie sa position d’index.
nomOuNumDePisteAudio
278
Chapitre 12 : Méthodes
Exemple
Cette instruction affecte à la variable nouvellePiste la piste audio 9 :
-- Syntaxe Lingo
nouvellePiste = channel(9)
// Syntaxe JavaScript
var nouvellePiste = channel(9);
Voir aussi
Piste audio
channel() (audio)
Utilisation
-- Syntaxe Lingo
_sound.channel(entNumDePiste)
// Syntaxe JavaScript
_sound.channel(entNumDePiste);
Description
Méthode audio ; renvoie une référence à une piste audio spécifiée.
La fonctionnalité de cette méthode est identique à celle de la méthode sound() du niveau
supérieur.
Paramètres
entNumDePiste
Requis. Nombre entier qui spécifie la piste audio à référencer.
Exemple
Cette instruction affecte à la variable maPiste la piste audio 2 :
-- Syntaxe Lingo
maPiste = _sound.channel(2)
// Syntaxe JavaScript
var maPiste = _sound.channel(2);
Voir aussi
Son, sound(), Piste audio
chapterCount()
Utilisation
-- Syntaxe Lingo
réfObjDvd.chapterCount({entTitre})
// Syntaxe JavaScript
réfObjDvd.chapterCount({entTitre});
Description
Méthode de DVD ; indique le nombre de chapitres disponibles dans un titre.
279
Paramètres
Facultatif. Nombre entier qui spécifie le titre contenant les chapitres à dénombrer. Si
ce paramètre est omis, chapterCount() renvoie le nombre de chapitres disponibles dans le titre
courant.
entTitre
Voir aussi
chapterCount, DVD
charPosToLoc()
Utilisation
-- Syntaxe Lingo
réfObjActeur.charPosToLoc(énièmeCaractère)
// Syntaxe JavaScript
réfObjActeur.charPosToLoc(énièmeCaractère);
Description
Fonction de champ ; renvoie le point de l’acteur champ entier (et pas seulement la partie affichée
sur la scène) qui est le plus proche d’un caractère spécifié. Elle est utile pour déterminer l’emplacement précis de caractères individuels.
Les valeurs de charPosToLoc sont exprimées en pixels et commencent à partir du coin supérieur
gauche de l’acteur champ. Le paramètre énièmeCaractère est 1 pour le premier caractère du
champ, 2 pour le deuxième, etc.
Paramètres
énièmeCaractère
Requis. Le caractère à tester.
Exemple
L’instruction suivante détermine le point auquel apparaît le cinquantième caractère de l’acteur
Titre et affecte le résultat à la variable emplacement :
-- Syntaxe Lingo
emplacement = member("Titre").charPosToLoc(50)
// Syntaxe JavaScript
var emplacement = member("Titre").charPosToLoc(50);
chars()
Utilisation
chars(expressionChaîne, premierCaractère, dernierCaractère)
Description
Fonction (Lingo uniquement) ; identifie une sous-chaîne de caractères dans une expression.
Les expressions premierCaractère et dernierCaractère doivent spécifier une position dans la
chaîne.
280
Chapitre 12 : Méthodes
Si les expressions premierCaractère et dernierCaractère sont égales, la chaîne ne renvoie
qu’un seul caractère. Si dernierCaractère est plus grand que la longueur de la chaîne, seule une
sous-chaîne allant jusqu’à la longueur de la chaîne est identifiée. Si dernierCaractère est placé
avant premierCaractère, cette fonction renvoie la valeur EMPTY.
Pour un exemple d’utilisation de chars() dans une animation, reportez-vous à l’animation Text
du dossier Learning/Lingo, lui-même inclus dans le dossier de Director.
Dans la syntaxe JavaScript, utilisez la fonction substr() de l’objet Chaîne.
Paramètres
expressionChaîne
Requis. Chaîne qui spécifie l’expression à partir de laquelle une sous-chaîne
est renvoyée.
premierCaractère
Requis. Nombre entier qui spécifie le point où la sous-chaîne commence.
dernierCaractère
Requis. Nombre entier qui spécifie le point où la sous-chaîne se termine.
Exemple
L’instruction suivante identifie le sixième caractère du mot Macromedia :
put chars ("Macromedia", 6, 6)
-- "m"
L’instruction suivante identifie les caractères compris entre les sixième et dixième caractères du
mot Macromedia :
put chars ("Macromedia", 6, 10)
-- "media"
L’instruction suivante essaie d’identifier les caractères compris entre le sixième et le vingtième
caractère du mot Macromedia. Puisque ce mot ne contient que 10 caractères, le résultat ne
contient que les caractères compris ente le sixième et le dixième caractère.
put chars ("Macromedia", 6, 20)
-- "media"
Voir aussi
char...of, length(), offset() (fonction de chaîne), number (caractères)
charToNum()
Utilisation
(expressionChaîne).charToNum
charToNum(expressionChaîne)
Description
Fonction (Lingo uniquement) ; renvoie le code ASCII correspondant au premier caractère d’une
expression.
La fonction charToNum() est particulièrement utile pour tester la valeur des caractères ASCII
créés avec des combinaisons de touches telles que la touche Ctrl et une autre touche alphanumérique.
Director ne fait pas la différence entre les caractères en majuscules et en minuscules si vous utilisez
l’opérateur de comparaison égal (=) ; par exemple, l’instruction put ("M" = "m") donne le
résultat 1 ou TRUE.
281
Evitez tout problème en utilisant charToNum() pour renvoyer le code ASCII d’un caractère et
utilisez ensuite le code ASCII pour faire référence à ce caractère.
Dans la syntaxe JavaScript, utilisez la fonction charCodeAt() de l’objet Chaîne.
Paramètres
expressionChaîne
Requis. Chaîne qui spécifie l’expression à tester.
Exemple
L’instruction suivante affiche le code ASCII de la lettre A :
put ("A").charToNum
-- 65
La comparaison suivante détermine si la lettre saisie est un A majuscule, puis passe à une séquence
correcte ou incorrecte du scénario :
-- Syntaxe Lingo
on CheckKeyHit theKey
if (theKey).charToNum = 65 then
go "Réponse correcte"
else
go "Réponse incorrecte"
end if
end
// Syntaxe JavaScript
function CheckKeyHit(theKey) {
if (theKey.charToNum() == 65) {
go ("Réponse correcte");
} else {
go ("Réponse incorrecte");
}
}
Voir aussi
numToChar()
clearAsObjects()
Utilisation
-- Syntaxe Lingo
clearAsObjects()
// Syntaxe JavaScript
clearAsObjects();
Description
Commande ; reconfigure le lecteur Flash global utilisé pour les objets ActionScript et supprime
tous les objets ActionScript de la mémoire. Cette commande n’efface ni ne reconfigure les
références à ces objets stockées dans Lingo. Les références Lingo resteront présentes mais feront
référence à des objets inexistants. Chaque référence doit être définie sur VOID individuellement.
282
Chapitre 12 : Méthodes
La commande clearAsObjects() n’affecte que les objets globaux, tels que le tableau créé dans
cette instruction :
-- Syntaxe Lingo
monTableauGlobal = newObject(#array)
// Syntaxe JavaScript
monTableauGlobal = new Array();
La commande clearAsObjects() n’a aucun effet sur les objets créés dans les références
d’images-objets, tel que :
monTableau = sprite(2).newObject(#array)
Paramètres
Aucun.
Exemple
Cette instruction supprime de la mémoire tous les objets ActionScript créés globalement :
-- Syntaxe Lingo
clearAsObjects()
// Syntaxe JavaScript
clearAsObjects();
Voir aussi
newObject(), setCallback()
clearCache
Utilisation
clearCache
Description
Commande ; vide la mémoire cache réseau de Director.
La commande clearCache vide uniquement la mémoire cache, qui est distincte de celle du
navigateur.
Les fichiers en cours d’utilisation ne sont pas supprimés de la mémoire cache (jusqu’à leur
inactivité).
Paramètres
Aucun.
283
Exemple
Le gestionnaire suivant vide la mémoire cache au lancement de l’animation :
-- Syntaxe Lingo
on startMovie
clearCache
end
// Syntaxe JavaScript
function startMovie() {
clearCache();
}
Voir aussi
cacheDocVerify(), cacheSize()
clearError()
Utilisation
-- Syntaxe Lingo
réfObjActeur.clearError()
// Syntaxe JavaScript
réfObjActeur.clearError();
Description
Commande Flash ; remet à zéro l’état d’erreur d’un acteur Flash en flux continu.
Si une erreur survient alors qu’un acteur est transféré en flux continu vers la mémoire, Director
affecte la valeur -1 à la propriété state de cet acteur, afin d’indiquer qu’une erreur s’est produite.
Dans ce cas, vous pouvez utiliser la fonction getError pour déterminer le type d’erreur survenue,
puis la commande clearError pour remettre à zéro l’état d’erreur de l’acteur. Une fois que vous
avez éliminé l’état d’erreur de l’acteur, Director essaie d’ouvrir ce dernier, si l’animation en a
encore besoin. D’autre part, la définition des propriétés pathName, linked et preload d’un
acteur élimine automatiquement la condition d’erreur.
Paramètres
Aucun.
Exemple
Le gestionnaire suivant vérifie l’occurrence d’une erreur de type mémoire épuisée pour l’acteur
Flash Dali, qui a été transféré en mémoire. Si une telle erreur est survenue, le script utilise la
commande unloadCast pour essayer de libérer de la mémoire ; il amène ensuite la tête de lecture
sur une image de l’animation Artistes de Director, dans laquelle l’image-objet de l’animation
Flash apparaît pour la première fois, de sorte que Director puisse relancer la lecture de l’animation
Flash. Si un autre type d’erreur est survenu, le script passe à une image appelée Désolé, qui
explique que l’animation Flash requise ne peut pas être lue.
284
Chapitre 12 : Méthodes
-- Syntaxe Lingo
on vérifierEtatFlash
if (member("Dali").getError() = #memory) then
member("Dali").clearError()
member("Dali").unload()
unloadCast
else
_movie.go("Désolé")
end if
end
// Syntaxe JavaScript
function CheckFlashStatus() {
var ge = member("Dali").getError();
if (ge = "memory") {
member("Dali").clearError();
unloadCast;
_movie.go("Artistes");
} else {
_movie.go("Désolé");
}
}
Voir aussi
state (Flash, SWA), getError() (Flash, SWA)
clearFrame()
Utilisation
-- Syntaxe Lingo
_movie.clearFrame()
// Syntaxe JavaScript
_movie.clearFrame();
Description
Méthode d’animation ; efface toutes les pistes d'images-objets dans une image pendant
l’enregistrement du scénario.
Paramètres
Aucun.
Exemple
Le gestionnaire suivant supprime le contenu de chaque image avant de les modifier pendant la
création du scénario :
-- Syntaxe Lingo
on newScore
_movie.beginRecording()
repeat with compteur = 1 to 50
_movie.clearFrame()
_movie.frameScript = 25
_movie.updateFrame()
end repeat
_movie.endRecording()
end
285
// Syntaxe JavaScript
function newScore() {
_movie.beginRecording();
for (var i = 1; i <= 50; i++) {
_movie.clearFrame();
_movie.frameScript = 25;
_movie.updateFrame();
}
_movie.endRecording();
}
Voir aussi
beginRecording(), endRecording(), Animation, updateFrame()
clearGlobals()
Utilisation
-- Syntaxe Lingo
_global.clearGlobals()
// Syntaxe JavaScript
_global.clearGlobals();
Description
Méthode globale ; donne à toutes les variables globales la valeur VOID (Lingo) ou null (syntaxe
JavaScript).
Cette méthode est utile lors de l’initialisation de variables globales ou de l’ouverture d’une
nouvelle animation qui exige un nouveau jeu de variables globales.
Paramètres
Aucun.
Exemple
Les gestionnaires suivants donnent à toutes les variables globales la valeur VOID (Lingo) ou null
(JavaScript) :
-- Syntaxe Lingo
on mouseDown
_global.clearGlobals()
end
// Syntaxe JavaScript
function mouseDown() {
_global.clearGlobals();
}
Voir aussi
Global
286
Chapitre 12 : Méthodes
clone
Utilisation
member(quelActeur).model(quelModèle).clone(nomDuClone)
member(quelActeur).group(quelGroupe).clone(nomDuClone)
member(quelActeur).light(quelleLumière).clone(nomDuClone)
member(quelActeur).camera(quelleCaméra).clone(nomDuClone)
Description
Commande 3D ; crée une copie du modèle, du groupe, de la lumière ou de la caméra, et de tous
ses enfants. Le clone a le même parent que le modèle, le groupe, la lumière ou la caméra à partir
duquel il a été cloné.
Le clone d’un modèle utilise la même ressource de modèle et la même liste de matériaux que le
modèle d’origine.
Si vous ne spécifiez pas le nomDuClone ou si vous spécifiez "", le clone ne sera pas pris en compte
par la méthode count, mais apparaîtra dans la scène.
Paramètres
nomDuClone
Requis. Spécifie le nom du nouveau clone.
Exemple
L’instruction suivante crée le clone Théière2 à partir du modèle Théière et renvoie une référence
au nouveau modèle.
copieDeThéière = member("Univers 3D").model("Théière").clone("Théière2")
Voir aussi
cloneDeep, cloneModelFromCastmember, cloneMotionFromCastmember, loadFile()
cloneDeep
Utilisation
member(quelActeur).model(quelModèle).cloneDeep(nomDuClone)
member(quelActeur).group(quelGroupe).cloneDeep(nomDeClone)
member(quelActeur).light(quelleLumière).cloneDeep(nomDeClone)
member(quelActeur).camera(quelleCaméra).cloneDeep(nomDeClone)
Description
Commande 3D ; crée une copie du modèle, du groupe, de la lumière ou de la caméra, plus tous
les éléments suivants :
• Les ressources de modèle, matériaux et textures utilisés par le modèle ou groupe d’origine
• Les enfants du modèle, du groupe, de la lumière ou de la caméra
• Les ressources de modèle, matériaux et textures utilisés par les enfants
Cette méthode utilise plus de mémoire et prend plus de temps que la commande clone.
Paramètres
nomDuClone
Requis. Spécifie le nom du nouveau clone.
287
Exemple
L’instruction suivante crée une copie du modèle Théière et de ses enfants, et des ressources
de modèle, des matériaux et des textures utilisés par Théière et ses enfants. La variable
copieDeThéière est une référence au modèle cloné.
copieDeThéière = member("Univers 3D").model("Théière").cloneDeep("Théière2")
Voir aussi
clone, cloneModelFromCastmember, cloneMotionFromCastmember, loadFile()
cloneModelFromCastmember
Utilisation
member(quelActeur).cloneModelFromCastmember\
(nomDeNouveauModèle, nomDeModèleSource, acteurSource)
Description
Commande 3D ; copie un modèle d’acteur, le renomme et l’insère dans un acteur en tant
qu’enfant de son univers 3D.
Cette commande copie également les enfants de nomDeModèleSource, ainsi que les ressources de
modèle, les matériaux et les textures, utilisés par le modèle et ses enfants.
Le chargement de l’acteur source doit être terminé pour la bonne exécution de cette commande.
Paramètres
nomDeNouveauModèle
nomDeModèleSource
acteurSource
Requis. Spécifie le nom du modèle qui vient d’être cloné.
Requis. Spécifie le modèle à cloner.
Requis. Spécifie l’acteur qui contient le modèle à cloner.
Exemple
L’instruction suivante crée une copie du modèle Pluton de l’acteur Scène et l’insère dans l’acteur
Scène2 avec le nouveau nom Planète. Les enfants de Pluton sont également importés, de même
que les ressources de modèle, les matériaux et les textures utilisés par Pluton et ses enfants.
member("Scène2").cloneModelFromCastmember("Planète", "Pluton", \
member("Scène"))
Voir aussi
cloneMotionFromCastmember, clone, cloneDeep, loadFile()
cloneMotionFromCastmember
Utilisation
member(quelActeur).cloneMotionFromCastmember(nomDeNouveauMouvement, \
nomDeMouvementSource, acteurSource)
Description
Commande 3D ; copie un mouvement d’un acteur, le renomme et l’insère dans un acteur.
Le chargement de l’acteur source doit être terminé pour la bonne exécution de cette commande.
288
Chapitre 12 : Méthodes
Paramètres
nomDeNouveauMouvement
nomDeMouvementSource
acteurSource
Requis. Spécifie le nom du mouvement qui vient d’être cloné.
Requis. Spécifie le mouvement à cloner.
Requis. Spécifie l’acteur qui contient le mouvement à cloner.
Exemple
L’instruction suivante copie le mouvement Marche de l’acteur Parc, nomme la copie
marcheBizarre, et la place dans l’acteur gbActeur.
member("gbActeur").cloneMotionFromCastmember("marcheBizarre", \
"Marche", member("Parc"))
Voir aussi
map (3D), cloneModelFromCastmember, clone, cloneDeep, loadFile()
close()
Utilisation
-- Syntaxe Lingo
réfObjFenêtre.close()
// Syntaxe JavaScript
réfObjFenêtre.close();
Description
Méthode de fenêtre ; ferme une fenêtre.
Toute tentative visant à fermer une fenêtre déjà fermée n’a aucun effet.
Veuillez noter que la fermeture d’une fenêtre ne termine pas l’exécution de l’animation dans la
fenêtre et ne la supprime pas non plus de la mémoire. Cette méthode sert simplement à fermer
la fenêtre dans laquelle l’animation est exécutée. Pour la rouvrir rapidement, utilisez la méthode
open() (fenêtre). Cette procédure assure un accès rapide aux fenêtres qui doivent rester
disponibles.
Pour supprimer totalement une fenêtre et la vider de la mémoire, utilisez la méthode forget().
Si vous utilisez la commande forget(), assurez-vous qu’aucun élément ne fait référence à
l’animation dans cette fenêtre, faute de quoi le système génère des erreurs lorsque les scripts
essaient de communiquer ou de dialoguer avec la fenêtre supprimée.
Paramètres
Aucun.
Exemple
L’instruction suivante ferme la fenêtre Panneau, qui se trouve dans le sous-dossier Sources MIAW
dans le dossier de l’animation courante :
-- Syntaxe Lingo
window(_movie.path & "Sources MIAW\Panneau").close()
// Syntaxe JavaScript
window(_movie.path + "Sources MIAW\\Panneau").close();
289
L’instruction suivante ferme la fenêtre 5 dans la liste windowList :
-- Syntaxe Lingo
window(5).close()
// Syntaxe JavaScript
window(5).close();
Voir aussi
forget() (fenêtre), open() (fenêtre), Fenêtre
closeFile()
Utilisation
-- Syntaxe Lingo
réfObjFileio.closeFile()
// Syntaxe JavaScript
réfObjFileio.closeFile();
Description
Méthode de Fileio ; ferme un fichier.
Paramètres
Aucun.
Voir aussi
Fileio
closeXlib
Utilisation
closeXlib quelFichier
Description
Commande ; ferme un fichier Xlibrary.
Les Xtras sont enregistrés dans des fichiers Xlibrary. Les fichiers Xlibrary sont les fichiers des
ressources contenant les Xtras. Les XCMD et XFCN HyperCard peuvent également être stockés
dans des fichiers Xlibrary.
La commande closeXlib ne fonctionne pas avec les URL.
Sous Windows, l’extension DLL des Xtras est facultative.
Nous vous recommandons de fermer tout fichier ouvert dès que vous n’en avez plus besoin.
Remarque : Cette commande n’est pas prise en charge dans Shockwave Player.
Paramètres
quelFichier Facultatif. Spécifie le fichier Xlibrary à fermer. Si le fichier Xlibrary se trouve
dans un dossier autre que celui de l’animation courante, quelFichier doit spécifier un chemin
d’accès. Si quelFichier est omis, tous les fichiers Xlibrary ouverts sont fermés.
290
Chapitre 12 : Méthodes
Exemple
L’instruction suivante ferme tous les fichiers Xlibrary ouverts :
closeXlib
L’instruction suivante ferme le fichier Xlibrary Disque vidéo qui se trouve dans le même dossier
que l’animation courante :
closeXlib "Xlibrary Disque vidéo"
L’instruction suivante ferme le fichier Xlibrary Transporter Xtras du dossier Nouveaux Xtras,
qui se trouve dans le même dossier que l’animation. Le disque est identifié par la variable
lecteurCourant :
closeXlib "@:Nouveaux Xtras:Transporter Xtras"
Voir aussi
interface(), openXlib
color()
Utilisation
-- Syntaxe Lingo
color(entIndexDePalette)
color(entRouge, entVert, entBleu)
// Syntaxe JavaScript
color(entIndexDePalette);
color(entRouge, entVert, entBleu);
Description
Fonction du niveau supérieur et type de données. Renvoie un objet de données Couleur sous la
forme de valeurs RVB ou de valeurs d'un index de palette 8 bits.
L’objet Couleur obtenu peut être appliqué à des acteurs, à des images-objets et à la scène si besoin
est.
Paramètres
entPaletteIndex Requis si vous utilisez des valeurs de palette 8 bits. Entier qui spécifie la valeur
de palette 8 bits à utiliser. Les valeurs correctes sont comprises entre 0 et 255. Toutes les autres
valeurs sont tronquées.
Requis si vous utilisez des valeurs RVB. Entier qui spécifie la composante rouge de la
couleur dans la palette courante. Les valeurs correctes sont comprises entre 0 et 255. Toutes les
autres valeurs sont tronquées.
entRouge
entVert Requis si vous utilisez des valeurs RVB. Entier qui spécifie la composante verte de la
couleur dans la palette courante. Les valeurs correctes sont comprises entre 0 et 255. Toutes les
autres valeurs sont tronquées.
entBleu Requis si vous utilisez des valeurs RVB. Entier qui spécifie la composante bleue de la
couleur dans la palette courante. Les valeurs correctes sont comprises entre 0 et 255. Toutes les
autres valeurs sont tronquées.
291
Exemple
Ces instructions affichent la couleur de l’image-objet 6 dans la fenêtre Messages, puis définissent
la couleur de l’image-objet 6 sur une nouvelle valeur :
-- Syntaxe Lingo
put(sprite(6).color) -- paletteIndex(255)
sprite(6).color = color(137)
put(sprite(6).color) -- paletteIndex(137)
// Syntaxe JavaScript
put(sprite(6).color) // paletteIndex(255);
sprite(6).color = color(137);
put(sprite(6).color) // paletteIndex(137);
constrainH()
Utilisation
-- Syntaxe Lingo
_movie.constrainH(entNumDimageObjet, entPosn)
// Syntaxe JavaScript
_movie.constrainH(entNumDimageObjet, entPosn);
Description
Méthode d’animation ; renvoie un nombre entier dont la valeur dépend des coordonnées
horizontales des côtés gauche et droit d’une image-objet.
Le nombre entier renvoyé peut avoir trois valeurs.
• Si le paramètre entPosn est compris entre les valeurs des coordonnées gauche et droite de
l’image-objet, le nombre entier renvoyé est égale à entPosn.
• Si le paramètre entPosn est inférieur à la valeur de la coordonnée gauche de l’image-objet,
le nombre entier renvoyé prend la valeur de la coordonnée gauche de l’image-objet.
• Si le paramètre entPosn est supérieur à la valeur de la coordonnée droite de l’image-objet,
le nombre entier renvoyé prend la valeur de la coordonnée droite de l’image-objet.
Cette méthode ne modifie pas les propriétés de l’image-objet.
Les méthodes constrainH() et constrainV() ne contraignent qu’un seul axe chacune.
Paramètres
Requis. Nombre entier qui spécifie l’image-objet dont les coordonnées
horizontales sont évaluées par rapport à entPosn.
entNumDimageObjet
entPosn Requis. Nombre entier à évaluer par rapport aux coordonnées horizontales des côtés
gauche et droit de l’image-objet identifiée par entNumDimageObjet.
292
Chapitre 12 : Méthodes
Exemple
Les instructions suivantes vérifient la fonction constrainH sur l’image-objet 1 lorsque ses
coordonnées gauche et droite sont 40 et 60 :
-- Syntaxe Lingo
put(constrainH(1, 20)) -- 40
put(constrainH(1, 55)) --55
put(constrainH(1, 100)) --60
// Syntaxe JavaScript
put(constrainH(1, 20)); // 40
put(constrainH(1, 55)); // 55
put(constrainH(1, 100)); // 60
L’instruction suivante limite les déplacements d’un curseur mobile (image-objet 1) aux bords
d’une jauge (image-objet 2) lorsque le pointeur de la souris dépasse les bords de cette dernière :
-- Syntaxe Lingo
sprite(1).locH = _movie.constrainH(2, _mouse.mouseH)
// Syntaxe JavaScript
sprite(1).locH = _movie.constrainH(2, _mouse.mouseH);
Voir aussi
constrainV(), Animation
constrainV()
Utilisation
-- Syntaxe Lingo
_movie.constrainV(entNumDimageObjet, entPosn)
// Syntaxe JavaScript
_movie.constrainV(entNumDimageObjet, entPosn);
Description
Méthode d’animation ; renvoie un nombre entier dont la valeur dépend des coordonnées
verticales des côtés supérieur et inférieur d’une image-objet.
Le nombre entier renvoyé peut avoir trois valeurs.
• Si le paramètre entPosn est compris entre les valeurs des coordonnées supérieure et inférieure
de l’image-objet, le nombre entier renvoyé est égale à entPosn.
• Si le paramètre entPosn est inférieur à la valeur de la coordonnée supérieure de l’image-objet,
le nombre entier renvoyé prend la valeur de la coordonnée supérieure de l’image-objet.
• Si le paramètre entPosn est supérieur à la valeur de la coordonnée inférieure de l’image-objet,
le nombre entier renvoyé prend la valeur de la coordonnée inférieure de l’image-objet.
Cette méthode ne modifie pas les propriétés de l’image-objet.
Les méthodes constrainV() et constrainH() ne contraignent qu’un seul axe chacune.
293
Paramètres
entNumDimageObjet Requis. Nombre entier qui identifie l’image-objet dont les coordonnées
verticales sont évaluées par rapport à entPosn.
entPosn Requis. Nombre entier à évaluer par rapport aux coordonnées verticales des côtés gauche
et droit de l’image-objet identifiée par entNumDimageObjet.
Exemple
Les instructions suivantes vérifient la fonction constrainV de l’image-objet 1 lorsque ses
coordonnées supérieure et inférieure sont 40 et 60 :
-- Syntaxe Lingo
put(constrainV(1, 20)) -- 40
put(constrainV(1, 55)) --55
put(constrainV(1, 100)) --60
// Syntaxe JavaScript
put(constrainV(1, 20)); // 40
put(constrainV(1, 55)); // 55
put(constrainV(1, 100)); // 60
L’instruction suivante limite les déplacements d’un curseur mobile (image-objet 1) aux bords
d’une jauge (image-objet 2) lorsque le pointeur de la souris dépasse les bords de cette dernière :
-- Syntaxe Lingo
sprite(1).locV = _movie.constrainV(2, _mouse.mouseH)
// Syntaxe JavaScript
sprite(1).locV = _movie.constrainV(2, _mouse.mouseH);
Voir aussi
constrainH(), Animation
copyPixels()
Utilisation
-- Syntaxe Lingo
réfObjImage.copyPixels(objImageSource, rectOuQuadDeDest, rectSource {,
listeDeParamètres})
// Syntaxe JavaScript
réfObjImage.copyPixels(objImageSource, rectOuQuadDeDest, rectSource {,
listeDeParamètres});
Description
Méthode d’image. Copie le contenu d’un rectangle inclus dans un objet image existant à
l’intérieur d’un nouvel objet image.
Lors de la copie de pixels d’une zone d’un acteur vers une autre zone du même acteur, il est
recommandé de copier d’abord les pixels dans un objet image dupliqué avant de les recopier dans
l’acteur d’origine. Copier directement d’une zone à l’autre dans la même image est déconseillé.
Pour simuler l’encre Dessin seul avec copyPixels(), créez un objet Dessin seul avec
createMatte(), puis transmettez cet objet en tant que paramètre #maskImage de
copyPixels().
294
Chapitre 12 : Méthodes
Pour un exemple d’utilisation de quadrilatère dans une animation, reportez-vous à l’animation
Quad du dossier Learning/Lingo, lui-même inclus dans le dossier de Director.
Paramètres
objImageSource
Requis. Référence à l’objet image source à partir duquel les pixels sont copiés.
rectOuQuadDeDest Requis si vous copiez les pixels dans un rectangle à coordonnée d’écran ou un
quadrilatère à virgule flottante. Le rectangle ou le quadrilatère dans lequel les pixels sont copiés.
rectSource
Requis. Rectangle source à partir duquel les pixels sont copiés.
Facultatif. Liste de paramètres qui peuvent être utilisés pour manipuler les
pixels copiés avant de les placer dans rectDeDest ou quadDeDest. La liste de propriétés peut
contenir l’intégralité ou une partie des paramètres suivants.
listeDeParamètres
Propriété
Usage et effet
#color
Couleur de premier plan à appliquer pour les effets de colorisation. La valeur
par défaut est noir.
#bgColor
Couleur d’arrière-plan à appliquer pour les effets de colorisation ou comme
transparence d’arrière-plan. La couleur par défaut est le blanc.
#ink
Type d’encre à appliquer aux pixels copiés. Il peut s’agir d’un symbole
d’encre ou de la valeur numérique correspondante. L’encre par défaut est
#copy.
#blendLevel
Degré d’opacité (transparence) à appliquer aux pixels copiés. La plage de
valeurs est comprise entre 0 et 225. La valeur par défaut est 255 (opaque).
L’utilisation d’une valeur inférieure à 255 définit le paramètre #ink sur
#blend, ou sur #blendTransparent s’il était initialement défini sur
#backgroundTransparent. #blendLevel peut également être remplacé par
#blend ; dans ce cas, utilisez une plage de valeurs comprise entre 0 et 100.
#dither
Valeur TRUE ou FALSE qui détermine si les pixels copiés seront tramés
lorsqu’ils seront placés dans le rectDeDestination des images 8 et 16 bits.
La valeur par défaut est FALSE, qui convertit directement les pixels copiés
dans la palette de couleurs de la réfObjImage.
#useFastQuads
Valeur TRUE ou FALSE qui détermine si les calculs de quadrilatères sont
effectués à l’aide de la méthode de Director, plus rapide mais moins
précise, lors de la copie de pixels dans un quadDeDestination. Définissez ce
paramètre sur TRUE si vous utilisez les quadrilatères pour des opérations
simples de rotation et d’inclinaison. Définissez ce paramètre sur FALSE pour
des quadrilatères aléatoires, tels que ceux utilisés pour les transformations
de perspective. La valeur par défaut est FALSE.
295
Propriété
Usage et effet
#maskImage
Spécifie un objet Masque ou Dessin seul, créé avec les fonctions
createMask() ou createMatte(), qui sera utilisé en tant que masque
pour les pixels à copier. Ceci permet de reproduire les effets des encres
d’images-objets Masque et Dessin seul. Si l’image source possède une
couche alpha et que sa propriété useAlpha est TRUE, la couche alpha sera
utilisée et l’objet Masque ou Dessin seul spécifié sera ignoré. La valeur par
défaut est pas de masque.
#maskOffset
Point indiquant la valeur de décalage x et y à appliquer au masque spécifié
par #maskImage. Le décalage est calculé par rapport au coin supérieur
gauche de l’image source. Le décalage par défaut est (0, 0).
Exemple
L’instruction suivante copie toute l’image de l’acteur Joyeux dans le rectangle de l’acteur Fleur.
Si les acteurs sont de tailles différentes, l’image de l’acteur Joyeux sera redimensionnée pour
s’ajuster au rectangle de l’acteur Fleur.
L’instruction suivante copie une portion de l’image de l’acteur Joyeux dans une portion de
l’acteur Fleur. La portion de l’image copiée de l’acteur Joyeux est située dans le rectangle
(0, 0, 200, 90). Elle est collée dans le rectangle (20, 20, 100, 40) à l’intérieur de l’image de
l’acteur Fleur. La portion copiée de l’acteur Joyeux est redimensionnée pour s’adapter aux
dimensions du rectangle dans lequel elle est collée.
L’instruction suivante copie entièrement l’image de l’acteur Joyeux dans un rectangle à l’intérieur
de l’acteur Fleur. Le rectangle dans lequel l’image copiée de l’acteur Joyeux est collée a la même
taille identique que le rectangle de l’acteur Joyeux, de sorte que l’image copiée n’est pas redimensionnée. Le niveau d’opacité de l’image copiée est de 50, elle est donc semi-tranparente, révélant
la portion de l’acteur Fleur sur laquelle elle est collée.
Voir aussi
color(), image()
copyToClipBoard()
Utilisation
-- Syntaxe Lingo
réfObjActeur.copyToClipBoard()
// Syntaxe JavaScript
réfObjActeur.copyToClipBoard();
Description
Méthode d’acteur ; copie un acteur désigné dans le Presse-papiers.
Il est possible d’appeler cette méthode sans que la fenêtre Distribution soit active.
Vous pouvez utiliser cette méthode pour copier des acteurs entre plusieurs animations ou
applications.
Paramètres
Aucun.
296
Chapitre 12 : Méthodes
Exemple
L’instruction suivante copie l’acteur Chaise dans le Presse-papiers :
-- Syntaxe Lingo
member("Chaise").copyToClipBoard()
// Syntaxe JavaScript
member("Chaise").copyToClipBoard();
L’instruction suivante copie l’acteur numéro 5 dans le Presse-papiers :
-- Syntaxe Lingo
member(5).copyToClipBoard()
// Syntaxe JavaScript
member(5).copyToClipBoard();
Voir aussi
Acteur, pasteClipBoardInto()
cos()
Utilisation
(angle).cos
cos (angle)
Description
Fonction (Lingo uniquement) ; calcule le cosinus de l’angle spécifié, exprimé en radians.
Dans la syntaxe JavaScript, utilisez la fonction cos() de l’objet Math.
Paramètres
angle
Requis. Nombre entier qui spécifie l’angle à tester.
Exemple
L’instruction suivante calcule le cosinus de pi sur 2 et l’affiche dans la fenêtre Messages :
put (PI/2).cos
Voir aussi
atan(), PI, sin()
297
count()
Utilisation
-- Syntaxe Lingo
liste.count
quelObjet.count
// Syntaxe JavaScript
liste.count;
quelObjet.count;
Description
Fonction ; renvoie le nombre d’entrées d’une liste linéaire ou de propriétés, le nombre de
propriétés d’un script parent sans compter les propriétés d’un script ancêtre ou les sous-chaînes
d’une expression texte telles que caractères, lignes ou mots.
La commande count fonctionne avec les listes linéaires et de propriétés, les objets créés avec des
scripts parents et la propriété the globals.
Pour un exemple d’utilisation de count() dans une animation, reportez-vous à l’animation Text
du dossier Learning/Lingo, lui-même inclus dans le dossier de Director.
Paramètres
Aucun.
Exemple
L’instruction suivante affiche la valeur 3, qui correspond au nombre d’entrées :
-- Syntaxe Lingo
put([10,20,30].count) -- 3
// Syntaxe JavaScript
put(list(10,20,30).count); // 3
Voir aussi
globals
createFile()
Utilisation
-- Syntaxe Lingo
réfObjFileio.createFile(chaîneNomDeFichier)
// Syntaxe JavaScript
réfObjFileio.createFile(chaîneNomDeFichier);
Description
Méthode de Fileio ; crée un fichier spécifié.
Paramètres
chaîneNomDeFichier
Requis. Chaîne qui spécifie le chemin et le nom du fichier à créer.
Voir aussi
Fileio
298
Chapitre 12 : Méthodes
createMask()
Utilisation
objetImage.createMask()
Description
La fonction suivante crée et renvoie un objet masque à utiliser avec la fonction copyPixels().
Les objets masque ne sont pas des objets image. Ils ne sont utilisés qu’avec la fonction
pour la reproduction de l’effet d’encre Masque. Afin de gagner du temps, si
vous envisagez d’utiliser plusieurs fois la même image en tant que masque, il est conseillé de
créer l’objet masque et de l’enregistrer dans une variable pour une utilisation ultérieure.
copyPixels()
Exemple
L’instruction suivante copie entièrement l’image de l’acteur Joyeux dans un rectangle à l’intérieur
de l’acteur Carré marron. L’acteur Dégradé2 est utilisé en tant que masque avec l’image copiée.
Le masque est décalé de 10 pixels vers le haut et vers la gauche du rectangle dans lequel l’image
Joyeux est collée.
member("Carré marron").image.copyPixels(member("Joyeux").image, \
rect(20, 20, 150, 108), member("Joyeux").rect, \
[#maskImage:member("Dégrad2").image.createMask(), maskOffset:point(-10, -10)])
Voir aussi
copyPixels(), createMatte(), ink
createMatte()
Utilisation
objetImage.createMatte({seuilAlpha})
Description
Cette fonction crée et renvoie un objet Dessin seul que vous pouvez utiliser avec copyPixels()
pour reproduire l’effet d’encre Dessin seul. L’objet Dessin seul est créé à partir de la couche alpha
de l’objet image spécifiée. Le paramètre facultatif seuilAlpha exclut de l’encre Dessin seul tous
les pixels dont la valeur de couche alpha est inférieure à ce seuil. Il n’est utilisé qu’avec les images
32 bits contenant une couche alpha. La valeur de seuilAlpha doit être comprise entre 0 et 255.
Les objets Dessin seul ne sont pas des objets image. Ils ne sont utilisés qu’avec la fonction
copyPixels(). Afin de gagner du temps, si vous envisagez d’utiliser plusieurs fois la même image
en tant que Dessin seul, il est conseillé de créer l’objet Dessin seul et de l’enregistrer dans une
variable pour une utilisation ultérieure.
Exemple
L’instruction suivante crée un nouvel objet Dessin seul à partir de la couche alpha de l’objet
image imageTest et ignore les pixels dont les valeurs alpha sont inférieures à 50 %.
nouveauDessinSeul = imageTest.createMatte(128)
Voir aussi
copyPixels(), createMask()
299
crop() (Image)
Utilisation
-- Syntaxe Lingo
réfObjImage.crop(rectDeRecadrage)
// Syntaxe JavaScript
réfObjImage.crop(rectDeRecadrage);
Description
Méthode d’image. Renvoie un nouvel objet image qui contient une copie d’un objet image source
recadré par rapport à un rectangle donné.
L’appel de crop() ne modifie pas l’objet image source.
Le nouvel objet image n’appartient plus à aucun acteur et n’est plus associé à la scène. Pour
affecter la nouvelle image à un acteur, définissez la propriété image de cet acteur.
Paramètres
rectDeRecadrage
Requis. Rectangle par rapport auquel la nouvelle image est recadrée.
Exemple
L’instruction Lingo suivante prend un cliché de la scène et la redimensionne dans le rect de
l’image-objet 10, capturant l’apparence courante de cette image-objet sur la scène :
L’instruction suivante utilise le rectangle de l’acteur Joyeux pour recadrer l’image de l’acteur
Fleur, puis applique l’image de l’acteur Joyeux au résultat :
member("Joyeux").image = member("Fleur").image.crop(member("Joyeux").rect)
Voir aussi
image (image), image(), rect (image)
crop() (Bitmap)
Utilisation
-- Syntaxe Lingo
réfObjActeur.crop()
// Syntaxe JavaScript
réfObjActeur.crop();
Description
Commande bitmap ; permet de recadrer un acteur bitmap à une taille spécifique.
La commande crop permet de recadrer des acteurs existants ou, en combinaison avec l’image de
la scène, de saisir un instantané, puis de le recadrer à la taille souhaitée pour l’afficher.
Le point d’alignement reste inchangé de sorte que le bitmap n’est pas déplacé par rapport à sa
position d’origine.
300
Chapitre 12 : Méthodes
Paramètres
rectDeRecadrage
Requis. Spécifie le rectangle par rapport auquel la nouvelle image est recadrée.
Exemple
L’instruction suivante affecte un acteur bitmap existant à un instantané de la scène, puis recadre
l’image résultante dans un rectangle égal à l’image-objet 10 :
-- Syntaxe Lingo
imageDeLaScène = (_movie.stage).image
imageDeLimageObjet = imageDeLaScène.crop(sprite(10).rect)
member("instantané de l’image-objet").image = imageDeLimageObjet
// Syntaxe JavaScript
var imageDeLaScène = (_movie.stage).image
var imageDeLimageObjet = imageDeLaScène.crop(sprite(10).rect);
member("instantané de l’image-objet").image = imageDeLimageObjet;
Voir aussi
picture (acteur)
cross
Utilisation
vecteur1.cross(vecteur2)
Description
Méthode 3D de vecteur ; renvoie un vecteur perpendiculaire à vecteur1 et vecteur2.
Exemple
Dans l’exemple suivant, pos1 est un vecteur sur l’axe des x et pos2 est un vecteur sur l’axe des y.
La valeur renvoyée par pos1.cross(pos2) est vector( 0.0000, 0.0000, 1.00000e4 ), qui
est perpendiculaire à pos1 et pos2.
pos1 = vector(100, 0, 0)
pos2 = vector(0, 100, 0)
put pos1.cross(pos2)
-- vector( 0.0000, 0.0000, 1.00000e4 )
Voir aussi
crossProduct(), perpendicularTo
301
crossProduct()
Utilisation
vecteur1.crossProduct(vecteur2)
Description
Méthode 3D de vecteur ; renvoie un vecteur perpendiculaire à vecteur1 et vecteur2.
Exemple
Dans l’exemple suivant, pos1 est un vecteur sur l’axe des x et pos2 est un vecteur sur l’axe des y.
La valeur renvoyée par pos1.crossProduct(pos2) est vector( 0.0000, 0.0000, 1.00000e4
), qui est perpendiculaire à pos1 et pos2.
pos1 = vector(100, 0, 0)
pos2 = vector(0, 100, 0)
put pos1.crossProduct(pos2)
-- vector( 0.0000, 0.0000, 1.00000e4 )
Voir aussi
perpendicularTo, cross
cursor()
Utilisation
-- Syntaxe Lingo
_player.cursor(entNumDeCurseur)
_player.cursor(numDacteurCurseur, numDacteurMasque)
_player.cursor(réfDacteurCurseur)
// Syntaxe JavaScript
_player.cursor(entNumDeCurseur);
_player.cursor(numDacteurCurseur, numDacteurMasque);
_player.cursor(réfDacteurCurseur);
Description
Méthode de lecteur ; change l’acteur ou le curseur intégré utilisé comme pointeur et reste en
vigueur jusqu’à ce que vous la désactiviez en affectant au curseur la valeur 0.
• Utilisez la syntaxe _player.cursor(numDacteurCurseur,
•
numDacteurMasque) pour
spécifier le numéro d’acteur à utiliser comme curseur et son masque facultatif. La zone
référencée du curseur correspond au point d’alignement de l’acteur.
L’acteur spécifié doit être un acteur 1 bit. Si l’acteur est plus grand que 16 x 16 pixels, Director
le recadre pour le transformer en carré de 16 x 16 pixels, à partir de l’angle supérieur gauche de
l’image. La zone référencée du curseur correspond toujours au point d’alignement de l’acteur.
Utilisez la syntaxe _player.cursor(réfDacteurCurseur) pour les curseurs personnalisés
proposés par l’Xtra Cursor.
Remarque : Bien que l’Xtra Cursor accepte les curseurs de différents types de distributions, les
acteurs texte ne peuvent pas être utilisés comme curseurs.
302
Chapitre 12 : Méthodes
• Utilisez la syntaxe _player.cursor(entNumDeCurseur) pour spécifier les curseurs par défaut
fournis par le système. Le terme entNumDeCurseur doit être l’un des nombres entiers suivants :
Valeur
Description
-1, 0
Flèche
1
Curseur en I
2
Croix
3
Croix épaisse
4
Montre (Macintosh) ou sablier (Windows)
5
Nord Sud Est Ouest (NSEO)
6
Nord Sud (NS)
200
Vide (masque le curseur)
254
Aide
256
Crayon
257
Gomme
258
Sélection
259
Pot de peinture
260
Main
261
Outil Rectangle
262
Outil Rectangle arrondi
263
Outil Cercle
264
Outil Ligne
265
Outil RTF
266
Outil Champ de texte
267
Outil Bouton
268
Outil Case à cocher
269
Outil Bouton radio
270
Outil Position
271
Outil Point d’alignement
272
Lasso
280
Doigt
281
Pipette
282
Attente bouton de souris enfoncé 1
283
Attente bouton de souris enfoncé 2
284
Taille verticale
303
Valeur
Description
285
Taille horizontale
286
Taille diagonale
290
Main fermée
291
Main sans déposer
292
Copie (main fermée)
293
Flèche inversée
294
Rotation
295
Inclinaison
296
Double flèche horizontale
297
Double flèche verticale
298
Double flèche sud-ouest nord-est
299
Double flèche nord-ouest sud-est
300
Pinceau pour enduire/estomper
301
Aérographe
302
Zoom avant
303
Zoom arrière
304
Annulation du zoom
305
Démarrer la forme
306
Ajouter un point
307
Fermer la forme
308
Zoom de la caméra
309
Déplacement de la caméra
310
Rotation de la caméra
457
Personnalisé
Pendant les événements système tels que le chargement d’un fichier, le système d’exploitation
peut afficher le curseur montre, puis revenir au curseur pointeur en rendant le contrôle à
l’application. Cela supplante les paramètres de la commande cursor de l’animation précédente.
Pour utiliser la commande cursor() au début d’une nouvelle animation chargée dans une
présentation utilisant un curseur personnalisé pour plusieurs animations, stockez tout numéro de
ressource de curseur spécial sous la forme d’une variable globale qui reste en mémoire entre les
animations.
Les commandes de curseur peuvent être interrompues par un Xtra ou tout autre élément externe.
Lorsque le curseur a une valeur dans Director et qu’un Xtra ou un élément externe en prend le
contrôle, la restitution de sa valeur d’origine n’a aucun effet, Director ne percevant pas que sa
valeur a changé. Pour résoudre ce problème, attribuez explicitement au curseur une troisième
valeur, puis rendez-lui sa valeur d’origine.
304
Chapitre 12 : Méthodes
Paramètres
entNumDeCurseur Requis lorsqu’un nombre entier est utilisé pour identifier un curseur. Nombre
entier qui spécifie le curseur intégré à utiliser en tant que curseur.
Requis lorsqu’un numéro d’acteur et son masque facultatif sont utilisés
pour identifier le curseur. Nombre entier qui spécifie le numéro de l’acteur à utiliser en tant que
curseur.
numDacteurCurseur
Requis lorsqu’un numéro d’acteur et son masque facultatif sont utilisés pour
identifier le curseur. Nombre entier qui spécifie le numéro de masque de numDacteurCurseur.
numDacteurMasque
réfDacteurCurseur Requis lorsqu’une référence d’acteur est utilisée pour identifier le curseur.
Référence à l’acteur à utiliser en tant que curseur.
Exemple
L’instruction suivante change le curseur en curseur montre sur un Macintosh et en sablier sous
Windows, si la valeur de la variable status est égale à 1 :
-- Syntaxe Lingo
if (status = 1) then
_player.cursor(4)
end if
// Syntaxe JavaScript
if (status == 1) {
_player.cursor(4);
}
Le gestionnaire suivant vérifie que l’acteur affecté à la variable est un acteur 1 bit et, le cas échéant,
l’utilise comme curseur :
-- Syntaxe Lingo
on monCurseur(unActeur)
if (member(UnActeur).depth = 1) then
_player.cursor(unActeur)
else
_sound.beep()
end if
end
// Syntaxe JavaScript
function monCurseur(unActeur) {
if (member(unActeur).depth == 1) {
_player.cursor(unActeur);
}
else {
_sound.beep();
}
}
Voir aussi
Lecteur
305
date() (formats)
Utilisation
-- Syntaxe Lingo
date({chaîneFormat})
date({entFormat})
date({entFormatAnnée, entFormatMois, entFormatJour})
// Syntaxe JavaScript
Date({“mois jj, aaaa hh:mm:ss”});
Date({“mois jj, aaaa”});
Date({aa,mm,jj,hh,mm,ss});
Date({aa,mm,jj});
Date({millisecondes});
Description
Fonction du niveau supérieur et type de données. Crée une instance d’objet Date au format standard que vous pouvez utiliser avec d’autres instances de date dans des opérations arithmétiques ou
pour manipuler les dates d’une plate-forme à l’autre, ainsi que dans des formats de pays différents.
Les objet Date Lingo et ceux de la syntaxe JavaScript sont différents ; par conséquent, il n’est pas
possible de créer des objets Date Lingo avec la syntaxe JavaScript et, inversement, de créer des
objets Date JavaScript avec la syntaxe Lingo.
Créez un nouvel objet Date dans la syntaxe JavaScript en utilisant la syntaxe new Date().
La syntaxe JavaScript tient compte de la casse. Par exemple, new date() provoque une erreur
d’exécution.
Lorsque vous créez une date en Lingo, utilisez quatre chiffres pour l’année, deux chiffres pour le
mois et deux chiffres pour le jour. Les expressions suivantes renvoient un objet Date correspondant au 21 octobre 2004.
Format de date
Emploi
chaîne
date(“20041021”)
entier
date(20041021)
séparation par virgules date(2004, 10, 21)
Les différentes propriétés de l’objet Date renvoyé sont les suivantes :
Propriété
Description
#year
Nombre entier représentant l’année
#month
Nombre entier représentant le mois de l’année
#day
Nombre entier représentant le jour du mois
Les opérations d’addition et de soustraction sur la date sont interprétées comme l’addition et la
soustraction de jours.
306
Chapitre 12 : Méthodes
Paramètres
chaîneFormat
Facultatif lors de la création d’un objet Date Lingo. Chaîne qui spécifie le nouvel
objet Date.
entFormat Facultatif lors de la création d’un objet Date Lingo. Nombre entier qui spécifie le
nouvel objet Date.
entFormatAnnée Facultatif lors de la création d’un objet Date Lingo. Nombre entier qui spécifie
les quatre chiffres de l’année du nouvel objet Date.
Facultatif lors de la création d’un objet Date Lingo. Nombre entier qui spécifie
les deux chiffres du mois du nouvel objet Date.
entFormatMois
Facultatif lors de la création d’un objet Date Lingo. Nombre entier qui spécifie
les deux chiffres du jour du nouvel objet Date.
entFormatJour
Facultatif lors de la création d’un objet Date dans la syntaxe JavaScript. Chaîne qui spécifie
le mois du nouvel objet Date. Les valeurs correctes sont comprises entre 0 (janvier) et 11
(décembre).
mois
jj Facultatif lors de la création d’un objet Date dans la syntaxe JavaScript. Nombre entier de
deux chiffres qui spécifie le jour du nouvel objet Date. Les valeurs correctes sont comprises entre
0 (dimanche) et 6 (samedi).
Facultatif lors de la création d’un objet Date dans la syntaxe JavaScript. Nombre entier de
quatre chiffres qui spécifie l’année du nouvel objet Date.
aaaa
hh Facultatif lors de la création d’un objet Date dans la syntaxe JavaScript. Nombre entier de
deux chiffres qui spécifie l’heure du nouvel objet Date. Les valeurs correctes sont comprises entre
0 (12:00) et 23 (23:00).
mm Facultatif lors de la création d’un objet Date dans la syntaxe JavaScript. Nombre entier de
deux chiffres qui spécifie les minutes du nouvel objet Date. Les valeurs correctes sont comprises
entre 0 et 59.
ss Facultatif lors de la création d’un objet Date dans la syntaxe JavaScript. Nombre entier de
deux chiffres qui spécifie les secondes du nouvel objet Date. Les valeurs correctes sont comprises
entre 0 et 59.
aa Facultatif lors de la création d’un objet Date dans la syntaxe JavaScript. Nombre entier de
deux chiffres qui spécifie l’année du nouvel objet Date. Les valeurs correctes sont comprises entre
0 et 99.
Facultatif lors de la création d’un objet Date dans la syntaxe JavaScript. Nombre
entier qui spécifie les millisecondes du nouvel objet Date. Les valeurs correctes sont comprises
entre 0 et 999.
millisecondes
307
Exemple
Les instructions suivantes créent et déterminent le nombre de jours séparant deux dates :
-- Syntaxe Lingo
maDateDeNaissance = date(19650712)
taDateDeNaissance = date(19450529)
put("Il y a" && abs(taDateDeNaissance - maDateDeNaissance) && "jours entre nos
\ dates de naissances.")
// Syntaxe JavaScript
var maDateDeNaissance = new Date(1965, 07, 12);
var taDateDeNaissance = new Date(1945, 05, 29);
put("Il y a " + Math.abs(((taDateDeNaissance - maDateDeNaissance)/1000/60/60/
24)) +
" jours entre nos dates de naissance.");
Les instructions suivantes permettent d’accéder à la propriété individuelle d’une date :
-- Syntaxe Lingo
maDateDeNaissance = date(19650712)
put("Je suis né au mois numéro"&&maDateDeNaissance.month)
// Syntaxe JavaScript
var maDateDeNaissance = new Date(1965, 07, 12);
put("Je suis né au mois numéro" + maDateDeNaissance.getMonth());
date() (Système)
Utilisation
-- Syntaxe Lingo
_system.date({aaaammjj})
// Syntaxe JavaScript
_system.date({aaaammjj});
Description
Méthode du système ; renvoie la date courante fournie par l’horloge du système.
Le format de date utilisé par Director varie suivant le format défini sur l’ordinateur.
• Sous Windows, vous pouvez personnaliser l’affichage de la date dans le Panneau de
•
configuration Paramètres régionaux. (Windows enregistre le format de date court dans le
fichier System.ini. Utilisez cette valeur pour déterminer ce qu’indiquent les parties de la date
au format court.)
Sur Macintosh, vous pouvez personnaliser l’affichage de la date dans le tableau de bord Date et
heure.
Paramètres
aaaammjj Facultatif. Nombre qui spécifie les quatre chiffres de l’année (aaaa),
du mois (mm) et les deux chiffres du jour (jj) de la date renvoyée.
308
Chapitre 12 : Méthodes
les deux chiffres
Exemple
L’instruction suivante détermine si la date en cours est le 1er janvier en vérifiant si les quatre
premiers caractères de la date sont 1/1/. Si c’est le 1er janvier, le message d’alerte Bonne année !
apparaît :
-- Syntaxe Lingo
if (_system.date().char[1..4] = "1/1/") then
_player.alert("Bonne année !")
end if
// Syntaxe JavaScript
if (_system.date().toString().substr(0, 4) == "1/1/") {
_player.alert("Bonne année !");
}
Voir aussi
Système
delay()
Utilisation
-- Syntaxe Lingo
_movie.delay(entBattements)
// Syntaxe JavaScript
_movie.delay(entBattements);
Description
Commande d’animation ; immobilise la tête de lecture pendant une durée donnée.
La seule activité de la souris et du clavier possible à ce moment-là consiste à arrêter l’animation en
appuyant sur Ctrl+Alt+point (Windows) ou Cmd+point (Macintosh). Dans la mesure où elle
augmente la durée des différentes images, la commande delay() est utile pour contrôler la
cadence de lecture d’une séquence d’images.
La méthode delay() peut être appliquée seulement lorsque la tête de lecture est en mouvement.
Toutefois, les gestionnaires peuvent toujours être exécutés lorsque la méthode delay() est active.
Seule la tête de lecture s’arrête ; l’exécution des scripts, elle, se poursuit. Placez les scripts utilisant
la méthode delay() dans un gestionnaire enterFrame ou exitFrame.
Pour simuler une interruption dans un gestionnaire lorsque la tête de lecture est immobile,
utilisez la propriété milliseconds de l’objet Système et patientez jusqu’à la fin du délai spécifié
avant de sortir de l’image.
Paramètres
Requis. Nombre entier qui spécifie la durée d’immobilisation de la tête de
lecture en nombre de battements. Un battement correspond à 1/60ème de seconde.
entBattements
309
Exemple
Le gestionnaire suivant interrompt l’animation pendant 2 secondes lorsque la tête de lecture
quitte l’image en cours :
-- Syntaxe Lingo
on keyDown
_movie.delay(2*60)
end
// Syntaxe JavaScript
function keyDown() {
_movie.delay(2*60);
}
Le gestionnaire suivant, qui peut être placé dans un script d’image, retarde l’animation d’un
nombre aléatoire de battements :
-- Syntaxe Lingo
on keyDown
if (_key.key = "x") then
_movie.delay(random(180))
end if
end
// Syntaxe JavaScript
function keyDown() {
if (_key.key == "x") {
_movie.delay(random(180));
}
}
Voir aussi
endFrame, milliseconds, Animation
delete()
Utilisation
-- Syntaxe Lingo
réfObjFileio.delete()
// Syntaxe JavaScript
réfObjFileio.delete();
Description
Méthode de Fileio ; supprime un fichier.
Paramètres
Aucun.
Voir aussi
Fileio
310
Chapitre 12 : Méthodes
deleteAt
Utilisation
liste.deleteAt(nombre)
deleteAt liste, nombre
Description
Commande de liste ; supprime un élément d’une liste linéaire ou de propriétés.
La commande deleteAt vérifie que l’élément se trouve dans la liste et, si vous essayez de
supprimer un objet qui n’est pas dans la liste, Director affiche un message d’erreur.
Paramètres
nombre
Requis. Spécifie la position de l’élément à supprimer dans la liste.
Exemple
L’instruction suivante supprime le deuxième élément de la liste designers, qui contient [dupont,
avatar, soldes] :
designers = ["dupont", "avatar", "soldes"]
designers.deleteAt(2)
Le résultat est la liste [dupont, soldes].
Le gestionnaire suivant vérifie si un objet se trouve dans la liste avant d’essayer de le supprimer :
on monDeleteAt laListe, Lindex
if laListe.count < Lindex then
beep
else
laListe.deleteAt(Lindex)
end if
end
Voir aussi
addAt
deleteCamera
Utilisation
member(quelActeur).deleteCamera(nomDeCaméra)
member(quelActeur).deleteCamera(index)
sprite(quelleImageObjet).deleteCamera(caméraOuIndex)
Description
Commande 3D ; dans un acteur, cette commande supprime la caméra de l’acteur et de l’univers
3D. Les enfants de la caméra sont retirés de l’univers 3D mais ne sont pas supprimés.
Il est impossible de supprimer la caméra par défaut de l’acteur.
Dans une image-objet, cette commande supprime la caméra de la liste des caméras de l’imageobjet. La caméra n’est pas supprimée de l’acteur.
Paramètres
nomDeCaméra, index ou caméraOuIndex. Requis. Chaîne ou nombre entier qui spécifie le nom
ou la position d’index de la caméra à supprimer.
311
Exemple
L’instruction suivante supprime deux caméras de l’acteur Pièce : tout d’abord la caméra
Caméra06, puis la caméra 1.
member("Pièce").deleteCamera("Caméra06")
member("Pièce").deleteCamera(1)
L’instruction suivante supprime deux caméras de la liste des caméras de l’image-objet 5 : tout
d’abord la deuxième caméra de la liste, puis la caméra Caméra06.
sprite(5).deleteCamera(2)
sprite(5).deleteCamera(member("Pièce").camera("Caméra06"))
Voir aussi
newCamera, addCamera, cameraCount()
deleteFrame()
Utilisation
-- Syntaxe Lingo
_movie.deleteFrame()
// Syntaxe JavaScript
_movie.deleteFrame();
Description
Méthode d’animation ; supprime l’image courante et fait de l’image suivante la nouvelle image
courante pendant une session de création du scénario uniquement.
Paramètres
Aucun.
Exemple
Le gestionnaire suivant vérifie si l’image-objet de la piste 10 de l’image courante a dépassé le bord
droit d’une scène de 640 x 480 pixels et, le cas échéant, supprime l’image :
-- Syntaxe Lingo
on testSprite
_movie.beginRecording()
if (sprite(10).locH > 640) then
_movie.deleteFrame()
end if
_movie.endRecording()
end
// Syntaxe JavaScript
function testSprite() {
_movie.beginRecording();
if (sprite(10).locH > 640) {
_movie.deleteFrame();
}
_movie.endRecording();
}
Voir aussi
beginRecording(), endRecording(), Animation, updateFrame()
312
Chapitre 12 : Méthodes
deleteGroup
Utilisation
member(quelActeur).deleteGroup(quelGroupe)
member(quelActeur).deleteGroup(index)
Description
Commande 3D ; supprime le groupe de l’acteur et de l’univers 3D. Les enfants du groupe sont
retirés de l’univers 3D mais ne sont pas supprimés.
Il est impossible de supprimer le groupe World, qui est le groupe par défaut.
Paramètres
ou index. Requis. Chaîne ou nombre entier qui spécifie le nom ou la position
d’index du groupe à supprimer.
quelGroupe
Exemple
La première ligne de cet exemple supprime le groupe Factice16 de l’acteur Scène. La deuxième
ligne supprime le troisième groupe de Scène.
member("Scène").deleteGroup("Factice16")
member("Scène").deleteGroup(3)
Voir aussi
newGroup, child (3D), parent
deleteLight
Utilisation
member(quelActeur).deleteLight(quelleLumière)
member(quelActeur).deleteLight(index)
Description
Commande 3D ; supprime la lumière de l’acteur et de l’univers 3D. Les enfants de la lumière
sont retirés de l’univers 3D mais ne sont pas supprimés.
Paramètres
quelleLumière ou index. Requis. Chaîne ou nombre entier qui spécifie le nom ou la position
d’index de la lumière à supprimer.
Exemple
Les exemples suivants suppriment les lumières de l’acteur Pièce.
member("Pièce").deleteLight("lumièreAmbiante")
member("Pièce").deleteLight(6)
Voir aussi
newLight
313
deleteModel
Utilisation
member(quelActeur).deleteModel(quelModèle)
member(quelActeur).deleteModel(index)
Description
Commande 3D ; supprime le modèle de l’acteur et de l’univers 3D. Les enfants du modèle sont
retirés de l’univers 3D mais ne sont pas supprimés.
Paramètres
ou index. Requis. Chaîne ou nombre entier qui spécifie le nom ou la position
d’index du modèle à supprimer.
quelModèle
Exemple
La première ligne de cet exemple supprime le modèle Lecteur3 de l’acteur gbUnivers. La
deuxième ligne supprime le neuvième modèle de gbUnivers.
member("gbUnivers").deleteModel("Lecteur3")
member("gbUnivers").deleteModel(9)
Voir aussi
newModel
deleteModelResource
Utilisation
member(quelActeur).deleteModelResource(quelleRessDeMod)
member(quelActeur).deleteModelResource(index)
Description
Commande 3D ; supprime la ressource de modèle de l’acteur et de l’univers 3D.
Les modèles qui utilisent la ressource de modèle supprimée deviennent invisibles car ils perdent
leur géométrie, mais ne sont ni supprimés ni retirés de l’univers.
Paramètres
quelleRessDeMod ou index. Requis. Chaîne ou nombre entier qui spécifie le nom ou la position
d’index de la ressource de modèle à supprimer.
Exemple
Les exemples suivants suppriment deux ressources de modèle de l’acteur ScèneDeRue.
member("ScèneDeRue").deleteModelResource("MaisonB")
member("ScèneDeRue").deleteModelResource(3)
Voir aussi
newModelResource, newMesh
314
Chapitre 12 : Méthodes
deleteMotion
Utilisation
member(quelActeur).deleteMotion(quelMouvement)
member(quelActeur).deleteMotion(index)
Description
Commande 3D ; supprime le mouvement de l’acteur.
Paramètres
quelMouvement ou index. Requis. Chaîne ou nombre entier qui spécifie le nom ou la position
d’index du mouvement à supprimer.
Exemple
La première ligne de l’exemple suivant supprime le mouvement Saut de l’acteur
ScèneDePiqueNique. La deuxième ligne supprime le cinquième mouvement de
ScèneDePiqueNique.
member("ScèneDePiqueNique").deleteMotion("Saut")
member("ScèneDePiqueNique").deleteMotion(5)
Voir aussi
newMotion(), removeLast()
deleteOne
Utilisation
liste.deleteOne(valeur)
deleteOne liste, valeur
Description
Commande de liste ; supprime une valeur d’une liste linéaire ou de propriétés. Pour une liste de
propriétés, deleteOne supprime également la propriété associée à la valeur supprimée. Si la valeur
se trouve à plusieurs endroits dans la liste, deleteOne ne supprime que la première occurrence.
L’utilisation de cette commande pour supprimer une propriété reste sans effet.
Paramètres
valeur
Requis. Valeur à supprimer de la liste.
Exemple
La première instruction suivante crée une liste contenant les jours mardi, mercredi et vendredi.
La seconde instruction suivante supprime le nom mercredi de la liste.
jours = ["mardi", "mercredi", "vendredi"]
jours.deleteOne("mercredi")
put jours
L’instruction put jours entraîne l’affichage du résultat dans la fenêtre Messages :
-- ["mardi", "vendredi"].
315
deleteProp
Utilisation
liste.deleteProp(élément)
deleteProp liste, élément
Description
Commande de liste ; supprime l’élément spécifié de la liste indiquée.
• Pour les listes linéaires, remplacez élément par le numéro correspondant à la position de
•
l’élément à supprimer dans la liste. La commande deleteProp a le même effet (dans les listes
linéaires) que la commande deleteAt. Un chiffre supérieur au nombre d’éléments de la liste
entraîne une erreur de script.
Pour les listes de propriétés, remplacez élément par le nom de la propriété à supprimer.
La suppression d’une propriété supprime également la valeur qui lui est associée. Si la liste
contient la même propriété à plusieurs endroits, seule la première occurrence de la propriété
est supprimée.
Paramètres
élément
Requis. Elément à supprimer de la liste.
Exemple
L’instruction suivante supprime la propriété color de la liste [#height:100, #width: 200,
appelée attributsDimageObjet :
#color: 34, #ink: 15],
attributsDimageObjet.deleteProp(#color)
Le résultat est la liste [#height:100, #width: 200, #ink: 15].
Voir aussi
deleteAt
deleteShader
Utilisation
member(quelActeur).deleteShader(quelMatériau)
member(quelActeur).deleteShader(index)
Description
Commande 3D ; retire le matériau de l’acteur.
Paramètres
quelMatériau ou index. Requis. Chaîne ou nombre entier qui spécifie le nom ou la position
d’index du matériau à supprimer.
316
Chapitre 12 : Méthodes
Exemple
La première ligne de cet exemple supprime le matériau Route de l’acteur ScèneDeRue.
La deuxième ligne supprime le troisième matériau de ScèneDeRue.
member("ScèneDeRue").deleteShader("Route")
member("ScèneDeRue").deleteShader(3)
Voir aussi
newShader, shaderList
deleteTexture
Utilisation
member(quelActeur).deleteTexture(quelleTexture)
member(quelActeur).deleteTexture(index)
Description
Commande 3D ; retire la texture de l’acteur.
Paramètres
quelleTexture ou index. Requis. Chaîne ou nombre entier qui spécifie le nom ou la position
d’index de la texture à supprimer.
Exemple
La première ligne de cet exemple supprime la texture Ciel de l’acteur ScèneDePiqueNique.
La deuxième ligne supprime la cinquième texture de ScèneDePiqueNique.
member("ScèneDePiqueNique).deleteTexture("Ciel")
member("ScèneDePiqueNique").deleteTexture(5)
Voir aussi
newTexture
deleteVertex()
Utilisation
-- Syntaxe Lingo
réfObjActeur.deleteVertex(indexASupprimer)
// Syntaxe JavaScript
réfObjActeur.deleteVertex(indexASupprimer);
Description
Commande de forme vectorielle ; supprime un sommet existant d’un acteur forme vectorielle à la
position d’index spécifiée.
Paramètres
indexASupprimer
Requis. Nombre entier qui spécifie la position d’index du sommet à
supprimer.
317
Exemple
La ligne suivante supprime le deuxième point de sommet de la forme vectorielle Archie :
-- Syntaxe Lingo
member("Archie").deleteVertex(2)
// Syntaxe JavaScript
member("Archie").deleteVertex(2);
Voir aussi
addVertex(), moveVertex(), originMode, vertexList
displayOpen()
Utilisation
-- Syntaxe Lingo
réfObjFileio.displayOpen()
// Syntaxe JavaScript
réfObjFileio.displayOpen();
Description
Méthode de Fileio ; affiche une boîte de dialogue d’ouverture.
Cette méthode renvoie au script le chemin d’accès complet et le nom du fichier sélectionné.
Paramètres
Aucun.
Voir aussi
Fileio
displaySave()
Utilisation
-- Syntaxe Lingo
réfObjFileio.displaySave(chaîneTitre, chaîneNomDeFichier)
// Syntaxe JavaScript
réfObjFileio.displaySave(chaîneTitre, chaîneNomDeFichier);
Description
Méthode de Fileio ; affiche une boîte de dialogue d’enregistrement.
Cette méthode renvoie au script le chemin d’accès complet et le nom du fichier enregistré.
318
Chapitre 12 : Méthodes
Paramètres
chaîneTitre. Requis. Chaîne qui représente le titre affiché dans la boîte de dialogue
d’enregistrement.
chaîneNomDeFichier.
Requis. Chaîne qui spécifie le chemin complet et le nom du fichier à
enregistrer.
Voir aussi
Fileio
do
Utilisation
do expressionChaîne
Description
Commande ; évalue une chaîne et exécute le résultat sous la forme d’une instruction de script.
Cette commande est pratique pour évaluer des expressions saisies par l’utilisateur et pour exécuter
des commandes placées dans des variables chaînes, des champs, des listes et des fichiers.
L’utilisation de variables locales non initialisées dans une commande do entraîne une erreur de
compilation. Il est conseillé d’initialiser à l’avance les variables locales.
Remarque : Cette commande ne permet pas la déclaration de variables globales, celles-ci devant
toujours être déclarées en avance.
La commande do fonctionne avec des chaînes à plusieurs lignes ainsi qu’avec les chaînes n’en
contenant qu’une seule.
Paramètres
expressionChaîne
Requis. Chaîne à évaluer.
Exemple
L’instruction suivante exécute l’instruction placée entre guillemets :
do "beep 2"
do listeDeCommandes[3]
doneParsing()
Utilisation
ObjetDanalyse.doneParsing()
Description
Fonction ; renvoie 1 (TRUE) lorsque l’objet d’analyse a terminé l’analyse du document avec
parseURL(). La valeur renvoyée est 0 (FALSE) jusqu’à la fin de l’analyse.
Paramètres
Aucun.
Voir aussi
parseURL()
319
dot()
Utilisation
vecteur1.dot(vecteur2)
Description
Méthode 3D de vecteur ; renvoie la somme des produits des composants x, y et z de deux
vecteurs. Si les deux vecteurs sont normalisés, le produit est le cosinus de l’angle entre les deux
vecteurs.
Pour manuellement arriver au dot de deux vecteurs, multipliez le composant x de vecteur1 par
le composant x de vecteur2, puis multipliez le composant y de vecteur1 par le composant y de
vecteur2, puis multipliez le composant z de vecteur1 par le composant z de vecteur2, avant de
finalement ajouter les trois produits.
Cette méthode est identique à la fonction dotProduct().
Paramètres
vecteur2
Requis. Le second des vecteurs dont la somme est renvoyée.
Exemple
Dans l’exemple suivant, l’angle séparant les vecteurs pos5 et pos6 est de 45°. La fonction
getNormalized renvoie les valeurs normalisées de pos5 et pos6 et les enregistre dans les variables
norm1 et norm2. Le produit dot de norm1 et norm2 est 0,7071, ce qui correspond au cosinus
de 45°.
pos5 = vector(100, 100, 0)
pos6 = vector(0, 100, 0)
put pos5.angleBetween(pos6)
-- 45.0000
norm1 = pos5.getNormalized()
put norm1
-- vector( 0.7071, 0.7071, 0.0000 )
norm2 = pos6.getNormalized()
put norm2
-- vector( 0.0000, 1.0000, 0.0000 )
put norm1.dot(norm2)
-- 0.7071
Voir aussi
dotProduct(), getNormalized, normalize
dotProduct()
Utilisation
vecteur1.dotProduct(vecteur2)
Description
Méthode 3D de vecteur ; renvoie la somme des produits des composants x, y et z de deux
vecteurs. Si les deux vecteurs sont normalisés, dotproduct renvoie le cosinus de l’angle entre les
deux vecteurs.
320
Chapitre 12 : Méthodes
Pour manuellement arriver au dot de deux vecteurs, multipliez le composant x de vecteur1 par
le composant x de vecteur2, puis multipliez le composant y de vecteur1 par le composant y de
vecteur2, puis multipliez le composant z de vecteur1 par le composant z de vecteur2, avant de
finalement ajouter les trois produits.
Cette méthode est identique à la fonction dot().
Paramètres
vecteur2
Requis. Le second des vecteurs dont la somme est renvoyée.
Exemple
Dans l’exemple suivant, l’angle séparant les vecteurs pos5 et pos6 est de 45°. La fonction
getNormalized renvoie les valeurs normalisées de pos5 et pos6 et les enregistre dans les variables
norm1 et norm2. Le dotProduct de norm1 et norm2 est 0.7071, ce qui est le cosinus de 45°.
pos5 = vector(100, 100, 0)
pos6 = vector(0, 100, 0)
put pos5.angleBetween(pos6)
-- 45.0000
norm1 = pos5.getNormalized()
put norm1
-- vector( 0.7071, 0.7071, 0.0000 )
norm2 = pos6.getNormalized()
put norm2
-- vector( 0.0000, 1.0000, 0.0000 )
put norm1.dotProduct(norm2)
-- 0.7071
Voir aussi
dot(), getNormalized, normalize
downloadNetThing
Utilisation
downloadNetThing URL, fichierLocal
Description
Commande ; copie un fichier depuis Internet vers un fichier placé sur le disque local, tandis que
la lecture de l’animation courante continue. Utilisez netDone pour vérifier si le téléchargement est
terminé.
Les animations Director en mode auteur et les projections prennent en charge la commande
mais celle-ci n’est pas prise en charge par Shockwave Player. Cela empêche
les utilisateurs de copier accidentellement des fichiers à partir d’Internet.
downLoadNetThing,
Bien que plusieurs opérations réseau puissent avoir lieu en même temps, l’exécution de plus de
quatre opérations simultanées réduit généralement les performances de façon inacceptable.
Ni la taille de la mémoire cache de l’animation Director, ni le paramètre de l’option Vérifier les
documents n’affectent le comportement de la commande downloadNetThing.
321
Paramètres
URL Requis. URL de n’importe quel objet pouvant être téléchargé : par exemple, un serveur FTP
ou HTTP, une page HTML, un acteur externe, une animation Director ou un graphique.
fichierLocal
Requis. Chemin d’accès et nom du fichier sur le disque local.
Exemple
Les instructions suivantes téléchargent un acteur externe depuis une URL vers le dossier de
Director et font de ce fichier l’acteur externe intitulé Distribution importante :
downLoadNetThing("http://www.cbDeMille.com/Milliers.cst", the \
applicationPath&"Milliers.Cst")
castLib("Distribution importante").fileName = the
applicationPath&"Milliers.Cst"
Voir aussi
importFileInto(), netDone(), preloadNetThing()
draw()
Utilisation
-- Syntaxe Lingo
réfObjImage.draw(x1, y1, x2, y2, objetCouleurOuListedeParamètres)
réfObjImage.draw(point(x, y), point(x, y), objetCouleurOuListedeParamètres)
réfObjImage.draw(rect, objetCouleurOuListedeParamètres)
// Syntaxe JavaScript
réfObjImage.draw(x1, y1, x2, y2, objetCouleurOuListedeParamètres);
réfObjImage.draw(point(x, y), point(x, y), objetCouleurOuListedeParamètres);
réfObjImage.draw(rect, objetCouleurOuListedeParamètres);
Description
Méthode d’image. Dessine une ligne ou une forme vide avec une couleur spécifiée dans une zone
rectangulaire d’un objet image donné.
Cette méthode renvoie une valeur égale à 1 si aucune erreur n’est détectée.
Si la liste des paramètres facultatifs n’est pas fournie, draw() dessine une ligne de 1 pixel entre le
premier et le second point donnés ou entre l’angle supérieur gauche et l’angle inférieur droit du
rectangle donné.
Pour optimiser les performances avec des images 8 bits (ou d’une qualité inférieure), l’objet
Couleur doit contenir une valeur de couleur indexée. Pour les images 16 ou 32 bits, utilisez une
valeur de couleur rvb.
Pour remplir une zone unie, utilisez la méthode fill().
Paramètres
Requis si vous dessinez une ligne avec des coordonnées x et y. Entier qui spécifie la coordonnée x du début de la ligne.
x1
Requis si vous dessinez une ligne avec des coordonnées x et y. Entier qui spécifie la coordonnée y du début de la ligne.
y1
Requis si vous dessinez une ligne avec des coordonnées x et y. Entier qui spécifie la coordonnée x de la fin de la ligne.
x2
322
Chapitre 12 : Méthodes
Requis si vous dessinez une ligne avec des coordonnées x et y. Entier qui spécifie la coordonnée y de la fin de la ligne.
y2
objCouleurOuListeDeParamètres Requis. Objet couleur ou liste de paramètres qui spécifie la
couleur de la ligne ou de la bordure de la forme. Il est possible d’utiliser la liste de paramètres à
la place d’un simple objet Couleur pour spécifier les propriétés suivantes.
Propriété
Description
#shapeType
Une valeur de symbole de #oval, #rect, #roundRect ou #line. La valeur par
défaut est #line.
#lineSize
Epaisseur du trait à utiliser pour le dessin de la forme.
#color
Un objet couleur, qui détermine la couleur de la bordure de la forme.
Requis si vous dessinez une ligne avec des points. Deux points qui
spécifient le début et la fin de la ligne.
point(x, y), point(x, y)
Requis si vous dessinez une forme. Rectangle qui spécifie la zone rectangulaire dans laquelle
la forme est dessinée.
rect
Exemple
L’instruction suivante dessine une ligne diagonale de 1 pixel, de couleur rouge foncé, du point
(0, 0) au point (128, 86) dans l’image de l’acteur Joyeux.
L’instruction suivante dessine un ovale vide de 3 pixels, rouge foncé, dans l’image de l’acteur
Joyeux. L’ovale est dessiné à l’intérieur du rectangle (0, 0, 128, 86).
Voir aussi
color(), copyPixels(), fill(), image(), setPixel()
duplicate() (image)
Utilisation
-- Syntaxe Lingo
réfObjImage.duplicate()
// Syntaxe JavaScript
réfObjImage.duplicate();
Description
Méthode d’image. Crée et renvoie une copie d’une image donnée.
La nouvelle image est entièrement indépendante de l’image d’origine et n’est liée à aucun acteur.
Si vous projetez d’apporter un grand nombre de modifications à une image, il est recommandé
d’en faire une copie indépendante d’un acteur.
Paramètres
Aucun.
323
Exemple
L’instruction suivante crée un nouvel objet image à partir de l’image de l’acteur Surface lunaire et
place le nouvel objet image dans la variable imageTemporaire :
imageTemporaire = member("Surface lunaire").image.duplicate()
Voir aussi
image()
duplicate() (fonction de liste)
Utilisation
(ancienneListe).duplicate()
duplicate(ancienneListe)
Description
Fonction de liste ; renvoie la copie d’une liste et copie des listes imbriquées (éléments de listes qui
sont eux-mêmes des listes) et leur contenu. Cette fonction est pratique pour enregistrer le contenu
courant d’une liste.
Lorsque vous affectez une liste à une variable, la variable contient une référence à la liste et non la
liste même. Cela signifie que les modifications apportées à la copie affectent également l’original.
Pour un exemple d’utilisation de duplicate() (fonction de liste) dans une animation,
reportez-vous à l’animation Vector Shapes du dossier Learning/Lingo, lui-même inclus dans le
dossier de Director.
Paramètres
ancienneListe
Requis. Spécifie la liste à dupliquer.
Exemple
Cette instruction copie la liste ClientsDuJour et l’affecte à la variable ListeDesClients :
ListeDesClients = ClientsDuJour.duplicate()
Voir aussi
image()
duplicate() (acteur)
Utilisation
-- Syntaxe Lingo
réfObjActeur.duplicate({entPosn})
// Syntaxe JavaScript
réfObjActeur.duplicate({entPosn});
Description
Méthode d’acteur ; crée une copie d’un acteur spécifié.
Cette méthode est destinée à être utilisée pendant la programmation plutôt que pendant
l’exécution, car elle crée un autre acteur en mémoire, ce qui risque d’entraîner des problèmes
de mémoire.
324
Chapitre 12 : Méthodes
Utilisez cette méthode pour enregistrer définitivement les modifications de l’acteur avec le fichier.
Paramètres
entPosn Facultatif. Nombre entier qui spécifie la fenêtre Distribution pour l’acteur copié. Si
le paramètre est omis, la copie de l’acteur est placée dans la première position disponible de la
fenêtre Distribution.
Exemple
L’instruction suivante copie l’acteur Bureau et le place dans la première position vide de la fenêtre
Distribution :
-- Syntaxe Lingo
member("Bureau").duplicate()
// Syntaxe JavaScript
member("Bureau").duplicate();
L’instruction suivante copie l’acteur Bureau et le place à la position 125 :
-- Syntaxe Lingo
member("Bureau").duplicate(125)
// Syntaxe JavaScript
member("Bureau").duplicate(125);
Voir aussi
Acteur
duplicateFrame()
Utilisation
-- Syntaxe Lingo
_movie.duplicateFrame()
// Syntaxe JavaScript
_movie.duplicateFrame();
Description
Méthode d’animation ; copie l’image courante et son contenu, insère la copie après l’image
courante et fait de la copie l’image courante. Cette méthode peut être utilisée pendant la création
du scénario uniquement.
Cette méthode a la même fonction que la méthode insertFrame().
Paramètres
Aucun.
325
Exemple
Lorsqu’elle est utilisée dans le gestionnaire suivant, la commande duplicateFrame crée une série
d’images dans lesquelles l’acteur Balle de la distribution externe Jouets est affecté à la piste
d’image-objet 20. Le nombre d’images est déterminé par l’argument nombreDimages.
-- Syntaxe Lingo
on animBalle(nombreDimages)
_movie.beginRecording()
sprite(20).member = member("Balle", "Jouets")
repeat with i = 0 to nombreDimages
_movie.duplicateFrame()
end repeat
_movie.endRecording()
end animBalle
// Syntaxe JavaScript
function animBalle(nombreDimages) {
_movie.beginRecording();
sprite(20).member = member("Balle", "Jouets");
for (var i = 0; i <= nombreDimages; i++) {
_movie.duplicateFrame();
}
_movie.endRecording();
}
Voir aussi
insertFrame(), Animation
enableHotSpot()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.enableHotSpot(idDeZoneRéférencée, trueOrFalse)
// Syntaxe JavaScript
réfObjImageObjet.enableHotSpot(idDeZoneRéférencée, trueOrFalse);
Description
Commande QTVR (QuickTime VR) ; détermine si une zone référencée dans une image-objet
QTVR spécifiée est activée (TRUE) ou désactivée (FALSE).
Paramètres
idDeZoneRéférencée
trueOuFalse
326
Requis. Spécifie la zone référencée dans l’image-objet QTVR à tester.
Requis. Valeur TRUE ou FALSE qui spécifie si l’image-objet QTVR est activée.
Chapitre 12 : Méthodes
endRecording()
Utilisation
-- Syntaxe Lingo
_movie.endRecording()
// Syntaxe JavaScript
_movie.endRecording();
Description
Méthode d’animation ; termine une session de mise à jour du scénario.
Vous pouvez reprendre le contrôle des pistes du scénario en créant des scripts après avoir appelé
endRecording().
Paramètres
Aucun.
Exemple
Lorsque utilisé dans le gestionnaire suivant, le mot-clé endRecording termine la session de
création de scénario :
-- Syntaxe Lingo
on animBalle(nombreDimages)
_movie.beginRecording()
horizontal = 0
vertical = 100
repeat with i = 1 to nombreDimages
_movie.go(i)
sprite(20).member = member("Balle")
sprite(20).locH = horizontal
sprite(20).locV = vertical
sprite(20).forecolor = 255
horizontal = horizontal + 3
vertical = vertical + 2
_movie.updateFrame()
end repeat
_movie.endRecording()
end animBalle
327
// Syntaxe JavaScript
function animBalle(nombreDimages) {
_movie.beginRecording();
var horizontal = 0;
var vertical = 100;
for (var i = 1; i <= nombreDimages; i++) {
_movie.go(1);
sprite(20).member = member("Balle");
sprite(20).locH = horizontal;
sprite(20).locV = vertical;
sprite(20).foreColor = 255;
horizontal = horizontal + 3;
vertical = vertical + 2;
_movie.updateFrame();
}
_movie.endRecording();
}
Voir aussi
beginRecording(), Animation, updateFrame()
erase()
Utilisation
-- Syntaxe Lingo
réfObjActeur.erase()
// Syntaxe JavaScript
réfObjActeur.erase();
Description
Méthode d’acteur ; supprime l’acteur spécifié et laisse son emplacement vide dans la fenêtre
Distribution.
Pour de meilleurs résultats, utilisez cette méthode pendant la programmation, et non dans les
projections, ce qui pourrait provoquer des problèmes de mémoire.
Paramètres
Aucun.
Exemple
L’instruction suivante supprime l’acteur Engrenage de la distribution Matériel :
-- Syntaxe Lingo
member("Engrenage", "Matériel").erase()
// Syntaxe JavaScript
member("Engrenage", "Matériel").erase();
328
Chapitre 12 : Méthodes
Le gestionnaire suivant supprime les acteurs du début à la fin :
-- Syntaxe Lingo
on effacerLesActeurs début, fin
repeat with i = début to fin
member(i).erase()
end repeat
end effacerLesActeurs
// Syntaxe JavaScript
function effacerLesActeurs(début, fin) {
for (var i=début; i<=fin; i++) {
member(i).erase();
}
}
Voir aussi
Acteur, new()
error()
Utilisation
-- Syntaxe Lingo
réfObjFileio.error(entErreur)
// Syntaxe JavaScript
réfObjFileio.error(entErreur);
Description
Méthode de Fileio ; renvoie un message d’erreur spécifié.
Paramètres
Requis. Nombre entier qui spécifie l’erreur. Les valeurs correctes incluent 0 ("OK") et
1 ("Memory allocation failure"). Toutes les autres valeurs renvoient "Unknown error".
entErreur
Voir aussi
Fileio
externalEvent()
Utilisation
externalEvent "chaîne"
Description
Commande ; envoie une chaîne au navigateur web pour qu’il l’interprète comme une instruction
de script, permettant la lecture d’une animation ou la communication avec la page HTML dans
laquelle elle est intégrée.
Cette commande fonctionne uniquement pour les animations dans des navigateurs.
Remarque : La commande externalEvent ne produit pas de valeur de renvoi. Il n’existe aucune
façon immédiate permettant de déterminer si le navigateur a traité l’événement ou l’a ignoré. Utilisez
on EvalScript dans le navigateur pour renvoyer un message à l’animation.
329
Paramètres
chaîne Requis. Chaîne à envoyer au navigateur. La chaîne doit être dans un langage de programmation pris en charge par le navigateur.
Exemple
Les instructions suivantes utilisent externalEvent dans l’environnement script LiveConnect,
supporté par Netscape 3.x et les versions plus récentes.
LiveConnect évalue la chaîne passée par externalEvent comme un appel de fonction. Les
auteurs utilisant JavaScript doivent définir et nommer cette fonction dans l’en-tête HTML.
Dans l’animation, le nom et les paramètres de la fonction sont définis comme une chaîne dans
externalEvent. Les paramètres devant être interprétés par le navigateur web comme des chaînes
distinctes, chaque paramètre est encadré de guillemets droits simples.
Instructions dans le code HTML :
function maFonction(param1, param2) {
//script placé ici
}
Instructions dans un script dans l’animation :
externalEvent ("maFonction ('param1','param2')")
Les instructions suivantes utilisent externalEvent dans l’environnement script ActiveX utilisé
par Internet Explorer sous Windows. ActiveX interprète externalEvent comme un événement
et traite cet événement et son paramètre de chaîne de la même façon qu’un événement onClick
dans un objet bouton.
• Instructions dans le code HTML :
Dans l’en-tête HTML, définissez une fonction repérant l’événement (l’exemple suivant est en
VBScript) :
Sub
nomDeLinstanceShockwave_externalEvent(unParamètre)
'script placé ici
End Sub
Vous pouvez également définir un script pour l’événement :
<SCRIPT FOR="nomDeLinstanceShockwave"
EVENT="externalEvent(unParamètre)"
LANGUAGE="VBScript">
'script placé ici
</SCRIPT>
Dans l’animation, incluez la fonction et les paramètres dans la chaîne externalEvent :
externalEvent ("maFonction ('param1','param2')")
Voir aussi
on EvalScript
330
Chapitre 12 : Méthodes
extrude3D
Utilisation
member(quelActeurTexte).extrude3D(member(quelActeur3D))
Description
Commande 3D ; crée une ressource de modèle #extruder dans un acteur 3D à partir du texte
d’un acteur texte.
Cela n’équivaut pas à utiliser la propriété 3D displayMode d’un acteur texte.
Pour créer un modèle avec extrude3D :
1 Créez une ressource de modèle #extruder dans un acteur 3D :
ressourceTexte = member("acteurTexte").extrude3D(member\
("acteur3D"))
2 Créez un modèle à l’aide de la ressource de modèle créée à l’étape 1 :
member("acteur3D").newModel("monTexte", ressourceTexte)
Paramètres
quelActeur3D
Requis. Acteur dans lequel une nouvelle ressource de modèle #extruder est créée.
Exemple
Dans l’exemple suivant, Logo est un acteur texte et Scène est un acteur 3D. La première ligne crée
une ressource de modèle dans Scène, qui est une version 3D du texte de Logo. La seconde ligne
utilise cette ressource de modèle pour créer un modèle nommé logo3D.
maRessourceDeModèleTexte = member("Logo").extrude3d(member("Scène"))
member("Scène").newModel("Logo3D", maRessourceDeModèleTexte)
Voir aussi
bevelDepth, bevelType, displayFace, smoothness, tunnelDepth, displayMode
externalParamName()
Utilisation
-- Syntaxe Lingo
_player.externalParamName(nomOuNumDeParam)
// Syntaxe JavaScript
_player.externalParamName(nomOuNumDeParam);
Description
Méthode de lecteur ; renvoie le nom d’un paramètre spécifié dans la liste de paramètres externes
d’une balise HTML <EMBED> ou <OBJECT>.
Si vous spécifiez un paramètre par son nom, cette méthode renvoie tous les noms de paramètres
qui correspondent à nomOuNumDeParam. La correspondance ne fait pas la distinction entre les
majuscules et les minuscules. Si aucun paramètre correspondant n’est trouvé, cette méthode
renvoie VOID (Lingo) ou null (syntaxe JavaScript).
331
Si vous spécifiez un paramètre par son numéro, cette méthode renvoie le nom de paramètre situé
à la position nomOuNumDeParam dans la liste des paramètres. Si aucun paramètre correspondant
n’est trouvé, cette méthode renvoie VOID ou null.
Cette méthode est valide uniquement pour les animations avec un contenu Shockwave exécutées
dans un navigateur. Elle ne peut pas être utilisée avec des animations Director ou des projections.
La liste suivante décrit les paramètres externes prédéfinis qui peuvent être utilisés.
332
Paramètre
Définition
swAudio
Chaîne qui spécifie l’emplacement d’un fichier audio Shockwave à lire avec
l’animation. Cette valeur est une URL complète.
swBackColor
Valeur de couleur destinée à modifier la propriété de couleur associée à la
scène de l'animation. Cette valeur est un nombre entier compris entre 0 et
255. Utilisez la plage 0–255 pour les animations en couleur 8 bits et la
plage 0–15 pour les animations en couleur 4 bits.
swBanner
Chaîne qui spécifie le texte à utiliser en tant que bandeau dans l’animation.
swColor
Valeur de couleur à utiliser pour modifier la couleur d’un objet spécifique.
Cette valeur est un nombre entier compris entre 0 et 255. Utilisez la plage
0–255 pour les animations en couleur 8 bits et la plage 0–15 pour les
animations en couleur 4 bits.
swForeColor
Nouvelle valeur de couleur de premier plan. Le texte écrit dans les acteurs
champ est rendu dans la couleur de premier plan actuellement active.
Cette valeur est un nombre entier compris entre 0 et 255. Utilisez la plage
0–255 pour les animations en couleur 8 bits et la plage 0–15 pour les
animations en couleur 4 bits.
swFrame
Valeur de chaîne correspondant au nom attribué à une image donnée de
l’animation.
swList
Liste d’éléments séparés par des virgules qui peut être analysée avec
un script. Les valeurs de la liste peuvent être des paires clé/valeur, des
éléments booléens, des nombres entiers ou des chaînes.
swName
Nom (par exemple, un nom d’utilisateur) à afficher ou utiliser dans
l’animation.
swPassword
Mot de passe, qui doit éventuellement être combiné avec la propriété
swName, à utiliser dans l’animation.
swPreloadTime
Nombre entier qui indique combien de secondes doivent s’écouler entre
le préchargement d’un fichier audio et le début de la lecture du son. Utilisé
avec Shockwave Audio pour améliorer les performances de la lecture en
augmentant la quantité de son déjà téléchargée avant qu’elle ne
commence.
swSound
Chaîne qui peut soit spécifier le nom d’un son à lire dans l’animation
Director soit indiquer si un son doit ou non être lu.
swText
Valeur (chaîne) qui spécifie le texte à utiliser dans l’animation.
swURL
URL (chaîne) qui peut spécifier l’emplacement d’une autre animation avec
un contenu Shockwave ou d’un autre fichier Shockwave Audio.
Chapitre 12 : Méthodes
Paramètre
Définition
swVolume
Nombre entier (valeur comprise entre 0 et 10 recommandée) utilisé pour
contrôler le niveau du volume de la sortie audio de l’animation. Une valeur
égale à 0 désactive le son, une valeur égale à 10 correspond au volume
maximum.
sw1 à sw9
Neuf propriétés supplémentaires pour les paramètres définis par l’auteur.
Paramètres
nomOuNumDeParam Requis. Chaîne qui spécifie le nom du paramètre à renvoyer ou nombre entier
qui spécifie sa position d’index.
Exemple
L’instruction suivante place la valeur d’un paramètre externe donné dans la variable maVariable :
-- Syntaxe Lingo
if (_player.externalParamName("swURL") = "URLsw") then
maVariable = _player.externalParamName("URLsw")
end if
// Syntaxe JavaScript
if (_player.externalParamName("URLsw") == "URLsw") {
var maVariable = _player.externalParamName("URLsw");
}
Voir aussi
externalParamValue(), Animation
externalParamValue()
Utilisation
-- Syntaxe Lingo
_player.externalParamValue(nomOuNumDeParam)
// Syntaxe JavaScript
_player.externalParamValue(nomOuNumDeParam);
Description
Renvoie la valeur d’un paramètre spécifié dans la liste de paramètres externes d’une balise HTML
<EMBED> ou <OBJECT>.
Si vous spécifiez un paramètre par son nom, cette méthode renvoie la valeur du premier paramètre dont le nom correspond à nomOuNumDeParam. La correspondance ne fait pas la distinction
entre les majuscules et les minuscules. Si aucun paramètre correspondant n’est trouvé, cette
méthode renvoie VOID (Lingo) ou null (syntaxe JavaScript).
Si vous spécifiez un paramètre par son numéro d’index, cette méthode renvoie le nom de paramètre situé à la position nomOuNumDeParam dans la liste des paramètres. Si aucun paramètre
correspondant n’est trouvé, cette méthode renvoie VOID ou null.
Cette méthode est valide uniquement pour les animations avec un contenu Shockwave exécutées
dans un navigateur. Elle ne peut pas être utilisée avec des animations Director ou des projections.
333
La liste suivante décrit les paramètres externes prédéfinis qui peuvent être utilisés.
334
Paramètre
Définition
swAudio
Chaîne qui spécifie l’emplacement d’un fichier audio Shockwave à lire avec
l’animation. Cette valeur est une URL complète.
swBackColor
Valeur de couleur destinée à modifier la propriété de couleur associée à la
scène de l'animation. Cette valeur est un nombre entier compris entre 0 et
255. Utilisez la plage 0–255 pour les animations en couleur 8 bits et la
plage 0–15 pour les animations en couleur 4 bits.
swBanner
Chaîne qui spécifie le texte à utiliser en tant que bandeau dans l’animation.
swColor
Valeur de couleur à utiliser pour modifier la couleur d’un objet spécifique.
Cette valeur est un nombre entier compris entre 0 et 255. Utilisez la plage
0–255 pour les animations en couleur 8 bits et la plage 0–15 pour les
animations en couleur 4 bits.
swForeColor
Nouvelle valeur de couleur de premier plan. Le texte écrit dans les acteurs
champ est rendu dans la couleur de premier plan actuellement active.
Cette valeur est un nombre entier compris entre 0 et 255. Utilisez la plage
0–255 pour les animations en couleur 8 bits et la plage 0–15 pour les
animations en couleur 4 bits.
swFrame
Valeur de chaîne correspondant au nom attribué à une image donnée de
l’animation.
swList
Liste d’éléments séparés par des virgules qui peut être analysée avec
un script. Les valeurs de la liste peuvent être des paires clé/valeur, des
éléments booléens, des nombres entiers ou des chaînes.
swName
Nom (par exemple, un nom d’utilisateur) à afficher ou utiliser dans
l’animation.
swPassword
Mot de passe, qui doit éventuellement être combiné avec la propriété
swName, à utiliser dans l’animation.
swPreloadTime
Nombre entier qui indique combien de secondes doivent s’écouler entre le
préchargement d’un fichier audio et le début de la lecture du son. Utilisé
avec Shockwave Audio pour améliorer les performances de la lecture en
augmentant la quantité de son déjà téléchargée avant qu’elle ne
commence.
swSound
Chaîne qui peut soit spécifier le nom d’un son à lire dans l’animation
Director soit indiquer si un son doit ou non être lu.
swText
Valeur (chaîne) qui spécifie le texte à utiliser dans l’animation.
swURL
URL (chaîne) qui peut spécifier l’emplacement d’une autre animation
Shockwave ou d’un autre fichier Shockwave Audio.
swVolume
Nombre entier (valeur comprise entre 0 et 10 recommandée) utilisé pour
contrôler le niveau du volume de la sortie audio de l’animation. Une valeur
égale à 0 désactive le son, une valeur égale à 10 correspond au volume
maximum.
sw1 à sw9
Neuf propriétés supplémentaires pour les paramètres définis par l’auteur.
Chapitre 12 : Méthodes
Paramètres
nomOuNumDeParam Requis. Chaîne qui spécifie le nom de la valeur de paramètre à renvoyer ou
nombre entier qui spécifie sa position d’index.
Exemple
L’instruction suivante place la valeur d’un paramètre externe dans la variable maVariable :
-- Syntaxe Lingo
if (_player.externalParamName("swURL") = "URLsw") then
maVariable = _player.externalParamValue("URLsw")
end if
// Syntaxe JavaScript
if (_player.externalParamName("URLsw") == "URLsw") {
var maVariable = _player.externalParamValue("URLsw");
}
Voir aussi
externalParamName(), Animation
extractAlpha()
Utilisation
objetImage.extractAlpha()
Description
Cette fonction copie la couche alpha de l’image 32 bits donnée et la renvoie sous forme d’un
nouvel objet image. Il en résulte une image 8 bits faite de niveaux de gris, représentant la couche
alpha.
Cette fonction s’avère pratique pour le sous-échantillonnage des images 32 bits avec des couches
alpha.
Exemple
L’instruction suivante place la couche alpha de l’image de l’acteur 1 dans la variable
alphaPrincipal :
alphaPrincipal = member(1).image.extractAlpha()
setAlpha(), useAlpha
fadeIn()
Utilisation
-- Syntaxe Lingo
réfObjPisteAudio.fadeOut({entMillisecondes})
// Syntaxe JavaScript
réfObjPisteAudio.fadeOut({entMillisecondes});
Description
Méthode de piste audio ; définit immédiatement le volume de la piste audio sur zéro pour le
ramener ensuite sur le volume courant en fonction du nombre de millisecondes défini.
Le paramètre de balance courant est conservé pour l’ensemble du fondu.
335
Paramètres
Facultatif. Nombre entier qui spécifie en combien de millisecondes le
volume augmente de nouveau jusqu’à sa valeur d’origine. Si aucune valeur n'est fournie, la
valeur par défaut est 1 000 millisecondes (1 seconde).
entMillisecondes
Exemple
L’instruction Lingo suivante amplifie le son de la piste 3 pendant une durée de 3 secondes à partir
du début de l’acteur intro2 :
-- Syntaxe Lingo
sound(3).play(member("intro2"))
sound(3).fadeIn(3000)
// Syntaxe JavaScript
sound(3).play(member("intro2"));
sound(3).fadeIn(3000);
Voir aussi
fadeOut(), fadeTo(), pan, Piste audio, volume (Windows Media)
fadeOut()
Utilisation
-- Syntaxe Lingo
réfObjPisteAudio.fadeOut({entMillisecondes})
// Syntaxe JavaScript
réfObjPisteAudio.fadeOut({entMillisecondes});
Description
Méthode de piste audio ; diminue progressivement le volume d’une piste audio jusqu’à zéro dans
un délai donné, défini en millisecondes.
Le paramètre de balance courant est conservé pour l’ensemble du fondu.
Paramètres
Facultatif. Nombre entier qui spécifie en combien de millisecondes le
volume est réduit à zéro. Si aucune valeur n'est fournie, la valeur par défaut est 1 000
millisecondes (1 seconde).
entMillisecondes
Exemple
L’instruction suivante diminue le son de la piste 3 sur de période de 5 secondes :
-- Syntaxe Lingo
sound(3).fadeOut(5000)
// Syntaxe JavaScript
sound(3).fadeOut(5000);
Voir aussi
fadeIn(), fadeTo(), pan, Piste audio, volume (Windows Media)
336
Chapitre 12 : Méthodes
fadeTo()
Utilisation
-- Syntaxe Lingo
réfObjPisteAudio.fadeTo(entVolume {, entMillisecondes})
// Syntaxe JavaScript
réfObjPisteAudio.fadeTo(entVolume {, entMillisecondes});
Description
Méthode de piste audio ; modifie progressivement le volume d’une piste audio jusqu’à un volume
spécifié dans un délai donné, défini en millisecondes.
Le paramètre de balance courant est conservé pour l’ensemble du fondu.
Pour un exemple d’utilisation de fadeTo() dans une animation, reportez-vous à l’animation
Sound Control du dossier Learning/Lingo, lui-même inclus dans le dossier de Director.
Paramètres
entVolume Requis. Nombre entier qui spécifie le nouveau niveau de volume souhaité. La plage
de valeurs du paramètre entVolume est comprise entre 0 et 255.
entMillisecondes Facultatif. Nombre entier qui spécifie en combien de millisecondes le niveau
du volume passe à entVolume. Si aucune valeur n'est fournie, la valeur par défaut est 1 000
millisecondes (1 seconde).
Exemple
L’instruction suivante fait passer le volume de la piste audio 4 à 150, sur une période de
2 secondes. Il peut s’agir d’une augmentation ou d’une diminution de volume, en fonction
du volume initial de la piste audio 4 au moment de départ du fondu.
-- Syntaxe Lingo
sound(4).fadeTo(150, 2000)
// Syntaxe JavaScript
sound(4).fadeTo(150, 2000);
Voir aussi
fadeIn(), fadeOut(), pan, Piste audio, volume (Windows Media)
fileName()
Utilisation
-- Syntaxe Lingo
réfObjFileio.fileName()
// Syntaxe JavaScript
réfObjFileio.fileName();
Description
Méthode de Fileio ; renvoie le chemin complet et le nom d’un fichier ouvert.
Vous devez d’abord ouvrir un fichier en appelant openFile() avant d’utiliser fileName() pour
renvoyer le nom du fichier.
337
Paramètres
Aucun.
Voir aussi
Fileio , openFile()
fill()
Utilisation
-- Syntaxe Lingo
réfObjImage.fill(gauche, haut, droite, bas, objetCouleurOuListedeParamètres)
réfObjImage.fill(point(x, y), point(x, y), objetCouleurOuListedeParamètres)
réfObjImage.fill(rect, objetCouleurOuListedeParamètres)
// Syntaxe JavaScript
réfObjImage.fill(gauche, haut, droite, bas, objetCouleurOuListedeParamètres);
réfObjImage.fill(point(x, y), point(x, y), objetCouleurOuListedeParamètres);
réfObjImage.fill(rect, objetCouleurOuListedeParamètres);
Description
Méthode d’image. Remplit une zone rectangulaire avec une couleur spécifiée dans un objet image
donné.
Cette méthode renvoie la valeur 1 si aucune erreur n’est détectée et zéro en cas d’erreur.
Pour optimiser les performances avec des images 8 bits (ou d’une qualité inférieure), l’objet
Couleur doit contenir une valeur de couleur indexée. Pour les images 16 ou 32 bits, utilisez une
valeur de couleur RVB.
Paramètres
gauche Requis si vous remplissez une zone spécifiée par des coordonnées. Nombre entier qui
spécifie le côté gauche de la zone à remplir.
Requis si vous remplissez une zone spécifiée par des coordonnées. Nombre entier qui
spécifie le côté supérieur de la zone à remplir.
haut
droite Requis si vous remplissez une zone spécifiée par des coordonnées. Nombre entier qui
spécifie le côté droit de la zone à remplir.
bas Requis si
vous remplissez une zone spécifiée par des coordonnées. Nombre entier qui spécifie
le côté inférieur de la zone à remplir.
objCouleurOuListeDeParamètres Requis. Objet Couleur ou liste de paramètres qui spécifie la
couleur de remplissage de la zone. Il est possible d’utiliser la liste de paramètres à la place d’un
simple objet Couleur pour spécifier les propriétés suivantes.
338
Propriété
Description
#shapeType
Une valeur de symbole de #oval, #rect, #roundRect ou #line. La valeur par
défaut est #line.
#lineSize
Epaisseur du trait à utiliser pour le dessin de la forme.
#color
Objet Couleur qui détermine la couleur de remplissage de la zone.
#bgColor
Objet Couleur qui détermine la couleur de la bordure de la zone.
Chapitre 12 : Méthodes
Requis si vous remplissez une zone avec des points. Deux points
qui spécifient les angles supérieur gauche et inférieur droit de la zone à remplir, par rapport à
l’angle supérieur gauche de l’objet image donné.
point(x, y), point(x, y)
Requis si vous remplissez une zone avec un rectangle. Rectangle qui spécifie la zone
rectangulaire à remplir.
rect
Exemple
L’instruction suivante rend l’objet image dans la variable monImage complètement noir :
L’instruction suivante dessine un ovale rempli dans l’objet image imageTest. L’ovale a un
remplissage vert et une bordure rouge d’une épaisseur de 5 pixels.
Voir aussi
color(), draw(), image()
findLabel()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.findLabel(quelNomDeLibellé)
// Syntaxe JavaScript
réfObjImageObjet.findLabel(quelNomDeLibellé);
Description
Fonction : cette fonction renvoie le numéro d’image (dans l’animation Flash) associée au nom
demandé.
Un 0 est renvoyé si le nom n’existe pas ou si cette portion de l’animation Flash n’a pas encore été
transférée en mémoire.
Paramètres
quelNomDeLibellé
Requis. Spécifie le libellé de l’image à rechercher.
findEmpty()
Utilisation
-- Syntaxe Lingo
réfObjDistribution.findEmpty({réfObjActeur})
// Syntaxe JavaScript
réfObjDistribution.findEmpty({réfObjActeur});
Description
Méthode de distribution ; affiche la prochaine position d’acteur vide ou la position après un
acteur spécifié.
Cette méthode est disponible uniquement sur la distribution courante.
Paramètres
réfObjActeur Facultatif. Référence à l’acteur après lequel la prochaine position d’acteur vide est
affichée. Si ce paramètre est omis, la prochaine position d’acteur vide est affichée.
339
Exemple
L’instruction suivante recherche le premier acteur vide à partir de l’acteur 100 :
-- Syntaxe Lingo
trace(castLib(1).findEmpty(member(100)))
// Syntaxe JavaScript
trace(castLib(1).findEmpty(member(100)));
Voir aussi
Bibliothèque de distribution, Acteur
findPos
Utilisation
liste.findPos(propriété)
findPos(liste, propriété)
Description
Commande de liste ; identifie la position d’une propriété dans une liste de propriétés.
L’utilisation de findPos avec des listes linéaires renvoie un nombre fictif si la valeur de
propriété est un nombre et une erreur de script si la valeur de propriété est une chaîne.
La commande findPos a la même fonction que la commande findPosNear, excepté que
a la valeur VOID lorsque la propriété spécifiée ne figure pas dans la liste.
findPos
Paramètres
propriété
Requis. Propriété dont la position est identifiée.
Exemple
L’instruction suivante identifie la position de la propriété c dans la liste Réponses, composée de
[#a:10, #b:12, #c:15, #d:22] :
Réponses.findPos(#c)
Le résultat est 3, c étant la troisième propriété de la liste.
Voir aussi
findPosNear, sort
findPosNear
Utilisation
listeTriée.findPosNear(valeurOuPropriété)
findPosNear(listeTriée, valeurOuPropriété)
Description
Commande de liste ; pour les listes triées uniquement, identifie la position d’un élément dans une
liste triée spécifiée.
La commande findPosNear fonctionne uniquement avec les listes triées. Remplacez
valeurOuPropriété par une valeur pour les listes linéaires triées et par une propriété pour les
listes de propriétés triées.
340
Chapitre 12 : Méthodes
La commande findPosNear est semblable à la commande findPos excepté que, lorsque la
propriété spécifiée n’est pas dans la liste, la commande findPosNear identifie la position de la
valeur ayant le nom alphanumérique le plus similaire. Cette commande est pratique pour trouver
le nom le plus proche dans un répertoire de noms triés.
Paramètres
valeurOuPropriété
Requis. Valeur ou propriété dont la position est identifiée.
Exemple
L’instruction suivante identifie la position d’une propriété dans la liste triée Réponses, composée
de [#Nil:2, #Pharaon:4, #Raja:0] :
Réponses.findPosNear(#Ni)
Le résultat est 1, Ni étant le plus proche de Nil, la première propriété de la liste.
Voir aussi
findPos
finishIdleLoad()
Utilisation
-- Syntaxe Lingo
_movie.finishIdleLoad(entBaliseDeChargement)
// Syntaxe JavaScript
_movie.finishIdleLoad(entBaliseDeChargement);
Description
Méthode d’animation ; force le chargement de tous les acteurs possédant la balise de chargement
spécifiée.
Paramètres
entBaliseDeChargement
Requis. Nombre entier qui spécifie la balise de chargement des acteurs
à charger.
Exemple
L’instruction suivante termine le chargement de tous les acteurs possédant la balise de chargement
20 :
-- Syntaxe Lingo
_movie.finishIdleLoad(20)
// Syntaxe JavaScript
_movie.finishIdleLoad(20);
Voir aussi
idleHandlerPeriod, idleLoadDone(), idleLoadMode, idleLoadPeriod, idleLoadTag,
idleReadChunkSize, Animation
341
flashToStage()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.flashToStage(pointDeLanimationFlash)
// Syntaxe JavaScript
réfObjImageObjet.flashToStage(pointDeLanimationFlash);
Description
Fonction ; renvoie la coordonnée de la scène Director correspondant à une coordonnée spécifiée
dans une image-objet d’animation Flash. Cette fonction accepte la coordonnée de piste et
d’animation Flash et renvoie la coordonnée de scène Director en valeurs de points Director :
par exemple, point (300,300).
Les coordonnées d’animation Flash sont mesurées en pixels d’animation Flash, qui sont
déterminés par la taille d’origine d’une animation lors de sa création dans Flash. Afin de calculer
les coordonnées de l’animation Flash, le point (0,0) d’une animation Flash est toujours son angle
supérieur gauche. La propriété originPoint de l’acteur est utilisée uniquement pour la rotation
et la mise à l’échelle, mais pas pour le calcul des coordonnées d’une animation.
La fonction flashToStage et la fonction stageToFlash correspondante sont pratiques pour
déterminer la coordonnée d’une animation Flash se trouvant à une coordonnée spécifique de la
scène Director. Pour Flash et Director, le point (0,0) est le coin supérieur gauche de la scène Flash
ou Director. Ces coordonnées peuvent ne pas coïncider sur la scène Director si une image-objet
Flash est étirée, mise à l’échelle ou a pivoté.
Paramètres
pointDeLanimationFlash Requis. Point dans l’image-objet de l’animation Flash dont les
coordonnées sont renvoyées.
Exemple
Le gestionnaire suivant accepte une valeur de point et une référence d’image-objet comme
paramètre, puis définit la coordonnée supérieure gauche de l’image-objet spécifiée en fonction
du point indiqué dans une image-objet d’animation Flash de la piste 10 :
-- Syntaxe Lingo
on déplacImObj(quelPointFlash, quelleImageObjet)
sprite(quelleImageObjet).loc = sprite(1).FlashToStage(quelPointFlash)
_movie.updatestage()
end
// Syntaxe JavaScript
function déplacImObj(quelPointFlash, quelleImageObjet) {
sprite(quelleImageObjet).loc = sprite(1).FlashToStage(quelPointFlash);
_movie.updateStage();
}
Voir aussi
stageToFlash()
342
Chapitre 12 : Méthodes
float()
Utilisation
(expression).float
float (expression)
Description
Fonction (Lingo uniquement) ; convertit une expression en un nombre à virgule flottante. Le
nombre de chiffres après la virgule (pour l’affichage uniquement, les calculs n’étant pas affectés)
est défini à l’aide de la propriété floatPrecision.
Dans la syntaxe JavaScript, utilisez la fonction parseFloat().
Paramètres
expression
Requis. Expression à convertir en nombre à virgule flottante.
Exemple
L’instruction suivante convertit le nombre entier 1 en 1 à virgule flottante :
put (1).float
-- 1.0
Les opérations mathématiques peuvent être réalisées avec float. Si l’un des termes a une valeur
float, toute l’opération est réalisée avec float :
"the floatPrecision = 1
put 2 +2
-- 4
put (2).float + 2
-- 4.0
the floatPrecision = 4
put 22 / 7
-- 3
put (22).float / 7
-- 3.1429"
Voir aussi
floatPrecision, ilk()
floatP()
Utilisation
(expression).floatP
floatP(expression)
Description
Fonction (Lingo uniquement) ; indique si une expression est un nombre à virgule flottante (1 ou
TRUE) ou non (0 ou FALSE).
Le P dans floatP signifie prédicat.
Paramètres
expression
Requis. Expression à tester.
343
Exemple
L’instruction suivante vérifie si 3.0 est un nombre à virgule flottante. La fenêtre Messages affiche
le nombre 1, indiquant que c’est le cas (TRUE).
put (3.0).floatP
-- 1
L’instruction suivante vérifie si 3 est un nombre à virgule flottante. La fenêtre Messages affiche le
nombre 0, indiquant que ce n’est pas le cas (FALSE).
put (3).floatP
-- 0
Voir aussi
float(), ilk(), integerP(), objectP(), stringP(), symbolP()
flushInputEvents()
Utilisation
-- Syntaxe Lingo
_player.flushInputEvents()
// Syntaxe JavaScript
_player.flushInputEvents();
Description
Méthode de lecteur ; purge les événements clavier ou souris de la file d’attente des messages de
Director.
En règle générale, cette commande est pratique lorsque le script exécute une boucle assez longue
et que vous souhaitez vous assurer que les commandes effectuées au clavier ou à l’aide de la souris
ne seront pas transmises.
Cette méthode n’est effective qu’en cours d’exécution et n’a aucun effet pendant la programmation.
Paramètres
Aucun.
Exemple
L’instruction suivante désactive les événements souris et clavier lors de l’exécution d’une boucle
de répétition :
-- Syntaxe Lingo
repeat with i = 1 to 10000
_player.flushInputEvents()
sprite(1).loc = sprite(1).loc + point(1, 1)
end repeat
344
Chapitre 12 : Méthodes
// Syntaxe JavaScript
for (var i = 1; i <= 10000; i++) {
_player.flushInputEvents();
sprite(1).loc = sprite(1).loc + point(1, 1);
}
Voir aussi
on keyDown, on keyUp, on mouseDown (gestionnaire d’événement), on mouseUp
(gestionnaire d’événement), Lecteur
forget() (fenêtre)
Utilisation
-- Syntaxe Lingo
réfObjFenêtre.forget()
// Syntaxe JavaScript
réfObjFenêtre.forget();
Description
Méthode de fenêtre ; ordonne au script de fermer la fenêtre et d’arrêter sa lecture lorsqu’elle n’est
plus utilisée et qu’aucune autre variable n’y fait référence.
L’appel de la méthode forget() sur une fenêtre supprime également la référence à cette fenêtre
de la liste windowList.
Lorsque la méthode forget window est appelée, la fenêtre et l’animation dans une fenêtre
(MIAW) disparaissent sans appeler les gestionnaires stopMovie, closeWindow ou
deactivateWindow.
S’il existe plusieurs références globales à l’animation dans une fenêtre, la fenêtre ne répond pas à la
méthode forget().
Paramètres
Aucun.
Exemple
L’instruction suivante ordonne à Lingo de supprimer la fenêtre Tableau de commande lorsque
l’animation ne l’utilise plus :
-- Syntaxe Lingo
window("Tableau de commande").forget()
// Syntaxe JavaScript
window("Tableau de commande").forget();
Voir aussi
close(), open() (fenêtre), Fenêtre, windowList
345
forget() (temporisation)
Utilisation
timeout("nomDeTemporisation").forget()
forget(timeout("nomDeTemporisation"))
Description
Cette fonction d’objet de temporisation supprime un objet de temporisation de la liste
timeoutList et l’empêche d’envoyer d’autres événements de temporisation.
Paramètres
Aucun.
Exemple
L’instruction suivante supprime l’objet de temporisation Réveil de la liste timeoutList :
timeout("Réveil").forget()
Voir aussi
timeout(), timeoutHandler, timeoutList, new()
framesToHMS()
Utilisation
framesToHMS(images, cadence, compensé, fractions)
Description
Fonction ; convertit le nombre d’images spécifié en durée équivalente en heures, minutes et
secondes. Cette fonction est pratique pour prévoir la durée de lecture réelle d’une animation
ou pour contrôler un appareil de lecture vidéo.
Le résultat est une chaîne sous la forme sHH:MM:SS.FFD, où :
s
Un caractère est utilisé si le temps est inférieur à zéro ou un espace si le temps est
supérieur ou égal à zéro.
HH
Heures.
MM
Minutes.
SS
Secondes.
FF
Indique une fraction de seconde si fractions a la valeur TRUE ou des images si fractions a
la valeur FALSE.
D
Un "d" est utilisé si compensé a la valeur TRUE ou un espace si compensé a la valeur FALSE.
Paramètres
images
Requis. Expression entière qui spécifie le nombre d’images.
cadence
Requis. Expression entière qui spécifie la cadence en nombre d’images par seconde.
Requis. Compense la cadence d'image NTSC couleur, qui n’est pas exactement de 30
images par seconde, et n’est utile que si la cadence est définie sur 30 images par seconde.
Normalement, ce paramètre a pour valeur FALSE.
compensé
346
Chapitre 12 : Méthodes
Requis. Détermine si les images résiduelles sont converties au centième de seconde le
plus proche (TRUE) ou renvoyées sous la forme d’un nombre entier d’images (FALSE).
fractions
Exemple
L’instruction suivante convertit une animation de 2710 images, 30 images par seconde. Les
arguments compensé et fractions sont tous les deux désactivés :
put framesToHMS(2710, 30, FALSE, FALSE)
-- " 00:01:30.10 "
Voir aussi
HMStoFrames()
frameReady() (animation)
Utilisation
-- Syntaxe Lingo
_movie.frameReady({entNumDimage})
_movie.frameReady(numDimageA, numDimageB)
// Syntaxe JavaScript
_movie.frameReady({entNumDimage});
_movie.frameReady(numDimageA, numDimageB);
Description
Méthode d’animation ; pour les animations Director, les projections et les animations avec
un contenu Shockwave, détermine si les acteurs d’une image ou d’une plage d’images ont été
téléchargés.
Cette méthode renvoie TRUE si les acteurs spécifiés ont été téléchargés et FALSE dans le cas
contraire.
Pour un exemple d’utilisation de la méthode frameReady() dans une animation Director,
consultez l’animation « Shockwave et flux continu » dans l’Aide de Director.
Paramètres
entNumDimage Facultatif si le test porte sur le téléchargement des acteurs d’une image unique.
Nombre entier qui spécifie l’image à tester. Si ce paramètres est omis, frameReady() détermine
si les acteurs utilisés dans n’importe quelle image du scénario ont été téléchargés.
numDimageA Requis si le test porte sur le téléchargement des acteurs d’une plage d’images.
Nombre entier qui spécifie la première image de la plage.
numDimageB Requis si le test porte sur le téléchargement des acteurs d’une plage d’images.
Nombre entier qui spécifie la dernière image de la plage.
347
Exemple
L’instruction suivante détermine si les acteurs de l’image 20 sont téléchargés et prêts à être
affichés :
-- Syntaxe Lingo
on exitFrame
if (_movie.frameReady(20)) then
_movie.go(20)
else
_movie.go(1)
end if
end
// Syntaxe JavaScript
function exitFrame() {
if (_movie.frameReady(20)) {
_movie.go(20);
}
else {
_movie.go(1);
}
}
Le script d’image suivant vérifie si l’image 25 d’une image-objet animation Flash dans la piste 5
peut être affichée. Dans le cas contraire, le script maintient la tête de lecture en boucle sur l’image
courante de l’animation Director. Lorsque l’image 25 peut être affichée, le script démarre
l’animation et laisse la tête de lecture passer à l’image suivante de l’animation Director.
Voir aussi
mediaReady, Animation
frameStep()
Utilisation
-- Syntaxe Lingo
réfObjDvd.frameStep(entImages)
// Syntaxe JavaScript
réfObjDvd.frameStep(entImages);
Description
Méthode de DVD ; avance d’un nombre d’images spécifié à partir de la position courante.
Paramètres
entImages
348
Requis. Nombre entier qui indique de combien d’images vous voulez avancer.
Chapitre 12 : Méthodes
Exemple
Cette instruction fait avancer de 100 images :
-- Syntaxe Lingo
member("drame").frameStep(100)
// Syntaxe JavaScript
member("drame").frameStep(100);
Voir aussi
DVD
freeBlock()
Utilisation
the freeBlock
Description
Fonction ; indique la taille du plus grand bloc de mémoire disponible, en octets. Un kilo-octet
(ko) correspond à 1 024 octets. Un méga-octet (Mo) correspond à 1 024 kilo-octets. Le chargement d’un acteur nécessite un bloc libre au moins aussi grand que l’acteur.
Paramètres
Aucun.
Exemple
L’instruction suivante détermine si le plus grand bloc de mémoire disponible est inférieur à 10 ko
et affiche un message d’alerte si c’est le cas :
-- Syntaxe Lingo
if (the freeBlock < (10 * 1024)) then alert "Mémoire insuffisante !"
// Syntaxe JavaScript
if (freeBlock < (10 * 1024)) {
alert("Mémoire insuffisante !")
}
Voir aussi
freeBytes(), memorySize, ramNeeded(), size
freeBytes()
Utilisation
the freeBytes
Description
Fonction ; indique le nombre total d’octets de mémoire disponible, qui ne forme pas forcément
un bloc continu. Un kilo-octet (ko) correspond à 1 024 octets. Un méga-octet (Mo) correspond à
1 024 kilo-octets.
Cette fonction est différente de freeBlock, puisqu’elle indique toute la mémoire disponible et
pas seulement la mémoire contiguë.
349
Sur Macintosh, la sélection de l’option Utiliser la mémoire temporaire du système dans les
préférences générales de Director ou dans la boîte de dialogue Options d’une projection indique à
la fonction freeBytes de renvoyer toute la mémoire disponible pour l’application. Cette
quantité est égale à la quantité affectée à l’application, affichée dans sa boîte de dialogue Lire les
informations, et à la valeur Mémoire disponible affichée dans la boîte de dialogue A propos de
votre Macintosh.
Paramètres
Aucun.
Exemple
L’instruction suivante vérifie si plus de 200 ko de mémoire son disponibles et lit une animation
couleur si c’est le cas :
if (the freeBytes > (200 * 1024)) then play movie "animationCouleur"
Voir aussi
freeBlock(), memorySize, objectP(), ramNeeded(), size
generateNormals()
Utilisation
member(quelActeur).modelResource(quelleRessDeMod).
generateNormals(style)
Description
Commande 3D de ressource de modèle #mesh ; calcule les vecteurs normal pour chaque sommet
de la maille.
Si le paramètre style a pour valeur #flat, chaque sommet reçoit une normale pour chaque face
à laquelle il appartient. Les trois sommets d’une face partagent la même normale. Par exemple,
si les sommets de face[1] reçoivent tous normal[1] et les sommets de face[2] reçoivent tous
normal[2], et que les deux faces partagent vertex[8], la normale de vertex[8] est normal[1]
pour face[1] et normal[2] pour face[2]. L’utilisation du paramètre #flat résulte en une
délimitation très claire des faces d’une maille.
Si le paramètre style a pour valeur #smooth, chaque sommet ne reçoit qu’une seule normale,
quel que soit le nombre de faces auquel il appartient, les trois sommets d’une face pouvant avoir
différente normales. Chaque normale de sommet est la moyenne des normales de toutes les faces
le partageant. L’utilisation du paramètre #smooth résulte en une apparence plus adoucie des faces
d’une maille, à l’exception des bords extérieurs, qui restent nets.
Une normale de sommet est le vecteur de direction indiquant la direction « vers l’avant » d’un
sommet. Si la normale de sommet pointe vers la caméra, les couleurs affichées dans la région de la
maille contrôlée par cette normale sont déterminées par le matériau. Si la normale de sommet
pointe en direction opposée à la caméra, la région de la maille contrôlée par cette normale ne sera
pas visible.
Si vous utilisez la commande generateNormals(), vous devrez utiliser la commande build()
pour reconstruire la maille.
Paramètres
style
350
Requis. Symbole qui spécifie le style du sommet.
Chapitre 12 : Méthodes
Exemple
L’instruction suivante calcule les normales de sommet de la ressource de modèle mailleDeSol.
Le paramètre style a pour valeur #smooth, tel que chaque sommet de la maille ne reçoive qu’une
seule normale.
member("Pièce").modelResource("mailleDeSol").generateNormals(#smooth)
Voir aussi
build(), face[ ], normalList, normals, flat
getaProp
Utilisation
listeDePropriétés.nomDePropriété
getaProp(liste, élément)
liste[positionDansLaListe]
listeDePropriétés [ #nomDePropriété ]
listeDePropriétés [ "nomDePropriété" ]
Description
Commande de liste ; pour les listes linéaires et de propriétés, identifie la valeur associée à
l’élément spécifié par élément, positionDansLaListe ou nomDePropriété dans la liste
spécifiée par liste.
• Lorsque la liste est linéaire, remplacez élément par le numéro correspondant à la position de
•
l’élément dans cette liste, indiquée par positionDansLaListe. Le résultat est la valeur située à
cette position.
Lorsque la liste est une liste de propriétés, remplacez élément par une propriété de la liste
comme dans nomDePropriété. Le résultat est la valeur associée à cette propriété.
La commande getaProp renvoie VOID si la valeur spécifiée n’est pas dans la liste.
Lorsque utilisée avec des listes linéaires, la commande getaProp a la même fonction que la
commande getAt.
Paramètres
nomOuNumDélément Requis. Pour les listes linéaires, nombre entier qui spécifie la position d’index
de la valeur dans la liste à renvoyer ; pour les listes de propriétés, symbole (Lingo) ou chaîne
(syntaxe JavaScript) qui spécifie la propriété dont la valeur est renvoyée.
Exemple
L’instruction suivante identifie la valeur associée à la propriété #pierre dans la liste de propriétés
âges, composée de [#jean:10, #pierre:12, #sophie:15, #barbara:22] :
put getaProp(âges, #pierre)
Le résultat est 12, car il s’agit de la valeur associée à la propriété #pierre.
Le même résultat peut être obtenu avec des crochets d’accès dans la même liste :
put âges[#jean]
Le résultat est à nouveau 12.
351
Pour obtenir la valeur située à une certaine position dans la liste, vous pouvez également utiliser
des crochets d’accès. Pour obtenir la troisième valeur de la liste associée à la troisième propriété,
utilisez la syntaxe suivante :
put âges[3]
-- 15
Remarque : Contrairement à la commande getAProp dans laquelle la valeur VOID est renvoyée
lorsqu’une propriété n’existe pas, une erreur de script a lieu si la propriété n’existe pas et que des
crochets d’accès sont utilisés.
Voir aussi
getAt, getOne(), getProp(), setaProp, setAt
getAt
Utilisation
getAt(liste, position)
liste [position]
Description
Commande de liste ; identifie l’élément situé à une position donnée dans une liste spécifiée. Si la
liste contient moins d’éléments que la position spécifiée, une erreur de script a lieu.
La commande getAt fonctionne avec les listes linéaires et de propriétés. Elle a la même fonction
que la commande getaProp pour les listes linéaires.
Elle est pratique pour extraire une liste d’une autre liste, comme deskTopRectList.
Paramètres
liste
Requis. Spécifie la liste dans laquelle l’élément existe.
position
Requis. Spécifie la position d’index de l’élément dans la liste.
Exemple
L’instruction suivante entraîne l’affichage dans la fenêtre Messages du troisième élément de la liste
Réponses, composée de [10, 12, 15, 22] :
put getAt(Réponses, 3)
-- 15
Le même résultat peut être renvoyé à l’aide de crochets d’accès :
put Réponses[3]
-- 15
352
Chapitre 12 : Méthodes
L’exemple suivant extrait la première entrée d’une liste de deux entrées indiquant les noms,
services et numéros d’identification des employés. Le second élément de la liste extraite est ensuite
renvoyé, identifiant le service dans lequel la première personne de la liste est employée. Le format
de la liste est [["Denis", "Conseil", 510], ["Sophie", "Distribution", 973]] et la liste est appelée
listeDinfosDesEmployés.
premièrePersonne = getAt(listeDinfosDesEmployés, 1)
put premièrePersonne
-- ["Denis", "Conseil", 510]
serviceDeLaPremièrePersonne = getAt(premièrePersonne, 2)
put serviceDeLaPremièrePersonne
-- "Conseil"
Il est également possible d’imbriquer des commandes getAt sans affecter de valeurs aux variables
dans les étapes intermédiaires. Ce format peut être plus difficile à lire et rédiger, mais contient
moins de texte.
serviceDeLaPremièrePersonne = getAt(getAt(listeDinfosDesEmployés, 1), 2)
put serviceDeLaPremièrePersonne
-- "Conseil"
Vous pouvez également utiliser les crochets d’accès :
premièrePersonne = listeDinfosDesEmployés[1]
put premièrePersonne
-- ["Denis", "Conseil", 510]
serviceDeLaPremièrePersonne = premièrePersonne[2]
put serviceDeLaPremièrePersonne
-- "Conseil"
De même qu’avec getAt, les crochets peuvent être imbriqués :
serviceDeLaPremièrePersonne = listeDinfosDesEmployés[1][2]
Voir aussi
getaProp, setaProp, setAt
getError() (Flash, SWA)
Utilisation
-- Syntaxe Lingo
réfObjActeur.getError()
// Syntaxe JavaScript
réfObjActeur.getError();
Description
Fonction ; pour les acteurs Shockwave Audio (SWA) ou Flash, indique si une erreur est survenue
pendant le transfert de l’acteur en mémoire et renvoie une valeur.
Les acteurs Shockwave Audio ont les valeurs entières getError() suivantes possibles et les
messages getErrorString() correspondants :
valeur getError()
message getErrorString()
0
OK
1
memory
353
valeur getError()
message getErrorString()
2
network
3
playback device
99
other
Les valeurs getError possibles des acteurs animation Flash sont les suivantes :
•
•
•
•
•
•
– Aucune erreur n’est survenue.
#memory – La mémoire est insuffisante pour le chargement de l’acteur.
#fileNotFound – Le fichier contenant les éléments de l’acteur est introuvable.
#network – Une erreur réseau a empêché le chargement de l’acteur.
#fileFormat – Le fichier a été trouvé, mais semble être d’un type incorrect ou une erreur est
survenue à la lecture.
#other – Une autre erreur est survenue.
FALSE
Lorsqu’une erreur survient pendant le transfert de l’acteur en mémoire, Director affecte la valeur
–1 à la propriété d’état de l’acteur. Utilisez la fonction getError pour déterminer le type d’erreur.
Paramètres
Aucun.
Exemple
Le gestionnaire suivant utilise getError pour déterminer si une erreur impliquant l’acteur
Shockwave Audio Norma Desmond parle est survenue et, le cas échéant, affiche la chaîne d’erreur
appropriée dans un champ :
-- Syntaxe Lingo
on exitFrame
if member("Norma Desmond parle").getError() <> 0 then
member("Affichage de l’erreur").text = member("Norma Desmond \
parle").getErrorString()
end if
end
// Syntaxe JavaScript
function exitFrame() {
var memNor = member("Norma Desmond parle").getError();
if (memNor != 0) {
member("Affichage de l’erreur").text =
member("Norma Desmond parle").getErrorString();
}
}
Le gestionnaire suivant vérifie si une erreur est survenue pour un acteur Flash intitulé Dali, lors de
son transfert en mémoire. Si une erreur est survenue et qu’il s’agit d’une erreur de mémoire, le
script utilise la commande unloadCast pour essayer de libérer de la mémoire et fait ensuite passer
la tête de lecture à une image appelée Artistes de l’animation Director, dans laquelle l’image-objet
d’animation Flash apparaît en premier, de façon à ce que Director puisse encore essayer de
charger et lire l’animation Flash. Si un autre type d’erreur est survenu, le script passe à une image
appelée Désolé, qui explique que l’animation Flash requise ne peut pas être lue.
354
Chapitre 12 : Méthodes
-- Syntaxe Lingo
on CheckFlashStatus
testErreur = member("Dali").getError()
if testErreur <> 0 then
if testErreur = #memory then
member("Dali").clearError()
unloadCast()
_movie.go("Artistes")
else
_movie.go("Désolé")
end if
end if
end
// Syntaxe JavaScript
function CheckFlashStatus() {
var testErreur = member("Dali").getError();
if (testErreur != 0) {
if (testErreur = "memory") {
member("Dali").clearError();
unloadCast();
_movie.go("Artistes");
} else {
_movie.go("Désolé");
}
}
}
Voir aussi
clearError(), getErrorString(), state (Flash, SWA)
getError() (XML)
Utilisation
gObjetDanalyse.getError()
Description
Fonction ; renvoie une chaîne d’erreur descriptive associée à un numéro d’erreur (comprenant le
numéro de la ligne et de la colonne de l’emplacement de l’erreur dans le code XML). Cette
fonction renvoie <VOID> lorsqu’il n’existe aucune erreur.
Paramètres
Aucun.
Exemple
Les instructions suivantes vérifient une erreur après l’analyse d’une chaîne contenant des données
XML :
errCode = ObjetDanalyse.parseString(member("texteXML").text)
chaîneDerreur = ObjetDanalyse.getError()
if voidP(chaîneDerreur) then
-- continuer et utiliser le code XML
else
alert "Désolé. Une erreur est survenue " & errorString
-- sortie du gestionnaire
exit
end if
355
getErrorString()
Utilisation
-- Syntaxe Lingo
réfObjActeur.getErrorString()
// Syntaxe JavaScript
réfObjActeur.getErrorString();
Description
Fonction ; pour les acteurs Shockwave Audio (SWA), renvoie la chaîne de message d’erreur
correspondant à la valeur de l’erreur renvoyée par la fonction getError().
Les valeurs entières getError() possibles et les messages getErrorString() correspondants
sont :
valeur getError()
message getErrorString()
0
OK
1
memory
2
network
3
playback device
99
other
Paramètres
Aucun.
Exemple
Le gestionnaire suivant utilise getError() pour déterminer si une erreur est survenue pour
l’acteur Shockwave Audio Norma Desmond parle et, si c’est le cas, utilise getErrorString pour
obtenir le message d’erreur et l’affecter à un acteur champ :
-- Syntaxe Lingo
on exitFrame
if member("Norma Desmond parle").getError() <> 0 then
member("Affichage de l’erreur").text = member("Norma Desmond \
parle").getErrorString()
end if
end
// Syntaxe JavaScript
function exitFrame() {
var memNor = member("Norma Desmond parle").getError();
if (memNor != 0) {
member("Affichage de l’erreur").text =
member("Norma Desmond parle").getErrorString();
}
}
Voir aussi
getError() (Flash, SWA)
356
Chapitre 12 : Méthodes
getFinderInfo()
Utilisation
-- Syntaxe Lingo
réfObjFileio.getFinderInfo()
// Syntaxe JavaScript
réfObjFileio.getFinderInfo();
Description
Méthode de Fileio (Macintosh uniquement) ; renvoie les informations du Finder pour un fichier
ouvert.
Vous devez d’abord ouvrir un fichier en appelant openFile() avant d’utiliser getFinderInfo()
pour renvoyer les informations du Finder relatives au fichier.
Paramètres
Aucun.
Voir aussi
Fileio, openFile()
getFlashProperty()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.getFlashProperty(NomDeCible, symProp)
// Syntaxe JavaScript
réfObjImageObjet.getFlashProperty(NomDeCible, symProp);
Description
Cette fonction permet à Lingo d’invoquer la fonction script d’action Flash getProperty() dans
l’image-objet Flash donnée. Cette fonction script d’action Flash est utilisée pour obtenir la valeur
des propriétés des recadrages ou des niveaux dans une animation Flash. Cette fonction est similaire au test des propriétés d’images-objets dans Director.
Pour obtenir une propriété globale de l’image-objet Flash, passez une ligne vide comme
nomDeCible. Ces propriétés globales Flash peuvent être testées : #focusRect et
#spriteSoundBufferTime.
Consultez la documentation de Flash pour plus d’informations sur ces propriétés.
Paramètres
nomDeCible Requis. Chaîne qui spécifie le nom du clip ou du niveau de l’animation dont vous
souhaitez obtenir la propriété dans l’image-objet Flash donnée.
symProp Requis. Symbole qui spécifie le nom de la propriété à obtenir. Les valeurs correctes sont :
#posX, #posY, #scaleX, #scaleY, #visible, #rotate, #alpha, #name, #width, #height,
#target, #url, #dropTarget, #totalFrames, #currentFrame, #cursor et #lastframeLoaded.
357
Exemple
L’instruction suivante obtient la valeur de la propriété #rotate du clip Etoile dans l’acteur Flash
de l’image-objet 3 :
-- Syntaxe Lingo
sprite(3).setFlashProperty("Etoile", #rotate)
sprite(3).getFlashProperty()
// Syntaxe JavaScript
sprite(3).setFlashProperty("Etoile", symbol("rotate"));
sprite(3).getFlashProperty();
getFrameLabel()
Utilisation
sprite(quelleImageObjetFlash).getFrameLabel(quelNuméroDimageFlash)
getFrameLabel(sprite quelleImageObjetFlash, quelNuméroDimageFlash)
Description
Fonction ; renvoie le libellé d’image d’une animation Flash associé au nom de numéro demandé.
Si le libellé n’existe pas ou si cette portion de l’animation Flash n’a pas encore été transférée en
mémoire, cette fonction renvoie une chaîne vide.
Paramètres
quelNuméroDimageFlash
Requis. Spécifie le numéro d’image associé au libellé d’image.
Exemple
Le gestionnaire suivant vérifie si le repère de l’image 15 de l’animation Flash lue dans l’imageobjet 1 porte le nom « Lions ». Le cas échéant, l’animation Director passe à l’image Lions. Dans le
cas contraire, l’animation Director reste dans l’image courante et la lecture de l’animation Flash se
poursuit.
-- Syntaxe Lingo
on exitFrame
if sprite(1).getFrameLabel(15) = "Lions" then
go "Lions"
else
go the frame
end if
end
// Syntaxe JavaScript
function exitFrame() {
if (sprite(1).getFrameLabel(15) == "Lions") {
_movie.go("Lions");
} else {
_movie.go(_movie.frame);
}
}
358
Chapitre 12 : Méthodes
getHardwareInfo()
Utilisation
getRendererServices().getHardwareInfo()
Description
Méthode 3D rendererServices ; renvoie une liste de propriétés contenant les informations
relatives à la carte vidéo de l’utilisateur. Cette liste contient les propriétés suivantes :
#present
est une valeur booléenne indiquant si l’ordinateur est équipé de matériel d’accélération
vidéo.
#vendor
#model
indique le nom du fabricant de la carte vidéo.
indique le modèle de la carte vidéo.
#version
indique la version du pilote vidéo.
#maxTextureSize est une liste linéaire contenant la largeur et hauteur maximum d’une texture,
en pixels. Les textures dépassant cette taille sont sous-échantillonnées à la taille maximum. Vous
pourrez éviter des erreurs de sous-échantillonnage en créant des textures de tailles variées et en
choisissant celles qui ne dépassent pas la valeur #maxTextureSize à l’exécution.
est une liste linéaire des formats supportés par la carte
vidéo. Pour plus d’informations, consultez textureRenderFormat.
#supportedTextureRenderFormats
#textureUnits
indique le nombre d’unités de texture disponibles pour la carte.
#depthBufferRange
depthBufferDepth.
est une liste linéaire de résolutions binaires associées à la propriété
#colorBufferRange
colorBufferDepth.
est une liste linéaire de résolutions binaires associées à la propriété
Exemple
L’instruction suivante affiche une liste de propriétés détaillée concernant le matériel de
l’utilisateur.
put getRendererServices().getHardwareInfo()
-- [#present: 1, #vendor: "NVIDIA Corporation", #model: \
"32MB DDR NVIDIA GeForce2 GTS (Dell)", #version: "4.12.01.0532", \
#maxTextureSize: [2048, 2048], #supportedTextureRenderFormats: \
[#rgba8888, #rgba8880, #rgba5650, #rgba5551, #rgba5550, \
#rgba4444], #textureUnits: 2, #depthBufferRange: [16, 24], \
#colorBufferRange: [16, 32]]
Voir aussi
getRendererServices()
359
getHotSpotRect()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.getHotSpotRect(idDeZoneRéférencée)
// Syntaxe JavaScript
réfObjImageObjet.getHotSpotRect(idDeZoneRéférencée);
Description
Fonction QuickTime VR ; renvoie un rectangle de délimitation approximative pour une zone
référencée. Si la zone référencée n’existe pas ou n’est pas visible sur la scène, cette fonction renvoie
rect(0, 0, 0, 0). Si la zone référencée est partiellement visible, cette fonction renvoie le rectangle de
délimitation pour la partie visible.
Paramètres
idDeZoneRéférencée
Requis. Spécifie la zone référencée pour laquelle un rectangle de délimita-
tion est renvoyé.
getLast()
Utilisation
liste.getLast()
getLast(liste)
Description
Fonction de liste ; identifie la dernière valeur d’une liste linéaire ou de propriétés spécifiée par
liste.
Paramètres
Aucun.
Exemple
L’instruction suivante identifie le dernier élément (22) de la liste Réponses, composée de [10, 12,
15, 22] :
put Réponses.getLast()
L’instruction suivante identifie le dernier élément (850) de la liste Devis, composée de
[#avatar:750, #dupont:600, #soldes:850] :
put Devis.getLast()
getLatestNetID
Utilisation
getLatestNetID
Description
Cette fonction renvoie un identifiant pour la dernière opération réseau entamée.
L’identificateur renvoyé par getLatestNetID peut être utilisé en tant que paramètre dans les
fonctions netDone, netError et netAbort pour identifier la dernière opération réseau.
360
Chapitre 12 : Méthodes
Remarque : Cette fonction est destinée à la compatibilité en amont. Il est recommandé d’utiliser l’ID
Réseau renvoyé par une fonction réseau de Lingo plutôt que par getLatestNetID. Cependant, si vous
utilisez getLatestNetID, faites-le immédiatement après la commande netLingo.
Paramètres
Aucun.
Exemple
Le script suivant affecte l’identifiant réseau d’une opération getNetText à l’acteur champ
Résultat, de manière à pouvoir récupérer ultérieurement les résultats de cette opération :
on débutDopération
global gIDréseau
getNetText("url")
set gIDréseau = getLatestNetID()
end
on vérifierLopération
global gIDréseau
if netDone(gIDréseau) then
put netTextResult into member "Résultat"
end if
end
Voir aussi
netAbort, netDone(), netError()
getLength()
Utilisation
-- Syntaxe Lingo
réfObjFileio.getLength()
// Syntaxe JavaScript
réfObjFileio.getLength();
Description
Méthode de Fileio ; renvoie la longueur d’un fichier ouvert.
Vous devez d’abord ouvrir un fichier en appelant openFile() avant d’utiliser getLength() pour
renvoyer la longueur du fichier.
Paramètres
Aucun.
Voir aussi
Fileio, openFile()
361
getNetText()
Utilisation
getNetText(URL {, chaîneOSduServeur} {, jeuDeCaractères})
getNetText(URL, listeDePropriétés {, chaîneOSduServeur} {, jeuDeCaractères})
Description
Fonction ; démarre la récupération de texte à partir d’un fichier placé sur un serveur HTTP ou
FTP ou lance une requête CGI.
La première syntaxe présentée entame la récupération du texte. Vous pouvez soumettre des
requêtes CGI HTTP de cette manière et devez les encoder correctement dans l’adresse URL.
La seconde syntaxe comprend une liste de propriétés et soumet une requête CGI, fournissant
le codage URL correct.
Utilisez le paramètre facultatif listeDePropriétés pour utiliser une liste de propriétés pour les
requêtes CGI. La liste de propriétés est encodée dans l’URL et l’URL envoyée est (chaîneURL &
"?" & listedePropriétésCodée).
Utilisez le paramètre facultatif chaîneOSduServeur pour encoder tout caractère renvoyé dans
listeDePropriétés. La valeur est par défaut UNIX mais peut recevoir Win ou Mac comme valeur
et convertit les retours chariot de l’argument listeDePropriétés en ceux utilisés par le serveur.
Pour la plupart des applications, ce paramètre n’est pas nécessaire, les ruptures de ligne n’étant
généralement pas utilisées dans les réponses de formulaires.
Le paramètre facultatif jeuDeCaractères ne s’applique que si l’utilisateur exécute Director sur
un système shift-JIS (Japonais). Les paramètres des jeux de caractères possibles sont JIS, EUC,
ASCII et AUTO. Lingo convertit les données récupérées de shift-JIS dans le jeu de caractères
spécifié. Avec le paramètre AUTO, le jeu de caractères essaie de déterminer le jeu de caractères du
texte récupéré et de le convertir au jeu de caractères de la machine locale. Le paramètre par défaut
est ASCII.
Utilisez netDone pour savoir quand l’opération getNetText est terminée et netError pour
savoir si elle a abouti. Utilisez netTextResult pour renvoyer le texte récupéré par getNetText.
Cette fonction est utilisable avec des URL relatives.
Pour un exemple d’utilisation de getNextText() dans une animation, reportez-vous à
l’animation Form and Post du dossier Learning/Lingo, lui-même inclus dans le dossier de
Director.
Paramètres
URL
Requis. URL du fichier qui contient le texte à récupérer.
listeDePropriétés
Facultatif. Spécifie une liste de propriétés utilisée pour les requêtes CGI.
chaîneOSduServeur Facultatif.
listeDePropriétés.
jeuDeCaractères
362
Spécifie le codage des caractères de retour chariot dans la liste
Facultatif. Spécifie les paramètres des caractères.
Chapitre 12 : Méthodes
Exemple
Le script suivant récupère du texte à partir de l’URL http://grandServeur.fr/exemple.txt et met à
jour l’acteur champ sur lequel la souris se trouve lorsque l’utilisateur clique dessus :
property spriteNum
property IDréseau
on mouseUp me
IDréseau = getNetText ("http://grandServeur.fr/exemple.txt")
end
on exitFrame me
if netDone(IDréseau) then
sprite(spriteNum).member.text = netTextResult(IDréseau)
end if
end
L’exemple suivant récupère les résultats d’une requête CGI :
getNetText("http://www.votreServeur.fr/cgi-bin/requête.cgi?nom=Jean")
Cet exemple est similaire au précédent, mais utilise une liste de propriétés pour soumettre une
requête CGI et effectue automatiquement le codage URL :
getNetText("http://www.votreServeur.fr/cgi-bin/requête.cgi", [#nom:"Jean"])
Voir aussi
netDone(), netError(), netTextResult()
getNormalized
Utilisation
getNormalized(vecteur)
vecteur.getNormalized()
Description
Méthode 3D de vecteur ; copie le vecteur et divise les composants x, y et z de la copie par la
longueur du vecteur d’origine. Le vecteur résultant a une longueur correspondant à une unité de
l’univers.
Cette méthode renvoie la copie et n’affecte pas le vecteur d’origine. Pour normaliser le vecteur
d’origine, utilisez la commande normalize.
Exemple
L’instruction suivante enregistre la valeur normalisée du vecteur monVecteur dans la variable
Norm. Norm a pour valeur vector(-0.1199, 0.9928, 0.0000) et 1 pour magnitude.
monVecteur = vector(-209.9019, 1737.5126, 0.0000)
Norm = monVecteur.getNormalized()
put Norm
-- vector( -0.1199, 0.9928, 0.0000 )
put Norm.magnitude
-- 1.0000
Voir aussi
normalize
363
getNthFileNameInFolder()
Utilisation
getNthFileNameInFolder(cheminDeDossier, numéroDeFichier)
Description
Méthode d’animation ; renvoie un nom de fichier du dossier en fonction du chemin d’accès et du
numéro spécifiés dans ce dossier. Pour être détectées par la fonction getNthFileNameInFolder
les animations Director doivent être définies comme visibles dans la structure des dossiers. Sur
Macintosh, d’autres types de fichiers peuvent être détectés, qu’ils soient visibles ou pas. Si cette
fonction renvoie une chaîne vide, vous avez spécifié un nombre supérieur au nombre de fichiers
dans le dossier.
La fonction getNthFileNameInFolder ne peut pas être utilisée avec des URL.
Pour spécifier d’autres noms de dossiers, utilisez l’opérateur @ pathname ou le chemin d’accès
complet défini dans le format de la plate-forme sur laquelle l’animation est exécutée.
Par exemple :
• Sous Windows, utilisez un chemin tel que C:\Director\Animations.
• Sur Macintosh, utilisez un chemin tel que DisqueDur:Director:Animations. Pour chercher des
•
fichiers se trouvant sur le bureau du Macintosh, utilisez le chemin DisqueDur:Desktop Folder.
Cette fonction n’est pas disponible dans Shockwave Player.
Paramètres
cheminDeDossier
Requis. Spécifie le chemin d’accès du dossier qui contient le fichier.
numéroDeFichier
Requis. Spécifie la position d’index du fichier dans le dossier.
Exemple
Le gestionnaire suivant renvoie une liste de noms de fichiers dans le dossier du chemin courant.
Pour appeler cette fonction, utilisez des parenthèses, comme dans put dossierCourant().
on dossierCourant
listeDeFichiers = [ ]
repeat with i = 1 to 100
n = getNthFileNameInFolder(the moviePath, i)
if n = EMPTY then exit repeat
listeDeFichiers.append(n)
end repeat
return listeDeFichiers
end dossierCourant
Voir aussi
@ (chemin d’accès), Animation
364
Chapitre 12 : Méthodes
getOne()
Utilisation
liste.getOne(valeur)
getOne(liste, valeur)
Description
Fonction de liste ; identifie la position (liste linéaire) ou la propriété (liste de propriétés) associée à
une valeur dans une liste.
Pour les valeurs contenues plus d’une fois dans la liste, seule la première occurrence est affichée.
La commande getOne renvoie le résultat 0 lorsque la valeur spécifiée n’est pas dans la liste.
Lorsque utilisée avec des listes linéaires, la commande getOne réalise les mêmes fonctions que la
commande getPos.
Paramètres
valeur
Requis. Spécifie la valeur associée à la position ou la propriété.
Exemple
L’instruction suivante identifie la position de la valeur 12 dans la liste linéaire Réponses,
composée de [10, 12, 15, 22] :
put Réponses.getOne(12)
Le résultat est 2, 12 étant la seconde valeur de la liste.
L’instruction suivante identifie la propriété associée à la valeur 12 dans la liste de propriétés
Réponses, composée de [#a:10, #b:12, #c:15, #d:22] :
put Réponses.getOne(12)
Le résultat est #b, correspondant à la propriété associée à la valeur 12.
Voir aussi
getPos()
getOSDirectory()
Utilisation
-- Syntaxe Lingo
réfObjFileio.getOSDirectory()
// Syntaxe JavaScript
réfObjFileio.getOSDirectory();
Description
Méthode de Fileio ; renvoie le chemin complet du dossier System (Macintosh) ou du répertoire
Windows (Windows).
Paramètres
Aucun.
Voir aussi
Fileio
365
getPixel()
Utilisation
-- Syntaxe Lingo
réfObjImage.getPixel(x, y {, #entier})
réfObjImage.getPixel(point(x, y) {, #entier})
// Syntaxe JavaScript
réfObjImage.getPixel(x, y {, #entier});
réfObjImage.getPixel(point(x, y) {, #entier});
Description
Méthode d’image. Renvoie une couleur indexée ou RVB du pixel en un point spécifié d’une
image donnée.
L’index des lignes et des colonnes de l’image renvoyée commence à 0. Par conséquent, pour
accéder au pixel situé dans le coin supérieur gauche d’une image, spécifiez l’emplacement (0,0),
et non (1,1). Si une image donnée a une hauteur de h pixels et une largeur de w pixels, pour
accéder au pixels situé dans le coin inférieur droit de l’image, spécifiez l’emplacement (w,1),
(h,1).
Cette méthode renvoie une valeur égale à 0 si le pixel spécifié se trouve en dehors de l’image
donnée.
Pour affecter à un grand nombre de pixels la couleur d’un autre pixel, la méthode la plus rapide
consiste à les définir en tant que nombres bruts (en utilisant le paramètre facultatif #entier). Les
valeurs de couleur brutes sont également pratiques en ce sens qu’elles contiennent à la fois des
informations de couche alpha et de couleurs dans les images 32 bits. Les informations de couche
alpha peuvent être extraites du nombre brut en divisant le nombre par 2^8+8+8.
Paramètres
x Requis si vous spécifiez un pixel avec des coordonnées x et y. Entier qui spécifie la coordonnée x
du pixel.
y1 Requis si vous spécifiez un
y du pixel.
#entier
pixel avec des coordonnées x et y. Entier qui spécifie la coordonnée
Facultatif. Symbole qui spécifie le nombre brut de la valeur de couleur renvoyée.
point(x, y)
Requis si vous spécifiez un pixel en utilisant un point. Point qui spécifie le point
du pixel.
Exemple
Les instructions suivantes définissent la couleur du pixel au point (90, 20) de l’acteur Joyeux et
définissent l’image-objet 2 sur cette couleur.
L’instruction suivante définit la variable alpha en fonction de la valeur de couche alpha du point
(25, 33) dans l’objet image 32 bits monImage.
Voir aussi
color(), image(), power(), setPixel()
366
Chapitre 12 : Méthodes
getPlayList()
Utilisation
-- Syntaxe Lingo
réfObjPisteAudio.getPlayList()
// Syntaxe JavaScript
réfObjPisteAudio.getPlayList();
Description
Méthode de piste audio ; renvoie une copie de la liste des sons mis en file d’attente pour une piste
audio.
La liste obtenue n’inclut pas le son en cours de lecture et ne peut pas être éditée directement.
Vous devez utiliser setPlayList().
La liste de lecture est une liste linéaire de listes de propriétés. Chaque liste de propriétés correspond à un acteur son placé en file d’attente. Chaque son placé en file d’attente peut spécifier ces
propriétés :
Propriété
Description
#member
L’acteur à placer en file d’attente. Cette propriété doit être spécifiée. Toutes
les autres sont facultatives.
#startTime
Position temporelle de départ de la lecture du son, en millisecondes. La
valeur par défaut est le début du son. Pour plus d’informations, consultez
startTime.
#endTime
Position temporelle de fin de la lecture du son, en millisecondes. La valeur
par défaut est la fin du son. Pour plus d’informations, consultez endTime.
#loopCount
Nombre de répétitions d’une boucle défini avec #loopStartTime et
#loopEndTime. La valeur par défaut est 1. Voir loopCount.
#loopStartTime
Position temporelle de départ de la boucle, en millisecondes. Pour plus
d’informations, consultez loopStartTime.
#loopEndTime
Position temporelle de fin de la boucle, en millisecondes. Pour plus
d’informations, consultez loopEndTime.
#preloadTime
Quantité de son à placer en mémoire tampon avant la lecture, en
millisecondes. Pour plus d’informations, consultez preloadTime.
Paramètres
Aucun.
367
Exemple
Le gestionnaire suivant place deux sons en file d’attente dans la piste audio 2, démarre leur
lecture, puis affiche la liste de lecture dans la fenêtre Messages. La liste de lecture ne contient que
le second son placé en file d’attente, le premier son étant déjà en cours de lecture.
-- Syntaxe Lingo
on playMusic
sound(2).queue(member("Carillon"))
sound(2).queue([#member:member("intro"), #startTime:3000, \
#endTime:10000, #loopCount:5, #loopStartTime:8000, #loopEndTime:8900])
put(sound(2).getPlayList())
sound(2).play()
end playMusic
// Syntaxe JavaScript
function playMusic() {
sound(2).queue(member("Carillon"));
sound(2).queue(propList("member",member("intro"), "startTime",3000,
"endTime",10000, "loopCount",5, "loopStartTime",8000, "loopEndTime",8900));
put(sound(2).getPlayList());
sound(2).play();
}
Voir aussi
endTime, loopCount, loopEndTime, loopStartTime, Acteur, member, preLoadTime,
queue(), setPlayList(), Piste audio, startTime
getPosition()
Utilisation
-- Syntaxe Lingo
réfObjFileio.getPosition()
// Syntaxe JavaScript
réfObjFileio.getPosition();
Description
Méthode de Fileio ; renvoie la position d’un fichier.
Paramètres
Aucun.
Voir aussi
Fileio
368
Chapitre 12 : Méthodes
getPref()
Utilisation
-- Syntaxe Lingo
_player.getPref(chaîneNomDePréf)
// Syntaxe JavaScript
_player.getPref(chaîneNomDePréf);
Description
Méthode de lecteur ; récupère le contenu du fichier spécifié.
Lorsque vous utilisez cette méthode, remplacez chaîneNomDePréf par le nom d’un fichier créé
par la méthode setPref(). Si un tel fichier n’existe pas, getPref() renvoie VOID (Lingo) ou
null (syntaxe JavaScript).
Le nom de fichier utilisé pour chaîneNomDePréf doit être un nom de fichier valide, et non un
chemin d’accès complet ; le chemin est fourni par Director. Le chemin vers le fichier est géré par
Director. Les seules extensions de fichiers valides pour chaîneNomDePréf sont .txt et .htm ; toute
autre extension est rejetée.
N’utilisez pas cette commande pour accéder à des médias en lecture seule ou verrouillés.
Remarque : Dans un navigateur, les données écrites par setPref() ne sont pas confidentielles.
Toute animation avec un contenu Shockwave est en mesure de lire ces informations et de les
télécharger vers un serveur. Les informations confidentielles ne doivent donc pas être stockées à
l’aide de la commande setPref().
Pour un exemple d’utilisation de getPref() dans une animation, reportez-vous à l’animation
Read and Write Text du dossier Learning/Lingo, lui-même inclus dans le dossier de Director.
Paramètres
chaîneNomDePréf
Requis. Chaîne qui spécifie le fichier dont le contenu est récupéré.
Exemple
Le gestionnaire suivant récupère le contenu du fichier Test et en affecte le texte au champ Score :
-- Syntaxe Lingo
on mouseUp
leTexte = _player.getPref("Test")
member("Score").text = leTexte
end
// Syntaxe JavaScript
function mouseUp() {
var leTexte = _player.getPref("Test");
member("Score").text = leTexte;
}
Voir aussi
Lecteur, setPref()
369
getPos()
Utilisation
liste.getPos(valeur)
getPos(liste, valeur)
Description
Fonction de liste ; identifie la position d’une valeur dans une liste. Lorsque la valeur spécifiée n’est
pas dans la liste, la commande getPos renvoie la valeur 0.
Pour les valeurs contenues plus d’une fois dans la liste, seule la première occurrence est affichée.
Cette commande réalise la même fonction que la commande getOne lorsque utilisée pour les
listes linéaires.
Paramètres
valeur
Requis. Spécifie la valeur associée à la position.
Exemple
L’instruction suivante identifie la position de la valeur 12 dans la liste Réponses, composée de
[#a:10, #b:12, #c:15, #d:22] :
put Réponses.getPos(12)
Le résultat est 2, 12 étant la seconde valeur de la liste.
Voir aussi
getOne()
getPref()
Utilisation
getPref(nomDeFichierDePréférences)
Description
Fonction ; récupère le contenu du fichier spécifié.
Lorsque vous utilisez cette fonction, remplacez nomDeFichierDePréférences par le nom du
fichier créé par la fonction setPref. Si un tel fichier n’existe pas, getPref renvoie VOID.
Le nom de fichier utilisé pour nomDeFichierDePréférences doit être un nom de fichier valide
et non un chemin d’accès complet ; Director fournit le chemin. Le chemin vers le fichier est géré
par Director. Les seules extensions de fichiers valides pour nomDeFichierDePréférences sont
.txt et .ht, toute autre extension étant rejetée.
N’utilisez pas cette commande pour accéder à des médias en lecture seule ou verrouillés.
Remarque : Dans un navigateur web, les données écrites par setPref ne sont pas confidentielles.
Toute animation avec un contenu Shockwave est en mesure de lire ces informations et de les
télécharger vers un serveur. Les informations confidentielles ne doivent donc pas être stockées à
l’aide de la commande setPref.
Pour un exemple d’utilisation de getPref() dans une animation, reportez-vous à l’animation
Read and Write Text du dossier Learning/Lingo, lui-même inclus dans le dossier de Director.
370
Chapitre 12 : Méthodes
Paramètres
nomDeFichierDePréférences
Requis. Spécifie le fichier à partir duquel le contenu est récupéré.
Exemple
Le gestionnaire suivant récupère le contenu du fichier Test et en affecte le texte au champ Score :
on mouseUp
leTexte = getPref("Test")
member("Score").text = leTexte
end
Voir aussi
setPref()
getProp()
Utilisation
getProp(liste, propriété)
liste.propriété
Description
Fonction de liste de propriétés ; identifie la valeur associée à une propriété dans une liste de
propriétés.
Presque identique à la commande getaProp, la commande getProp affiche un message d’erreur
si la propriété spécifiée n’est pas dans la liste ou si vous spécifiez une liste linéaire.
Paramètres
liste
Requis. Spécifie la liste de propriétés dans laquelle la propriété est récupérée.
propriété
Requis. Spécifie la propriété à laquelle la valeur identifiée est associée.
Exemple
L’instruction suivante identifie la valeur associée à la propriété #c dans la liste de
propriétés Réponses, composée de [#a:10, #b:12, #c:15, #d:22] :
getProp(Réponses, #c)
Le résultat est 15, qui est la valeur associée à #c.
Voir aussi
getOne()
getPropAt()
Utilisation
liste.getPropAt(index)
getPropAt(liste, index)
Description
Fonction de liste de propriétés ; pour les listes de propriétés uniquement, identifie le nom de la
propriété associée à une position spécifiée dans une liste de propriétés. Si l’élément spécifié n’est
pas dans la liste ou si vous utilisez getPropAt() avec une liste linéaire, une erreur de script a lieu.
371
Paramètres
index
Requis. Spécifie la position d’index de la propriété dans la liste de propriétés.
Exemple
L’instruction suivante affiche la seconde propriété de la liste donnée :
put Réponses.getPropAt(2)
-- #b
Le résultat est 20, qui est la valeur associée à #b.
getRendererServices()
Utilisation
getRendererServices()
getRendererServices().quellePropriétéDeGetRendererServices
Description
Commande 3D ; renvoie l’objet rendererServices. Cet objet contient les informations sur le
matériel et les propriétés qui affectent tous les acteurs et images-objets 3D.
L’objet rendererServices a les propriétés suivantes :
•
•
•
•
•
•
•
indique le rasteriseur logiciel utilisé pour le rendu des images-objets 3D.
rendererDeviceList renvoie une liste des rasteriseurs logiciels présents sur le système de
l’utilisateur. Les valeurs possibles sont #openGL, #directX5_2, #directX7_0 et #software.
La valeur de renderer doit être une de celles-ci. Cette propriété peut être testée, mais pas
définie.
textureRenderFormat indique le format de pixel utilisé par le moteur de rendu. Les valeurs
possibles sont #rgba8888, #rgba8880, #rgba5650, #rgba5550, #rgba5551 et #rgba4444. Les
quatre chiffres de chaque symbole indiquent le nombre de bits utilisés pour chaque
composante rouge, verte, bleue et alpha.
depthBufferDepth indique le codage binaire du tampon de sortie matériel.
colorBufferDepth indique le codage binaire du tampon des couleurs. Cette propriété peut
être testée, mais pas définie.
modifiers est une liste linéaire des modificateurs disponibles et pouvant être utilisées par les
modèles des acteurs 3D. Les valeurs possibles sont #collision, #bonesPlayer,
#keyframePlayer, #toon, #lod, #meshDeform, #sds, #inker et des modificateurs basés sur
des Xtras publiés par des tiers. Cette propriété peut être testée, mais pas définie.
primitives est une liste linéaire des types de primitives disponibles et pouvant être utilisés
dans la création de ressources de modèle. Les valeurs possibles sont #sphere, #box,
#cylinder, #plane, #particle et des types de primitives basés sur des Xtras publiés par
d’autres éditeurs. Cette propriété peut être testée, mais pas définie.
renderer
Remarque : Pour plus d’informations, consultez les entrées des différentes propriétés.
Paramètres
Aucun.
Voir aussi
renderer, preferred3dRenderer, active3dRenderer, rendererDeviceList
372
Chapitre 12 : Méthodes
getStreamStatus()
Utilisation
getStreamStatus(IDréseau)
getStreamStatus(chaîneURL)
Description
Fonction ; renvoie une liste de propriétés correspondant au format utilisé pour la fonction
tellStreamStatus disponible globalement et pouvant être utilisée avec des appels d’imagesobjets ou d’objets. La liste contient les chaînes suivantes :
#URL
Chaîne contenant l’emplacement de l’URL utilisée pour le début des opérations
réseau.
#state
Chaîne composée de Connecting (connexion), Started (démarrée), InProgress (en
cours), Complete (terminée), Error (erreur) ou NoInformation (aucune information) ;
cette dernière chaîne sert lorsque l’ID réseau est tellement ancienne que les
informations d’état n’existent plus ou que l’URL spécifiée dans chaîneURL n’a pas
été trouvée dans la mémoire cache.
#bytesSoFar
Nombre d’octets récupérés jusqu’à maintenant à partir du réseau.
#bytesTotal
Nombre total d’octets dans le flux, s’il est connu. Cette valeur peut être zéro si le
serveur HTTP n’indique pas la longueur du contenu dans l’en-tête MIME.
#error
Chaîne contenant "" (EMPTY) si le téléchargement n’est pas terminé, OK s’il a abouti
ou un code d’erreur si le téléchargement s’est terminé par une erreur.
Par exemple, vous pouvez démarrer une opération réseau avec getNetText( ) et suivre sa
progression avec getStreamStatus().
Paramètres
IDréseau
Facultatif. Opération réseau qui représente le flux de texte sur lequel intervenir.
Exemple
L’instruction suivante affiche dans la fenêtre Messages l’état courant d’un téléchargement démarré
avec getNetText() et l’identifiant réseau obtenu, placé dans la variable IDréseau :
put getStreamStatus(IDréseau)
-- [#URL: "www.macromedia.com", #state: "InProgress", #bytesSoFar: 250, \
#bytesTotal: 50000, #error: EMPTY]
Voir aussi
on streamStatus, tellStreamStatus()
373
getVariable()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet).getVariable(nomDeVariable {, valeurOuRéfRenvoyée})
// Syntaxe JavaScript
réfObjImageObjet.getVariable(nomDeVariable {, valeurOuRéfRenvoyée});
Description
Cette fonction renvoie la valeur courante de la variable donnée de l’image-objet donnée. Les
variables Flash ont été introduites dans la version 4 de Flash.
Cette fonction peut être utilisée de deux façons.
La définition du paramètre optionnel valeurOuRéfRenvoyée sur TRUE (valeur par défaut)
renvoie la valeur courante de la variable en tant que chaîne. La définition du paramètre
valeurOuRéfRenvoyée sur FALSE renvoie la valeur littérale courante de la variable Flash.
Si la valeur de la variable Flash est une référence d’objet, vous devez définir le paramètre
sur FALSE pour que la valeur renvoyée soit traitée en tant que référence
d’objet. Si elle est renvoyée en tant que chaîne, la chaîne ne constituera pas une référence d’objet
valide.
valeurOuRéfRenvoyée
Paramètres
nomDeVariable
Requis. Spécifie le nom de la variable dont la valeur est renvoyée.
valeurOuRéfRenvoyée Facultatif. Spécifie si la valeur renvoyée est une chaîne (TRUE) ou une
référence d’objet (FALSE).
Exemple
L’instruction suivante définit la variable valeurT sur la valeur de la chaîne de la variable Flash
appelée gAutreVar dans l’animation Flash, au niveau de l’image-objet 3 :
-- Syntaxe Lingo
valeurT = sprite(3).getVariable("gAutreVar", TRUE)
put(valeurT) -- "5"
// Syntaxe JavaScript
var valeurT = sprite(3).getVariable("gAutreVar", true);
trace(valeurT); // 5
L’instruction suivante définit la variable objetT de manière à référencer le même objet que la
variable appelée gVar dans l’animation Flash, au niveau de l’image-objet 3 :
-- Syntaxe Lingo
objetT = sprite(3).getVariable("gVar",FALSE)
// Syntaxe JavaScript
var objetT = sprite(3).getVariable("gVar",0);
374
Chapitre 12 : Méthodes
L’instruction suivante renvoie la valeur de la variable URLactuelle de l’acteur Flash de l’imageobjet 3 et l’affiche dans la fenêtre Messages.
-- Syntaxe Lingo
put(sprite(3).getVariable("URLactuelle"))
// Syntaxe JavaScript
trace(sprite(3).getVariable("URLactuelle"));
Voir aussi
setVariable()
getWorldTransform()
Utilisation
member(quelActeur).node(quelNœud).getWorldTransform()
member(quelActeur).node(quelNoeud).getWorldTransform().\
position
member(quelActeur).node(quelNœud).getWorldTransform().\
rotation
member(quelActeur).node(quelNœud).getWorldTransform().scale
Description
Commande 3D ; renvoie une transformation relative à l’univers du modèle, du groupe, de la
caméra ou de la lumière, représenté par nœud.
La propriété transform du nœud est calculée en fonction de la transformation du parent du
nœud et est donc relative au parent. La commande getWorldTransform() calcule la transformation du nœud par rapport à l’origine de l’univers 3D ; elle est donc relative à l’univers.
Utilisez member(quelActeur).node(quelNœud).getWorldTransform().position pour
rechercher la propriété position de la transformation relative à l'univers du nœud. Vous pouvez
également utiliser worldPosition comme raccourci de getWorldTransform().position.
Utilisez member(quelActeur).node(quelNœud).getWorldTransform().rotation pour
rechercher la propriété rotation de la transformation relative à l'univers du nœud.
Utilisez member(quelActeur).node(quelNœud).getWorldTransform().scale pour
rechercher la propriété scale de la transformation relative à l'univers du nœud.
Ces propriétés peuvent être testées, mais pas définies.
Exemple
L’instruction suivante indique la transformation relative à l’univers du modèle Boîte, suivie de ses
propriétés de position et de rotation.
put member("Univers 3D").model("Boîte").getworldTransform()
-- transform(1.000000,0.000000,0.000000,0.000000, \
0.000000,1.000000,0.000000,0.000000, \
0.000000,0.000000,1.000000,0.000000, -\
94.144844,119.012825,0.000000,1.000000)
put member("Univers 3D").model("Boîte").getworldTransform().position
-- vector( -94.1448, 119.0128, 0.0000 )
put member("Univers 3D").model("Boîte").getworldTransform().rotation
-- vector( 0.0000, 0.0000, 0.0000 )
Voir aussi
worldPosition, transform (propriété)
375
go()
Utilisation
-- Syntaxe Lingo
_movie.go(nomOuNumDimage {, nomDanimation})
// Syntaxe JavaScript
_movie.go(nomOuNumDimage {, nomDanimation});
Description
Méthode d’animation ; place la tête de lecture sur l'image spécifiée dans une animation donnée.
Cette méthode peut être employée pour demander à la tête de lecture d'effectuer une boucle vers
le repère précédent, offrant ainsi un moyen pratique de conserver la tête de lecture dans la même
partie de l'animation pendant que le script reste actif.
Il est préférable d’utiliser des libellés de repères plutôt que des numéros d’images pour
nomOuNumDimage, la modification d’une animation pouvant entraîner le changement des
numéros d’images. L’utilisation de libellé de repères facilite également la lecture des scripts.
Lorsque vous appelez go() avec le paramètre nomDanimation, l’image 1 de l’animation est
chargée. Si la méthode go() est appelée à partir d’un gestionnaire, le gestionnaire dans laquelle
elle est placée poursuit son exécution. Pour suspendre le gestionnaire pendant la lecture de
l’animation, utilisez la méthode play(), qui peut être suivie d’un appel de playDone() pour
revenir en arrière.
Lorsque vous spécifiez une animation à lire, indiquez son chemin d’accès si l’animation se trouve
dans un dossier différent, mais, pour éviter un éventuel échec du chargement, n’incluez pas
l’extension du fichier de l’animation (.dir, .dxr ou .dcr).
Pour passer plus facilement à une animation sur une URL, utilisez la méthode
downloadNetThing() afin de télécharger le fichier de l’animation sur un disque local, puis
utilisez la méthode go() avec le paramètre nomDanimation cette animation sur le disque local.
La méthode goLoop() envoie la tête de lecture vers le repère précédent et offre ainsi un moyen
pratique de conserver la tête de lecture dans la même partie de l'animation pendant que la syntaxe
Lingo ou JavaScript reste active.
Les paramètres suivants sont réinitialisés au chargement d’une animation : propriétés beepOn
et constraint ; keyDownScript, mouseDownScript et mouseUpScript ; propriétés d’imagesobjets cursor et immediate ; méthodes cursor() et puppetSprite() ; et menus personnalisés.
Cependant, la propriété timeoutScript n’est pas réinitialisée au chargement d’une animation.
Paramètres
nomOuNumDimage Requis. Chaîne qui spécifie le repère de l’image sur laquelle la tête de lecture se
place ou nombre entier qui spécifie le numéro de cette image.
nomDanimation Facultatif. Chaîne qui spécifie l’animation contenant l’image définie par
nomOuNumDimage. Cette valeur doit spécifier un fichier d’animation ; si l’animation se trouve
dans un autre dossier, nomDanimation doit également spécifier le chemin d’accès.
376
Chapitre 12 : Méthodes
Exemple
L’instruction suivante envoie la tête de lecture au point de repère intitulé Début :
-- Syntaxe Lingo
_movie.go("Début")
// Syntaxe JavaScript
_movie.go("Début");
L’instruction suivante envoie la tête de lecture au point de repère Mémoire de l’animation
intitulée Mon animation :
-- Syntaxe Lingo
_movie.go("Mémoire", "Mon animation")
// Syntaxe JavaScript
_movie.go("Mémoire", "Mon animation");
Le gestionnaire suivant indique à l’animation de faire une boucle sur l’image courante. Ce
gestionnaire est pratique pour faire en sorte que l’animation s’arrête sur une image pendant la
lecture tout en répondant aux événements.
-- Syntaxe Lingo
on exitFrame
_movie.go(_movie.frame)
end
// Syntaxe JavaScript
function exitFrame() {
_movie.go(_movie.frame);
}
Voir aussi
downloadNetThing, goLoop(), Animation
goLoop()
Utilisation
-- Syntaxe Lingo
_movie.goLoop()
// Syntaxe JavaScript
_movie.goLoop();
Description
Méthode d’animation ; envoie la tête de lecture au point de repère précédent dans l’animation, un
point de repère avant l’image courante si l’image courante n’a pas de repère ou à l’image courante
si l’image courante possède un repère.
Si aucun repère ne se trouve à gauche de la tête de lecture, la tête de lecture se place sur :
• Le prochain repère à droite si l’image courante ne possède pas de repère.
• L’image courante si celle-ci possède un repère.
• L’image 1 si l’animation ne contient aucun repère.
Paramètres
Aucun.
377
Exemple
L’instruction suivante fait faire une boucle à l’animation entre l’image courante et le repère
précédent :
-- Syntaxe Lingo
_movie.goLoop()
// Syntaxe JavaScript
_movie.goLoop();
Voir aussi
go(), goNext(), goPrevious(), Animation
goNext()
Utilisation
-- Syntaxe Lingo
_movie.goNext()
// Syntaxe JavaScript
_movie.goNext();
Description
Méthode d’animation ; place la tête de lecture sur le repère suivant dans l’animation.
Si aucun repère ne se trouve à droite de la tête de lecture, celle-ci se place sur le dernier repère de
l’animation ou sur l’image 1 si l’animation ne contient aucun repère.
Paramètres
Aucun.
Exemple
L’instruction suivante envoie la tête de lecture sur le repère suivant de l’animation :
-- Syntaxe Lingo
_movie.goNext()
// Syntaxe JavaScript
_movie.goNext();
Voir aussi
go(), goLoop(), goPrevious(), Animation
378
Chapitre 12 : Méthodes
goPrevious()
Utilisation
-- Syntaxe Lingo
_movie.goPrevious()
// Syntaxe JavaScript
_movie.goPrevious();
Description
Méthode d’animation ; place la tête de lecture sur le point de repère précédent dans l’animation.
Ce repère est situé deux repères avant l’image courante si celle-ci ne possède pas de repère ou un
repère avant l’image courante si elle en possède un.
Si aucun repère ne se trouve à gauche de la tête de lecture, la tête de lecture se place sur un des
éléments suivants :
• Le prochain repère à droite si l’image courante ne possède pas de repère.
• L’image courante si celle-ci possède un repère.
• L’image 1 si l’animation ne contient aucun repère.
Paramètres
Aucun.
Exemple
L’instruction suivante envoie la tête de lecture sur le repère précédent dans l’animation :
-- Syntaxe Lingo
_movie.goPrevious()
// Syntaxe JavaScript
_movie.goPrevious();
Voir aussi
go(), goLoop(), goNext(), Animation
goToFrame()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.goToFrame(nomOuNumDimage)
// Syntaxe JavaScript
réfObjImageObjet.goToFrame(nomOuNumDimage);
Description
Commande ; lit une image-objet d’animation Flash à partir de l’image identifiée par le paramètre
nomOuNumDimage. Vous pouvez identifier l’image par un nombre entier indiquant le numéro
d’image ou par une chaîne indiquant le nom du libellé. L’utilisation de la commande goToFrame
a le même effet que la définition de la propriété frame d’une image-objet d’animation Flash.
379
Exemple
Le gestionnaire suivant passe à différents points d’une animation Flash dans la piste 5. Il accepte
un paramètre qui indiquant l’image à laquelle il doit passer.
-- Syntaxe Lingo
on Navigate(Cible)
sprite(5).goToFrame(Cible)
end
// Syntaxe JavaScript
function Navigate(Cible) {
sprite(5).goToFrame(Cible);
}
gotoNetMovie
Utilisation
gotoNetMovie URL
gotoNetMovie (URL)
Description
Commande ; récupère et lit une nouvelle animation avec un contenu Shockwave à partir d’un
serveur HTTP ou FTP. L’exécution de l’animation courante continue jusqu’à ce que la nouvelle
animation soit disponible.
Seules les URL sont supportées comme paramètres valides. L’URL peut spécifier un nom de
fichier ou un repère dans une animation. Les URL relatives fonctionnent si l’animation se trouve
sur un serveur Internet, mais vous devez inclure l’extension avec le nom de fichier.
Lorsque vous réalisez des tests sur un disque ou réseau local, les médias doivent se trouver dans un
répertoire appelé dswmedia.
Si une opération gotoNetMovie est en cours et que vous envoyez une seconde commande
gotoNetMovie avant la fin de la première, la seconde commande annule la première.
Paramètres
URL
Requis. Spécifie l’URL du contenu Shockwave à lire.
Exemple
Dans l’instruction suivante, l’URL indique un nom de fichier Director :
gotoNetMovie "http://www.votreserveur.fr/animations/animation1.dcr"
Dans l’instruction suivante, l’URL indique un repère dans un nom de fichier :
gotoNetMovie "http://www.votreserveur.fr/animations/boutons.dcr#Contenu"
Dans l’instruction suivante, gotoNetMovie est utilisée comme une fonction. Cette fonction
renvoie l’identifiant réseau pour l’opération.
monIDréseau = gotoNetMovie ("http://www.votreServeur.fr/animations/
boutons.dcr#Contenu")
380
Chapitre 12 : Méthodes
gotoNetPage
Utilisation
gotoNetPage "URL", {"nomDeCible"}
Description
Commande ; ouvre une animation avec un contenu Shockwave ou un autre fichier MIME dans le
navigateur.
Seules les URL sont supportées comme paramètres valides. Les URL relatives fonctionnent si
l’animation se trouve sur un serveur HTTP ou FTP.
Dans l’environnement de programmation, la commande gotoNetPage lance le navigateur préféré
s’il est activé. Dans les projections, cette commande essaie de lancer le navigateur préféré, défini
dans la boîte de dialogue des préférences réseau ou la commande browserName. Si aucune
commande n’a été utilisée pour définir le navigateur préféré, la commande goToNetPage essaie
de trouver un navigateur web sur l’ordinateur.
Paramètres
URL
Requis. Spécifie l’URL de l’animation avec un contenu Shockwave ou du fichier MIME à
lire.
nomDeCible
Facultatif. Paramètre HTML qui identifie le cadre ou la fenêtre dans lequel la page
est chargée.
• Si nomDeCible est une fenêtre ou un cadre dans le navigateur web, gotoNetPage en remplace
le contenu.
• Si nomDeCible n’est pas un cadre ou une fenêtre ouverts, goToNetPage ouvre une nouvelle
•
fenêtre. L’utilisation de la chaîne "_new" provoque systématiquement l’ouverture d’une
nouvelle fenêtre.
Si nomDeCible est omis, gotoNetPage remplace la page courante, où qu’elle se trouve.
Exemple
Le script suivant charge le fichier nouvellePage.html dans le cadre ou la fenêtre intitulé(e) frwin.
S’il existe une fenêtre ou un cadre intitulés frwin, cette fenêtre ou ce cadre est utilisé. Si la fenêtre
frwin n’existe pas, une nouvelle fenêtre intitulée frwin est créée.
on keyDown
gotoNetPage "nouvellePage.html", "frwin"
end
Le gestionnaire suivant ouvre une nouvelle fenêtre, quelle que soit la fenêtre ouverte par le
navigateur :
on mouseUp
goToNetPage "Nouvelles_du_jour.html", "_new"
end
Voir aussi
browserName(), netDone()
381
group()
Utilisation
member(quelActeur).group(quelGroupe)
member(quelActeur).group[index]
Description
Elément 3D ; nœud de l’univers 3D qui a un nom, une transformation, un parent et des enfants,
mais aucune autre propriété.
Chaque acteur 3D est associé à un groupe par défaut nommé Univers et qui ne peut pas être
supprimé. La hiérarchie parent de tous les modèles, lumières, caméras et groupes qui existent dans
l’univers 3D se terminent dans group("world").
Exemple
L’instruction suivante indique que le quatrième groupe de l’acteur nouveauMartien est le groupe
Direct01.
put member("nouveauMartien").group[4]
-- group("Direct01")
Voir aussi
newGroup, deleteGroup, child (3D), parent
halt()
Utilisation
-- Syntaxe Lingo
_movie.halt()
// Syntaxe JavaScript
_movie.halt();
Description
Méthode d’animation ; quitte le gestionnaire courant et tout autre gestionnaire qui l’a appelé et
arrête l’animation pendant la programmation ou quitte la projection pendant son exécution.
Paramètres
Aucun.
382
Chapitre 12 : Méthodes
Exemple
L’instruction suivante vérifie si la quantité de mémoire disponible est inférieure à 50 ko et, le cas
échéant, quitte tous les gestionnaires qui l’ont appelée et arrête l’animation :
-- Syntaxe Lingo
if (_system.freeBytes < (50*1024)) then
_movie.halt()
end if
// Syntaxe JavaScript
if (_system.freeBytes < (50*1024)) {
_movie.halt();
}
Voir aussi
Animation
handler()
Utilisation
objetScript.handler(#symboleDeGestionnaire)
Description
Cette fonction renvoie TRUE si l’objetScript donné contient un gestionnaire spécifié et FALSE
dans le cas contraire. L’objet script doit être un script parent, un objet enfant ou un comportement.
Paramètres
symboleDeGestionnaire
Requis. Spécifie le nom du gestionnaire.
Exemple
Le code Lingo suivant appelle un gestionnaire sur un objet, uniquement si le gestionnaire en
question existe :
if objetAraignée.handler(#saut) = TRUE then
objetAraignée.saut()
end if
Voir aussi
handlers(), new(), rawNew(), script()
handlers()
Utilisation
objetScript.handlers()
Description
Cette fonction renvoie une liste linéaire des gestionnaires dans l’objetScript donné. Chaque
nom de gestionnaire est présenté sous forme de symbole dans la liste. Cette fonction est pratique
pour le débogage des animations.
Vous ne pouvez pas accéder directement aux gestionnaires d’un acteur script. Vous devez y
accéder par l’intermédiaire de la propriété script de l’acteur.
383
Paramètres
Aucun.
Exemple
L’instruction suivante affiche la liste des gestionnaires de l’objet enfant voitureRouge dans la
fenêtre Messages :
put voitureRouge.handlers()
-- [#accélérer, #tourner, #arrêter]
L’instruction suivante affiche la liste des gestionnaires du script parent ScriptParentDeVoiture
dans la fenêtre Messages :
put member("ScriptParentDeVoiture").script.handlers()
-- [#accélérer, #tourner, #arrêter]
Voir aussi
handler(), script()
hilite (commande)
Utilisation
expressionSousChaîneChamp.hilite()
hilite expressionSousChaîneChamp
Description
Commande ; sélectionne l’expression de sous-chaîne spécifiée dans l’image-objet champ, qui peut
être n’importe quelle sous-chaîne que Lingo vous permet de définir, telle qu’un caractère, un mot
ou une ligne. Sur Macintosh, la couleur de sélection est définie dans le tableau de bord Couleur.
Paramètres
Aucun.
Exemple
L’instruction suivante sélectionne le troisième mot dans l’acteur champ Commentaires, qui
contient la chaîne Pensée du jour :
member("Commentaires").word[4].hilite()
L’instruction suivante entraîne l’affichage du texte sélectionné dans le champ mesRecettes de
l’image-objet sans surbrillance :
monNombreDeLignes = member("mesRecettes").line.count
member("mesRecettes").line[monNombreDeLignes + 1].hilite()
Voir aussi
char...of, item...of, line...of, word...of, delete(), mouseChar, mouseLine,
mouseWord, field, selection() (fonction), selEnd, selStart
384
Chapitre 12 : Méthodes
hitTest()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.hitTest(point)
// Syntaxe JavaScript
réfObjImageObjet.hitTest(point);
Description
Fonction ; indique la partie d’une animation Flash se trouvant directement sur un emplacement
spécifique de la scène Director. L’emplacement de la scène Director est exprimé en valeur de
points Director : par exemple, point (100,50). La fonction hitTest renvoie ces valeurs :
•
#background
– L’emplacement spécifié est dans l’arrière-plan de l’image-objet animation
Flash.
•
•
•
– L’emplacement spécifié est dans une image-objet remplie.
#button – L’emplacement spécifié est dans la zone référencée d’un bouton.
#editText – L’emplacement spécifié est dans un champ de texte modifiable Flash.
#normal
Paramètres
point
Requis. Spécifie le point à tester.
Exemple
Le script d’image suivant vérifie si la souris se trouve au-dessus d’un bouton dans une image-objet
animation Flash dans la piste 5 et, le cas échéant, le script définit un champ de texte utilisé pour
afficher un message d’état :
-- Syntaxe Lingo
on exitFrame
if sprite(5).hitTest(_mouse.mouseLoc) = #button then
member("Ligne de message").text = "Cliquez ici pour lire l’animation."
_movie.updatestage()
else
member("message").text = " "
end if
_movie.go(_movie.frame)
end
// Syntaxe JavaScript
function exitFrame() {
var hT = sprite(5).hitTest(_mouse.mouseLoc);
if (hT = "bouton") {
member("Ligne de message").text = "Cliquez ici pour lire l’animation.";
_movie.updatestage();
} else {
member("Ligne de message").text = "";
}
_movie.go(_movie.frame)
}
385
HMStoFrames()
Utilisation
HMStoFrames(hms, cadence, compensé, fractions)
Description
Fonction ; convertit les animations mesurées en heures, minutes et secondes au nombre
équivalent d’images ou convertit un nombre d’heures, minutes et secondes en temps si vous
donnez à l’argument cadence la valeur 1 (1 image = 1 seconde).
Paramètres
hms
Requis. Expression de chaîne qui spécifie le temps sous la forme sHH:MM:SS.FFD, où :
s
Un caractère est utilisé si le temps est inférieur à zéro ou un espace si le temps est
supérieur ou égal à zéro.
HH
Heures.
MM
Minutes.
SS
Secondes.
FF
Indique une fraction de seconde si fractions a la valeur TRUE ou des images si fractions a
la valeur FALSE.
D
Un d est utilisé si composé a la valeur TRUE ou un espace si composé a la valeur FALSE.
cadence
Requis. Spécifie la cadence en images par seconde.
compensé Requis. Expression logique qui détermine si l’image est compensée (TRUE) ou non
(FALSE). Si la chaîne hms se termine par d, le temps est traité comme une image compensée,
quelle que soit la valeur de l’argument compensé.
Requis. Expression logique qui détermine la signification des nombres après les
secondes ; il peut s’agir de fractions de secondes arrondies au centième de seconde le plus proche
(TRUE) ou du nombre d’images résiduelles (FALSE).
fractions
Exemple
L’instruction suivante détermine le nombre d’images dans une animation d’une minute, 30,1
secondes lorsque la cadence est de 30 images par seconde. Les arguments compensé et fractions
ne sont pas utilisés.
put HMStoFrames(" 00:01:30.10 ", 30, FALSE, FALSE)
-- 2710
L’instruction suivante convertit 600 secondes en minutes :
put framesToHMS(600, 1,0,0)
>> -- " 00:10:00.00 "
L’instruction suivante convertit une heure et demie en secondes :
put HMStoFrames("1:30:00", 1,0,0)
>> -- 5400
Voir aussi
framesToHMS()
386
Chapitre 12 : Méthodes
hold()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.hitTest(point)
// Syntaxe JavaScript
réfObjImageObjet.hitTest(point);
Description
Commande Flash ; arrête une image-objet animation Flash lue dans l’image courante, sans
interrompre la lecture audio.
Paramètres
Aucun.
Exemple
Le script d’image suivant arrête la lecture des images-objets animation Flash dans les pistes 5 à 10
sans interrompre la lecture audio de ces pistes :
-- Syntaxe Lingo
on enterFrame
repeat with i = 5 to 10
sprite(i).hold()
end repeat
end
// Syntaxe JavaScript
function enterFrame() {
var i = 5;
while (i < 11) {
sprite(i).hold();
i++;
}
}
Voir aussi
playRate (QuickTime, AVI)
identity()
Utilisation
member(quelActeur).model(quelModèle).transform.identity()
member(quelActeur).group(quelGroupe).transform.identity()
member(quelActeur).camera(quelleCaméra).transform.identity()
sprite(quelleImageObjet).camera{(index)}.transform.identity()
member(quelActeur).light(quelleLumière).transform.identity()
référenceDeTransformation.identity()
Description
Commande 3D ; fait de la transformation la transformation d’identité, qui est
transform(1.0000,0.0000,0.0000,0.0000, 0.0000,1.0000,0.0000,0.0000,
0.0000,0.0000,1.0000,0.0000, 0.0000,0.0000,0.0000,1.0000).
La propriété position de la transformation d’identité est vector(0, 0, 0).
387
La propriété rotation de la transformation d’identité est vector(0, 0, 0).
La propriété scale de la transformation d’identité est vector(1, 1, 1).
La transformation d’identité est relative au parent.
Paramètres
Aucun.
Exemple
L’instruction suivante fait de la transformation du modèle Boîte la transformation d’identité.
member("Univers 3D").model("Boîte").transform.identity()
Voir aussi
transform (propriété), getWorldTransform()
idleLoadDone()
Utilisation
-- Syntaxe Lingo
_movie.idleLoadDone(entBaliseDeChargement)
// Syntaxe JavaScript
_movie.idleLoadDone(entBaliseDeChargement);
Description
Méthode d’animation ; indique si tous les acteurs ayant la balise spécifiée ont été chargés (TRUE)
ou s’ils doivent encore être chargés (FALSE).
Paramètres
entBaliseDeChargement
Requis. Nombre entier qui spécifie la balise de chargement des acteurs
à tester.
Exemple
L’instruction suivante vérifie si tous les acteurs dont la balise de chargement est 20 ont été chargés
et, le cas échéant, lit l’animation Kiosque :
-- Syntaxe Lingo
if (_movie.idleLoadDone(20)) then
_movie.play(1, "Kiosque")
end if
// Syntaxe JavaScript
if (_movie.idleLoadDone(20)) {
_movie.play(1, "Kiosque");
}
Voir aussi
idleHandlerPeriod, idleLoadMode, idleLoadPeriod, idleLoadTag,
idleReadChunkSize, Animation
388
Chapitre 12 : Méthodes
ignoreWhiteSpace()
Utilisation
objetDanalyseXML.ignoreWhiteSpace(trueOuFalse)
Description
Commande XML ; spécifie si l’objet d’analyse doit ignorer ou conserver les espaces vierges dans
les listes Lingo. Lorsque ignoreWhiteSpace() a pour valeur TRUE (la valeur par défaut), l’objet
d’analyse ignore les espaces vierges. Lorsque cette commande a pour valeur FALSE, l’objet
d’analyse conserve les espaces vierges et les traite comme des données réelles.
Lorsqu’un élément possède des balises initiales et finales distinctes, telles que <exemple>
</exemple>, les caractères de l’élément sont ignorés si (et uniquement si) il n’est composé que
d’espaces vierges. En cas de présence d’un espace autre qu’un espace vierge, ou si
ignoreWhiteSpace() a pour valeur FALSE, un nœud CDATA contenant le même texte y
compris l’espace vierge, sera créé.
Paramètres
trueOuFalse Requis. Valeur qui spécifie si l’objet d’analyse doit ignorer les espaces vierges (TRUE)
ou non (FALSE).
Exemple
Les instructions Lingo suivantes laissent à ignoreWhiteSpace() sa valeur par défaut de TRUE
et convertissent le document XML donné en une liste. L’élément <exemple> ne possède pas
d’enfant dans la liste.
TexteXML = "<exemple> </exemple>"
ObjetDanalyse.parseString(TexteXML)
laListe = ObjetDanalyse.makelist()
put laListe
-- ["ROOT OF XML DOCUMENT": ["!ATTRIBUTES": [:], "exemple": ["!ATTRIBUTES":
[:]]]]
Les instructions Lingo suivantes donnent à ignoreWhiteSpace() la valeur FALSE et convertissent
le document XML donné en une liste. L’élément <exemple> possède maintenant un enfant
contenant un espace.
TexteXML = "<exemple> </exemple>"
objetDanalyse.ignoreWhiteSpace(FALSE)
ObjetDanalyse.parseString(TexteXML)
laListe = ObjetDanalyse.makelist()
put laListe
-- ["ROOT OF XML DOCUMENT": ["!ATTRIBUTES": [:], "exemple": ["!ATTRIBUTES":
[:], "!CHARDATA": " "]]]
Les instructions Lingo suivantes laissent à ignoreWhiteSpace() sa valeur par défaut de TRUE et
analysent le document XML donné. Il n’existe qu’un seul nœud enfant de la balise <exemple>
et qu’un seul nœud enfant de la balise <inf>.
texteXML = "<exemple> <inf> phrase 1 </inf></exemple>"
ObjetDanalyse.parseString(TexteXML)
laListe = objetDanalyse.makeList()
put laListe
-- ["ROOT OF XML DOCUMENT": ["!ATTRIBUTES": [:], "exemple": ["!ATTRIBUTES":
[:], "inf": ["!ATTRIBUTES": [:], "!CHARDATA": " phrase 1 "]]]]
389
Les instructions Lingo suivantes donnent à ignoreWhiteSpace() la valeur FALSE et analysent le
document XML donné. Il existe maintenant deux nœuds enfants de la balise <exemple>, le
premier étant un caractère d’espace.
texteXML = "<exemple> <inf> phrase 1 </inf></exemple>"
gObjetDanalyse.ignoreWhiteSpace(FALSE)
gObjetDanalyse.parseString(texteXML)
laListe = gObjetDanalyse.makeList()
put laListe
-- ["ROOT OF XML DOCUMENT": ["!ATTRIBUTES": [:], "exemple": ["!ATTRIBUTES":
[:], "!CHARDATA": " ", "inf": ["!ATTRIBUTES": [:], "!CHARDATA": " phrase 1
"]]]]
ilk()
Utilisation
ilk(objet)
ilk(objet, type)
Description
Fonction ; indique le type d’un objet.
Le tableau suivant présente la valeur renvoyée pour chaque type d’objet reconnu par ilk() :
390
Type d’objet ilk(objet)
renvoie
ilk(objet, type)
liste linéaire
#list
#list ou #linearlist
ilk ([1,2,3])
liste de
propriétés
#proplist
#list ou #proplist
ilk ([#Alui: 1234, #Aelle: 7890])
entier
#integer
#integer ou #number
ilk (333)
valeur à
virgule
flottante
#float
#float ou #number
ilk (123.456)
chaîne
#string
#string
ilk ("asdf")
rect
#rect
#rect ou #list
ilk (sprite(1).rect)
point
#point
#point ou #list
ilk (sprite(1).loc)
couleur
#color
#color
ilk (sprite(1).color)
date
#date
#date
ilk (the systemdate)
symbole
#symbol
#symbol
ilk (#bonjour)
void
#void
#void
ilk (void)
image
#picture
#picture
ilk (member (2).picture)
instance de
script parent
#instance
#object
ilk (new (script "blabla"))
instance
d’Xtra
#instance
#object
ilk (new (xtra "fileio"))
Chapitre 12 : Méthodes
Exemple
renvoie 1 uniquement si le type =
Type d’objet ilk(objet)
renvoie
ilk(objet, type)
acteur
#member
#object ou #member
ilk (member 1)
Xtra
#xtra
#object ou #xtra
ilk (xtra "fileio")
script
#script
#object ou #script
ilk (script "blabla")
castlib
#castlib
#object ou #castlib
ilk (castlib 1)
image-objet
#sprite
#object ou #sprite
ilk (sprite 1)
son
#instance ou
#instance ou #sound
#sound (lorsque
Exemple
renvoie 1 uniquement si le type =
ilk (sound "tralala")
l’Xtra de
contrôle audio
est absent)
fenêtre
#window
#object ou #window
ilk (the stage)
médias
#media
#object ou #media
ilk (member (2).media)
timeout
#timeout
#object ou #timeout
ilk (timeOut("compteurIntervalle"))
image
#image
#object ou #image
ilk ((the stage).image)
Paramètres
objet
Requis. Spécifie l’objet à tester.
type Facultatif. Spécifie le type par rapport auquel l’objet est comparé. Si l’objet est du type
spécifié, la fonction ilk renvoie la valeur TRUE. Si l’objet n’est pas du type spécifié, la fonction
ilk renvoie la valeur FALSE.
Exemple
L’instruction ilk suivante identifie le type de l’objet appelé Devis :
Devis = [:]
put ilk( Devis )
-- #proplist
L’instruction suivante ilk teste si la variable Total est une liste et affiche le résultat dans la fenêtre
Messages :
Total = 2+2
put ilk( Total, #list )
-- 0
Dans ce cas, étant donné que la variable n’est pas une liste, la fenêtre Messages affiche 0,
l’équivalent numérique de FALSE.
L’exemple suivant teste une variable intitulée maVariable et vérifie qu’elle correspond à un objet
de date avant de l’afficher dans la fenêtre Messages :
maVariable = the systemDate
if ilk(maVariable, #date) then put maVariable
-- date( 1999, 2, 19 )
391
ilk (3D)
Utilisation
ilk(objet)
ilk(objet,type)
objet.ilk
objet.ilk(type)
Description
Fonction Lingo ; indique le type d’un objet.
Le tableau suivant présente la valeur renvoyée pour chaque type d’objet 3D reconnu par ilk().
Le dictionnaire Lingo principal contient une liste des valeurs renvoyées pour les objets autres que
3D.
Type d’objet
ilk(objet) renvoie
ilk(objet, type) uniquement si type =
services de rendu #renderer
#renderer
ressource de
modèle
#modelResource, #plane, #box,
#sphere, #cylinder,
#particle, #mesh
Identique à ilk(objet), à l’exception de
#modelResource qui est équivalent aux
ressources générées par un fichier *.w3d
importé
modèle
#model
#model
mouvement
#motion
#motion ou #list
matériau
#shader
#shader ou #list
texture
#texture
#texture ou #list
groupe
#group
#group
caméra
#camera
#camera
données de
collision
#collisiondata
#collisiondata
vecteurs
#vector
#vector
transformation
#transform
#transform
Paramètres
objet
Requis. Spécifie l’objet à tester.
type Facultatif. Spécifie le type par rapport auquel l’objet est comparé. Si l’objet est du type
spécifié, la fonction ilk renvoie la valeur TRUE. Si l’objet n’est pas du type spécifié, la fonction
ilk renvoie la valeur FALSE.
Exemple
L’instruction suivante indique que monObjet est un objet de mouvement.
put MonObjet.ilk
-- #motion
392
Chapitre 12 : Méthodes
L’instruction suivante vérifie si monObjet est un objet de mouvement. La valeur renvoyée, 1,
indique qu’il s’agit bien d’un tel objet.
put MonObjet.ilk(#motion)
-- 1
Voir aussi
tweenMode
image()
Utilisation
-- Syntaxe Lingo
image(entLargeur, entHauteur, entProfondeurDeBit)
// Syntaxe JavaScript
image(entLargeur, entHauteur, entProfondeurDeBit);
Description
Fonction du niveau supérieur ; crée et renvoie une nouvelle image avec des dimensions spécifiées.
Si vous créez une nouvelle image en utilisant la fonction image() du niveau supérieur, la nouvelle
image est un ensemble de données d'images autonome et elle est indépendante de toutes les autres
images. Les modifications apportées aux autres images n’ont aucune incidence sur la nouvelle
image.
Si vous faites référence à une image en définissant une variable égale à une image source telle
qu’un acteur ou l’image de la scène, la variable contient une référence à l’image source. Une
modification apportée à l’image dans l’objet source ou la variable sera répercutée dans l’autre
image.
Pour éviter ce comportement et créer une copie d’une image indépendante de l’image source,
utilisez la méthode duplicate(). La méthode duplicate() renvoie une copie d’une image
source qui hérite de toutes les valeurs de l’image source, mais qui n’est pas liée à cette dernière.
Par conséquent, une modification apportée à l’image source ou à la nouvelle copie de l’image
source n’aura aucune incidence sur l’autre image.
Si un objet image est créé en référence à un acteur, l’objet contiendra une référence à l’image de
l’acteur. Toutes les modifications apportées à l’image sont répercutées dans l’acteur et dans les
images-objets créées à partir de cet acteur.
Lorsque vous créez un nouvel objet image, par défaut, la couleur d’arrière-plan est blanche
(color(255,255,255)) et la couche alpha est complètement opaque (color(0,0,0)).
La couleur de la couche alpha pour une transparence de 100 % est le blanc (color(255,255,255)) ;
pour une opacité de 100 %, la couleur de la couche alpha est le noir (color(0,0,0)).
Pour un exemple d’utilisation d’une méthode image() dans une animation, reportez-vous à
l’animation Imaging du dossier Learning/Lingo, lui-même inclus dans le dossier de Director.
Paramètres
entLargeur
Requis. Nombre entier qui spécifie la largeur de la nouvelle image.
entHauteur
Requis. Nombre entier qui spécifie la hauteur de la nouvelle image.
393
entProfondeurDeBit Requis. Nombre entier qui spécifie la profondeur de bit de la nouvelle
image. Les valeurs correctes sont 1, 2, 4, 8, 16 et 32.
Exemple
L’exemple suivant crée une image 8 bits d’une largeur de 200 pixels et d’une hauteur de
200 pixels.
-- Syntaxe Lingo
monImage = image(200, 200, 8)
// Syntaxe JavaScript
var objImage = image(200, 200, 8);
L’exemple suivant crée une image en faisant référence à l’image de la scène.
-- Syntaxe Lingo
objImage = _movie.stage.image
// Syntaxe JavaScript
var objImage = _movie.stage.image;
Voir aussi
duplicate() (image), fill(), image (image)
importFileInto()
Utilisation
-- Syntaxe Lingo
réfObjActeur.importFileInto(chaîneFichierOuUrl)
// Syntaxe JavaScript
réfObjActeur.importFileInto(chaîneFichierOuUrl);
Description
Méthode d’acteur ; remplace le contenu d’un acteur donné par un fichier spécifié.
La méthode importFileInto() est pratique dans les situations suivantes.
• Lorsque vous finalisez ou développez une animation, elle permet d’intégrer des médias externes
•
•
liés de façon à pouvoir les modifier pendant le projet.
Lorsque vous créez un scénario à partir d’une syntaxe Lingo ou JavaScript pendant la création
de l’animation, elle permet d’affecter un contenu aux nouveaux acteurs.
Lors du téléchargement de fichiers à partir d’Internet, elle permet de télécharger le fichier à
partir d’une URL spécifique et de définir le nom de fichier du média lié.
Remarque : Pour importer un fichier à partir d’une URL, il est généralement plus efficace de
télécharger d’abord le fichier sur un disque local avec preloadNetThing(), puis de l’importer depuis
le disque local. La fonction preloadNetThing() minimise également les problèmes de
téléchargement potentiels.
• Elle permet d’importer des documents RTF et HTML dans des acteurs texte en gardant le
format et les liens intacts.
L’utilisation de la méthode importFileInto() dans les projections peut rapidement consommer
la mémoire disponible et il est donc plus judicieux de réutiliser, si possible, les mêmes acteurs
pour les données importées.
394
Chapitre 12 : Méthodes
Dans Director et les projections, importFileInto() télécharge automatiquement le fichier.
Dans Shockwave Player, appelez preloadNetThing() et attendez la fin du téléchargement avant
d’utiliser importFileInto() avec le fichier.
Paramètres
chaîneFichierOuUrl Requis. Chaîne qui spécifie le fichier qui remplacera le contenu de l’acteur.
Exemple
Le gestionnaire suivant affecte une URL contenant un fichier GIF à la variable URLtemporaire,
puis utilise la commande importFileInto pour importer le fichier de l’URL dans un nouvel
acteur bitmap :
-- Syntaxe Lingo
on exitFrame
URLtemporaire = "http://www.uneUrl.fr/couronne.gif"
_movie.newMember(#bitmap).importFileInto(URLtemporaire)
end
// Syntaxe JavaScript
function exitFrame() {
var URLtemporaire = "http://www.dukeOfUrl.com/crown.gif";
_movie.newMember("bitmap").importFileInto(URLtemporaire);
}
L’instruction suivante remplace le contenu de l’acteur son Mémoire par le fichier audio Vent :
-- Syntaxe Lingo
member("Mémoire").importFileInto("Vent.wav")
// Syntaxe JavaScript
member("Mémoire").importFileInto("Vent.wav");
Les instructions suivantes téléchargent un fichier externe depuis une URL dans le dossier de
Director et importent ce fichier dans l’acteur son Norma Desmond parle :
-- Syntaxe Lingo
downLoadNetThing("http://www.cbDeMille.com/CinémaParlant.AIF", \
_player.applicationPath & "CinémaParlant.AIF")
member("Norma Desmond parle").importFileInto(_player.applicationPath &
"CinémaParlant.AIF")
// Syntaxe JavaScript
downLoadNetThing("http://www.cbDeMille.com/CinémaParlant.AIF",
_player.applicationPath + "CinémaParlant.AIF");
member("Norma Desmond parle").importFileInto(_player.applicationPath +
"CinémaParlant.AIF");
Voir aussi
downloadNetThing, fileName (fenêtre), Acteur, preloadNetThing()
395
insertBackdrop
Utilisation
sprite(quelleImageObjet).camera{(index)}.insertBackdrop(index, \
texture, emplacementDansLimageObjet, rotation)
member(quelActeur).camera(quelleCaméra).\
insertBackdrop(index, texture, emplacementDansLimageObjet, rotation)
Description
Commande 3D de caméra ; ajoute un fond à la liste des fonds de la caméra, à une position
spécifiée dans la liste.
Paramètres
index Requis. Spécifie la position d’index où le fond est ajouté dans la liste des fonds de la
caméra.
texture
Requis. Spécifie la texture du fond ajouté.
emplacementDansLimageObjet Requis. Emplacement 2D dont le fond est affiché dans l’imageobjet 3D. Cet emplacement est mesuré à partir du coin supérieur gauche de l’image-objet.
rotation
Facultatif. Spécifie la rotation texture du fond ajouté.
Exemple
La première ligne de l’exemple suivant crée une texture nommée Cèdre. La deuxième ligne insère
cette texture à la première position de la liste des fonds de la caméra de l’image-objet 5. Le fond
est placé au point (300, 120), mesuré à partir du coin supérieur gauche de l’image-objet. La
rotation est de 45°.
t1 = member("Scène").texture("Cèdre")
sprite(5).camera.insertBackdrop(1, t1, point(300, 120), 45)
Voir aussi
removeBackdrop, bevelDepth, overlay
insertFrame()
Utilisation
-- Syntaxe Lingo
_movie.insertFrame()
// Syntaxe JavaScript
_movie.insertFrame();
Description
Méthode d’animation ; crée une copie de l’image courante et de son contenu.
L’image copiée est insérée après l’image courante et devient alors l’image courante.
Cette méthode ne peut être utilisée que pendant une session d’enregistrement du scénario et
remplit la même fonction que la méthode duplicateFrame().
Paramètres
Aucun.
396
Chapitre 12 : Méthodes
Exemple
Le gestionnaire suivant crée une image dans laquelle l’acteur transition Brouillard est affecté à la
piste des transitions, suivie d’un groupe d’images vides. L’argument nombreDimages définit ce
nombre d’images.
-- Syntaxe Lingo
on animBalle(nombreDimages)
_movie.beginRecording()
_movie.frameTransition = member("Brouillard").number
_movie.go(_movie.frame +1)
repeat with i = 0 to nombreDimages
_movie.insertFrame()
end repeat
_movie.endRecording()
end animBalle
// Syntaxe JavaScript
function animBalle(nombreDimages) {
_movie.beginRecording();
_movie.frameTransition = member("Brouillard").number;
_movie.go(_movie.frame+1);
for (var i = 0; i <= nombreDimages; i++) {
_movie.insertFrame();
}
_movie.endRecording();
}
Voir aussi
duplicateFrame(), Animation
insertOverlay
Utilisation
sprite(quelleImageObjet).camera{(index)}.insertOverlay(index, \
texture, emplacementDansLimageObjet, rotation)
member(quelActeur).camera(quelleCaméra).\
insertOverlay(index, texture, \
emplacementDansLimageObjet, rotation)
Description
Commande 3D de caméra ; ajoute un recouvrement à la liste des recouvrements de la caméra, à
une position spécifiée dans la liste.
Paramètres
index Requis. Spécifie la position d’index où le recouvrement est ajouté dans la liste des recouvre-
ments de la caméra.
texture
Requis. Spécifie la texture du recouvrement ajouté.
emplacementDansLimageObjet Requis. Emplacement 2D auquel où le recouvrement est affiché
dans l’image-objet 3D. Cet emplacement est mesuré à partir du coin supérieur gauche de l’imageobjet.
rotation
Facultatif. Spécifie la rotation texture du recouvrement ajouté.
397
Exemple
La première ligne de l’exemple suivant crée une texture nommée Cèdre. La deuxième ligne insère
cette texture à la première position de la liste des recouvrements de la caméra de l’image-objet 5.
Le recouvrement est placé au point (300, 120), mesuré à partir du coin supérieur gauche de
l’image-objet. La rotation est de 45°.
t1 = member("Scène").texture("Cèdre")
sprite(5).camera.insertOverlay(1, t1, point(300, 120), 45)
Voir aussi
removeOverlay, overlay, bevelDepth
inside()
Utilisation
point.inside(rectangle)
inside(point, rectangle)
Description
Fonction ; indique si un point donné se trouve à l’intérieur d’un rectangle spécifié (TRUE) ou en
dehors (FALSE).
Paramètres
rectangle
Requis. Spécifie le rectangle qui contient le point à tester.
Exemple
L’instruction suivante indique si le point Centre se trouve à l’intérieur du rectangle Zone et
affiche le résultat dans la fenêtre Messages :
put Centre.inside(Zone)
Voir aussi
map(), mouseH, mouseV, point()
installMenu
Utilisation
installMenu réfObjActeurChamp
Description
Commande ; installe le menu défini dans l’acteur champ spécifié par réfObjActeurChamp. Ces
menus personnalisés n’apparaissent que pendant la lecture de l’animation. Pour les supprimer,
utilisez la commande installMenu sans argument, ou avec 0 comme argument. Cette
commande ne fonctionne pas avec les menus hiérarchiques.
Pour plus de détails sur la définition d’articles de menus dans les acteurs champ, consultez le motclé menu.
Il est conseillé d’éviter la modification fréquente des menus, celle-ci affectant les ressources du
système.
398
Chapitre 12 : Méthodes
Sous Windows, si le menu ne tient pas à l’écran, seule une partie est affichée. Sur Macintosh, vous
pouvez faire défiler les menus qui ne tiennent pas à l’écran.
Remarque : Les menus ne sont pas disponibles dans Shockwave Player.
Paramètres
réfObjActeurChamp
Facultatif. Spécifie l’acteur champ dans lequel un menu est installé.
Exemple
L’instruction suivante installe le menu défini dans l’acteur champ 37 :
installMenu 37
L’instruction suivante installe le menu défini dans l’acteur champ Barre de menu :
installMenu member "Barre de menu"
L’instruction suivante désactive les menus qui ont été installés avec la commande installMenu :
installMenu 0
Voir aussi
menu
integer()
Utilisation
(expressionNumérique).integer
integer(expressionNumérique)
Description
Fonction (Lingo uniquement) ; arrondit la valeur d’une expression au nombre entier le plus
proche.
Vous pouvez forcer un nombre entier en une chaîne avec la fonction string().
Dans la syntaxe JavaScript, utilisez la fonction parseInt().
Paramètres
expressionNumérique
Requis. La valeur numérique à arrondir à un nombre entier.
Exemple
L’instruction suivante arrondit le nombre 3,75 au nombre entier le plus proche :
put integer(3.75)
-- 4
L’instruction suivante arrondit la valeur entre parenthèses. Cela permet de donner une valeur
utilisable à la propriété d’image-objet locH, qui exige un nombre entier :
sprite(1).locH = integer(0.333 * largeurDeScène)
Voir aussi
float(), string()
399
integerP()
Utilisation
expression.integerP
(expressionNumérique).integerP
integerP(expression)
Description
Fonction (Lingo uniquement) ; indique si une expression spécifiée est un entier (1 ou TRUE) ou
non (0 ou FALSE). Le P de la fonction integerP signifie prédicat.
Paramètres
expression
Requis. Expression à tester.
Exemple
L’instruction suivante vérifie si le nombre 3 est un entier et affiche 1 (TRUE) dans la fenêtre
Messages :
put(3).integerP
-- 1
L’instruction suivante vérifie si le nombre 3 est un entier. Puisque le nombre 3 est entouré de
guillemets droits, il n’est pas considéré comme un entier et 0 (FALSE) est affiché dans la fenêtre
Messages :
put("3").integerP
-- 0
L’instruction suivante vérifie si la valeur numérique de la chaîne de l’acteur champ Saisie est un
entier et affiche une alerte si ce n’est pas le cas :
if field("Saisie").value.integerP = FALSE then alert "Saisissez un entier."
Voir aussi
floatP(), integer(), ilk(), objectP(), stringP(), symbolP()
interface()
Utilisation
xtra("nomDeLxtra").interface()
interface(xtra "nomDeLxtra")
Description
Fonction ; renvoie une chaîne délimitée par des retours chariot décrivant l’Xtra et fournissant une
liste de ses méthodes. Cette fonction remplace maintenant la fonction obsolète mMessageList.
Paramètres
Aucun.
Exemple
L’instruction suivante affiche les données produites par cette fonction utilisée avec l’Xtra
QuickTime Asset dans la fenêtre Messages :
put Xtra("QuickTimeSupport").interface()
400
Chapitre 12 : Méthodes
interpolate()
Utilisation
transformation1.interpolate(transformation2,pourcentage)
Description
Méthode 3D transform ; renvoie une copie de transformation1 créée par l’interpolation
de la position et de la rotation de transformation1 et de la position et de la rotation de
transformation2, en fonction du pourcentage spécifié. La transformation1 d’origine n’est
pas affectée. Pour interpoler transformation1, utilisez interpolateTo().
Pour effectuer l’interpolation manuellement, multipliez la différence des deux nombres par le
pourcentage. Par exemple, l’interpolation de 4 à 8 par 50 % donne 6.
Exemple
Dans l’exemple suivant, tBoîte est la transformation du modèle nommé Boîte et tSphère est la
transformation du modèle nommé Sphère. La troisième ligne de l’exemple interpole une copie
de la transformation de Boîte à mi-chemin jusqu’à la transformation de Sphère.
tBoîte = member("Univers 3D").model("Boîte").transform
tSphère = member("Univers 3D").model("Sphère").transform
tNouv = tBoîte.interpolate(tSphère, 50)
Voir aussi
interpolateTo()
interpolateTo()
Utilisation
transformation1.interpolateTo(transformation2, pourcentage)
Description
Méthode 3D transform ; modifie transformation1 en interpolant la position et la rotation de
transformation1 par la position et la rotation d’une nouvelle transformation en fonction d’un
pourcentage spécifié. La transformation1 d’origine est changée. Pour interpoler une copie de
transformation1, utilisez la fonction interpolate().
Pour effectuer l’interpolation manuellement, multipliez la différence des deux nombres par le
pourcentage. Par exemple, l’interpolation de 4 à 8 par 50 % donne 6.
Paramètres
transformation2 Requis. Spécifie la transformation résultant de l’interpolation d’une
transformation donnée.
pourcentage
Requis. Spéifie le pourcentage de rotation de transformation2.
401
Exemple
Dans l’exemple suivant, tBoîte est la transformation du modèle nommé Boîte et tSphère est la
transformation du modèle nommé Sphère. La troisième ligne de l’exemple interpole la transformation de Boîte à mi-chemin jusqu’à la transformation de Sphère.
tBoîte = member("Univers 3D").model("Boîte").transform
tSphère = member("Univers 3D").model("Sphère").transform
tBoîte.interpolateTo(tSphère, 50)
Voir aussi
interpolate()
intersect()
Utilisation
rectangle1. intersect(rectangle2)
intersect(rectangle1, rectangle2)
Description
Fonction ; détermine le rectangle formé par l’intersection de deux rectangles.
Paramètres
rectangle2
Requis. Spécifie le second rectangle du test d’intersection.
Exemple
Cette instruction affecte la variable nouveauRectangle au rectangle formé par l’intersection du
rectangle Outils avec le rectangle Rampe :
nouveauRectangle = Outils.intersect(Rampe)
Voir aussi
map(), rect(), union()
inverse()
Utilisation
member(quelActeur).model(quelModèle).transform.inverse()
member(quelActeur).group(quelGroupe).transform.inverse()
member(quelActeur).camera(quelleCaméra).transform.inverse()
sprite(quelleImageObjet).camera{(index)}.transform.inverse()
member(quelActeur).light(quelleLumière).transform.inverse()
référenceDeTransformation.inverse()
Description
Méthode 3D transform ; renvoie une copie de la transformation, avec ses propriétés de position
et de rotation inversées.
Cette méthode ne change pas la transformation d’origine. Pour inverser la transformation
d’origine, utilisez la fonction invert().
Paramètres
Aucun.
402
Chapitre 12 : Méthodes
Exemple
L’instruction suivante inverse une copie de la transformation du modèle Fauteuil.
boxInv = member("Univers 3D").model("Fauteuil").transform.inverse()
Voir aussi
invert()
invert()
Utilisation
member(quelActeur).model(quelModèle).transform.invert()
member(quelActeur).group(quelGroupe).transform.invert()
member(quelActeur).camera(quelleCaméra).transform.invert()
sprite(quelleImageObjet).camera{(index)}.transform.invert()
member(quelActeur).light(quelleLumière).transform.invert()
référenceDeTransformation.invert()
Description
Méthode 3D transform ; inverse les propriétés de position et de rotation de la transformation.
Cette méthode change la transformation d’origine. Pour inverser une copie de la transformation
d’origine, utilisez la fonction inverse().
Paramètres
Aucun.
Exemple
L’instruction suivante inverse la transformation du modèle Boîte.
member("Univers 3D").model("Boîte").transform.invert()
Voir aussi
inverse()
isBusy()
Utilisation
-- Syntaxe Lingo
réfObjPisteAudio.isBusy()
// Syntaxe JavaScript
réfObjPisteAudio.isBusy();
Description
Méthode de piste audio ; détermine si un son est lu (TRUE) ou non (FALSE) sur une piste audio.
Vérifiez d’abord que la tête de lecture a bougé avant d’utiliser isBusy() pour vérifier la piste
audio. Si cette fonction continue de renvoyer la valeur FALSE après la lecture présumée d’un son,
ajoutez la méthode updateStage() pour démarrer la lecture du son avant que la tête de lecture
ne se remette à bouger.
403
Cette méthode fonctionne avec les pistes audio occupées par des acteurs son réels. Dans la mesure
où les composants audio QuickTime, Flash et Shockwave gèrent le son différemment, cette
méthode ne peut pas fonctionner avec ces types de médias.
Il est conseillé d’utiliser la propriété status d’une piste audio, plutôt que la propriété isBusy().
La propriété status s’avère plus appropriée dans la plupart des cas.
Paramètres
Aucun.
Exemple
L’instruction suivante vérifie si un son est lu dans la piste audio 1 et, le cas échéant, effectue une
lecture en boucle dans l’image. Cela permet au son d’être lu en entier avant que la tête de lecture
ne passe à une autre image.
-- Syntaxe Lingo
if (sound(1).isBusy()) then
_movie.go(_movie.frame)
end if
// Syntaxe JavaScript
if (sound(1).isBusy()) {
_movie.go(_movie.frame);
}
Voir aussi
status, Piste audio
isInWorld()
Utilisation
member(quelActeur).model(quelModèle).isInWorld()
member(quelActeur).camera(quelleCaméra).isInWorld()
member(quelActeur).light(quelleLumière).isInWorld()
member(quelActeur).group(quelGroupe).isInWorld()
Description
Commande 3D ; renvoie la valeur TRUE si la hiérarchie parent du modèle, de la caméra, de la
lumière ou du groupe se termine dans l’univers. Si la valeur de isInWorld est TRUE, le modèle, la
caméra, la lumière, ou le groupe, fonctionne dans l’univers 3D de l’acteur.
Les modèles, caméras, lumières et groupes peuvent être enregistrés dans un acteur 3D mais ne
peuvent pas être utilisés dans son univers 3D. Utilisez les commandes addToWorld et
removeFromWorld pour ajouter et supprimer des modèles, des caméras, des lumières et des
groupes de l’univers 3D de l’acteur.
Paramètres
Aucun.
404
Chapitre 12 : Méthodes
Exemple
L’instruction suivante indique que le modèle Théière existe dans l’univers 3D de l’acteur
scèneDeTable.
put member("ScèneDeTable").model("Théière").isInWorld()
-- 1
Voir aussi
addToWorld, removeFromWorld, child (3D)
isPastCuePoint()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.isPastCuePoint(IDduRepère)
// Syntaxe JavaScript
réfObjImageObjet.isPastCuePoint(IDduRepère);
Description
Fonction ; détermine si une piste d’image-objet ou une piste audio est passée par un point de
repère spécifié dans ses médias. Cette fonction peut être utilisée avec les fichiers audio (WAV,
AIFF, SND, SWA, AU), QuickTime ou Xtra supportant les points de repère.
Remplacez réfObjImageObjet par une piste d’image-objet ou une piste audio. Les sons
Shockwave Audio (SWA) peuvent apparaître sous forme d’images-objets dans les pistes d’imagesobjets, mais sont lus dans les pistes audio. Il est conseillé de faire référence aux images-objets
audio SWA par le numéro de leur piste d’image-objet plutôt que par celui de leur piste audio.
Remplacez IDduRepère par une référence à un point de repère :
• Si IDduRepère est un entier, isPastCuePoint renvoie 1 si le point de repère a été dépassé et 0
•
dans le cas contraire.
Si IDduRepère est un nom, isPastCuePoint renvoie le nombre de points de repère dépassés
portant ce nom.
Si la valeur spécifiée pour IDduRepère n’existe pas dans l’image-objet ou le son, la fonction
renvoie 0.
Le nombre renvoyé par isPastCuePoint est basé sur la position absolue de l’image-objet dans
son média. Par exemple, lorsqu’un son dépasse le point de repère Principal, puis se met en boucle
et dépasse de nouveau ce point de repère, isPastCuePoint renvoie 1 au lieu de 2.
Lorsque le résultat de isPastCuePoint est traité comme un opérateur booléen, la fonction
renvoie la valeur TRUE si un point identifié par IDduRepère a été dépassé et FALSE si ce n’est pas le
cas.
Paramètres
Requis. Chaîne ou nombre entier qui spécifie le nom ou le numéro du point de
repère spécifié.
IDduRepère
405
Exemple
L’instruction suivante lit un son jusqu’au troisième passage sur le point de repère Fin du choeur :
-- Syntaxe Lingo
if (sound(1).isPastCuePoint("Fin du chœur")=3) then
sound(1).stop()
end if
// Syntaxe JavaScript
var fc = sound(1).isPastCuePoint("Fin du chœur");
if (fc == 3) {
sound(1).stop();
}
L’exemple suivant permet d’afficher dans l’acteur « champ 2 » des informations concernant la
lecture de la musique sur la piste audio 1. Si le point de repère « Apogée » n’a pas encore été
atteint, le texte de « champ 2 » est « Début du morceau. » Sinon, le texte est « Fin du morceau. »
-- Syntaxe Lingo
if not sound(1).isPastCuePoint("Apogée") then
member("champ 2").text = "Début du morceau."
else
member("champ 2").text = "Fin du morceau."
end if
// Syntaxe JavaScript
var fc = sound(1).isPastCuePoint("Apogée");
if (cmx != 1) {
member("champ 2").text = "Début du morceau.";
} else {
member("champ 2").text = "Fin du morceau.";
}
keyPressed()
Utilisation
-- Syntaxe Lingo
_key.keyPressed({codeOuCaractèreDeTouche})
// Syntaxe JavaScript
_key.keyPressed({codeOuCaractèreDeTouche});
Description
Méthode de touche ; renvoie la chaîne de caractères affectée à la dernière touche activée ou,
éventuellement, indique si une touche spécifiée a été activée.
Si le paramètre codeOuCaractèreDeTouche est omis, cette méthode renvoie la chaîne de
caractères affectée à la dernière touche activée. Si aucune touche n’a été activée, elle renvoie une
chaîne vide.
Lorsque le paramètre codeOuCaractèreDeTouche est utilisé pour spécifier la touche actuellement
activée, cette méthode renvoie TRUE si l’utilisateur appuie sur cette touche spécifique ou FALSE
dans le cas contraire.
Cette méthode est mise à jour lorsque l’utilisateur appuie sur des touches pendant une boucle
repeat (Lingo) ou for (syntaxe JavaScript). Elle présente un avantage par rapport à la propriété
key, qui n’est pas mise à jour pendant une boucle repeat ou for.
406
Chapitre 12 : Méthodes
Utilisez l’animation Clavier et Lingo pour tester la correspondance entre les caractères et les
touches sur différents claviers.
Paramètres
codeOuCaractèreDeTouche
Facultatif. Code de touche ou chaîne de caractères ASCII à tester.
Exemple
L’instruction suivante vérifie si l’utilisateur a appuyé sur la touche Entrée sous Windows ou sur la
touche Retour du Macintosh et, le cas échéant, exécute le gestionnaire miseAjourDesDonnées :
-- Syntaxe Lingo
if (_key.keyPressed(RETURN)) then
miseAjourDesDonnées
end if
// Syntaxe JavaScript
if (_key.keyPressed(36)) {
miseAjourDesDonnées();
}
L'instruction suivante utilise le code de la touche a pour vérifier si elle est enfoncée et affiche le
résultat dans la fenêtre Messages :
-- Syntaxe Lingo
if (_key.keyPressed(0)) then
put("La touche est enfoncée")
end if
// Syntaxe JavaScript
if (_key.keyPressed(0)) {
put("La touche est enfoncée");
}
L’instruction suivante utilise les chaînes ASCII pour vérifier si les touches a et b sont enfoncées et
affiche le résultat dans la fenêtre Messages :
-- Syntaxe Lingo
if (_key.keyPressed("a") and _key.keyPressed("b")) then
put("Les deux touches sont enfoncées")
end if
// Syntaxe JavaScript
if (_key.keyPressed("a") && _key.keyPressed("b")) {
put("Les deux touches sont enfoncées");
}
Voir aussi
Touche, key, keyCode
407
label()
Utilisation
-- Syntaxe Lingo
_movie.label(chaîneNomDeRepère)
// Syntaxe JavaScript
_movie.label(chaîneNomDeRepère);
Description
Méthode d’animation ; indique l’image associée à un libellé de repère.
Le paramètre chaîneNomDeRepère doit être un libellé dans l’animation courante. Si ce n’est pas le
cas, cette méthode renvoie 0.
Paramètres
chaîneNomDeRepère
Requis. Chaîne qui spécifie le nom du libellé de repère associé à une image.
Exemple
L’instruction suivante place la tête de lecture sur la dixième image après le repère intitulé Début :
-- Syntaxe Lingo
_movie.go(_movie.label("Début") + 10)
// Syntaxe JavaScript
_movie.go(_movie.label("Début") + 10);
Voir aussi
frameLabel, go(), labelList, Animation
last()
Utilisation
the last sousChaîne of ( expressionSousChaîne )
the last sousChaîne in (expressionSousChaîne)
Description
Fonction ; identifie la dernière sous-chaîne dans une expression de sous-chaîne.
Les expressions de sous-chaînes peuvent correspondre à tout caractère, mot, élément ou ligne
extrait d’un conteneur de caractères. Les conteneurs peuvent être des acteurs champ, des variables
contenant des chaînes, et les caractères, mots, lignes et plages spécifiés dans les conteneurs.
Paramètres
expressionSousChaîne
Requis. Spécifie l’expression de sous-chaîne qui contient la dernière
sous-chaîne.
Exemple
L’instruction suivante identifie le dernier mot de la chaîne Macromedia, la société multimédia et
affiche le résultat dans la fenêtre Messages :
put the last word of "Macromedia, la société multimédia"
Le résultat est le mot multimédia.
408
Chapitre 12 : Méthodes
L’instruction suivante identifie le dernier caractère de la chaîne Macromedia, la société
multimédia et affiche le résultat dans la fenêtre Messages :
put last char("Macromedia, la société multimédia")
Le résultat est la lettre a.
Voir aussi
char...of, word...of
lastClick()
Utilisation
the lastClick
Description
Fonction ; renvoie le nombre de battements (1 battement = 1/60ème de seconde) écoulés depuis
le dernier clic de la souris.
Cette fonction peut être testée, mais pas définie.
Paramètres
Aucun.
Exemple
L’instruction suivante vérifie si 10 secondes se sont écoulées depuis le dernier clic de la souris et, le
cas échéant, fait passer la tête de lecture sur le repère Pas de clic :
if the lastClick > 10 * 60 then go to "Pas de clic"
Voir aussi
lastEvent(), lastKey, lastRoll, milliseconds
lastEvent()
Utilisation
the lastEvent
Description
Fonction ; renvoie le nombre de battements (1 battement = 1/60ème de seconde) écoulés depuis
la dernière fois où l’utilisateur a appuyé sur le bouton de la souris, a survolé un élément avec la
souris ou a appuyé sur une touche.
Paramètres
Aucun.
409
Exemple
L’instruction suivante vérifie si 10 secondes se sont écoulées depuis la dernière fois où l’utilisateur
a appuyé sur le bouton de la souris, a survolé un élément avec la souris ou a appuyé sur une
touche. Si c’est le cas, la tête de lecture est placée sur le repère Aide :
if the lastEvent > 10 * 60 then go to "Aide"
Voir aussi
lastClick(), lastKey, lastRoll, milliseconds
length()
Utilisation
chaîne.length
length(chaîne)
Description
Fonction ; renvoie le nombre de caractères de la chaîne spécifiée par chaîne, y compris les espaces
et les caractères de contrôle tels que Tab et Retour.
Paramètres
Aucun.
Exemple
L’instruction suivante affiche le nombre de caractères de la chaîne « Macro »&« media » :
put ("Macro" & "media").length
-- 10
L’instruction suivante vérifie si le contenu de l’acteur champ Nom de fichier contient plus de 31
caractères et, le cas échéant, affiche un message d’alerte :
-- Syntaxe Lingo
if member("Nom de fichier").text.length > 31 then
alert "Ce nom de fichier est trop long."
end if
// Syntaxe JavaScript
if (member("Nom de fichier").text.length > 31) {
alert ("Ce nom de fichier est trop long.");
}
Voir aussi
chars(), offset() (fonction de chaîne)
light()
Utilisation
member(quelActeur).light(quelleLumière)
member(quelActeur).light[index]
member(quelActeur).light(quelleLumière).quellePropriétéDeLumière
member(quelActeur).light[index].quellePropriétéDeLumière
Description
Elément 3D ; objet à une position de vecteur à partir de laquelle la lumière émane.
410
Chapitre 12 : Méthodes
Pour une liste complète des propriétés et des méthodes, consultez les rubriques Utilisation de
Director dans le panneau d’aide de Director.
Exemple
L’exemple suivant indique les deux façons de faire référence à une lumière. La première ligne
utilise une chaîne entre parenthèses et la seconde utilise un nombre entre crochets. La chaîne
correspond au nom de la lumière et le nombre à la position de la lumière dans la liste des lumières
de l’acteur.
cetteLumière = member("Univers 3D").light("spot01")
cetteLumière = member("Univers 3D").light[2]
Voir aussi
newLight, deleteLight
lineHeight()
Utilisation
-- Syntaxe Lingo
réfObjActeur.lineHeight(numéroDeLigne)
// Syntaxe JavaScript
réfObjActeur.lineHeight(numéroDeLigne);
Description
Fonction ; renvoie la hauteur, en pixels, d’une ligne spécifique dans un acteur champ spécifié.
Paramètres
numéroDeLigne
Requis. Nombre entier qui spécifie la ligne à mesurer.
Exemple
Cette instruction détermine la hauteur, en pixels, de la première ligne de l’acteur champ
Nouvelles du jour et affecte le résultat à la variable titre :
-- Syntaxe Lingo
titre = member("Nouvelles du jour").lineHeight(1)
// Syntaxe JavaScript
var titre = member("Nouvelles du jour").lineHeight(1);
linePosToLocV()
Utilisation
-- Syntaxe Lingo
réfObjActeur.linePosToLocV(numéroDeLigne)
// Syntaxe JavaScript
réfObjActeur.linePosToLocV(numéroDeLigne);
Description
Fonction ; renvoie la distance, en pixels, d’une ligne spécifique à partir du bord supérieur de
l’acteur champ spécifié.
411
Paramètres
numéroDeLigne
Requis. Nombre entier qui spécifie la ligne à mesurer.
Exemple
Cette instruction mesure la distance, en pixels, entre la deuxième ligne de l’acteur champ
Nouvelles du jour et le bord supérieur de l’acteur et affecte le résultat à la variable
débutDeChaîne :
-- Syntaxe Lingo
débutDeChaîne = member("Nouvelles du jour").linePosToLocV(2)
// Syntaxe JavaScript
var débutDeChaîne = member("Nouvelles du jour").linePosToLocV(2);
linkAs()
Utilisation
unActeur.linkAs()
Description
Fonction d’acteur script ; ouvre une boîte de dialogue d’enregistrement, permettant d’enregistrer
le contenu du script dans un fichier externe. L’acteur script est alors lié à ce fichier.
Les scripts liés sont importés dans l’animation lorsque vous les enregistrez comme projection ou
comme animation avec un contenu Shockwave. Ceci diffère des autres médias liés, qui restent
externes à l’animation, à moins que vous ne les importiez explicitement.
Paramètres
Aucun.
Exemple
L’instruction suivante, saisie dans la fenêtre Messages, ouvre une boîte de dialogue
d’enregistrement, permettant d’enregistrer le script Mouvement aléatoire comme fichier externe :
member("Mouvement aléatoire").linkAs()
importFileInto, linked
list()
Utilisation
-- Syntaxe Lingo
list()
[]
list(valeurDeChaîne1, valeurDeChaîne2, ...)
[valeurDeChaîne1, valeurDeChaîne2, ...]
// Syntaxe JavaScript
list();
list(valeurDeChaîne1, valeurDeChaîne2, ...);
Description
Fonction du niveau supérieur ; crée une liste linéaire.
412
Chapitre 12 : Méthodes
Lorsque vous créez une liste en utilisant la syntaxe list(), avec ou sans paramètres, les valeurs de
la liste sont indexées à partir de 1.
Lorsque vous créez une liste en utilisant la syntaxe [], avec ou sans paramètres, les valeurs de la
liste sont indexées à partir de 0.
La longueur maximale d’une ligne de script exécutable est de 256 caractères. Il n’est pas possible
de créer des listes importantes avec list(). Pour créer une liste contenant une grande quantité de
données, mettez les données entre crochets ([]), placez-les dans un champ, puis affectez le champ
à une variable. Le contenu de cette variable deviendra une liste des données.
Paramètres
valeurDeChaîne1, valeurDeChaîne2 ...
Facultatif. Liste de chaînes qui spécifient les valeurs
initiales dans la liste.
Exemple
L’instruction suivante associe la variable Designers à une liste linéaire contenant les noms Jean,
Pierre et Marc :
-- Syntaxe Lingo
designers = list("Jean", "Pierre", "Marc") – utilisation de list()
designers = ["Jean", "Pierre", "Marc"] – utilisation de crochets
// Syntaxe JavaScript
var designers = list("Jean", "Pierre", "Marc");
Voir aussi
propList()
listP()
Utilisation
listP(élément)
Description
Fonction ; indique si un élément spécifié est une liste, un rectangle ou un point (1 ou TRUE) ou
non (0 ou FALSE).
Paramètres
élément
Requis. Spécifie l’élément à tester.
Exemple
L’instruction suivante vérifie si la liste contenue dans la variable designers est une liste, un
rectangle ou un point et affiche le résultat dans la fenêtre Messages :
put listP(designers)
Le résultat est 1, équivalent numérique de TRUE.
Voir aussi
ilk(), objectP()
413
loadFile()
Utilisation
member(quelActeur).loadFile(nomDeFichier {, écraser?, \
générerDesNomsUniques?})
Description
Commande d’acteur 3D ; importe les actifs d’un fichier *.w3d dans un acteur.
La propriété state de l’acteur doit avoir pour valeur -1 (erreur) ou 4 (chargé) avant l’utilisation
de la commande loadFile.
Paramètres
nomDeFichier
Requis. Spécifie le fichier *.w3d qui contient les actifs à importer.
écraser? Facultatif. Indique si les actifs du fichier *.w3d remplacent ceux de l’acteur (TRUE) ou
s’ils sont ajoutés à ceux de l’acteur (FALSE). La valeur par défaut de écraser? est TRUE.
générerDesNomsUniques? Facultatif. Si ce paramètre a pour valeur TRUE, tout élément du fichier
*.w3d portant le même nom qu’un élément correspondant de l’acteur sera renommé. S’il a pour
valeur FALSE, les éléments de l’acteur seront remplacés par les éléments correspondants ayant le
même nom dans le fichier *.w3d. La valeur par défaut de générerDesNomsUniques? est TRUE.
Exemple
L’instruction suivante importe le contenu du fichier Camion.w3d dans l’acteur Route. Le
contenu de Camion.w3d sera ajouté au contenu de Route. Si certains objets importés ont le
même nom que des objets déjà présents dans Route, Director leur donnera un nouveau nom.
member("Route").loadFile("Camion.w3d", FALSE, TRUE)
L’instruction suivante importe le contenu du fichier Chevy.w3d dans l’acteur Route. Chevy.w3d
se trouve dans un dossier Modèles, un niveau au-dessous de l’animation. Le contenu de Route
sera remplacé par celui de Chevy.w3d. Le troisième paramètre n’a aucune importance étant
donné que la valeur du second paramètre est TRUE.
member("Route").loadFile(the moviePath & "Modèles\Chevy.w3d", \
TRUE, TRUE)
Voir aussi
state (3D)
locToCharPos()
Utilisation
-- Syntaxe Lingo
réfObjActeur.locToCharPos(emplacement)
// Syntaxe JavaScript
réfObjActeur.locToCharPos(emplacement);
Description
Fonction ; renvoie le numéro du caractère de l’acteur champ spécifié qui est le plus proche d’un
point dans le champ.
414
Chapitre 12 : Méthodes
La valeur 1 correspond au premier caractère de la chaîne, la valeur 2 au second caractère de cette
chaîne, et ainsi de suite.
Paramètres
emplacement Requis. Point à l’intérieur de l’acteur champ. La valeur de emplacement est un
point calculé par rapport au coin supérieur gauche de l’acteur champ.
Exemple
L’instruction suivante détermine le caractère le plus proche du point situé à 100 pixels sur la
droite et à 100 pixels en dessous du coin supérieur gauche de l’acteur champ Nouvelles du jour.
Elle affecte ensuite le résultat à la variable MiseEnPage.
-- Syntaxe Lingo
miseEnPage = member("Nouvelles du jour").locToCharPos(point(100, 100))
// Syntaxe JavaScript
var miseEnPage = member("Nouvelles du jour").locToCharPos(point(100, 100));
locVToLinePos()
Utilisation
-- Syntaxe Lingo
réfObjActeur.locVToLinePos(locV)
// Syntaxe JavaScript
réfObjActeur.locVToLinePos(locV);
Description
Fonction ; renvoie le numéro de la ligne de caractères apparaissant à une position verticale
spécifiée.
Paramètres
emplacementV Requis. Spécifie la position verticale de la ligne de caractères. Cette valeur
correspond au nombre de pixels depuis le haut de l’acteur champ, et non depuis la partie de
l’acteur champ actuellement affichée sur la scène.
Exemple
L’instruction suivante détermine la ligne de caractères qui apparaît à 150 pixels du haut de
l’acteur champ Nouvelles du jour et affecte le résultat à la variable sautDePage:
-- Syntaxe Lingo
sautDePage = member("Nouvelles du jour").locVToLinePos(150)
// Syntaxe JavaScript
var sautDePage = member("Nouvelles du jour").locVToLinePos(150);
415
log()
Utilisation
log(nombre)
Description
Fonction mathématique (Lingo uniquement) ; calcule le logarithme naturel d’un nombre
spécifié.
Dans la syntaxe JavaScript, utilisez la fonction log() de l’objet Math.
Paramètres
nombre Requis. Valeur numérique à partir de laquelle le logarithme naturel est calculé. Il doit
s’agir d’un nombre entier supérieur à 0.
Exemple
L’instruction suivante affecte le logarithme naturel de 10,5 à la variable Réponse.
Réponse = log(10.5)
Exemple
L’instruction suivante calcule le logarithme de la racine carrée de la valeur Nombre et affecte le
résultat à la variable Réponse :
Réponse = log(Nombre.sqrt)
makeList()
Utilisation
-- Syntaxe Lingo
objetDanalyse.makeList()
// Syntaxe JavaScript
objetDanalyse.makeList();
Description
Fonction ; renvoie une liste de propriétés basée sur le document XML analysé à l’aide de
parseString() ou parseURL().
Paramètres
Aucun.
416
Chapitre 12 : Méthodes
Exemple
Le gestionnaire suivant analyse un document XML et renvoie la liste résultante :
-- Syntaxe Lingo
on conversionEnListe chaîneXML
objetDanalyse = new(xtra "xmlparser")
codeErreur = objetDanalyse.parseString(chaîneXML)
chaîneDerreur = ObjetDanalyse.getError()
if voidP(chaîneDerreur) then
listeAnalysée = objetDanalyse.makeList()
else
alert "Désolé. Une erreur est survenue" && chaîneDerreur
exit
end if
return listeAnalysée
end
// Syntaxe JavaScript
function conversionEnListe(chaîneXML) {
objetDanalyse = new Xtra("xmlparser"); // vérifier la syntaxe
codeErreur = objetDanalyse.parseString(chaîneXML);
chaîneDerreur = objetDanalyse.getError();
if (voidP(chaîneDerreur)) {
listeAnalysée = objetDanalyse.makeList();
} else {
alert ("Désolé. Une erreur est survenue" + chaîneDerreur);
return FALSE;
}
return listeAnalysée;
}
Voir aussi
makeSubList()
makeScriptedSprite()
Utilisation
-- Syntaxe Lingo
réfObjPisteDimageObjet.makeScriptedSprite({réfObjActeur, emplacement})
// Syntaxe JavaScript
réfObjPisteDimageObjet.makeScriptedSprite({réfObjActeur, emplacement});
Description
Méthode de piste d’image-objet ; bascule le contrôle d’une piste d'image-objet du scénario vers le
script et place éventuellement une image-objet d’un acteur donné à un emplacement spécifié sur
la scène.
Appelez removeScriptedSprite() pour basculer de nouveau le contrôle de l’image-objet vers le
scénario.
417
Paramètres
réfObjActeur Facultatif. Référence à l’acteur à partir duquel une image-objet contrôlée par
script est créée. Si vous founissez seulement ce paramètre, l’image-objet est placée au centre de la
scène.
Facultatif. Point qui spécifie l’emplacement de la scène où est placée l’image-objet
contrôlée par script.
emplacement
Exemple
L’instruction suivante crée une image-objet scriptée dans la piste des images-objets 5 à partir de
l’acteur intitulé cerf-volant et la place à un point spécifique de la scène :
-- Syntaxe Lingo
channel(5).makeScriptedSprite(member("cerf-volant"), point(35, 70))
// Syntaxe JavaScript
channel(5).makeScriptedSprite(member("cerf-volant"), point(35, 70));
Voir aussi
removeScriptedSprite(), Piste d’image-objet
makeSubList()
Utilisation
nœudXML.makeSubList()
Description
Fonction ; renvoie une liste de propriétés d’un nœud enfant de la même façon que makeList()
renvoie la racine d’un document XML sous la forme d’une liste.
Paramètres
Aucun.
Exemple
Avec le code XML suivant :
<?xml version="1.0"?>
<e1>
<nomDeBalise attr1="val1" attr2="val2"/>
<e2>élém 2</e2>
<e3>élém 3</e3>
</e1>
L’instruction suivante renvoie une liste de propriétés constituée du contenu du premier enfant de
la balise <e1> :
put gObjetDanalyse.child[ 1 ].child[ 1 ].makeSubList()
-- ["nomDeBalise": ["!ATTRIBUTES": ["attr1": "val1", "attr2": "val2"]]]
Voir aussi
makeList()
418
Chapitre 12 : Méthodes
map()
Utilisation
map(rectCible, rectSource, rectDeDestination)
map(pointCible, rectSource, rectDeDestination)
Description
Fonction ; permet de positionner et de dimensionner un rectangle ou un point en fonction du
rapport existant entre un rectangle source et un rectangle cible.
La relation de la valeur pointCible avec la valeur rectSource contrôle la relation du résultat de
la fonction avec rectDeDestination.
Paramètres
rectCible
Requis. Rectangle cible dans la relation.
pointCible
Requis. Point cible dans la relation.
rectSource
Requis. Rectangle source dans la relation.
rectDeDestination
Requis. Rectangle de destination.
Exemple
Dans le comportement suivant, toutes les images-objets ont déjà été définies comme déplaçables.
L’image-objet 2b contient un petit bitmap. L’image-objet 1s est une image-objet de forme
rectangulaire, suffisamment grande pour contenir facilement l’image-objet 2b. L’image-objet 4b
est une version plus grande du bitmap compris dans l’image-objet 2b. L’image-objet 3s est une
version plus grande de la forme comprise dans l’image-objet 1s. Le déplacement des imagesobjets 2b ou 1s entraîne le déplacement de l’image-objet 4b. Lorsque vous faites glisser l’imageobjet 2b, ses mouvements sont copiés par l’image-objet 4b. Lorsque vous faites glisser l’imageobjet 1s, l’image-objet 4b se déplace dans la direction opposée. Le redimensionnement de
l’image-objet 2b ou 1s produira des résultats intéressants.
on exitFrame
sprite(4b).rect = map(sprite(2b).rect, sprite(1s).rect, sprite(3s).rect)
go the frame
end
map (3D)
Utilisation
member(quelActeur).motion(quelMouvement).\
map(quelAutreMouvement {, nomDeSegment})
Description
Commande de mouvement 3D ; mappe un mouvement spécifié sur le mouvement courant et
l’applique à un segment et à tous les enfants de ce dernier. Cette commande remplace tout
mouvement précédemment mappé dans le segment spécifié et ses enfants. Cette commande ne
modifie pas la liste de lecture d’un modèle.
419
Paramètres
quelAutreMouvement
Requis. Chaîne qui spécifie le nom du mouvement à mapper.
Facultatif. Chaîne qui spécifie le nom du segment auquel le mouvement mappé
est appliqué. Si ce paramètre est omis, le segment racine est utilisé.
nomDeSegment
Exemple
L’instruction suivante mappe le mouvement Plafond au mouvement Assis, à partir du segment
Cou. Le modèle s’assiéra et regardera le plafond simultanément.
member("Restaurant").motion("Assis").map("Plafond", "Cou")
Voir aussi
motion(), duration (3D), cloneMotionFromCastmember
mapMemberToStage()
Utilisation
sprite(quelNuméroDimageObjet).mapMemberToStage(quelPointDeLacteur)
mapMemberToStage(sprite quelNuméroDimageObjet, quelPointDeLacteur)
Description
Fonction ; utilise l’image-objet et le point spécifiés pour renvoyer un point équivalent dans les
dimensions de la scène. Cette propriété tient compte de la transformation actuelle de l’imageobjet en utilisant quad ou le rectangle si celui-ci n’est pas transformé.
Elle est idéale pour déterminer si l’utilisateur a cliqué sur une zone spécifique d’un acteur, même
si son image-objet sur la scène a été transformée de manière importante.
Si le point de la scène spécifié ne se trouve pas à l’intérieur de l’image-objet, la valeur VOID est
renvoyée.
Paramètres
quelPointDeLacteur
Requis. Point à partir duquel un point équivalent est renvoyé.
Voir aussi
map(), mapStageToMember()
mapStageToMember()
Utilisation
sprite(quelNuméroDimageObjet).mapStageToMember(quelPointDeLaScène)
mapStageToMember(sprite quelNuméroDimageObjet, quelPointDeLaScène)
Description
Fonction ; utilise l’image-objet et le point spécifiés pour renvoyer un point équivalent dans les
dimensions de l’acteur. Cette propriété tient compte de la transformation actuelle de l’imageobjet en utilisant quad ou le rectangle si celui-ci n’est pas transformé.
Elle est idéale pour déterminer si l’utilisateur a cliqué sur une zone spécifique d’un acteur, même
si son image-objet sur la scène a été transformée de manière importante.
420
Chapitre 12 : Méthodes
Si le point de la scène spécifié ne se trouve pas à l’intérieur de l’image-objet, cette fonction renvoie
la valeur VOID.
Paramètres
quelPointDeLaScène
Requis. Point à partir duquel un point équivalent est renvoyé.
Voir aussi
map(), mapMemberToStage()
marker()
Utilisation
-- Syntaxe Lingo
_movie.marker(nomOuNumDeRepère)
// Syntaxe JavaScript
_movie.marker(nomOuNumDeRepère);
Description
Méthode d’animation ; renvoie le numéro des repères situés avant et après l’image courante.
Cette méthode est utile pour implémenter un bouton Suivant ou Précédent ou pour définir une
boucle d’animation.
Si le paramètre nomOuNumDeRepère est un nombre entier, il peut être positif, négatif ou égal à
zéro. Par exemple :
•
•
•
•
•
marker(2) – Renvoie
le numéro d’image du deuxième repère après l’image courante.
marker(1) – Renvoie le numéro d’image du premier repère après l’image courante.
marker(0) – Renvoie le numéro de l’image courante si celle-ci contient un repère ou, si elle
n’en contient pas, celui de l’image contenant le repère précédent.
marker(-1) – Renvoie le numéro d’image du premier repère précédant le repère (0).
marker(-2) – Renvoie le numéro d’image du second repère précédant le repère (0).
Si le paramètre nomOuNumDeRepère est une chaîne, marker() renvoie le numéro de la première
image dont le repère correspond à la chaîne.
Paramètres
nomOuNumDeRepère Requis. Chaîne qui spécifie un libellé de repère ou nombre entier qui spécifie
un numéro de repère.
Exemple
L’instruction suivante fait passer la tête de lecture au début de l’image courante si celle-ci contient
un repère ou la fait passer au repère précédent dans le cas contraire :
-- Syntaxe Lingo
_movie.go(_movie.marker(0))
// Syntaxe JavaScript
_movie.go(_movie.marker(0));
421
L’instruction suivante donne à la variable repèreSuivant la même valeur que celle du repère
suivant du scénario :
-- Syntaxe Lingo
repèreSuivant = _movie.marker(1)
// Syntaxe JavaScript
repèreSuivant = _movie.marker(1);
Voir aussi
frame, frameLabel, go(), label(), markerList, Animation
max()
Utilisation
liste.max()
max(liste)
max(valeur1, valeur2, valeur3, ...)
Description
Fonction (Lingo uniquement) ; renvoie la valeur la plus élevée dans la liste spécifiée ou dans une
série de valeurs donnée.
La fonction max peut également être utilisée avec les caractères ASCII, de la même manière que les
opérateurs < et > peuvent être utilisés avec des chaînes.
Paramètres
valeur1, valeur2, valeur3, ...
Facultatif. Liste de valeurs dans laquelle la valeur la plus
élevée est sélectionnée.
Exemple
Le gestionnaire suivant affecte à la variable Gagnant la valeur maximum de la liste Devis, qui est
composée de [#Martin:600, #Dupont:750, #Lajoie:230]. Le résultat est ensuite inséré dans le
contenu de l’acteur champ Félicitations.
-- Syntaxe Lingo
on rechercheDuGagnant Devis
Gagnant = Devis.max()
member("Félicitations").text = \
"Vous avez gagné, avec un devis de " & Gagnant &"euros !"
end
// Syntaxe JavaScript
function rechercheDuGagnant(Devis) {
Gagnant = Devis.max();
member("Félicitations").text = "Vous avez gagné, avec un devis de " +
Gagnant \
+ "euros !");
}
422
Chapitre 12 : Méthodes
maximize()
Utilisation
-- Syntaxe Lingo
réfObjFenêtre.maximize()
// Syntaxe JavaScript
réfObjFenêtre.maximize();
Description
Méthode de fenêtre ; agrandit une fenêtre.
Utilisez cette méthode lorsque vous créez des barres de titre personnalisées.
Paramètres
Aucun.
Exemple
Ces instructions agrandissent la fenêtre intitulée Artistes si elle n’est pas déjà agrandie.
-- Syntaxe Lingo
if (window("Artistes").sizeState <> #maximized) then
window("Artistes").maximize()
end if
// Syntaxe JavaScript
if (window("Artistes").sizeState != symbol("maximized")) {
window("Artistes").maximize();
}
Voir aussi
minimize(), Fenêtre
mci
Utilisation
mci "chaîne"
Description
Commande ; exclusive à l’environnement Windows, passe les chaînes spécifiées par chaîne à
l’interface de contrôle des médias de Windows pour le contrôle des extensions multimédia.
Remarque : Microsoft ne recommande plus l’utilisation de l’interface MCI de 16 bits. Vous devrez
peut-être utiliser des Xtras de fabricants tiers pour remplacer cette fonctionnalité.
Paramètres
chaîne
Requis. Chaîne qui est transmise à l’interface MCI.
Exemple
L’instruction suivante ordonne à la commande play cdaudio from 200 to 600 track 7 de ne
lire le CD audio que lorsque l’animation est lue sous Windows :
mci "play cdaudio from 200 to 600 track 7"
423
member()
Utilisation
-- Syntaxe Lingo
member(nomOuNumDacteur {, nomOuNumDeDistribution})
// Syntaxe JavaScript
member(nomOuNumDacteur {, nomOuNumDeDistribution});
Description
Fonction du niveau supérieur ; crée une référence à un acteur et, éventuellement, spécifie la
distribution qui contient cet acteur.
Lorsqu’elle est utilisée à la fois avec le paramètre nomOuNumDacteur et le paramètre
nomOuNumDeDistribution, la méthode member() est une référence spécifique à une distribution
et à un de ses acteurs :
trace(sprite(1).member);
// (member 1 of castLib 1)
Cette méthode est différente de la propriété d’image-objet spriteNum, qui est toujours un
nombre entier désignant une position dans une distribution, mais qui ne spécifie pas la
distribution :
trace(sprite(2).spriteNum);
// 2
Le numéro d’un acteur est également une référence absolue à un acteur spécifique d’une
distribution particulière :
trace(sprite(3).member.number)
// 3
Paramètres
nomOuNumDacteur Requis. Chaîne qui spécifie le nom de l’acteur à référencer ou nombre entier
qui spécifie sa position d’index.
nomOuNumDeDistribution Facultatif. Chaîne qui spécifie le nom de la distribution à laquelle
l’acteur appartient ou nombre entier qui spécifie sa position d’index. Si ce paramètre est omis,
member() effectue une recherche dans toutes les distributions jusqu’à ce qu’il trouve une
correspondance.
Exemple
Cette instruction affecte à la variable ailesMem l’acteur Avions, qui se trouve dans la distribution
Transport.
-- Syntaxe Lingo
ailesMem = member("Avions", "Transport")
// Syntaxe JavaScript
var ailesMem = member("Avions", "Transport");
Voir aussi
Acteur, Image-objet, spriteNum
424
Chapitre 12 : Méthodes
mergeDisplayTemplate()
Utilisation
-- Syntaxe Lingo
_movie.mergeDisplayTemplate(listeDesPropriétés)
// Syntaxe JavaScript
_movie.mergeDisplayTemplate(listeDesPropriétés);
Description
Méthode d’animation ; fusionne un nombre arbitraire de propriétés de gabarit d’affichage avec le
jeu de propriétés existant en une seule opération.
Paramètres
listeDesPropriétés Requis. Liste de propriétés qui contient les propriétés de gabarit d’affichage à fusionner avec le jeu de propriétés existant. En Lingo, listeDesPropriétés est une liste
de paires nom/valeur ou symbole/valeur séparées par des virgules. Dans la syntaxe JavaScript,
listeDesPropriétés est une liste de paires nom/valeur séparées par des virgules.
Exemple
Cette instruction fusionne une valeur pour la propriété title dans displayTemplate :
-- Syntaxe Lingo
_movie.mergeDisplayTemplate(propList(#title, "Bienvenue !"))
// Syntaxe JavaScript
_movie.mergeDisplayTemplate(propList("title", "Bienvenue !"))
Voir aussi
appearanceOptions, displayTemplate, Animation, propList(), titlebarOptions
mergeProps()
Utilisation
-- Syntaxe Lingo
réfObjFenêtre.mergeProps(listeDesPropriétés)
// Syntaxe JavaScript
réfObjFenêtre.mergeProps(listeDesPropriétés);
Description
Méthode de fenêtre. Fusionne un nombre arbitraire de propriétés de fenêtre avec le jeu de
propriétés existant en une seule opération.
Paramètres
listeDesPropriétés Requis. Jeu de propriétés de fenêtre à fusionner avec le jeu de propriétés
existant. Les propriétés sont spécifiées par les propriétés appearanceOptions et
titlebarOptions.
• En Lingo, listeDesPropriétés est une liste de paires nom/valeur ou symbole/valeur séparées
•
par des virgules.
Dans la syntaxe JavaScript, listeDesPropriétés est une liste de paires nom/valeur séparées
par des virgules.
425
Exemple
Cette instruction définit diverses propriétés pour la fenêtre intitulée Voitures.
-- Syntaxe Lingo
window("Voitures").mergeProps([#title:"Photos de voitures", #resizable:FALSE,
\
#titlebarOptions:[#closebox:TRUE, #icon:member(2)], \
#appearanceOptions:[#border:#line, #shadow:TRUE]])
// Syntaxe JavaScript
window("Voitures").mergeProps(propList("title","Photos de voitures",
"resizable",false,
"titlebarOptions",propList("closebox",true, "icon",member(2)),
"appearanceOptions",propList("border","line", "shadow",true)));
Voir aussi
appearanceOptions, titlebarOptions, Fenêtre
mesh (propriété)
Utilisation
member(quelActeur).model(quelModèle).\
meshdeform.mesh[index].propriétéDeMaille
Description
Commande 3D ; permet d’accéder aux propriétés de maille des modèles auxquels est associé le
modificateur meshDeform. Lorsque utilisée comme mesh.count, cette commande renvoie le
nombre total de mailles du modèle référencé.
Les propriétés de chacune des mailles auxquelles il est possible d’accéder sont les suivantes :
•
•
•
•
•
•
•
permet d’obtenir ou de définir la liste des couleurs utilisées par la maille spécifiée.
vertexList permet d’obtenir ou de définir la liste des sommets utilisés par la maille spécifiée.
normalList vous permet d’obtenir ou de définir la liste des vecteurs de normales utilisés par la
maille spécifiée.
textureCoordinateList permet d’obtenir ou de définir les coordonnées de texture utilisées
par la première couche de texture de la maille spécifiée. Pour obtenir ou définir les
coordonnées de texture pour toute autre couche de texture de la maille spécifiée, utilisez
meshdeform.mesh[index].texturelayer[index].textureCoordinateList.
textureLayer[index] permet d’obtenir ou de définir l’accès aux propriétés de la couche de
texture spécifiée.
face[index] permet d’obtenir ou de définir les sommets, les normales, les coordonnées de
texture, les couleurs et les matériaux utilisés par les faces de la maille spécifiée.
face.count permet d’obtenir le nombre total des faces qui se trouvent à l’intérieur de la maille
spécifiée.
colorList
Remarque : Pour plus d’informations sur ces propriétés, consultez les entrées correspondantes (et
qui apparaissent sous la section Voir aussi de cette entrée).
Paramètres
Aucun.
426
Chapitre 12 : Méthodes
Exemple
Le code Lingo suivant ajoute le modificateur #meshDeform au modèle truc1, puis affiche la liste
des sommets de la première maille du modèle truc1.
member("nouveauMartien").model("truc1").addModifier(#meshDeform)
put member("nouveauMartien").model("truc1").meshDeform.mesh[1].vertexList
-- [vector(239.0, -1000.5, 27.4), vector\
(162.5, -1064.7, 29.3), vector(115.3, -1010.8, -40.6),
vector(239,0, -1000,5, 27,4), vector(115,3, -1010,8, -40,6),
vector(162.5, -1064.7, 29.3), vector(359.0, -828.5, -46.3),
vector(309.9, -914.5, -45.3)]
L’instruction suivante affiche le nombre de mailles du modèle Avion.
put member("world").model("Avion").meshDeform.mesh.count
-- 4
Voir aussi
meshDeform (modificateur), colorList, textureCoordinateList, textureLayer,
normalList, vertexList (déformation de maille), face[ ]
meshDeform (modificateur)
Utilisation
member(quelActeur).model(quelModèle).meshDeform.nomDePropriété
Description
Modificateur 3D ; permet de contrôler les différents aspects de la structure de maille du modèle
référencé. Lorsque vous ajoutez le modificateur #meshDeform (à l’aide de la commande
addModifier) à un modèle, vous avez accès aux propriétés suivantes du modificateur
#meshDeform :
Remarque : Pour plus d’informations sur ces propriétés, consultez les entrées correspondantes (et
qui apparaissent sous la section Voir aussi de cette entrée).
•
•
•
renvoie le nombre total de faces du modèle référencé.
renvoie le nombre de mailles du modèle référencé.
mesh[index] permet d’accéder aux propriétés de la maille spécifiée.
face.count
mesh.count
Paramètres
Aucun.
Exemple
L’instruction suivante affiche le nombre de faces du modèle gbFace.
put member("Univers 3D").model("gbFace").meshDeform.face.count
-- 432
L’instruction suivante affiche le nombre de mailles du modèle gbFace.
put member("Univers 3D").model("gbFace").meshDeform.mesh.count
-- 2
427
L’instruction suivante affiche le nombre de faces de la deuxième maille du modèle gbFace.
put member("Univers 3D").model("gbFace").meshDeform.mesh[2].face.count
-- 204
Voir aussi
mesh (propriété), addModifier
min
Utilisation
liste.min
min(liste)
min (a1, a2, a3...)
Description
Fonction (Lingo uniquement) ; spécifie la valeur minimale dans une liste.
Paramètres
a1, a2, a3, ...
Facultatif. Liste de valeurs dans laquelle la valeur la plus faible est sélectionnée.
Exemple
Le gestionnaire suivant donne à la variable vPlusBas la valeur la plus faible de la liste Devis, qui
est composée de [#Pierre:600, #Paul:750, #Jean:230]. Le résultat est alors inséré dans l’acteur
champ Désolé :
on rechercheDuPlusBas Devis
vPlusBas = Devis.min()
member("Désolé").text = \
"Votre offre de " & vPlusBas && " euros n’a pas été acceptée !"
end
Voir aussi
max()
minimize()
Utilisation
-- Syntaxe Lingo
réfObjFenêtre.minimize()
// Syntaxe JavaScript
réfObjFenêtre.minimize();
Description
Méthode de fenêtre ; réduit une fenêtre.
Utilisez cette méthode lorsque vous créez des barres de titre personnalisées.
Paramètres
Aucun.
428
Chapitre 12 : Méthodes
Exemple
Ces instructions réduisent la fenêtre intitulée Artistes si elle n’est pas déjà réduite.
-- Syntaxe Lingo
if (window("Artistes").sizeState <> #minimized) then
window("Artistes").minimize()
end if
// Syntaxe JavaScript
if (window("Artistes").sizeState != symbol("minimized")) {
window("Artistes").minimized();
}
Voir aussi
maximize(), Fenêtre
model
Utilisation
member(quelActeur).model(quelModèle)
member(quelActeur).model[index]
member(quelActeur).model.count
member(quelActeur).model(quelModèle).nomDePropriété
member(quelActeur).model[index].nomDePropriété
Description
Commande 3D ; renvoie le modèle trouvé dans l’acteur référencé dont le nom est spécifié par
quelModèle, ou trouvé à la position d’index spécifiée par index. Si aucun modèle n’existe pour
le paramètre spécifié, la commande renvoie void. Tout comme model.count, la commande
renvoie le nombre de modèles détectés dans l’acteur référencé. Cette commande permet
également d’accéder aux propriétés du modèle spécifié.
Les comparaisons de noms de modèle ne sont pas sensibles à la hauteur de casse. La position
d’index d’un modèle particulier peut changer lorsque des objets dans des positions inférieures
sont supprimés.
Si aucun modèle n’utilise le nom spécifié ou n’est trouvé à la position d’index spécifiée, cette
commande renvoie void.
Paramètres
quelModèle
Facultatif. Chaîne qui spécifie le nom du modèle à renvoyer.
Exemple
L’instruction suivante enregistre une référence au modèle Lecteur dans la variable ceModèle :
ceModèle = member("Univers3D").model("Lecteur")
L’instruction suivante enregistre une référence au huitième modèle de l’acteur Univers3D dans la
variable ceModèle.
ceModèle = member("Univers3D").model[8]
L’instruction suivante indique que quatre modèles se trouvent dans l’acteur de l’image-objet 1.
put sprite(1).member.model.count
-- 4
429
modelResource
Utilisation
member(quelActeur).modelResource(quelleRessDeMod)
member(quelActeur).modelResource[index]
member(quelActeur).modelResource.count
member(quelActeur).modelResource(quelleRessDeMod).\
nomDePropriété
member(quelActeur).modelResource[index].nomDePropriété
Description
Commande 3D ; renvoie la ressource de modèle trouvée dans l’acteur référencé dont le nom est
spécifié par quelleRessDeMod, ou trouvée à la position d’index spécifiée par le paramètre index.
Si aucune ressource de modèle n’existe pour le paramètre spécifié, la commande renvoie void.
Tout comme modelResource.count, la commande renvoie le nombre de ressources de modèle
détectées dans l’acteur référencé. Cette commande permet également d’accéder aux propriétés du
modèle spécifié.
Les comparaisons de chaînes de noms de ressources de modèle ne sont pas sensibles à la hauteur
de casse. La position d’index d’une ressource de modèle particulière peut changer lorsque des
objets dans des positions inférieures sont supprimés.
Paramètres
quelleRessDeMod
Facultatif. Chaîne qui spécifie le nom de la ressource de modèle à renvoyer.
Exemple
L’instruction suivante enregistre une référence à la ressource de modèle MaisonA dans la variable
cetteRessourceDeModèle.
cetteRessourceDeModèle = member("Univers3D").modelResource("MaisonA")
L’instruction suivante enregistre une référence à la quatorzième ressource de modèle de l’acteur
Univers3D dans la variable cetteRessourceDeModèle.
cetteRessourceDeModèle = member("Univers3D").modelResource[14]
L’instruction suivante indique que dix ressources de modèle se trouvent dans l’acteur de l’imageobjet 1.
put sprite(1).member.modelResource.count
--10
modelsUnderLoc
Utilisation
member(quelActeur).camera(quelleCaméra).modelsUnderLoc\
(pointDansLimageObjet {, nombreMaxDeModèles, précision})
Description
Commande 3D ; renvoie une liste des modèles situés sous un point spécifié à l’intérieur du
rectangle d’une image-objet utilisant la caméra référencée.
Dans la liste renvoyée, le premier modèle listé est celui qui est le plus proche du spectateur et le
dernier modèle listé est le plus éloigné.
430
Chapitre 12 : Méthodes
Une seule intersection (la plus proche) est renvoyée par modèle.
La commande renvoie une liste vide s’il n’existe aucun modèle sous le point spécifié.
Paramètres
Requis. Point sous lequel est située une liste de modèles. Ce point est
défini par rapport au coin supérieur gauche de l’image-objet, en pixels.
pointDansLimageObjet
nombreMaxDeModèles Facultatif. Nombre entier qui spécifie la longueur maximale de la liste
renvoyée. Si ce paramètre n’est pas spécifié, la commande renvoie une liste contenant les
références de tous les modèles détectés sous le point spécifié.
Facultatif. Symbole qui spécifie le niveau de détail des informations renvoyées. Les
valeurs correctes sont :
précision
•
•
#simple renvoie une liste contenant les références des modèles situés sous le point. C’est la
valeur par défaut.
#detailed renvoie une liste de listes de propriétés, représentant chacune un modèle rencontré.
Chaque liste de propriétés doit contenir les propriétés suivantes :
■ #model est une référence à l’objet de modèle rencontré.
■ #distance est la distance séparant la caméra du point d’intersection avec le modèle.
■ #isectPosition est un vecteur représentant la position du point d’intersection dans
l’univers.
■ #isectNormal est le vecteur de la maille au point d’intersection.
■ #meshID est l’identifiant de la maille coupée, qui peut être utilisé comme index dans la liste
des mailles du modificateur meshDeform.
■ #faceID est l’identifiant de la face coupée, qui peut être utilisé comme index dans la liste
des faces du modificateur meshDeform.
■ #vertices est une liste de vecteurs contenant trois éléments qui représentent les positions
dans l’univers des sommets de la face intersectée.
■ #uvCoord est une liste de propriétés contenant les propriétés #u et #v représentant les
coordonnées barycentriques u et v de la face.
Exemple
La première ligne du gestionnaire suivant transfère l’emplacement du curseur d’un point de la
scène à un point de l’image-objet 5. La deuxième ligne utilise la commande modelsUnderLoc
pour obtenir les trois premiers modèles situés sous ce point. La troisième ligne affiche des
informations détaillées sur les modèles dans la fenêtre Messages.
-- Syntaxe Lingo
on mouseUp
pt = the mouseLoc - point(sprite(5).left, sprite(5).top)
m = sprite(5).camera.modelsUnderLoc(pt, 3, #detailed)
put m
end
431
// Syntaxe JavaScript
function mouseUp() {
pt = _mouse.mouseLoc - point(sprite(5).left, sprite(5).top);
m = sprite(5).camera.modelsUnderLoc(pt, 3, #detailed)
put(m);
}
Voir aussi
modelsUnderRay, modelUnderLoc
modelsUnderRay
Utilisation
member(quelActeur).modelsUnderRay(vecteurDemplacement, vecteurDeDirection {,
nombreMaxDeModèles, précision})
Description
Commande 3D ; renvoie une liste des modèles situés sous un rayon tracé à partir d’une position
spécifiée dans une direction donnée ; les deux vecteurs étant spécifiés en coordonnées relatives à
l'univers.
Dans la liste renvoyée, le premier modèle listé est le plus proche de la position spécifiée par
vecteurDemplacement et le dernier modèle listé est le plus éloigné de cette position.
Une seule intersection (la plus proche) est renvoyée par modèle.
La commande renvoie une liste vide s’il n’existe aucun modèle sous le rayon spécifié.
Paramètres
vecteurDemplacement Requis. Vecteur à partir duquel un rayon est dessiné et sous lequel se
trouve une liste de modèles.
vecteurDeDirection
Requis. Vecteur qui spécifie la direction dans laquelle le rayon est orienté.
nombreMaxDeModèles Facultatif. Nombre entier qui spécifie la longueur maximale de la liste
renvoyée. Si ce paramètre n’est pas spécifié, la commande renvoie une liste contenant les
références de tous les modèles détectés sous le rayon spécifié.
Facultatif. Symbole qui spécifie le niveau de détail des informations renvoyées. Les
valeurs correctes sont :
précision
•
•
432
#simple renvoie une liste contenant les références des modèles situés sous le point. C’est la
valeur par défaut.
#detailed renvoie une liste de listes de propriétés, représentant chacune un modèle rencontré.
Chaque liste de propriétés doit contenir les propriétés suivantes :
■ #model est une référence à l’objet de modèle rencontré.
■ #distance est la distance séparant la position d’univers spécifiée par
vecteurDemplacement du point d’intersection avec le modèle.
■ #isectPosition est un vecteur représentant la position du point d’intersection dans
l’univers.
■ #isectNormal est le vecteur de la maille au point d’intersection.
■ #meshID est l’identifiant de la maille coupée, qui peut être utilisé comme index dans la liste
des mailles du modificateur meshDeform.
Chapitre 12 : Méthodes
■
■
■
#faceID est l’identifiant de la face coupée, qui peut être utilisé comme index dans la liste
des faces du modificateur meshDeform.
#vertices est une liste de vecteurs contenant trois éléments qui représentent les positions
dans l’univers des sommets de la face intersectée.
#uvCoord est une liste de propriétés contenant les propriétés #u et #v représentant les
coordonnées barycentriques u et v de la face.
Exemple
L’instruction suivante affiche les informations détaillées d’un modèle intersecté par un rayon tracé
à partir de la position de vector(0, 0, 300), en direction de l’axe des z négatif.
put member("3d").modelsUnderRay(vector(0, 0, 300), vector(0, 0, -\
1), 3, #detailed)
-- [[#model: model("mSphere"), #distance: 275.0000, \
#isectPosition: vector( 0.0000, 0.0000, 25.0000 ), #isectNormal: \
vector( -0.0775, 0.0161, 0.9969 ), #meshID: 1, #faceID: 229, \
#vertices: [vector( 0.0000, 0.0000, 25.0000 ), vector( -3.6851, \
1.3097, 24.6922 ), vector( -3.9017, 0.2669, 24.6922 )], \
#uvCoord: [#u: 0.0000, #v: 0.0000]]]
Voir aussi
modelsUnderLoc, modelUnderLoc
modelUnderLoc
Utilisation
member(quelActeur).camera(quelleCaméra).\
modelUnderLoc(pointDansLimageObjet)
Description
Commande 3D ; renvoie une référence au premier modèle situé sous un point spécifié à
l’intérieur du rectangle d’une image-objet utilisant la caméra référencée.
Cette commande renvoie void si aucun modèle n’est situé sous le point spécifié.
Pour obtenir une liste de tous les modèles situés sous un point spécifié et des informations
détaillées les concernant, consultez modelsUnderLoc.
Paramètres
pointDansLimageObjet Requis. Point sous lequel se trouve le premier modèle. L’emplacement
de pointDansLimageObjet est calculé en fonction du coin supérieur gauche de l’image-objet, en
pixels.
Exemple
La première ligne du gestionnaire suivant transfère l’emplacement du curseur d’un point de la
scène à un point de l’image-objet 5. La deuxième ligne détermine le premier modèle situé sous ce
point. La troisième ligne affiche les résultats dans la fenêtre Messages.
-- Syntaxe Lingo
on mouseUp
pt = the mouseLoc - point(sprite(5).left, sprite(5).top)
m = sprite(5).camera.modelUnderLoc(pt)
put m
end
433
// Syntaxe JavaScript
function mouseUp() {
pt = _mouse.mouseLoc - point(sprite(5).left, sprite(5).top);
m = sprite(5).camera.modelUnderLoc(pt);
put(m);
}
Voir aussi
modelsUnderLoc, modelsUnderRay
motion()
Utilisation
member(quelActeur).motion(quelMouvement)
member(quelActeur).motion[index]
member(quelActeur).motion.count
Description
Commande 3D ; renvoie le mouvement trouvé dans l’acteur référencé dont le nom est spécifié
par quelMouvement, ou trouvé à la position d’index spécifiée par index. Tout comme
motion.count, cette propriété renvoie le nombre total de mouvements détectés dans l’acteur.
Les comparaisons de chaînes de nom d’objet ne sont pas sensibles à la hauteur de casse. La
position d’index d’un mouvement particulier peut changer lorsque des objets dans des positions
inférieures sont supprimés.
Si aucun mouvement n’utilise le nom spécifié ou n’est trouvé à la position d’index spécifiée, cette
commande renvoie void.
Exemple
ceMouvement = member("Univers 3D").motion("Aile")
ceMouvement = member("Univers 3D").motion[7]
put member("séquence").motion.count
-- 2
Voir aussi
duration (3D), map (3D)
move()
Utilisation
-- Syntaxe Lingo
réfObjActeur.move({entPosn, nomDeDistribution})
// Syntaxe JavaScript
réfObjActeur.move({entPosn, nomDeDistribution});
Description
Méthode d’acteur ; déplace un acteur spécifié vers le premier emplacement vide de la distribution
dans laquelle il est inclus ou vers un emplacement spécifié dans une distribution donnée.
434
Chapitre 12 : Méthodes
Pour obtenir les meilleurs résultats, utilisez cette méthode pendant la programmation, et non
pendant l’exécution d’une animation, car le déplacement est en général enregistré avec le fichier.
En général, l’emplacement réel de l’acteur n’affecte pas la plupart des présentations quand
l’utilisateur final les lit. Pour changer le contenu de l’image-objet ou modifier son affichage
pendant la lecture de l’animation, utilisez la propriété member de l’image-objet.
Paramètres
entPosn Facultatif. Nombre entier qui spécifie la position vers laquelle l’acteur est déplacé dans la
distribution nomDeDistribution.
nomDeDistribution
Facultatif. Chaîne qui spécifie le nom de la distribution vers laquelle
l’acteur est déplacé.
Exemple
L’instruction suivante déplace l’acteur Temple vers le premier emplacement vide de la fenêtre
Distribution :
-- Syntaxe Lingo
member("Temple").move()
// Syntaxe JavaScript
member("Temple").move();
L’instruction suivante déplace l’acteur Temple vers l’emplacement 20 de la fenêtre Distribution
Bitmaps :
-- Syntaxe Lingo
member("Temple").move(20, "Bitmaps")
// Syntaxe JavaScript
member("Temple").move(20, "Bitmaps");
Voir aussi
Acteur
moveToBack()
Utilisation
-- Syntaxe Lingo
réfObjFenêtre.moveToBack()
// Syntaxe JavaScript
réfObjFenêtre.moveToBack();
Description
Méthode de fenêtre ; déplace une fenêtre derrière toutes les autres fenêtres.
Paramètres
Aucun.
435
Exemple
Les instructions suivantes placent la première fenêtre de la liste windowList derrière toutes les
autres fenêtres :
-- Syntaxe Lingo
maFenêtre = _player.windowList[1]
maFenêtre.moveToBack()
// Syntaxe JavaScript
var maFenêtre = _player.windowList[1];
maFenêtre.moveToBack();
Si vous connaissez le nom de la fenêtre à déplacer, utilisez la syntaxe suivante :
-- Syntaxe Lingo
window("Fenêtre Démo").moveToBack()
// Syntaxe JavaScript
window("Fenêtre Démo").moveToBack();
Voir aussi
moveToFront(), Fenêtre
moveToFront()
Utilisation
-- Syntaxe Lingo
réfObjFenêtre.moveToFront()
// Syntaxe JavaScript
réfObjFenêtre.moveToFront();
Description
Méthode de fenêtre ; déplace une fenêtre devant toutes les autres fenêtres.
Paramètres
Aucun.
Exemple
Les instructions suivantes placent la première fenêtre de la liste windowList devant toutes les
autres fenêtres :
-- Syntaxe Lingo
maFenêtre = _player.windowList[1]
maFenêtre.moveToFront()
// Syntaxe JavaScript
var maFenêtre = _player.windowList[1];
maFenêtre.moveToFront();
436
Chapitre 12 : Méthodes
Si vous connaissez le nom de la fenêtre à déplacer, utilisez la syntaxe suivante :
-- Syntaxe Lingo
window("Fenêtre Démo").moveToFront()
// Syntaxe JavaScript
window("Fenêtre Démo").moveToFront();
Voir aussi
moveToBack(), Fenêtre
moveVertex()
Utilisation
-- Syntaxe Lingo
réfObjActeur.moveVertex(indexDeSommet, changementX, changementY)
// Syntaxe JavaScript
réfObjActeur.moveVertex(indexDeSommet, changementX, changementY);
Description
Fonction ; place le sommet d’un acteur forme vectorielle à un autre emplacement.
Les coordonnées horizontales et verticales du déplacement sont calculées en fonction de la
position courante du point du sommet. L’emplacement de celui-ci dépend de l’origine de l’acteur
forme vectorielle.
La modification de l’emplacement du sommet affecte la forme de la même manière que si vous
faites glisser le sommet dans l’éditeur.
Paramètres
indexDeSommet
changementX
Requis. Spécifie la position d’index du sommet à déplacer.
Requis. Spécifie la distance sur laquelle le sommet doit être déplacé horizontale-
ment.
changementY
Requis. Spécifie la distance sur laquelle le sommet doit être déplacé verticalement.
Exemple
L’instruction suivante déplace le premier sommet de l’acteur forme vectorielle Archie de 25 pixels
vers la droite et de 10 pixels vers le bas par rapport à sa position actuelle :
-- Syntaxe Lingo
member("Archie").moveVertex(1, 25, 10)
// Syntaxe JavaScript
member("Archie").moveVertex(1, 25, 10);
Voir aussi
addVertex(), deleteVertex(), moveVertexHandle(), originMode, vertexList
437
moveVertexHandle()
Utilisation
-- Syntaxe Lingo
réfObjActeur.moveVertexHandle(indexDeSommet, indexDePoignée, changementX,
changementY)
// Syntaxe JavaScript
réfObjActeur.moveVertexHandle(indexDeSommet, indexDePoignée, changementX,
changementY);
Description
Fonction ; déplace la poignée du sommet d’un acteur de forme vectorielle vers un autre emplacement.
Les coordonnées horizontales et verticales du déplacement sont calculées par rapport à la position
courante de la poignée du sommet. L’emplacement de la poignée du sommet dépend du sommet
qu’elle contrôle.
La modification de l’emplacement de la poignée de contrôle affecte la forme de la même manière
que si vous faites glisser le sommet dans un éditeur.
Paramètres
indexDeSommet
Requis. Spécifie la position d’index du sommet qui contient la poignée à
déplacer.
indexDePoignée
Requis. Spécifie la position d’index de la poignée à déplacer.
changementX Requis. Spécifie la distance sur laquelle vous voulez déplacer la poignée du sommet
horizontalement.
changementY
Requis. Spécifie la distance sur laquelle vous voulez déplacer la poignée du sommet
verticalement.
Exemple
L’instruction suivante déplace la première poignée de contrôle du deuxième sommet de l’acteur
forme vectorielle Archie de 15 pixels vers la droite et de 5 pixels vers le haut :
-- Syntaxe Lingo
moveVertexHandle(member("Archie"), 2, 1, 15, -5)
// Syntaxe JavaScript
moveVertexHandle(member("Archie"), 2, 1, 15, -5)
Voir aussi
addVertex(), deleteVertex(), originMode, vertexList
multiply()
Utilisation
transformation.multiply(transformation2)
Description
Commande 3D ; applique les effets de position, de rotation et de redimensionnement de
transformation2 après la transformation d’origine.
438
Chapitre 12 : Méthodes
Paramètres
transformation2 Requis. Spécifie la transformation qui contient les effets à appliquer à une
autre transformation.
Exemple
L’instruction suivante applique les effets de position, rotation et redimensionnement de la
transformation du modèle Mars à la transformation du modèle Pluton. Cela a le même effet que
de définir Mars comme le parent de Pluton pour une image.
member("Scène").model("Pluton").transform.multiply(member("Scène")\
.model("Mars").transform)
neighbor
Utilisation
member(quelActeur).model(quelModèle).meshdeform.mesh[index].\
face[index].neighbor[index]
Description
Commande 3D ; commande meshDeform qui renvoie une liste de listes décrivant les voisins
d’une face particulière d’une maille à l’opposé du coin de face spécifié par l’index de voisinage
(1,2,3). Si la liste est vide, la face n’a aucun voisin dans cette direction. Si la liste contient plus
d’une liste, la maille est non-manifold. La liste contient généralement une liste unique de quatre
valeurs entières : [indexDeMaille, indexDeFace, indexDeSommet, inverse?].
La valeur indexDeMaille est l’index de la maille contenant la face voisine. La valeur
indexDeFace est l’index de la face voisine dans la maille. La valeur indexDeSommet est l’index des
sommets non partagés de la face voisine. La valeur inverse? indique si l’orientation de la face est
la même (1) ou l’inverse (2) de la face d’origine.
Paramètres
Aucun.
Voir aussi
meshDeform (modificateur)
netAbort
Utilisation
netAbort(URL)
netAbort(IDréseau)
Description
Commande ; annule une opération réseau sans attendre de résultat.
L’utilisation d’un identifiant de réseau constitue la manière la plus efficace d’annuler une
opération réseau. Cet identifiant est renvoyé lorsque vous utilisez une fonction réseau telle que
getNetText() ou postNetText().
439
Dans certains cas, si l’identifiant de réseau n’est pas disponible, vous pouvez utiliser une URL
pour annuler la transmission de données à partir de cette URL. Celle-ci doit être identique à
l’URL utilisée au départ de l’opération réseau. Si le transfert des données est terminé, cette
commande n’a aucun effet.
Paramètres
URL
Requis. Spécifie l’URL à annuler.
IDréseau
Facultatif. Spécifie l’ID de l’opération réseau à annuler.
Exemple
L’instruction suivante passe un identifiant de réseau à netAbort pour annuler une opération
réseau particulière :
-- Syntaxe Lingo
on mouseUp
netAbort(monIDréseau)
end
// Syntaxe JavaScript
function mouseUp() {
netAbort(monIDréseau);
}
Voir aussi
getNetText(), postNetText
netDone()
Utilisation
netDone()
netDone(IDréseau)
Description
Fonction ; indique si une opération de chargement en tâche de fond (telle que getNetText,
preloadNetThing, gotoNetMovie, gotoNetPage ou netTextResult) est terminée ou a été
interrompue par suite d’une erreur du navigateur (TRUE, valeur par défaut) ou si elle est encore
en cours (FALSE).
• Utilisez netDone() pour tester la dernière opération réseau.
• Utilisez netDone(IDréseau) pour tester l’opération réseau identifiée par IDréseau.
La fonction netDone renvoie 0 lorsqu’une opération de chargement en tâche de fond est en cours.
Paramètres
IDréseau
440
Facultatif. Spécifie l’ID de l’opération réseau à tester.
Chapitre 12 : Méthodes
Exemple
Le gestionnaire suivant utilise la fonction netDone pour vérifier si la dernière opération réseau est
terminée. Si l’opération est terminée, le texte renvoyé par netTextResult est affiché dans l’acteur
Affichage du texte.
-- Syntaxe Lingo
on exitFrame
if netDone() = 1 then
member("Affichage du texte").text = netTextResult()
end if
end
// Syntaxe JavaScript
function exitFrame() {
if (netDone() == 1) {
member("Affichage du texte").text = netTextResult();
}
}
Le gestionnaire suivant utilise un identifiant de réseau spécifique comme argument pour que
netDone vérifie l’état d’une opération réseau particulière :
-- Syntaxe Lingo
on exitFrame
-- rester sur cette image jusqu’à la fin de
-- l’opération réseau
global monIDréseau
if netDone(monIDréseau) = FALSE then
go to the frame
end if
end
// Syntaxe JavaScript
function exitFrame() {
// rester sur cette image jusqu’à la fin de l’opération réseau
global monIDréseau;
if (!(netDone(monIDréseau))) {
_movie.go(_movie.frame);
}
}
Voir aussi
getNetText(), netTextResult(), gotoNetMovie, preloadNetThing()
netError()
Utilisation
netError()
netError(IDréseau)
Description
Fonction ; détermine si une erreur s’est produite pendant une opération réseau, et, le cas échéant,
renvoie un numéro d’erreur correspondant à un message d’erreur. Si l’opération s’est déroulée
sans erreur, cette fonction renvoie un code indiquant que tout va bien. Si aucune opération de
chargement en tâche de fond n’a commencé, ou si l’opération est en cours, cette fonction renvoie
une chaîne vide.
441
• Utilisez netError() pour tester la dernière opération réseau.
• Utilisez netError(IDréseau) pour tester l’opération réseau spécifiée par IDréseau.
Plusieurs codes d’erreur peuvent être renvoyés :
0
Tout va bien.
4
Classe MOA incorrecte. Les Xtras requis, réseau ou non, ne sont pas installés
correctement ou ne sont pas installés du tout.
5
Interface MOA incorrecte. Voir 4.
6
URL incorrecte ou classe MOA incorrecte. Les Xtras requis, réseau ou non, ne sont pas
installés correctement ou ne sont pas installés du tout.
20
Erreur interne. Renvoyé par netError() dans le navigateur Netscape si celui-ci a
détecté une erreur de réseau ou une erreur interne.
4146
La connexion n’a pas pu être établie avec l’hôte distant.
4149
Les données fournies par le serveur ont un format inattendu.
4150
Fermeture prématurée et inattendue de la connexion.
4154
L’opération n’a pas pu aboutir par suite du dépassement du temps imparti.
4155
Mémoire insuffisante pour terminer la transaction.
4156
La réponse du protocole à la requête indique une erreur de réponse.
4157
La transaction n’a pas pu être authentifiée.
4159
URL non valide.
4164
Impossible de créer de socket.
4165
L’objet demandé est introuvable (l’URL est peut-être incorrecte).
4166
Echec de proxy générique.
4167
Le transfert a été interrompu volontairement par le client.
4242
Téléchargement annulé par netAbort(url).
4836
Téléchargement annulé ou interrompu pour une raison inconnue, probablement une
erreur du réseau.
Paramètres
IDréseau
Facultatif. Spécifie l’ID de l’opération réseau à tester.
Exemple
L’instruction suivante passe un identifiant de réseau à netError pour vérifier l’état d’erreur d’une
opération réseau spécifique :
-- Syntaxe Lingo
on exitFrame
global monIDréseau
if netError(monIDréseau)<>"OK" then beep
end
442
Chapitre 12 : Méthodes
// Syntaxe JavaScript
function exitFrame() {
global monIDréseau;
if (netError(monIDréseau) != "OK") {
_sound.beep();
}
}
netLastModDate()
Utilisation
netLastModDate()
Description
Fonction ; renvoie la date de la dernière modification de l’en-tête HTTP de l’élément spécifié.
Cette chaîne utilise le format de temps universel (GMT) : Jjj, nn Mmm aaaa hh:mm:ss GMT
(par exemple, Thu, 30 Jan 1997 12:00:00 AM GMT). Les jours et les mois peuvent être écrits en
entier. Cette chaîne est toujours en anglais.
La fonction netLastModDate ne peut être appelée qu’une fois que netDone et netError
rapportent que l’opération s’est terminée avec succès. Dès que l’opération suivante démarre,
l’animation ou la projection Director efface les résultats de l’opération précédente pour
économiser de la mémoire.
La chaîne de date est extraite de l’en-tête HTTP dans le format offert par le serveur. Cependant,
cette chaîne n’est pas toujours fournie et, le cas échéant, netLastModDate renvoie EMPTY.
Paramètres
Aucun.
Exemple
Les instructions suivantes vérifient la date d’un fichier téléchargé depuis Internet :
-- Syntaxe Lingo
if netDone() then
laDate = netLastModDate()
if laDate.char[6..11] <> "30 Jan" then
alert "Ce fichier est périmé."
end if
end if
// Syntaxe JavaScript
if (netDone()) {
laDate = netLastModDate();
if (laDate.char[6..11] != "30 Jan") {
alert("Ce fichier est périmé");
}
}
Voir aussi
netDone(), netError()
443
netMIME()
Utilisation
netMIME()
Description
Fonction ; fournit le type MIME du fichier Internet renvoyé par la dernière opération réseau
(le fichier HTTP ou FTP téléchargé en dernier).
La fonction netMIME ne peut être appelée qu’une fois que netDone et netError rapportent que
l’opération s’est terminée avec succès. Dès que l’opération suivante démarre, l’animation ou la
projection Director efface les résultats de l’opération précédente pour économiser de la mémoire.
Paramètres
Aucun.
Exemple
Le gestionnaire suivant vérifie le type MIME d’un fichier téléchargé depuis Internet et répond en
conséquence :
-- Syntaxe Lingo
on vérifierLopérationRéseau uneURL
if netDone (uneURL) then
set monTypeMime = netMIME()
case monTypeMime of
"image/jpeg": go frame "info jpeg"
"image/gif": go frame "info gif"
"application/x-director": goToNetMovie uneURL
"text/html": goToNetPage uneURL
otherwise: alert "Veuillez choisir un autre fichier."
end case
else
go the frame
end if
end
444
Chapitre 12 : Méthodes
// Syntaxe JavaScript
function vérifierLopérationRéseau(uneURL) {
if (netDone (uneURL)) {
monTypeMime = netMIME();
switch (monTypeMime) {
case "image/jpeg":
_movie.go("Lions");
break;
case "image/gif":
_movie.go("info gif");
break;
case "application/x-director":
goToNetMovie(uneURL);
break;
case "text/html":
goToNetPage(uneURL);
break;
default:
alert("Veuillez choisir un autre fichier.");
}
} else {
_movie.go(_movie.frame);
}
}
Voir aussi
netDone(), netError(), getNetText(), postNetText, preloadNetThing()
netStatus
Utilisation
netStatus chaîneDeMessage
Description
Commande ; affiche la chaîne spécifiée dans la zone d’état de la fenêtre du navigateur.
La commande netStatus ne fonctionne pas dans les projections.
Paramètres
chaîneDeMessage
Requis. Spécifie la chaîne à afficher.
Exemple
L’instruction suivante place la chaîne Test dans la zone d’état du navigateur web dans lequel
l’animation est lue :
-- Syntaxe Lingo
on exitFrame
netStatus "Test"
end
// Syntaxe JavaScript
function exitFrame() {
_movie.netStatus("Test");
}
445
netTextResult()
Utilisation
netTextResult(IDréseau)
netTextResult()
Description
Fonction ; renvoie le texte obtenu par l’opération réseau spécifiée. Si aucun identifiant réseau
n’est spécifié, netTextResult renvoie le résultat de la dernière opération réseau.
Si l’opération réseau spécifiée était getNetText(), le texte renvoyé correspond à celui du fichier
sur le réseau.
Si l’opération réseau spécifiée était postNetText, le résultat correspond à la réponse du serveur.
Dès que l’opération suivante démarre, Director efface les résultats de l’opération précédente pour
économiser de la mémoire.
Lorsqu’une animation est lue sous forme d’applet, cette fonction renvoie les résultats valides des
dernières 10 demandes. Lorsqu’une animation est lue sous forme d’animation avec un contenu
Shockwave, cette fonction ne renvoie que les résultats valides de l’opération getNetText() la plus
récente.
Paramètres
IDréseau
Facultatif. Spécifie l’ID de l’opération réseau qui contient le texte à renvoyer.
Exemple
Le gestionnaire suivant utilise les fonctions netDone et netError pour tester si la dernière
opération réseau s’est terminée avec succès. Si l’opération est terminée, le texte renvoyé par
netTextResult est affiché dans l’acteur Affichage du texte.
-- Syntaxe Lingo
global gIDréseau
on exitFrame
if (netDone(gIDréseau) = TRUE) and (netError(gIDréseau) = "OK") then
member("Affichage du texte").text = netTextResult()
end if
end
// Syntaxe JavaScript
global gIDréseau;
function exitFrame() {
if (netDone(gIDréseau) && (netError(gIDréseau) == "OK")) {
member("Affichage du texte").text = netTextResult();
}
}
Voir aussi
netDone(), netError(), postNetText
446
Chapitre 12 : Méthodes
new()
Utilisation
new(type)
new(type, castLib quelleDistribution)
new(type, member quelActeur of castLib quelleDistribution)
nomDeVariable = new(scriptParent arg1, arg2, ...)
new(script nomDuScriptParent, valeur1, valeur2, ...)
timeout("nom").new(période, #gestionnaire, {, objetCible})
new(xtra "nomDeLxtra")
Description
Fonction ; crée un nouvel acteur, objet enfant, objet de temporisation ou instance d’Xtra, et
permet d’affecter des valeurs de propriétés individuelles aux objets enfants.
Pour les acteurs, le paramètre type sert à définir le type de l’acteur. Les valeurs prédéfinies offertes
correspondent aux différents types d’acteurs : #bitmap, #field, etc. La fonction new permet
également de créer des types d’acteurs Xtra, auxquels vous pouvez attribuer n’importe quel nom.
Vous pouvez également créer un nouvel acteur curseur de couleur en utilisant l’Xtra Custom
Cursor. Utilisez new(#cursor), puis définissez les propriétés de l’acteur obtenu de manière à
pouvoir les utiliser.
Les paramètres facultatifs quelActeur et quelleDistribution spécifient la position de l’acteur
et la fenêtre Distribution dans laquelle il est créé. Si vous ne spécifiez pas de position, l’acteur est
placé dans la première position vide de cette distribution. La fonction new renvoie la position de
l’acteur.
Lorsque l’argument de la fonction new est un script parent, la fonction new crée un objet enfant.
Le script parent doit contenir un gestionnaire on new définissant l’état initial de l’objet enfant ou
la valeur de ses propriétés ; il renvoie la référence me de l’objet enfant.
L’objet enfant possède tous les gestionnaires du script parent. Il utilise les mêmes noms de
variables de propriétés que celles qui sont déclarées dans le script parent, mais peut toutefois avoir
ses propres valeurs pour ces propriétés.
Puisque l’objet enfant est une valeur, il peut être affecté à des variables, placé dans des listes ou
être passé comme paramètre.
Comme avec toute autre variable, vous pouvez utiliser la commande put pour afficher des
informations sur un objet enfant dans la fenêtre Messages.
Lorsque new() est utilisé pour créer un objet de temporisation, la période définit le nombre de
millisecondes séparant les événements de temporisation envoyés par l’objet de temporisation.
La valeur #gestionnaire est un symbole identifiant le gestionnaire qui sera appelé lors de
chaque événement de temporisation. La valeur objetCible identifie le nom de l’objet enfant
contenant la valeur #gestionnaire. Si aucune valeur objetCible n’est définie, la valeur
#gestionnaire est considérée comme étant dans un script d’animation.
Lorsqu’un objet de temporisation est créé, il active son objetCible pour la réception des événements système prepareMovie, startMovie, stopMovie, prepareFrame et exitFrame. Pour en
profiter, l’objetCible doit contenir des gestionnaires pour ces événements. Les événements ne
doivent pas obligatoirement survenir dans l’ordre pour que le reste de l’animation puisse y
accéder.
447
Pour un exemple d’utilisation de new() dans une animation, reportez-vous aux animations Parent
Scripts et Read and Write Text du dossier Learning/Lingo, lui-même inclus dans le dossier de
Director.
Exemple
Pour créer un nouvel acteur bitmap dans le premier emplacement disponible de la distribution,
utilisez la syntaxe suivante :
set nouvelActeur = new(#bitmap)
Une fois cette ligne exécutée, nouvelActeur contient la référence de l’acteur que vous venez de
créer :
put nouvelActeur
-- (member 1 of castLib 1)
Le script startMovie suivant crée un nouvel acteur Flash au moyen de la commande new, définit
la propriété linked de l’acteur nouvellement créé de sorte que ses éléments soient stockés dans un
fichier externe, puis définit la propriété pathName de l’acteur comme emplacement d’une
animation Flash sur le web :
on startMovie
acteurFlash = new(#flash)
member(acteurFlash).pathName = "http://www.uneURL.fr/monFlash.swf"
end
Lorsque l’animation démarre, le gestionnaire suivant crée un nouvel acteur curseur animé en
couleur et stocke son numéro d’acteur dans la variable curseurPersonnalisé. Cette variable sert
à définir la propriété castMemberList de l’acteur qui vient d’être créé et à afficher le nouveau
curseur.
on startmovie
curseurPersonnalisé = new(#cursor)
member(curseurPersonnalisé).castMemberList = [member 1, member 2, member 3]
cursor (member(curseurPersonnalisé))
end
Les instructions du script parent suivantes contiennent un gestionnaire on new servant à créer un
objet enfant. Le script parent est un acteur script appelé Oiseau qui contient ces gestionnaires.
on new me, nomDeLoiseau
return me
end
on voler me
put "Je vole"
end
Dans l’exemple suivant, la première instruction crée un objet enfant à partir du script de
l’exemple précédent et le place dans la variable monOiseau. La seconde instruction fait voler
l’oiseau en appelant le gestionnaire voler du script parent Oiseau :
monOiseau = script("Oiseau").new()
monOiseau.voler()
448
Chapitre 12 : Méthodes
L’instruction suivante crée un autre script parent Oiseau contenant la variable de propriété
vitesse :
property vitesse
on new me, vitesseInitiale
vitesse = vitesseInitiale
return me
end
on voler me
put "Je vole à " & vitesse & "kmh"
end
Les instructions suivantes créent deux objets enfants appelés monOiseau1 et monOiseau2. Les
vitesses suivantes leur sont attribuées : 15 et 25, respectivement. Lorsque le gestionnaire voler
est appelé pour chaque objet enfant, la vitesse de ce dernier s’affiche dans la fenêtre Messages.
monOiseau1 = script("Oiseau").new(15)
monOiseau2 = script("Oiseau").new(25)
monOiseau1.voler()
monOiseau2.voler()
Le message suivant apparaît dans la fenêtre Messages :
-- "Je vole à 15 kmh"
-- "Je vole à 25 kmh"
L’instruction suivante crée un objet de temporisation nommé compteurDintervalle qui
envoie un événement de temporisation au gestionnaire on bipChaqueMinute de l’objet enfant
lecteur1 toutes les 60 secondes :
timeout("compteurDintervalle").new(60000, #bipChaqueMinute, lecteur1)
Voir aussi
on stepFrame, actorList, ancestor, me, type (acteur), timeout()
newCamera
Utilisation
member(quelActeur).newCamera(nomDeNouvelleCaméra)
Description
Commande 3D ; crée une caméra dans un acteur.
Paramètres
nomDeNouvelleCaméra Requis. Spécifie le nom de la nouvelle caméra. Le nom spécifié de la
nouvelle caméra doit être unique dans l’acteur.
Exemple
L’instruction suivante crée une nouvelle caméra appelée Caméra_embarquée.
member("Univers 3D").newCamera("Caméra_embarquée")
449
newCurve()
Utilisation
-- Syntaxe Lingo
réfObjActeur.newCurve(positionDansLaListeDesSommets)
// Syntaxe JavaScript
réfObjActeur.newCurve(positionDansLaListeDesSommets);
Description
Fonction ; ajoute un symbole #newCurve à la liste vertexList de réfObjActeur, qui ajoute une
nouvelle forme à la forme vectorielle. Vous pouvez fractionner une forme existante en appelant
newCurve() positionné au milieu d’une série de sommets.
Paramètres
positionDansLaListeDesSommets
Requis. Indique à quelle position le symbole #newCurve est
ajouté à la vertexList.
Exemple
Les instructions suivantes ajoutent une nouvelle courbe à l’acteur 2 à la troisième position de la
liste des sommets de l’acteur. La seconde ligne de l’exemple remplace le contenu de la courbe 2
par le contenu de la courbe 3.
-- Syntaxe Lingo
member(2).newCurve(3)
member(2).curve[2]=member(2).curve[3]
// Syntaxe JavaScript
member(2).newCurve(3);
member(2).curve[2] = member(2).curve[3];
Voir aussi
curve, vertexList
newGroup
Utilisation
member(quelActeur).newGroup(nomDeNouveauGroupe)
Description
Commande 3D ; crée un groupe et l’ajoute à la palette des groupes.
Paramètres
nomDeNouveauGroupe Requis. Spécifie le nom du nouveau groupe. Le nom du nouveau groupe
doit être unique dans la palette des groupes.
Exemple
L’instruction suivante crée le groupe gbGroupe2 dans l’acteur Scène et une référence à ce groupe
dans la variable ng.
ng = member("Scène").newGroup("gbGroupe2")
450
Chapitre 12 : Méthodes
newLight
Utilisation
member(quelActeur).newLight(nomDeNouvelleLumière, #indicateurDeType)
Description
Commande 3D ; crée une lumière avec un type spécifié et l’ajoute à la palette des lumières.
Paramètres
Requis. Spécifie le nom de la nouvelle lumière. Le nom de la nouvelle
lumière doit être unique dans la palette des lumières.
nomDeNouvelleLumière
indicateurDeType
Requis. Symbole qui spécifie le type de la nouvelle lumière. Les valeurs
correctes sont :
•
•
•
•
est une lumière généralisée dans l’univers 3D.
est une lumière émise dans une direction spécifique.
#point est une source lumineuse similaire à une ampoule.
#spot est un effet de projecteur.
#ambient
#directional
Exemple
L’instruction suivante crée une lumière dans l’acteur Univers 3D. Il s’agit d’une lumière
d’ambiance appelée « lumière ambiante ».
member("Univers 3D").newLight("lumière ambiante", #ambient)
newMember()
Utilisation
-- Syntaxe Lingo
_movie.newMember(symbole)
_movie.newMember(chaîneTypeDacteur)
// Syntaxe JavaScript
_movie.newMember(chaîneTypeDacteur);
Description
Méthode d’animation ; crée un acteur et vous permet d’affecter des valeurs de propriétés
individuelles aux objets enfants.
Pour les nouveaux acteurs, le paramètre symbole ou chaîneTypeDacteur définit le type de
l’acteur. Les valeurs prédéfinies offertes correspondent aux différents types d’acteurs : #bitmap,
#field, etc. La méthode newMember() crée également des types d’acteurs Xtra, auxquels vous
pouvez attribuer n’importe quels noms.
Vous pouvez également créer un nouvel acteur curseur de couleur en utilisant l’Xtra Custom
Cursor. Utilisez newMember(#cursor), puis définissez les propriétés de l’acteur obtenu de
manière à pouvoir les utiliser.
Une fois que la méthode newMember() a été appelée, le nouveau membre est placé dans la
première miniature libre de la distribution.
451
Lorsque l’argument de la fonction new() est un script parent, la fonction new crée un objet
enfant. Le script parent doit contenir un gestionnaire on new définissant l’état initial de l’objet
enfant ou la valeur de ses propriétés ; il renvoie la référence me de l’objet enfant.
L’objet enfant possède tous les gestionnaires du script parent. Il utilise les mêmes noms de
variables de propriétés que celles qui sont déclarées dans le script parent, mais peut toutefois avoir
ses propres valeurs pour ces propriétés.
Puisque l’objet enfant est une valeur, il peut être affecté à des variables, placé dans des listes ou
être passé comme paramètre.
Comme avec toute autre variable, vous pouvez utiliser la méthode put() pour afficher des
informations sur un objet enfant dans la fenêtre Messages.
Lorsque new() est utilisé pour créer un objet de temporisation, la période définit le nombre de
millisecondes séparant les événements de temporisation envoyés par l’objet de temporisation.
La valeur #gestionnaire est un symbole identifiant le gestionnaire qui sera appelé lors de
chaque événement de temporisation. La valeur objetCible identifie le nom de l’objet enfant
contenant la valeur #gestionnaire. Si aucune valeur objetCible n’est définie, la valeur
#gestionnaire est considérée comme étant dans un script d’animation.
Lorsqu’un objet de temporisation est créé, il active son objetCible pour la réception des événements système prepareMovie, startMovie, stopMovie, prepareFrame et exitFrame. Pour en
profiter, l’objetCible doit contenir des gestionnaires pour ces événements. Les événements
ne doivent pas obligatoirement survenir dans l’ordre pour que le reste de l’animation puisse y
accéder.
Pour un exemple d’utilisation de newMember() dans une animation, reportez-vous aux animations Parent Scripts et Read and Write Text du dossier Learning/Lingo, lui-même inclus dans
le dossier de Director.
Paramètres
symbole
(Lingo uniquement) Requis. Symbole qui spécifie le type du nouvel acteur.
chaîneTypeDacteur
Requis. Chaîne qui spécifie le type du nouvel acteur.
Exemple
Les instructions suivantes créent un nouvel acteur bitmap et l’affecte à la variable
nouveauBitmap.
-- Syntaxe Lingo
nouveauBitmap = _movie.newMember(#bitmap) – avec un symbole
nouveauBitmap = _movie.newMember("bitmap") – avec une chaîne
// Syntaxe JavaScript
var nouveauBitmap = _movie.newMember("bitmap");
Voir aussi
Animation, type (acteur)
452
Chapitre 12 : Méthodes
newMesh
Utilisation
member(quelActeur).newMesh(nomDeMaille, nombreDeFaces, nombreDeSommets,
nombreDeNormales,nombreDeCouleurs,nombreDeCoordonnéesDeTexture)
Description
Commande 3D ; crée une ressource de modèle de maille. Après avoir créé une maille, vous devez
au moins définir les valeurs des propriétés vertexList et face[index].vertices de la nouvelle
maille, puis appeler sa commande build() pour générer la géométrie.
Paramètres
nomDeMaille
Requis. Spécifie le nom de la nouvelle ressource de modèle de maille.
nombreDeFaces
Requis. Spécifie le nombre total de triangles devant apparaître dans la maille.
nombreDeSommets Requis. Spécifie le nombre total de sommets utilisés par toutes les faces
(triangulaires). Un sommet peut être partagé par plus d’une face.
nombreDeNormales Facultatif. Spécifie le nombre total de normales. Une normale peut être
partagée par plus d’une face. La normale d’un coin de triangle définit la direction extérieure au
triangle, ce qui affecte l’éclairage de cet angle. Entrez 0 ou ignorez ce paramètre si vous prévoyez
d’utiliser la commande generateNormals() de la maille pour générer les normales.
Facultatif. Spécifie le nombre total de couleurs utilisées par toutes les faces.
Une couleur peut être partagée par plus d’une face. Vous pouvez spécifier une couleur pour
chaque angle de chaque face. Spécifiez les couleurs pour obtenir un dégradé de couleurs
progressif. Entrez 0 ou ignorez ce paramètre pour obtenir la couleur blanche par défaut pour
chaque coin de face.
nombreDeCouleurs
nombreDeCoordonnéesDeTexture Facultatif. Spécifie le nombre total de coordonnées de texture
spécifiées par l’utilisateur utilisées par toutes les faces. Entrez 0 ou ignorez ce paramètre pour
obtenir les coordonnées de texture par défaut générées par un placage planaire. Pour plus
d’informations, consultez la description de #planar dans l’entrée shader.textureWrapMode.
Spécifiez les coordonnées de texture lorsque vous avez besoin de contrôler précisément le placage
des textures sur les faces de la maille.
Exemple
L’exemple suivant crée une ressource de modèle de type #mesh, en spécifie les propriétés, puis
l’utilise pour créer un nouveau modèle. Le processus est décrit dans les explications accompagnant
l’exemple suivant :
La ligne 1 crée une maille contenant 6 faces, composées de 5 sommets et 3 couleurs uniques. Le
nombre de normales et le nombre de coordonnées de textures ne sont pas définis. Les normales
seront créées par la commande generateNormals.
La ligne 2 définit les cinq sommets uniques utilisés par les faces de la maille.
La ligne 3 définit les trois couleurs uniques utilisées par les faces de la maille.
Les lignes 4 à 9 désignent les sommets à utiliser pour les coins de chaque face de la pyramide.
Veuillez noter que l’ordre des sommets suit le sens des aiguilles d’une montre.
GenerateNormals() est basé sur un ordre suivant le sens des aiguilles d’une montre.
453
Les lignes 10 à 15 affectent des couleurs aux coins de chaque face. Les couleurs seront étalées sur
les faces en dégradés.
La ligne 16 crée les normales de Triangle en appelant la commande generateNormals().
La ligne 17 appelle la commande build pour construire la maille.
nm = member("Formes").newMesh("pyramide",6 , 5, 0, 3)
nm.vertexList = [ vector(0,0,0), vector(40,0,0), \
vector(40,0,40), vector(0,0,40), vector(20,50,20) ]
nm.colorList = [ rgb(255,0,0), rgb(0,255,0), rgb(0,0,255) ]
nm.face[1].vertices = [ 4.10.2 ]
nm.face[2].vertices = [ 4.2,3 ]
nm.face[3].vertices = [ 5.20.1 ]
nm.face[4].vertices = [ 5.30.2 ]
nm.face[5].vertices = [ 5.4,3 ]
nm.face[6].vertices = [ 5.10.4 ]
nm.face[1].colors = [3,200.3]
nm.face[2].colors = [3.30.2]
nm.face[3].colors = [1.30.2]
nm.face[4].colors = [1.20.3]
nm.face[5].colors = [1.30.2]
nm.face[6].colors = [1.20.3]
nm.generateNormals(#flat)
nm.build()
nm = member("Formes").newModel("Pyramide1", nm)
Voir aussi
newModelResource
newModel
Utilisation
member( quelActeur ).newModel( nomDeNouveauModèle \
{, quelleRessDeMod } )
Description
Commande 3D ; crée un modèle dans l’acteur référencé. La propriété resource de tous les
nouveaux modèles est définie sur VOID par défaut.
Paramètres
nomDeNouveauModèle
Requis. Spécifie le nom du nouveau modèle. Le nom du nouveau modèle
doit être unique.
quelleRessDeMod
Facultatif. Spécifie la ressource de modèle à utiliser pour créer le modèle.
Exemple
L’instruction suivante crée le modèle Nouvelle maison dans l’acteur Univers 3D.
member("Univers 3D").newModel("Nouvelle maison")
La ressource de modèle pour le nouveau modèle peut également être définie à l’aide du paramètre
facultatif quelleRessDeMod.
member("Univers 3D").newModel("Nouvelle maison", member("Univers \
3D").modelResource("grandeBoîte"))
454
Chapitre 12 : Méthodes
newModelResource
Utilisation
member(quelActeur).newModelResource(nomDeNouvelleRessourceDeModèle\
{ ,#type, #faisantFaceA })
Description
Commande 3D ; crée une ressource de modèle, éventuellement, avec des paramètres type et
faisantFaceA donnés, et l’ajoute à la palette de ressources de modèle.
Si vous ne spécifiez pas le paramètre faisantFaceA, mais que vous spécifiez #box, #sphere,
#particle ou #cylinder comme paramètre type, seules les faces avant seront générées. Si vous
spécifiez #plane, les faces avant et arrière sont créées. Les ressources de modèle de type #plane
ont deux mailles générées (une pour chaque côté), et par conséquent, deux matériaux dans
shaderList.
Une valeur de face #both crée le double de mailles et aussi le double d’entrées de matériaux dans
shaderList. Il y en aura 2 pour les plans et les sphères (respectivement, pour l’intérieur et
l’extérieur du modèle), 12 pour les cubes (6 à l’extérieur, 6 à l’intérieur) et 6 pour les cylindres
(le sommet, la base et les contours extérieur et intérieur).
Paramètres
nomDeNouvelleRessourceDeModèle
Requis. Spécifie le nom de la nouvelle ressource de modèle.
Facultatif. Spécifie le type de primitive de la nouvelle ressource de modèle. Les valeurs
correctes sont :
type
•
•
•
•
•
#plane
#box
#sphere
#cylinder
#particle
faisantFaceA Facultatif. Spécifie la face de la nouvelle ressource de modèle. Les valeurs correctes
sont :
•
•
•
#front
#back
#both
Exemple
Le gestionnaire suivant crée une boîte. La première ligne du gestionnaire crée une ressource de
modèle nommée boîte10. Elle est de type #box et est définie pour que seule sa face arrière soit
présentée. Les trois lignes suivantes définissent les dimensions de boîte10 et la dernière ligne crée
un nouveau modèle qui utilise boîte10 comme ressource de modèle.
on créationDeBoîte
nmr = member("3D").newModelResource("boîte10", #box, #back)
nmr.height = 50
nmr.width = 50
nmr.length = 50
aa = member("3D").newModel("gb5", nmr)
end
455
L’instruction suivante crée une ressource de modèle en forme de boîte, appelée
« boîteAchapeaux4 ».
member("Etagère").newModelResource("boîteAchapeaux4", #box)
Voir aussi
primitives
newMotion()
Utilisation
member(quelActeur).newMotion(nom)
Description
Commande 3D ; crée un mouvement dans un acteur référencé et renvoie une référence au
nouveau mouvement. Un nouveau mouvement peut être utilisé pour combiner plusieurs
mouvements existants dans la liste des mouvements de l’acteur, au moyen de la commande
map().
Paramètres
nom Requis. Spécifie le nom du nouveau mouvement. Le nom du nouveau mouvement doit être
unique dans l’acteur référencé.
Exemple
L’instruction suivante crée un mouvement dans l’acteur 1, courseEtOndulation, qui est utilisé
pour combiner les mouvements de course et d’ondulation provenant de la liste des mouvements
de l’acteur :
courseEtOndulation = member(1).newMotion("courseEtOndulation")
courseEtOndulation.map("course", "bassin")
courseEtOndulation.map("ondulation", "épaule")
newObject()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.newObject(typeDobjet {, arg1, arg2 ....})
// Syntaxe JavaScript
réfObjImageObjet.newObject(typeDobjet {, arg1, arg2 ....});
Description
Commande d’image-objet Flash ; crée un objet ActionScript du type spécifié.
La syntaxe suivante crée un objet dans une image-objet Flash :
réfDimageObjetFlash.newObject("typeDobjet" {, arg1, arg2 ....})
La syntaxe suivante crée un objet global :
newObject("typeDobjet" {, arg1, arg2 ....})
456
Chapitre 12 : Méthodes
Remarque : Si vous n’avez pas importé d’acteur Flash, vous devrez ajouter manuellement l’Xtra
Flash Asset à la liste des Xtras de votre animation pour permettre aux commandes Flash globales de
fonctionner correctement dans Shockwave Player et dans les projections. Vous pouvez ajouter les
Xtras à la liste des Xtras en choisissant Modification > Animation > Xtras. Pour plus d’informations sur
la gestion des Xtras pour les animations distribuées, consultez les rubriques Utilisation de Director
dans le panneau d'aide de Director.
Paramètres
typeDobjet
Requis. Spécifie le type de l’objet à créer.
arg1, arg2, ... Facultatif. Spécifie les arguments d’initialisation nécessaires à l’objet. Chaque
argument doit être séparé des autres par une virgule.
Exemple
Cette instruction définit la variable tObjetDeConnexionLocale sur une référence à un nouvel
objet LocalConnection dans l’animation Flash, au niveau de l’image-objet 3 :
-- Syntaxe Lingo
tObjetDeConnexionLocale = sprite(3).newObject("LocalConnection")
// Syntaxe JavaScript
var tObjetDeConnexionLocale = sprite(3).newObject("LocalConnection");
L’instruction suivante définit la variable tObjetTableau sur une référence à un nouvel objet
Tableau dans l’animation Flash, au niveau de l’image-objet 3. Le tableau contient les 3 nombres
entiers : 23, 34 et 19.
-- Syntaxe Lingo
tObjetTableau = sprite(3).newObject("Tableau",23,34,19)
// Syntaxe JavaScript
var tObjetTableau = sprite(3).newObject("Tableau",23,34,19);
Voir aussi
setCallback(), clearAsObjects()
newShader
Utilisation
member(quelActeur).newShader(nomDeNouveauMatériau, #typeDeMatériau)
Description
Commande 3D ; crée un matériau du type spécifié dans la liste des matériaux de l’acteur référencé
et renvoie une référence au nouveau matériau.
Chaque type de matériau possède un groupe de propriétés qui lui sont spécifiques, en plus des
propriétés de matériau #standard. Toutefois, même si vous pouvez attribuer n’importe quelle
propriété de matériau #standard à un matériau d’un autre type, il est possible que la propriété
n’ait aucun effet visible. C’est ce qui se produit lorsque la propriété #standard est appliquée, car
elle remplace la nature du type de matériau. Par exemple, la propriété de matériau standard
diffuseLightMap est ignorée par les matériaux du type #engraver, #newsprint et #painter.
457
Paramètres
Requis. Spécifie le nom du nouveau matériau. Le nom du nouveau
matériau doit être unique dans la liste des matériaux.
nomDeNouveauMatériau
typeDeMatériau Requis. Symbole qui détermine le style dans lequel le matériau est appliqué.
Les valeurs correctes sont :
• Les matériaux #standard sont photoréalistes et ont les propriétés suivantes : ambient, blend,
blendConstant, blendConstantList, blendFunction, blendFunctionList, blendSource,
blendSourceList, diffuse, diffuseLightMap, emissive, flat, glossMap, ilk, name,
region, renderStyle, silhouettes, specular, specularLightMap, texture,
textureMode, textureModeList, textureRepeat, textureRepeatList,
textureTransform, textureTransformList, transparent, useDiffuseWithTexture,
wrapTransform et wrapTransformList.
• Les matériaux #painter sont estompés, donnent l’apparence d’une peinture et ont, en plus de
toutes les propriétés #standard, les propriétés suivantes : colorSteps, hilightPercentage,
hilightStrength, name, shadowPercentage, shadowStrength et style.
• Les matériaux #engraver sont striés, donnent l’apparence d’une gravure et ont, en plus
•
de toutes les propriétés #standard, les propriétés suivantes : brightness, density, name
et rotation.
Les matériaux #newsprint sont en pointillés, donnent l’apparence d’une reproduction
de journal et ont, en plus de toutes les propriétés #standard, les propriétés suivantes :
brightness, density et name.
Exemple
L’instruction suivante crée le matériau #painter nouveauPeintre.
nouveauPeintre = member("Univers 3D").newShader("nouveauPeintre",#painter)
Voir aussi
shadowPercentage
newTexture
Utilisation
member(quelActeur).newTexture(nomDeNouvelleTexture \
{,#indicateurDeType, référenceDobjetSource})
Description
Commande 3D ; crée une texture dans la palette des textures de l’acteur référencé et renvoie une
référence à la nouvelle texture. Les textures d’acteur ne fonctionnent que lorsque vous spécifiez
l’acteur dans le constructeur newTexture.
Paramètres
Requis. Spécifie le nom de la nouvelle texture. Le nom de la nouvelle
texture doit être unique dans la palette de textures de l’acteur référencé.
nomDeNouvelleTexture
458
Chapitre 12 : Méthodes
Facultatif. Spécifie le type de la nouvelle texture. Si ce paramètre est omis,
la nouvelle texture est créée sans type spécifique. Les valeurs correctes sont :
indicateurDeType
•
•
#fromCastMember
(un acteur)
(un objet image Lingo)
#fromImageObject
référenceDobjetSource Facultatif. Spécifie une référence à l’acteur ou à l’objet image Lingo
source. Si ce paramètre est omis, la nouvelle texture est créée à partir d’aucune source spécifique.
référenceDobjetSource doit faire référence à un acteur si indicateurDeType est défini sur
#fromCastMember et à un objet image Lingo si indicateurDeType est défini sur
#fromImageObject.
Exemple
La première ligne de cette instruction crée une texture nommée Gazon 02 à partir de l’acteur 5 de
la distribution 1. La seconde ligne crée une texture vierge appelée Vierge.
member("Univers 3D").newTexture("Gazon \
02",#fromCastMember,member(5,1))
member("Univers 3D").newTexture("Vierge")
normalize
Utilisation
normalize(vecteur)
vecteur.normalize()
Description
Commande 3D ; normalise un vecteur en divisant les composants x, y et z par la magnitude du
vecteur. Les vecteurs normalisés ont toujours une magnitude de 1.
Paramètres
Aucun.
Exemple
L’instruction suivante indique la valeur du vecteur monVecteur avant et après la normalisation.
monVecteur = vector(-209.9019, 1737.5126, 0.0000)
monVecteur.normalize()
put monVecteur
-- vector( -0.1199, 0.9928, 0.0000 )
put monVecteur.magnitude
-- 1.0000
L’instruction suivante indique la valeur du vecteur ceVecteur avant et après la normalisation.
ceVecteur = vector(-50.0000, 0.0000, 0.0000)
normalize(ceVecteur)
put ceVecteur
-- vector( 0.0000, -1.0000, 0.0000 )
Voir aussi
getNormalized, randomVector(), magnitude
459
nothing
Utilisation
nothing
Description
Commande ; n’a aucun effet. Cette commande est pratique pour clarifier une instruction
if...then. Une instruction imbriquée if...then...else ne contenant aucune commande
explicite après la clause else peut nécessiter l’utilisation de else nothing, afin d’empêcher
Lingo d’interpréter la clause else comme faisant partie de la clause if qui la précède.
Paramètres
Aucun.
Exemple
L’instruction imbriquée if...then...else du gestionnaire suivant utilise la commande
nothing à la suite de la clause else de l’instruction :
-- Syntaxe Lingo
on mouseDown
if the clickOn = 1 then
if sprite(1).moveableSprite = TRUE then
member("Notice").text = "Faites glisser la balle"
else nothing
else member("Notice").text = "Cliquez à nouveau"
end if
end
// Syntaxe JavaScript
function mouseDown() {
if (_mouse.clickOn == 1) {
if (sprite(1).moveableSprite) {
member("Notice").text = "Faites glisser la balle";
} else {
// do nothing
}
} else {
member("Notice").text = "Cliquez à nouveau"
}
}
Avec le gestionnaire suivant, l’animation n’évolue pas tant que l’utilisateur appuie sur le bouton
de la souris :
-- Syntaxe Lingo
on mouseDown
repeat while the stillDown
nothing
end repeat
end mouseDown
460
Chapitre 12 : Méthodes
// Syntaxe JavaScript
function mouseDown() {
do {
// do nothing
} while _mouse.stillDown;
}
Voir aussi
if
nudge()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.nudge(#direction)
// Syntaxe JavaScript
réfObjImageObjet.nudge(#direction);
Description
Commande QuickTime VR ; déplace la perspective de l’image-objet QuickTime VR spécifiée
dans la direction spécifiée.
Une poussée vers la droite entraîne un déplacement de l’image de l’image-objet vers la gauche.
La commande nudge ne renvoie pas de valeur.
Paramètres
direction
Requis. Spécifie la direction du déplacement de la perspective. Les valeurs correctes
sont :
•
•
•
•
•
•
•
•
#down
#downLeft
#downRight
#left
#right
#up
#upLeft
#upRight
Exemple
Le gestionnaire suivant entraîne le déplacement vers la gauche de la perspective de l’image-objet
QuickTime VR pendant que le pointeur de la souris est positionné sur l’image-objet.
-- Syntaxe Lingo
on mouseDown me
repeat while the stillDown
sprite(1).nudge(#left)
end repeat
end
461
// Syntaxe JavaScript
function mouseDown() {
do {
sprite(1).nudge(#left);
} while _mouse.stillDown;
}
numToChar()
Utilisation
numToChar(expressionEntière)
Description
Fonction ; affiche une chaîne contenant le caractère dont le code ASCII est la valeur d’une
expression spécifiée. Elle est utile pour interpréter les données de sources externes qui sont
présentées sous forme de nombres plutôt que sous forme de caractères.
Les valeurs ASCII allant jusqu’à 127 sont standard sur tous les ordinateurs. Les valeurs
supérieures ou égales à 128 font référence à des caractères différents sur différents ordinateurs.
Paramètres
expressionEntière
Requis. Spécifie le nombre ASCII dont le caractère correspondant est
renvoyé.
Exemple
L’instruction suivante affiche dans la fenêtre Messages le caractère dont le code ASCII est 65 :
put numToChar(65)
Le résultat est la lettre A.
Le gestionnaire suivant supprime tous les caractères non alphabétiques d’une chaîne quelconque
et ne renvoie que des majuscules :
-- Syntaxe Lingo
on ForcerDesMajuscules saisie
sortie = EMPTY
num = length(saisie)
repeat with i = 1 to num
leCodeASCII = charToNum(saisie.char[i])
if leCodeASCII = min(max(96, leCodeASCII), 123) then
leCodeASCII = leCodeASCII - 32
if leCodeASCII = min(max(63, leCodeASCII), 91) then
put numToChar(leCodeASCII) after sortie
end if
end if
end repeat
return sortie
end
462
Chapitre 12 : Méthodes
// Syntaxe JavaScript
function ForcerDesMajuscules(saisie) {
sortie = "";
num = saisie.length;
for (i=1;i<=num;i++) {
leCodeASCII = saisie.char[i].charToNum();
if (leCodeASCII == min(max(96, leCodeASCII), 123) {
leCodeASCII = leCodeASCII - 32;
if (leCodeASCII == min(max(63, leCodeASCII), 91) {
sortie = sortie + leCodeASCII.numToChar();
}
}
}
return sortie;
}
Voir aussi
charToNum()
objectP()
Utilisation
objectP(expression)
Description
Fonction ; indique si une expression spécifiée est un objet créé par un script parent, un Xtra ou
une fenêtre (TRUE) ou non (FALSE).
Le P dans objectP signifie prédicat.
Il est judicieux d’utiliser objectP pour déterminer les éléments en cours d’utilisation lors de la
création d’objets par des scripts parents ou des instances d’Xtra.
Pour un exemple d’utilisation de objectP() dans une animation, reportez-vous à l’animation
Read and Write Text du dossier Learning/Lingo, lui-même inclus dans le dossier de Director.
Paramètres
expression
Requis. Spécifie l’expression à tester.
Exemple
L’instruction suivante vérifie si un objet est affecté à la variable globale gBaseDeDonnées et, dans
la négative, en affecte un. Cette vérification s’utilise généralement lorsque vous effectuez des
initialisations au début d’une animation ou d’une section qui ne doit pas être répétée.
-- Syntaxe Lingo
if objectP(gBaseDeDonnées) then
nothing
else
gBaseDeDonnées = script("Contrôleur de base de données").new()
end if
463
// Syntaxe JavaScript
if (objectP(BaseDeDonnées)) {
// do nothing
} else {
gBaseDeDonnées = script("Contrôleur de base de données").new();
}
Voir aussi
floatP(), ilk(), integerP(), stringP(), symbolP()
offset() (fonction de chaîne)
Utilisation
offset(expressionChaîne1, expressionChaîne2)
Description
Fonction ; renvoie un nombre entier indiquant la position du premier caractère d’une chaîne
dans une autre chaîne. Cette fonction renvoie 0 si la première chaîne est introuvable dans la
seconde chaîne. Lingo considère les espaces comme des caractères dans les deux chaînes.
Sur Macintosh, la comparaison des chaînes ne tient pas compte de la casse. Ainsi, Lingo considère
a et Å comme identiques sur Macintosh.
Paramètres
expressionChaîne1
Requis. Spécifie la sous-chaîne à rechercher dans expressionChaîne2.
expressionChaîne2
Requis. Spécifie la chaîne qui contient la sous-chaîne expressionChaîne1.
Exemple
L’instruction suivante affiche dans la fenêtre Messages la position du début de la chaîne media
dans la chaîne Macromedia :
put offset("media","Macromedia")
Le résultat est 6.
L’instruction suivante affiche dans la fenêtre Messages la position du début de la chaîne Micro
dans la chaîne Macromedia :
put offset("Micro", "Macromedia")
Le résultat est 0 car « Macromedia » ne contient pas la chaîne « Micro ».
464
Chapitre 12 : Méthodes
Le gestionnaire suivant recherche toutes les instances de la chaîne représentée par
chaîneAtrouver dans la chaîne représentée par saisie, puis les remplace par la chaîne
représentée par chaîneAinsérer.
-- Syntaxe Lingo
on ChercherEtRemplacer saisie, chaîneAtrouver, chaîneAinsérer
sortie = ""
Longueur = chaîneAtrouver.length - 1
repeat saisie input contains chaîneAtrouver
currOffset = offset(chaîneAtrouver, saisie)
sortie = sortie & saisie.char [1..currOffset]
delete the last char of sortie
sortie = sortie & chaîneAinsérer
delete input.char [1.. (currOffset + Longueur)]
end repeat
set sortie = sortie & saisie
return sortie
end
// Syntaxe JavaScript
function ChercherEtRemplacer (saisie, chaîneAtrouver, chaîneAinsérer) {
sortie = "";
Longueur = chaîneAtrouver.length - 1;
do {
currOffset = offset(chaîneAtrouver, saisie);
sortie = sortie + saisie.char [0..currOffset];
sortie = sortie.substr(0,sortie.length-2);
sortie = sortie + chaîneAinsérer;
saisie = saisie.substr(currOffset+Longueur,saisie.length);
} while (saisie.indexOf(chaîneAtrouver) >= 0);
sortie = sortie + saisie;
return sortie;
}
Voir aussi
chars(), length(), contains, starts
offset() (fonction de rectangle)
Utilisation
rectangle.offset(changementHorizontal, changementVertical)
offset (rectangle, changementHorizontal, changementVertical)
Description
Fonction ; produit un rectangle décalé par rapport au rectangle spécifié par rectangle.
Paramètres
changementHorizontal Requis. Spécifie le décalage horizontal, en pixels. Lorsque
changementHorizontal est supérieur à 0, le décalage se produit vers la droite de la scène ;
lorsque changementVertical est inférieur à 0, le décalage se produit vers la gauche de la scène.
changementVertical Requis. Spécifie le décalage vertical, en pixels. Lorsque
changementVertical est supérieur à 0, le décalage se produit vers le bas de la scène ; lorsque
changementHorizontal est inférieur à 0, le décalage se produit vers le haut de la scène.
465
Exemple
Le gestionnaire suivant déplace l’image-objet 1 de cinq pixels vers la droite et de cinq pixels vers le
bas.
-- Syntaxe Lingo
on mouvementDiagonal
nouveauRect=sprite(1).rect.offset(5, 5)
sprite(1).rect=nouveauRect
end
// Syntaxe JavaScript
function diagonalMove() {
nouveauRect = sprite(1).rect.offset(5,5);
sprite(1).rect = nouveauRect;
}
open() (lecteur)
Utilisation
-- Syntaxe Lingo
_player.open({chaîneCheminDeDoc,} chaîneCheminDapplication)
// Syntaxe JavaScript
_player.open({chaîneCheminDeDoc,} chaîneCheminDapplication);
Description
Méthode de lecteur ; ouvre une application spécifiée et, éventuellement, un fichier spécifié en
même temps que l’application.
Si chaîneCheminDeDoc ou chaîneCheminDapplication se trouvent dans un autre dossier que
l’animation courante, vous devez spécifier le chemin d’accès complet du ou des fichiers.
L’ordinateur doit avoir assez de mémoire pour exécuter simultanément Director et d’autres
applications.
Il s’agit d’une méthode très simple pour ouvrir une application ou un document au sein d’une
application. Pour d’autres contrôles, consultez les options disponibles dans les Xtras fournis par
d’autres développeurs.
Paramètres
chaîneCheminDeDoc Facultatif. Chaîne qui spécifie le document à ouvrir en même temps que
l’application spécifiée par chaîneCheminDapplication.
chaîneCheminDapplication
466
Chapitre 12 : Méthodes
Requis. Chaîne qui spécifie le chemin de l’application à ouvrir.
Exemple
L’instruction suivante ouvre l’application TextEdit, qui se trouve dans le dossier Applications sur
le disque dur (Macintosh), ainsi que le document Synopsis :
-- Syntaxe Lingo
_player.open("Synopsis", "HD:Applications:TextEdit")
// Syntaxe JavaScript
_player.open("Synopsis", "HD:Applications:TextEdit");
Voir aussi
Lecteur
open() (fenêtre)
Utilisation
-- Syntaxe Lingo
réfObjFenêtre.open()
// Syntaxe JavaScript
réfObjFenêtre.open();
Description
Méthode de fenêtre ; ouvre une fenêtre et la place devant toutes les autres fenêtres.
Si aucune animation n’est affectée à la fenêtre sur laquelle la méthode open() est appelée, la boîte
de dialogue d’ouverture de fichier s’affiche.
Si la référence à l’objet fenêtre réfObjFenêtre est remplacée par le nom de fichier d’une
animation, la fenêtre utilise le nom de fichier comme nom de fenêtre. Mais vous devez alors
affecter une animation à la fenêtre avec la propriété fileName de la fenêtre.
Si la référence à l’objet fenêtre réfObjFenêtre est remplacée par un nom de fenêtre, la fenêtre
prend ce nom. Mais vous devez alors affecter une animation à la fenêtre avec la propriété
fileName de la fenêtre.
Pour ouvrir une fenêtre qui utilise une animation provenant d’une adresse URL, téléchargez le
fichier sur votre disque local à l’aide de la commande downloadNetThing, puis utilisez-le depuis
votre disque local. Cette procédure minimise les problèmes d’attente pendant le téléchargement.
Lorsque vous utilisez une animation locale, chargez au moins la première image de l’animation
avec preloadMovie() avant d’appeler open(). Cette procédure réduit les risques de retard liés au
chargement des animations.
L’ouverture d’une animation dans une fenêtre n’est pas encore supportée pour la lecture dans un
navigateur web.
Paramètres
Aucun.
467
Exemple
L’instruction suivante ouvre la fenêtre Tableau de commande et la place au premier plan :
-- Syntaxe Lingo
window("Tableau de commande").open()
// Syntaxe JavaScript
window("Tableau de commande").open();
Voir aussi
close(), downloadNetThing, fileName (fenêtre), preLoadMovie(), Fenêtre
openFile()
Utilisation
-- Syntaxe Lingo
réfObjFileio.openFile(chaîneNomDeFichier, entMode)
// Syntaxe JavaScript
réfObjFileio.openFile(chaîneNomDeFichier, entMode)
Description
Méthode de Fileio ; ouvre un fichier spécifié avec un mode spécifié.
Paramètres
chaîneNomDeFichier
Requis. Chaîne qui spécifie le chemin complet et le nom du fichier à
ouvrir.
entMode
Requis. Nombre entier qui spécifie le mode du fichier. Les valeurs correctes sont :
• 0—Lecture/écriture
• 1—Lecture seule
• 2—Ecriture
Voir aussi
Fileio
openXlib
Utilisation
openXlib quelFichier
Description
Commande ; ouvre un fichier Xlibrary spécifié.
Il est recommandé de fermer tout fichier ouvert dès que vous n’en avez plus besoin. La commande
openXlib n’a aucun effet sur un fichier ouvert.
La commande openXlib ne supporte pas les URL comme références de fichiers.
Les fichiers Xlibrary contiennent des Xtras. A la différence de openResFile, openXlib met ces
Xtras à la disposition de Director.
Lorsque vous ouvrez un Xtra de programmation avec openXlib, utilisez closeXlib pour le
fermer lorsque Director a fini de l’utiliser.
468
Chapitre 12 : Méthodes
Sous Windows, l’extension .dll est facultative.
Remarque : Cette commande n’est pas prise en charge dans Shockwave Player.
Paramètres
quelFichier Requis. Spécifie le fichier Xlibrary à ouvrir. Si le fichier n’est pas dans le dossier de
l’animation courante, quelFichier doit inclure le chemin.
Exemple
L’instruction suivante ouvre le fichier Xlibrary Vidéodisque :
openXlib "Xlibrary Vidéodisque"
L’instruction suivante ouvre le fichier Xlibrary Xtras, situé dans un dossier différent de celui de
l’animation courante :
openXlib "Mon disque:Nouveautés:Transporter Xtras"
Voir aussi
closeXlib, interface()
param()
Utilisation
param(positionDeParamètre)
Description
Fonction ; renvoie la valeur d’un paramètre transmis à un gestionnaire.
Cette fonction peut s’utiliser pour déterminer le type d’un paramètre particulier afin d’éviter les
erreurs dans un gestionnaire.
Paramètres
positionDeParamètre
Requis. Spécifie la position du paramètre dans les arguments transmis au
gestionnaire.
Exemple
Le gestionnaire suivant accepte un nombre quelconque d’arguments, fait le total du nombre
transmis en paramètres, puis renvoie la somme :
-- Syntaxe Lingo
on ajouterLesNombres
somme = 0
repeat with numDeParamCourant = 1 to the paramCount
somme = somme + param(numDeParamCourant)
end repeat
return somme
end
469
// Syntaxe JavaScript
function ajouterLesNombres() {
somme = 0
for (numDeParamCourant=1;numDeParamCourant<=paramCount;numDeParamCourant++)
{
somme = somme + param(numDeParamCourant);
}
return somme;
}
Vous l’utilisez en transmettant les valeurs à ajouter :
put ajouterLesNombres(3, 4, 5, 6)
-- 18
put ajouterLesNombres(5, 5)
-- 10
Voir aussi
getAt, param(), paramCount(), return (mot-clé)
paramCount()
Utilisation
the paramCount
Description
Fonction ; indique le nombre de paramètres transmis au gestionnaire courant.
Paramètres
Aucun.
Exemple
L’instruction suivante définit la variable compteur en fonction du nombre de paramètres
transmis au gestionnaire courant :
set compteur = the paramCount
parseString()
Utilisation
objetDanalyse.parseString(chaîneAanalyser)
Description
Fonction ; utilisée pour analyser un document XML déjà disponible pour une animation
Director. Le premier paramètre est la variable contenant l’objet d’anamyse. La valeur renvoyée
est <VOID> en cas de succès de l’opération ou un code d’erreur en cas d’échec. L’échec est généralement dû à un problème au niveau de la syntaxe ou de la structure XML. Une fois l’opération
terminée, l’objet d’analyse contient les données XML analysées.
L’analyse du code XML d’une URL requiert l’utilisation de la commande parseURL().
Paramètres
chaîneAanalyser
470
Requis. Spécifie la chaîne de données XML à analyser.
Chapitre 12 : Méthodes
Exemple
L’instruction suivante analyse les données XML de l’acteur texte texteXML. Une fois l’opération
terminée, la variable gObjetDanalyse contient les données XML analysées.
codeErreur = gObjetDanalyse.parseString(member("texteXML"))
Voir aussi
getError() (XML), parseURL()
parseURL()
Utilisation
objetDanalyse.parseURL(chaîneURL {,#gestionnaireAappelerAlaFin} {,
objetContenantLeGestionnaire})
Description
Fonction ; analyse un document XML résidant à une adresse Internet externe. Le premier
paramètre est l’objet d’analyse contenant une instance de l’Xtra XMLParser.
Cette fonction renvoie un résultat immédiat et l’adresse URL complète peut donc ne pas être
encore analysée. Il est important d’utiliser la fonction doneParsing() avec parseURL() afin
d’être averti(e) de la fin de l’opération d’analyse.
Cette opération étant asynchrone (et pouvant prendre un certain temps), vous pouvez utiliser des
paramètres facultatifs permettant d’appeler un gestionnaire spécifique à la fin de l’opération.
La valeur renvoyée est VOID en cas de succès de l’opération ou un code d’erreur en cas d’échec.
L’analyse du code XML local requiert l’utilisation de la commande parseString().
Paramètres
chaîneURL
Requis. Spécifie l’URL réelle où résident les données XML.
gestionnaireAappelerAlaFin
Facultatif. Spécifie le nom du gestionnaire à exécuter une fois
l’analyse de l’URL terminée.
objetContenantLeGestionnaire Facultatif. Spécifie le nom de l’objet script contenant le
gestionnaire gestionnaireAappelerAlaFin. Si ce paramètre est omis, le gestionnaire est
supposé être un gestionnaire d’animation.
Exemple
L’instruction suivante analyse le fichier sample.xml de monEntreprise.fr. Utilisez la fonction
doneParsing() pour déterminer à quel moment l’opération d’analyse est terminée.
codeErreur = gObjetDanalyse.parseURL("http://www.monEntreprise.fr/
exemple.xml")
L’instruction Lingo suivante analyse le fichier exemple.xml et appelle le gestionnaire on
analyseTerminée. Aucun objet script n’étant donné avec la fonction doneParsing(), le
gestionnaire on analyseTerminée est considéré comme étant dans un script de l’animation.
codeErreur = gObjetDanalyse.parseURL("http://www.monEntreprise.fr/
exemple.xml", #analyseTerminée)
471
Le script de l’animation contient le gestionnaire on analyseTerminée :
on analyseTerminée
global gObjetDanalyse
if voidP(gObjetDanalyse.getError()) then
put "Analyse réussie"
else
put "Erreur d’analyse :"
put "
" & gObjetDanalyse.getError()
end if
end
L’instruction Lingo suivante analyse le document exemple.xml qui se trouve sur
www.monEntreprise.fr et appelle le gestionnaire on analyseTerminée de l’objet script
objetTest, qui est un enfant du script parent scriptTest :
objetDanalyse = new(xtra "XMLParser")
objetTest = new(script "scriptTest", objetDanalyse)
codeErreur = gObjetDanalyse.parseURL("http://www.monEntreprise.fr/
exemple.xml", #analyseTerminée, objetTest)
Le script parent scriptTest est le suivant :
property monObjetDanalyse
on new me, objetDanalyse
monObjetDanalyse = objetDanalyse
end
on analyseTerminée me
if voidP(monObjetDanalyse.getError()) then
put "Analyse réussie"
else
put "Erreur d’analyse :"
put "
" & monObjetDanalyse.getError()
end if
end
Voir aussi
getError() (XML), parseString()
pass
Utilisation
pass
Description
Commande ; transmet un message d’événement à la position suivante dans la hiérarchie des
messages et déclenche l’exécution de plusieurs gestionnaires pour un événement donné.
La commande pass passe à la position suivante dès son exécution. Aucun élément suivant la
commande pass dans le gestionnaire n’est exécuté.
Par défaut, un message d’événement s’arrête à la première position contenant un gestionnaire
pour l’événement, généralement au niveau de l’image-objet.
L’inclusion de la commande pass dans un gestionnaire entraîne la transmission de l’événement à
d’autres objets dans la hiérarchie, même si le gestionnaire pourrait autrement intercepter
l’événement.
472
Chapitre 12 : Méthodes
Paramètres
Aucun.
Exemple
Le gestionnaire suivant détermine les touches enfoncées et autorise leur transmission à l’imageobjet texte modifiable s’il s’agit de caractères valides :
-- Syntaxe Lingo
on keyDown me
caractèresAdmis = "1234567890"
if caractèresAdmis contains the key then
pass
else
beep
end if
end
// Syntaxe JavaScript
function keyDown() {
caractèresAdmis = "1234567890";
if (caractèresAdmis.indexOf(_key.key) >= 0) {
pass();
} else {
_sound.beep();
}
}
Voir aussi
stopEvent()
pasteClipBoardInto()
Utilisation
-- Syntaxe Lingo
réfObjActeur.pasteClipBoardInto()
// Syntaxe JavaScript
réfObjActeur.pasteClipBoardInto();
Description
Méthode d’acteur ; colle le contenu du Presse-papiers dans un acteur spécifié et efface l’acteur
existant.
Vous pouvez coller tout élément dont le format peut être utilisé par Director pour un acteur.
Lorsque vous copiez une chaîne à partir d’une autre application, son format n’est pas conservé.
Cette méthode est un moyen pratique de copier dans la fenêtre Distribution des objets provenant
d’autres animations et d’autres applications. Les acteurs copiés devant être conservés en RAM,
évitez d’utiliser cette commande pendant la lecture dans les situations où la mémoire arrive à
épuisement.
Lorsque vous utilisez cette méthode dans Shockwave Player ou dans l’environnement auteur
et avec des projections dont la propriété safePlayer a la valeur TRUE, une boîte de dialogue
d’avertissement s’affiche pour permettre à l’utilisateur d’annuler l’opération de collage.
473
Paramètres
Aucun.
Exemple
L’instruction suivante colle le contenu du Presse-papiers dans l’acteur bitmap Temple :
-- Syntaxe Lingo
member("Temple").pasteClipBoardInto()
// Syntaxe JavaScript
member("Temple").pasteClipBoardInto();
Voir aussi
Acteur, safePlayer
pause() (DVD)
Utilisation
-- Syntaxe Lingo
réfObjDvd.pause()
// Syntaxe JavaScript
réfObjDvd.pause();
Description
Méthode de DVD ; met en pause la lecture.
Paramètres
Aucun.
Voir aussi
DVD
pause() (piste audio)
Utilisation
-- Syntaxe Lingo
réfObjPisteAudio.pause()
// Syntaxe JavaScript
réfObjPisteAudio.pause();
Description
Méthode de piste audio ; interrompt la lecture du son courant dans une piste audio.
Une méthode play() subséquente entraînera la reprise de la lecture.
Paramètres
Aucun.
474
Chapitre 12 : Méthodes
Exemple
L’instruction suivante met en pause la lecture de l’acteur son lu dans la piste audio 1 :
-- Syntaxe Lingo
sound(1).pause()
// Syntaxe JavaScript
sound(1).pause();
Voir aussi
breakLoop(), play() (piste audio), playNext() (piste audio), queue(), rewind()
(piste audio), Piste audio, stop() (piste audio)
pause() (3D)
Utilisation
member(quelActeur).model(quelModèle).bonesPlayer.pause()
member(quelActeur).model(quelModèle).keyframePlayer.pause()
Description
Commande de modificateur 3D #keyframePlayer et #bonesPlayer ; stoppe le mouvement du
modèle en cours d’exécution. Utilisez la commande play() pour que le mouvement reprenne son
cours.
Lorsque le mouvement d’un modèle est arrêté à l’aide de cette commande, la propriété
bonesPlayer.playing du modèle prend la valeur FALSE.
Paramètres
Aucun.
Exemple
L’instruction suivante met l’animation courante du modèle Fourmi3 en pause.
member("ScèneDePiqueNique").model("Fourmi3").bonesplayer.pause()
Voir aussi
play() (3D), playing (3D), playlist
pause() (RealMedia, SWA, Windows Media)
Utilisation
-- Syntaxe Lingo
réfObjActeurOuImageObjet.pause()
// Syntaxe JavaScript
réfObjActeurOuImageObjet.pause();
Description
Méthode d’image-objet ou d’acteur RealMedia et Windows Media ; interrompt la lecture du flux
multimédia.
La valeur de mediaStatus devient #paused.
475
L’appel de cette méthode, lors de la lecture du flux RealMedia ou Windows Media, ne modifie
pas la propriété currentTime et n’efface pas le contenu de la mémoire tampon. En revanche, elle
permet aux commandes play suivantes de reprendre la lecture sans devoir remettre le flux
RealMedia en tampon.
Paramètres
Aucun.
Exemple
Les exemples suivants arrêtent la lecture de l’image-objet 2 ou de l’acteur Real.
-- Syntaxe Lingo
sprite(2).pause()
member("Real").pause()
// Syntaxe JavaScript
sprite(2).pause();
member("Real").pause();
Voir aussi
mediaStatus (RealMedia, Windows Media), play() (RealMedia, SWA, Windows
Media), seek(), stop() (RealMedia, SWA, Windows Media)
perpendicularTo
Utilisation
vecteur1.perpendicularTo(vecteur2)
Description
Commande 3D de vecteur ; renvoie un vecteur perpendiculaire au vecteur d’origine et à un
second vecteur. Cette commande équivaut à la commande de vecteur crossProduct.
Paramètres
vecteur2
Requis. Spécifie le second vecteur.
Exemple
Dans l’exemple suivant, pos1 est un vecteur sur l’axe des x et pos2 est un vecteur sur l’axe des y.
La valeur renvoyée par pos1.perpendicularTo(pos2) est vector( 0.0000, 0.0000,
1.00000e4 ). Les deux dernières lignes de l’exemple indiquent le vecteur perpendiculaire à pos1
et pos2.
pos1 = vector(100, 0, 0)
pos2 = vector(0, 100, 0)
put pos1.perpendicularTo(pos2)
-- vector( 0.0000, 0.0000, 1.00000e4 )
Voir aussi
crossProduct(), cross
476
Chapitre 12 : Méthodes
pictureP()
Utilisation
-- Syntaxe Lingo
pictureP(valeurDimage)
// Syntaxe JavaScript
pictureP(valeurDimage);
Description
Fonction ; indique si l’état de la propriété picture de l’acteur spécifié est TRUE ou FALSE.
Etant donné que pictureP ne vérifie pas directement si une image est associée à un acteur, vous
devez le faire en vérifiant la propriété picture de l’acteur.
Paramètres
valeurDimage
Requis. Spécifie une référence à l’image d’un acteur.
Exemple
La première instruction affecte la valeur de la propriété picture de l’acteur Temple, qui est un
bitmap, à la variable valeurDimage. La seconde vérifie si Temple est une image en vérifiant la
valeur affectée à valeurDimage.
-- Syntaxe Lingo
valeurDimage = member("Temple").picture
put pictureP(valeurDimage)
// Syntaxe JavaScript
var valeurDimage = member("Temple").picture;
put(pictureP(valeurDimage));
Le résultat est 1, équivalent numérique de TRUE.
play() (3D)
Utilisation
member(quelActeur).model(quelModèle).bonesPlayer.play()
member(quelActeur).model(quelModèle).keyframePlayer.play()
member(quelActeur).model(quelModèle).bonesPlayer.\
play(nomDeMouvement {, enBoucle, positionInitiale, positionFinale, échelle,
décalage})
member(quelActeur).model(quelModèle).keyframePlayer.\
play(nomDeMouvement {, enBoucle, positionInitiale, positionFinale, échelle,
décalage})
Description
Commande 3D #keyframePlayer et #bonesPlayer ; entraîne ou reprend l’exécution d’un
mouvement.
Lorsque le mouvement d’un modèle est démarré ou redémarré à l’aide de cette commande, la
propriété bonesPlayer.playing du modèle prend la valeur TRUE.
Utilisez play() sans paramètre pour reprendre l’exécution d’un mouvement qui a été arrêté à
l’aide de la commande pause().
477
L’utilisation de la commande play() pour démarrer un mouvement insère le mouvement au
début de la liste de lecture du modificateur. Si cela interrompt la lecture d’un autre mouvement,
le mouvement interrompu reste dans la liste de lecture et est positionné après le mouvement qui
vient d’être démarré. Lorsque le mouvement qui vient d’être démarré se termine (s’il n’est pas en
boucle) ou que la commande playNext() est émise, la lecture du mouvement interrompu
recommence là où elle s’était arrêtée.
Paramètres
Requis. Spécifie le nom du mouvement à exécuter. Lorsque nomDeMouvement
est le seul paramètre transmis à play(), le mouvement est exécuté une fois par le modèle du
début à la fin, à la cadence définie par la propriété playRate du modificateur.
nomDeMouvement
enBoucle
Facultatif. Spécifie si le mouvement est lu une seule fois (FALSE) ou continuellement
(TRUE).
positionInitiale Facultatif. Ce paramètre est mesuré en millisecondes, à partir du début du
mouvement. Lorsque enBoucle a pour valeur TRUE, la première itération de la boucle commence
à décalage et se termine à positionFinale, avec toutes les répétitions suivantes du mouvement
démarrant à positionInitiale et se terminant à positionFinale.
positionFinale Facultatif. Ce paramètre est mesuré en millisecondes, à partir du début du
mouvement. Lorsque enBoucle a pour valeur FALSE, le mouvement démarre à la position
décalage et se termine à la positionFinale. Lorsque enBoucle a pour valeur TRUE, la première
itération de la boucle commence à décalage et se termine à positionFinale, avec toutes les
répétitions suivantes démarrant à positionInitiale et se terminant à positionFinale.
Donnez à positionFinale la valeur -1 si le mouvement doit être lu jusqu’à la fin.
cadenceDeLecture Facultatif. Spécifie la cadence réelle de la lecture du mouvement. La valeur
du paramètre cadenceDeLecture est multipliée par la propriété playRate du modificateur
#keyframePlayer ou #bonesPlayer du modèle pour déterminer la cadence réelle de la lecture
du mouvement.
décalage Facultatif. Ce paramètre est mesuré en millisecondes, à partir du début du mouvement.
Lorsque enBoucle a pour valeur FALSE, le mouvement démarre à la position décalage et se
termine à la positionFinale. Lorsque enBoucle a pour valeur TRUE, la première itération de la
boucle commence à décalage et se termine à positionFinale, avec toutes les répétitions
suivantes démarrant à positionInitiale et se terminant à positionFinale. Vous pouvez
également donner au paramètre décalage la valeur #synchronized pour démarrer le
mouvement à la même position, par rapport à la durée, que l’animation courante.
Exemple
La commande suivante entraîne le modèle Marcheur à lire le mouvement Chute. Après la lecture
de ce mouvement, le modèle reprendra la lecture de tout autre mouvement précédemment
interrompu.
sprite(1).member.model("Marcheur").bonesPlayer.play("Chute", 0, \
0, -1, 1, 0)
478
Chapitre 12 : Méthodes
La commande suivante entraîne le modèle Marcheur à lire le mouvement coupDenvoi. Si
Marcheur est en train d’exécuter un mouvement, il sera interrompu par le mouvement
coupDenvoi dont une section sera jouée en boucle. La première itération de la boucle démarrera
2000 millisecondes à compter du début du mouvement. Toutes les itérations suivantes de la
boucle démarreront à 1000 millisecondes du début de coupDenvoi et se termineront à 5000
millisecondes du début de coupDenvoi. La cadence de lecture sera égale à trois fois la propriété
playRate du modificateur bonesPlayer du modèle.
sprite(1).member.model("Marcheur").bonesPlayer.play("coupDenvoi", 1, \
1000, 5000, 3, 2000)
Voir aussi
queue() (3D), playNext() (3D), playRate (3D), playlist, pause() (3D),
removeLast(), playing (3D)
play() (DVD)
Utilisation
-- Syntaxe Lingo
réfObjDvd.play()
réfObjDvd.play(titreDébut, chapitreDébut, titreFin, chapitreFin)
réfObjDvd.play(listePositionsDeDébut, listePositionsDeFin)
// Syntaxe JavaScript
réfObjDvd.play();
réfObjDvd.play(titreDébut, chapitreDébut, titreFin, chapitreFin);
réfObjDvd.play(listePositionsDeDébut, listePositionsDeFin);
Description
Méthode de DVD ; commence ou reprend la lecture.
En l’absence de paramètres, cette méthode reprend la lecture au début d’un disque ou, si la lecture
a été arrêtée, à la valeur spécifiée par la propriété . La lecture se poursuit jusqu’à la valeur spécifiée
par la propriété stopTimeList, si elle a été définie.
Avec les paramètres titreDébut, chapitreDébut, titreFin et chapitreFin, cette méthode
commence la lecture à un titre et un chapitre donnés. La lecture continue jusqu’aux paramètres
titreFin et chapitreFin, s’ils sont définis.
Avec les paramètres listePositionsDeDébut et listePositionsDeFin, cette méthode lit la
valeur spécifiée par le paramètre listePositionsDeDébut jusqu’à la valeur spécifiée par le
paramètre listePositionsDeFin.
Les formats de liste suivants sont utilisés pour listePositionsDeDébut et
listePositionsDeFin :
[#title:1, #chapter:1, #hours:0, #minutes:1, #seconds:1]
or
[#title:1, #hours:0, #minutes:1, #seconds:1]
Cette méthode renvoie la valeur 0 en cas de réussite.
479
Paramètres
titreDébut Requis si la lecture commence au niveau d’un titre et d’un chapitre donnés. Nombre
entier qui spécifie le titre contenant le chapitre à lire. Ce paramètre remplacera la propriété de
l’acteur.
Requis si la lecture commence au niveau d’un titre et d’un chapitre donnés.
Nombre entier qui spécifie le chapitre à lire. Ce paramètre remplacera la propriété de l’acteur.
chapitreDébut
titreFin Requis si la lecture doit s’arrêter au niveau d’un titre et d’un chapitre donnés. Nombre
entier qui spécifie le titre auquel la lecture s’arrêtera. Ce paramètre remplacera la propriété de
l’acteur.
chapitreFin Requis si la lecture doit s’arrêter au niveau d’un titre et d’un chapitre donnés.
Nombre entier qui spécifie le chapitre à lire. Ce paramètre remplacera la propriété de l’acteur.
listePositionsDeDébut Requis si la lecture commence à une position donnée. Liste de
propriétés qui spécifie la position à laquelle la lecture commence. Ce paramètre remplacera la
propriété de l’acteur.
Requis si la lecture commence à une position donnée. Liste de propriétés
qui spécifie la position à laquelle la lecture s’arrête. Ce paramètre remplacera la propriété de
l’acteur.
listePositionsDeFin
Exemple
Cette instruction reprend la lecture d’une image-objet en pause :
-- Syntaxe Lingo
member(12).play()
// Syntaxe JavaScript
member(12).play();
Ces instructions commencent la lecture au chapitre 2 du titre 1 et l’arrêtent au chapitre 4 :
member(15).play([#title:1, #chapter:2], [#title:1, #chapter:4])
or
member(15).play(1,2,1,4)
Cette instruction commence la lecture au niveau de la 10ème seconde du chapitre 2 et l’arrête à la
17ème seconde :
member(15).play([#title:2, #seconds:10], [#title:2, #seconds:17])
Voir aussi
DVD, startTimeList, stopTimeList
480
Chapitre 12 : Méthodes
play() (piste audio)
Utilisation
-- Syntaxe Lingo
réfObjPisteAudio.play()
réfObjPisteAudio.play(réfObjActeur)
réfObjPisteAudio.play(listeDesPropriétés)
// Syntaxe JavaScript
réfObjPisteAudio.play();
réfObjPisteAudio.play(réfObjActeur);
réfObjPisteAudio.play(listeDesPropriétés);
Description
Méthode de piste audio ; commence la lecture des sons mis en file d’attente sur une piste audio ou
met en file d’attente et commence de lire un acteur donné.
Les acteurs son mettent un certain temps à se charger en mémoire RAM avant que la lecture
ne puisse commencer. Il est conseillé de placer les sons en file d’attente avec queue() avant
d’entamer leur lecture et d’utiliser ensuite la première forme de cette méthode. La seconde forme
ne tire pas parti du préchargement accompli à l’aide de la commande queue().
L’utilisation d’une liste de propriétés facultative permet de définir les paramètres de lecture exacts
d’un son.
Pour un exemple d’utilisation de queue() dans une animation, reportez-vous à l’animation
Sound Control du dossier Learning/Lingo, lui-même inclus dans le dossier de Director.
Paramètres
réfObjActeur Requis si vous lisez un acteur son spécifique. Référence à l’objet acteur à mettre en
file d’attente et à lire.
Requis si vous spécifiez des paramètres de lecture pour un son. Liste de
propriétés qui spécifie les paramètres de lecture exacts pour le son. La définition de ces propriétés
est facultative :
listeDesPropriétés
Propriété
Description
#member
L’acteur à placer en file d’attente. Cette propriété doit être spécifiée. Toutes les
autres sont facultatives.
#startTime
Position temporelle de départ de la lecture du son, en millisecondes. La valeur par
défaut est le début du son. Pour plus d’informations, consultez startTime.
#endTime
Position temporelle de fin de la lecture du son, en millisecondes. La valeur par
défaut est la fin du son. Pour plus d’informations, consultez endTime.
#loopCount
Nombre de répétitions d’une boucle défini avec #loopStartTime et #loopEndTime.
La valeur par défaut est 1. Voir loopCount.
#loopStartTime
Position temporelle de départ de la boucle, en millisecondes. Pour plus
d’informations, consultez loopStartTime.
481
Propriété
Description
#loopEndTime
Position temporelle de fin de la boucle, en millisecondes. Pour plus
d’informations, consultez loopEndTime.
#preloadTime
Quantité de son à placer en mémoire tampon avant la lecture, en millisecondes.
Pour plus d’informations, consultez preloadTime.
Exemple
L’instruction suivante lit l’acteur son Intro sur la piste audio 1 :
-- Syntaxe Lingo
sound(1).play(member("Intro"))
// Syntaxe JavaScript
sound(1).play(member("Intro"));
L’instruction suivante exécute la lecture de l’acteur Crédits sur la piste audio 2. La lecture
commence à la quatrième seconde du son et se termine à la quinzième seconde. La section
comprise entre 10,5 et 14 secondes exécute une lecture en boucle à 6 reprises.
-- Syntaxe Lingo
sound(2).play([#member:member("Crédits"), #startTime:4000, \
#endTime:15000, #loopCount:6, #loopStartTime:10500, #loopEndTime:14000])
// Syntaxe JavaScript
sound(2).play(propList("member",member("Crédits"), "startTime",4000,
"endTime",15000, "loopCount",6, "loopStartTime",10500,
"loopEndTime",14000));
Voir aussi
endTime, loopCount, loopEndTime, loopStartTime, pause() (piste audio),
preLoadTime, queue(), Piste audio, startTime, stop() (piste audio)
play() (RealMedia, SWA, Windows Media)
Utilisation
-- Syntaxe Lingo
réfObjWindowsMedia.play()
réfObjRealMedia.play()
// Syntaxe JavaScript
réfObjWindowsMedia.play();
réfObjRealMedia.play();
Description
Méthode d’acteur ou d’image-objet Windows Media ou RealMedia ; lit l’acteur Windows Media
ou RealMedia ou lit l’image-objet sur la scène.
Pour les acteurs, seul le son est rendu s’il est présent dans l’animation. Si l’acteur est déjà en cours
de lecture, cette méthode n’a aucun effet.
Paramètres
Aucun.
482
Chapitre 12 : Méthodes
Exemple
Les exemples suivants démarrent le processus de lecture en flux continu de l’image-objet 2 et de
l’acteur Real.
-- Syntaxe Lingo
sprite(2).play()
member("Real").play()
// Syntaxe JavaScript
sprite(2).play();
member("Real").play();
Voir aussi
RealMedia, Windows Media
playFile()
Utilisation
-- Syntaxe Lingo
réfObjPisteAudio.playFile(chaîneCheminDeFichier)
// Syntaxe JavaScript
réfObjPisteAudio.playFile(chaîneCheminDeFichier);
Description
Méthode de piste audio ; lit le son AIFF, SWA, AU ou WAV dans une piste audio.
Pour que le son soit lu correctement, l’Xtra MIX qui convient doit être accessible à l’animation
(il est généralement placé dans le dossier des Xtras de l’application).
Lorsque le fichier audio ne se trouve pas dans le même dossier que l’animation,
chaîneCheminDeFichier doit indiquer son chemin d’accès complet.
Pour lire des sons obtenus à partir d’une adresse URL, il est judicieux d’utiliser la commande
downloadNetThing() ou preloadNetThing() pour télécharger d’abord le fichier sur le disque
local. Vous éviterez ainsi les problèmes pouvant se produire en attente de téléchargement.
La méthode playFile() lit les fichiers en flux continu à partir du disque dur au lieu de le faire
depuis la mémoire vive. Par conséquent, l'utilisation de la mathode playFile() pendant la
lecture d'une vidéo numérique ou le chargement d'acteurs en mémoire peut occasionner des
conflits, l'ordinateur tentant de lire simultanément deux emplacements du disque.
Paramètres
chaîneCheminDeFichier Requis. Chaîne qui spécifie le nom du fichier à lire. Lorsque le
fichier audio ne se trouve pas dans le même dossier que l’animation en cours de lecture,
chaîneCheminDeFichier doit indiquer son chemin d'accès complet.
Exemple
L’instruction suivante lit le fichier Tonnerre dans la piste 1 :
-- Syntaxe Lingo
sound(1).playFile("Tonnerre.wav")
// Syntaxe JavaScript
sound(1).playFile("Tonnerre.wav");
483
L’instruction suivante lit le fichier Tonnerre dans la piste 3 :
-- Syntaxe Lingo
sound(3).playFile(_movie.path & "Tonnerre.wav")
// Syntaxe JavaScript
sound(3).playFile(_movie.path + "Tonnerre.wav");
Voir aussi
play() (piste audio), Piste audio, stop() (piste audio)
playFromToTime()
Utilisation
-- Syntaxe Lingo
réfObjWindowsMedia.playFromToTime(entPositionInitiale, entPositionFinale)
// Syntaxe JavaScript
réfObjWindowsMedia.playFromToTime(entPositionInitiale, entPositionFinale);
Description
Méthode d’image-objet Windows Media. Démarre la lecture à une position de départ spécifiée et
l’interrompt à une position de fin spécifiée.
Paramètres
entPositionInitiale Requis. Nombre entier qui spécifie la position, en millisecondes, à partir
de laquelle la lecture commence.
entPositionFinale
Requis. Nombre entier qui spécifie la position, en millisecondes, à laquelle
la lecture s’arrête.
Exemple
Cette instruction spécifie que l’image-objet intitulée Vidéo doit être lue du repère des 30 secondes
au repère des 40 secondes.
-- Syntaxe Lingo
sprite("Vidéo").playFromToTime(30000, 40000)
// Syntaxe JavaScript
sprite("Vidéo").playFromToTime(30000, 40000);
Voir aussi
Windows Media
484
Chapitre 12 : Méthodes
playNext() (piste audio)
Utilisation
-- Syntaxe Lingo
réfObjPisteAudio.playNext()
// Syntaxe JavaScript
réfObjPisteAudio.playNext();
Description
Méthode de piste audio ; entraîne l’interruption immédiate de la lecture du son sur la piste audio
concernée et entame la lecture du son suivant placé en file d’attente.
Si la file d’attente ne contient pas d’autres sons, la lecture du son est simplement stoppée.
Paramètres
Aucun.
Exemple
L’instruction suivante lit le son suivant placé en file d’attente dans la piste audio 2.
-- Syntaxe Lingo
sound(2).playNext()
// Syntaxe JavaScript
sound(2).playNext();
Voir aussi
pause() (piste audio), play() (piste audio), Piste audio,stop() (piste audio)
playNext() (3D)
Utilisation
member(quelActeur).model(quelModèle).bonesPlayer.playNext()
member(quelActeur).model(quelModèle).keyframePlayer.playNext()
Description
Commande 3D de modificateur #keyframePlayer et #bonesPlayer ; démarre la lecture du
mouvement suivant dans la liste de lecture du modificateur #keyframePlayer ou #bonesPlayer
du modèle. Le mouvement en cours de lecture, qui est la première entrée de la liste de lecture, est
interrompu et retiré de la liste.
Si la fusion des mouvements est activée et qu’au moins deux mouvements sont présents dans la
liste de lecture, la fusion du mouvement courant avec le suivant dans la liste de lecture commencera avec l’appel de playNext().
Exemple
L’instruction suivante interrompt le mouvement actuellement exécuté par le modèle 1 et démarre
la lecture du mouvement suivant dans la liste de lecture :
member("scène").model[1].bonesPlayer.playnext()
Voir aussi
blend (3D), playlist
485
playerParentalLevel()
Utilisation
-- Syntaxe Lingo
réfObjDvd.playerParentalLevel()
// Syntaxe JavaScript
réfObjDvd.playerParentalLevel();
Description
Méthode de DVD ; renvoie le niveau parental du lecteur.
Les niveaux parentaux possibles sont compris entre 1 et 8.
Paramètres
Aucun.
Voir aussi
DVD
point()
Utilisation
-- Syntaxe Lingo
point(entH, entV)
// Syntaxe JavaScript
point(entH, entV);
Description
Fonction du niveau supérieur et type de données. Renvoie un point avec des coordonnées
horizontale et verticale spécifiées.
Un point a une propriété locH et une propriété locV.
Les coordonnées d’un point peuvent être modifiées par des opérations arithmétiques avec Lingo
uniquement. Par exemple, les deux points suivants peuvent être ajoutés ensemble avec Lingo,
mais NaN est renvoyé avec la syntaxe JavaScript :
-- Lingo
pointA = point(10,10)
pointB = point(5,5)
put(pointA + pointB)
-- point(15,15)
// Syntaxe JavaScript
var pointA = point(10,10);
var pointB = point(5,5);
trace(pointA + pointB);
// NaN
Pour un exemple d’utilisation de point() dans une animation, reportez-vous aux animations
Imaging et Vector Shapes du dossier Learning/Lingo, lui-même inclus dans le dossier de Director.
486
Chapitre 12 : Méthodes
Paramètres
entH
Requis. Entier qui spécifie la coordonnée horizontale du point.
entV
Requis. Entier qui spécifie la coordonnée verticale du point.
Exemple
L’instruction suivante définit la variable dernièrePosition au point (250, 400) :
-- Syntaxe Lingo
dernièrePosition = point(250, 400)
// Syntaxe JavaScript
var dernièrePosition = point(250, 400);
L’instruction suivante ajoute 5 pixels à la coordonnée horizontale du point affecté à la variable
monPoint :
-- Syntaxe Lingo
monPoint.locH = monPoint.locH + 5
// Syntaxe JavaScript
monPoint.locH = monPoint.locH + 5;
En Lingo uniquement, les instructions suivantes définissent les coordonnées sur la scène d’une
image-objet comme mouseH et mouseV plus 10 pixels. Ces deux instructions sont équivalentes.
-- Syntaxe Lingo
sprite(_mouse.clickOn).loc = point(_mouse.mouseH, _mouse.mouseV) \
+ point(10, 10)
sprite(_mouse.clickOn).loc = _mouse.mouseLoc + 10
Voir aussi
locH, locV
pointAt
Utilisation
member(quelActeur).model(quelModèle).pointAt\
(positionDuVecteur{, vecteurVertical})
member(quelActeur).camera(quelleCaméra).pointAt\
(positionDuVecteur{, vecteurVertical})
member(quelActeur).light(quelleLumière).pointAt\
(positionDuVecteur{, vecteurVertical})
member(quelActeur).group(quelGroupe).pointAt\
(positionDuVecteur{, vecteurVertical})
Description
Commande 3D ; fait pivoter l’objet référencé pour que son vecteur horizontal pointe vers une
position relative à l’univers spécifiée, puis fait pivoter l’objet référencé pour que son vecteur
vertical pointe dans la direction indiquée par un vecteur relatif spécifié.
Le vecteur vertical et le vecteur horizontal de l’objet sont définis par la propriété
pointAtOrientation de l’objet.
487
Paramètres
Requis. Spécifie la position relative à l’univers. Cette valeur peut également
être une référence de nœud.
positionDuVecteur
vecteurVertical Facultatif. Spécifie un vecteur relatif à l’univers qui indique comment le
vecteur vertical de l’objet devrait être orienté. Si ce paramètre n’est pas spécifié, pointAt utilise
par défaut l’axe des y de l’univers comme vecteur vertical recommandé. Si vous essayez de diriger
l’objet pour que son vecteur horizontal soit parallèle à l’axe des y de l’univers, l’axe des x de
l’univers sera utilisé comme vecteur vertical recommandé. La direction horizontale de l’objet et
la direction spécifiée par vecteurVertical n’ont pas besoin d’être perpendiculaires, car cette
commande n’utilise que le paramètre vecteurVertical comme vecteur de recommandation.
Exemple
L’exemple suivant dirige trois objets vers le modèle Mars : la caméra camMars, la lumière Spot
et le modèle Pistolet.
posDansCetUnivers = member("Scène").model("Mars").worldPosition
member("Scène").camera("camMars").pointAt(posDansCetUnivers)
member("Scène").light("Spot").pointAt(posDansCetUnivers)
member("Scène").model("Pistolet").pointAt(posDansCetUnivers, \
vector(0,0,45))
Si vous utilisez un redimensionnement non uniforme et un pointAtOrientation personnalisé
sur le même nœud (tel qu’un modèle), l’appel de pointAt entraînera probablement un redimensionnement non uniforme inattendu. Cela s’explique par l’ordre dans lequel le redimensionnement non uniforme et la rotation utilisés pour orienter correctement le nœud sont appliqués.
Pour remédier à ce problème, effectuez l’une des opérations suivantes :
• Evitez d’utiliser un redimensionnement non uniforme et une valeur pointAtOrientation qui
n’est pas celle définie par défaut sur le même nœud.
• Supprimez votre propriété d’échelle avant d’utiliser pointAt, puis appliquez-la ensuite à
nouveau.
Par exemple :
scale = nœud.transform.scale
nœud.scale = vector( 1, 1, 1 )
nœud.pointAt(vector(0, 0, 0)) -- pointAtOrientation autre que défaut
nœud.transform.scale = scale
Voir aussi
pointAtOrientation
488
Chapitre 12 : Méthodes
pointInHyperlink()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.pointInHyperlink(point)
// Syntaxe JavaScript
réfObjImageObjet.pointInHyperlink(point);
Description
Fonction d’image-objet texte ; renvoie TRUE ou FALSE selon que le point spécifié est ou non dans
un hyperlien de l’image-objet texte. En règle générale, le point est la position du curseur. Cela est
utile pour définir des curseurs personnalisés.
Paramètres
point
Requis. Spécifie le point à tester.
Voir aussi
cursor(), mouseLoc
pointToChar()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.pointToChar(pointAConvertir)
// Syntaxe JavaScript
réfObjImageObjet.pointToChar(pointAConvertir);
Description
Fonction ; renvoie un nombre entier représentant la position du caractère situé dans l’image-objet
texte ou champ à une coordonnée d’écran spécifiée ou renvoie -1 si le point n’est pas dans le texte.
Cette fonction permet de déterminer le caractère sous le curseur.
Paramètres
pointAconvertir
Requis. Spécifie la coordonnée d’écran à tester.
Exemple
Les instructions suivantes affichent le numéro du caractère cliqué, ainsi que la lettre, dans la
fenêtre Messages :
-- Syntaxe Lingo
property spriteNum
on mouseDown me
pointCliqué = _mouse.mouseLoc
acteurCourant = sprite(spriteNum).member
numDuCaractère = sprite(spriteNum).pointToChar(pointCliqué)
caractère = acteurCourant.char[numDuCaractère]
put("Caractère sélectionné" && numDuCaractère & ", lettre" && caractère)
end
489
// Syntaxe JavaScript
function mouseDown() {
var pointCliqué = _mouse.mouseLoc;
var acteurCourant = sprite(this.spriteNum).member;
var numDuCaractère = sprite(this.spriteNum).pointToChar(pointCliqué);
var caractère = acteurCourant.getProp("char", numDuCaractère);
put ("Caractère sélectionné " + numDuCaractère + ", lettre " + caractère);
}
Voir aussi
mouseLoc, pointToWord(), pointToItem(), pointToLine(), pointToParagraph()
pointToItem()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.pointToItem(pointAConvertir)
// Syntaxe JavaScript
réfObjImageObjet.pointToItem(pointAConvertir);
Description
Fonction ; renvoie un nombre entier représentant la position de l’élément situé dans l’image-objet
texte ou champ à une coordonnée d’écran spécifiée ou renvoie -1 si le point n’est pas dans le texte.
Les éléments sont séparés par la propriété itemDelimiter, qui est par défaut une virgule.
Cette fonction permet de déterminer l’élément sous le curseur.
Paramètres
pointAconvertir
Requis. Spécifie la coordonnée d’écran à tester.
Exemple
Les instructions suivantes affichent le numéro de l’élément cliqué, ainsi que son texte, dans la
fenêtre Messages :
-- Syntaxe Lingo
property spriteNum
on mouseDown me
pointCliqué = _mouse.mouseLoc
acteurCourant = sprite(spriteNum).member
numéroDélément = sprite(spriteNum).pointToItem(pointCliqué)
texteDélément = acteurCourant.item[numéroDélément]
put("Elément cliqué" && numéroDélément & ", le texte" && texteDélément)
end
490
Chapitre 12 : Méthodes
// Syntaxe JavaScript
function mouseDown() {
var pointCliqué = _mouse.mouseLoc;
var acteurCourant = sprite(this.spriteNum).member;
var numéroDélément = sprite(this.spriteNum).pointToItem(pointCliqué);
var texteDélément = acteurCourant.getProp("item" ,numéroDélément);
trace("Elément cliqué " + numéroDélément + ", le texte" + texteDélément);
}
Voir aussi
itemDelimiter, mouseLoc, pointToChar(), pointToWord(), pointToItem(),
pointToLine(), pointToParagraph()
pointToLine()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.pointToLine(pointAConvertir)
// Syntaxe JavaScript
réfObjImageObjet.pointToLine(pointAConvertir);
Description
Fonction ; renvoie un nombre entier représentant la position de la ligne dans l’image-objet texte
ou champ à une coordonnée d’écran spécifiée ou renvoie -1 si le point n’est pas dans le texte. Les
lignes sont séparées par des retours chariot dans l’acteur texte ou champ.
Cette fonction permet de déterminer la ligne sous le curseur.
Paramètres
pointAconvertir
Requis. Spécifie la coordonnée d’écran à tester.
Exemple
Les instructions suivantes affichent le numéro de la ligne cliquée, ainsi que son texte, dans la
fenêtre Messages :
-- Syntaxe Lingo
property spriteNum
on mouseDown me
pointCliqué = _mouse.mouseLoc
acteurCourant = sprite(spriteNum).member
numDeLigne = sprite(spriteNum).pointToLine(pointCliqué)
texteDeLigne = acteurCourant.line[numDeLigne]
put("Ligne cliquée" && numDeLigne & ", le texte" && texteDeLigne)
end
491
// Syntaxe JavaScript
function mouseDown() {
var pointCliqué = _mouse.mouseLoc;
var acteurCourant = sprite(this.spriteNum).member;
var numDeLigne = sprite(this.spriteNum).pointToLine(pointCliqué);
var texteDeLigne = acteurCourant.getProp("line", numDeLigne);
put("Ligne cliquée" + numDeLigne + ", le texte" + texteDeLigne);
}
Voir aussi
itemDelimiter, mouseLoc, pointToChar(), pointToWord(), pointToItem(),
pointToLine(), pointToParagraph()
pointToParagraph()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.pointToParagraph(PointAConvertir)
// Syntaxe JavaScript
réfObjImageObjet.pointToParagraph(PointAConvertir);
Description
Fonction ; renvoie un nombre entier représentant le numéro du paragraphe situé dans l’imageobjet texte ou champ à une coordonnée d’écran spécifiée ou renvoie -1 si le point n’est pas dans
le texte. Les paragraphes sont séparés par des retours chariot dans un bloc de texte.
Cette fonction permet de déterminer le paragraphe sous le curseur.
Paramètres
pointAconvertir
Requis. Spécifie la coordonnée d’écran à tester.
Exemple
Les instructions suivantes affichent le numéro du paragraphe cliqué, ainsi que son texte, dans la
fenêtre Messages :
-- Syntaxe Lingo
property spriteNum
on mouseDown me
pointCliqué = _mouse.mouseLoc
acteurCourant = sprite(spriteNum).member
numDeParagraphe = sprite(spriteNum).pointToParagraph(pointCliqué)
texteDuParagraphe = acteurCourant.paragraph[numDeParagraphe]
put("Paragraphe cliqué" && numDeParagraphe & ", le texte" &&
texteDuParagraphe)
end
492
Chapitre 12 : Méthodes
// Syntaxe JavaScript
function mouseDown() {
var pointCliqué = _mouse.mouseLoc;
var acteurCourant = sprite(this.spriteNum).member;
var numDeParagraphe = sprite(this.spriteNum).pointToParagraph(pointCliqué);
var texteDuParagraphe= acteurCourant.getProp("paragraph", numDeParagraphe);
trace("Paragraphe cliqué " + numDeParagraphe + ", le texte" +
texteDuParagraphe);
}
Voir aussi
itemDelimiter, mouseLoc, pointToChar(), pointToWord(), pointToItem(),
pointToLine()
pointToWord()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.pointToWord(pointAConvertir)
// Syntaxe JavaScript
réfObjImageObjet.pointToWord(pointAConvertir);
Description
Fonction ; renvoie un nombre entier représentant le numéro du mot situé dans l’image-objet
texte ou champ à une coordonnée d’écran spécifiée ou renvoie -1 si le point n’est pas dans le texte.
Les mots sont séparés par des espaces dans un bloc de texte.
Cette fonction permet de déterminer le mot sous le curseur.
Paramètres
pointAconvertir
Requis. Spécifie la coordonnée d’écran à tester.
Exemple
Les instructions suivantes affichent le numéro du mot cliqué, ainsi que son texte, dans la fenêtre
Messages :
-- Syntaxe Lingo
property spriteNum
on mouseDown me
pointCliqué = _mouse.mouseLoc
acteurCourant = sprite(spriteNum).member
numDuMot = sprite(spriteNum).pointToWord(pointCliqué)
texteDuMot = acteurCourant.word[numDuMot]
put("Mot cliqué" && numDuMot & ", le texte" && texteDuMot)
end
493
// Syntaxe JavaScript
function mouseDown(me) {
var pointCliqué = _mouse.mouseLoc;
var acteurCourant = sprite(this.spriteNum).member;
var numDuMot = sprite(this.spriteNum).pointToWord(pointCliqué);
var texteDuMot = acteurCourant.getProp("word", numDuMot);
trace("Mot cliqué" + numDuMot + ", le texte" + texteDuMot);
}
Voir aussi
itemDelimiter, mouseLoc, pointToChar(), pointToItem(), pointToLine(),
pointToParagraph()
postNetText
Utilisation
postNetText(url, listeDePropriétés {,chaîneOSduServeur}
{,chaîneJeuCarServeur})
postNetText(url, textePosté {,chaîneOSduServeur} {,chaîneJeuCarServeur})
Description
Commande ; envoie une requête POST à une URL (une URL HTTP) avec des données spécifiées.
Cette commande est similaire à getNetText(). Comme pour getNetText(), la réponse du
serveur est renvoyée via netTextResult(IDRéseau) une fois que netDone(IDRéseau) reçoit la
valeur 1 et si netError(IDRéseau) a la valeur 0 ou OK.
Les arguments facultatifs peuvent être omis quelle que soit leur position.
Cette commande possède en outre un avantage supplémentaire par rapport à getNetText() :
en effet, une requête postNetText() peut être arbitrairement longue, alors que la longueur de la
requête getNetText() est limitée à celle d’une adresse URL (1 Ko ou 4 Ko, selon le navigateur
web).
Remarque : Si vous utilisez postNetText pour afficher des données dans un domaine différent de
celui dans lequel l’animation est lue, une alerte de sécurité est déclenchée lors de la lecture dans
Shockwave Player.
Pour un exemple d’utilisation de postNetText dans une animation, reportez-vous à l’animation
Forms and Post du dossier Learning/Lingo, lui-même inclus dans le dossier de Director.
Paramètres
url
Requis. Spécifie l’URL à laquelle la requête POST doit être envoyée.
ou TextePosté Requis. Spécifie les données à envoyer avec la demande.
Lorsqu’une liste de propriétés est utilisée à la place d’une chaîne, les informations sont envoyées
avec METHOD=POST, de la même manière qu’un navigateur web affiche un formulaire HTML.
Cette procédure facilite la construction et l’affichage des données d’un formulaire dans un titre
Director. Les noms des propriétés correspondent aux noms des champs du formulaire HTML
et leurs valeurs à celles des champs.
listeDePropriétés
La liste de propriétés peut utiliser des chaînes ou des symboles comme noms de propriétés. Si un
symbole est utilisé, il est automatiquement converti en chaîne sans le signe # du début. De même,
les valeurs numériques sont converties en chaînes si elles sont utilisées comme valeur d’une
propriété.
494
Chapitre 12 : Méthodes
Remarque : Si la forme secondaire est utilisée (une chaîne remplace la liste de propriétés), la chaîne
textePosté est envoyée au serveur sous forme de requête HTTP POST en utilisant le type mime
text/plain. Bien que pratique dans certaines applications, cette méthode n’est pas compatible avec
l’affichage de formulaires HTML.
chaîneOSduServeur Facultatif. La valeur par défaut est UNIX, mais ce paramètre peut prendre la
valeur Windows ou Mac et convertit les retours chariot de l’argument listeDePropriétés dans le
format utilisé par le serveur afin d’éviter toute confusion. Pour la plupart des applications, ce
paramètre n’est pas nécessaire, les ruptures de ligne n’étant généralement pas utilisées dans les
réponses de formulaires.
Facultatif. Ce paramère ne s’applique que si l’utilisateur travaille sur un
système Shift-JIS (japonais). Ses valeurs possibles sont JIS, EUC, ASCII et AUTO. Les données
envoyées sont converties de Shift-JIS dans le jeu de caractères désigné. Les données renvoyées sont
traitées de la même façon qu’avec getNetText() (converties du jeu de caractères nommé à ShiftJIS). Si AUTO est utilisé, les données affichées dans le jeu de caractères local ne sont pas converties ;
les résultats renvoyés par le serveur sont convertis comme pour getNetText(). "ASCII" est la
valeur par défaut si chaîneJeuCarServeur est omis. ASCII n’offre aucune conversion pour
l’envoi ou les résultats.
chaîneJeuCarServeur
Exemple
L’instruction suivante omet le paramètre chaîneJeuCarServeur :
IDréseau = postNetText("www.dom.fr\baseDeDonnées.cgi", "Jean Martin", "Win")
L’exemple suivant génère un formulaire à partir des champs de saisie de l’utilisateur pour son
prénom et son nom, ainsi qu’un score. Notez que chaîneOSduServeur et
chaîneJeuCarServeur ont été omis :
nom = member("Nom").text
prénom = member("Prénom").text
score = member("Score").text
listeInfos = ["Prénom":prénom, "Nom":nom, "Score":score]
IDréseau = postNetText("www.mondomaine.fr\baseUtilisateurs.cgi", listeInfos)
Voir aussi
getNetText(), netTextResult(), netDone(), netError()
power()
Utilisation
power(base, exposant)
Description
Fonction mathématique ; calcule la valeur d’un nombre déterminé qui est élevé à une puissance
donnée.
Paramètres
base
Requis. Spécifie le numéro de base.
exposant
Requis. Spécifie la valeur de l’exposant.
495
Exemple
L’instruction suivante donne à la variable vRésultat la valeur du cube de 4 :
set vRésultat = power(4,3)
preLoad() (acteur)
Utilisation
-- Syntaxe Lingo
réfObjActeur.preLoad({réfObjDernierActeur})
// Syntaxe JavaScript
réfObjActeur.preLoad({réfObjDernierActeur});
Description
Méthode d’acteur ; précharge un acteur ou une plage d’acteurs en mémoire et arrête le
préchargement lorsque la mémoire est pleine ou lorsque tous les acteurs spécifiés ont été
préchargés.
En l’absence du paramètre réfObjDernierActeur, preLoad() précharge tous les acteurs utilisés
depuis l’image courante jusqu’à la dernière image d’une animation.
Paramètres
réfObjDernierActeur Facultatif. Référence au dernier acteur d’une plage d’acteurs qui est
chargé en mémoire. Le premier acteur de la plage est spécifié par réfObjActeur.
Exemple
L’instruction suivante indique dans la fenêtre Messages si l’animation QuickTime Chaise
pivotante peut être préchargée en mémoire :
-- Syntaxe Lingo
put(member("Chaise pivotante").preload())
// Syntaxe JavaScript
put(member("Chaise pivotante").preload());
Le gestionnaire startMovie suivant définit un acteur animation Flash pour une lecture en flux
continu puis définit sa propriété bufferSize :
-- Syntaxe Lingo
on startMovie
member("Démo Flash").preload = FALSE
member("Démo Flash").bufferSize = 65536
end
// Syntaxe JavaScript
function startMovie() {
member("Démo Flash").preload = false;
member("Démo Flash").bufferSize = 65536;
}
Voir aussi
Acteur
496
Chapitre 12 : Méthodes
preLoad() (animation)
Utilisation
-- Syntaxe Lingo
_movie.preLoad({nomOuNumDimage})
_movie.preLoad(nomOuNumDimageInitiale, nomOuNumDimageFinale)
// Syntaxe JavaScript
_movie.preLoad({nomOuNumDimage});
_movie.preLoad(nomOuNumDimageInitiale, nomOuNumDimageFinale);
Description
Méthode d’animation ; précharge en mémoire des acteurs de l’image ou de la plage d’images
spécifiée et s’arrête lorsque la mémoire disponible est saturée ou que tous les acteurs spécifiés
ont été préchargés, comme suit :
• En l’absence d’arguments, cette méthode précharge tous les acteurs utilisés depuis l’image
•
•
courante jusqu’à la dernière image d’une animation.
Si un seul argument est fourni (nomOuNumDimage), la méthode précharge tous les acteurs
utilisés dans la plage d’images depuis l’image courante jusqu’à l’image nomOuNumDimage,
comme spécifié par le numéro ou le nom de l’image.
Si deux arguments sont fournis (nomOuNumDimageInitiale et nomOuNumDimageFinale) la
méthode précharge tous les acteurs utilisés dans la plage d’images depuis l’image
nomOuNumDimageInitiale jusqu’à l’image nomOuNumDimageFinale, comme spécifié par le
numéro ou le nom de l’image.
La méthode preLoad() renvoie aussi le numéro de la dernière image qu’il a été possible de
charger. Pour obtenir cette valeur, utilisez la fonction result().
Paramètres
nomOuNumDimage Facultatif. Chaîne qui spécifie l’image à précharger ou nombre entier qui
spécifie son numéro.
nomOuNumDimageInitiale Requis si vous préchargez une plage d’images. Chaîne qui spécifie le
nom du libellé de la première image dans la plage d’images à précharger ou nombre entier qui
spécifie le numéro de cette image.
Requis si vous préchargez une plage d’images. Chaîne qui spécifie le
nom du libellé de la dernière image dans la plage d’images à précharger ou nombre entier qui
spécifie le numéro de cette image.
nomOuNumDimageFinale
Exemple
L’instruction suivante précharge les acteurs utilisés depuis l’image courante jusqu’à l’image
contenant le repère suivant :
-- Syntaxe Lingo
_movie.preLoad(_movie.marker(1))
// Syntaxe JavaScript
_movie.preLoad(_movie.marker(1));
497
L’instruction suivante précharge les acteurs utilisés de l’image 10 à l’image 50 :
-- Syntaxe Lingo
_movie.preLoad(10, 50)
// Syntaxe JavaScript
_movie.preLoad(10, 50);
Voir aussi
Animation, result
preLoadBuffer()
Utilisation
-- Syntaxe Lingo
réfObjActeur.preLoadBuffer()
// Syntaxe JavaScript
réfObjActeur.preLoadBuffer();
Description
Commande ; précharge une partie d’un fichier Shockwave Audio (SWA) spécifié en mémoire.
La quantité préchargée est déterminée par la propriété preLoadTime. Cette commande ne
fonctionne que si l’acteur SWA est arrêté.
Une fois la commande preLoadBuffer réussie, la propriété d’acteur state est égale à 2.
La plupart des propriétés des acteurs SWA ne peuvent être testées qu’après la réussite complète
de la commande preLoadBuffer. Ces propriétés sont : cuePointNames, cuePointTimes,
currentTime, duration, percentPlayed, percentStreamed, bitRate, sampleRate et
numChannels.
Paramètres
Aucun.
Exemple
L’instruction suivante charge l’acteur Jacques Brel en mémoire :
-- Syntaxe Lingo
member("Jacques Brel").preLoadBuffer()
// Syntaxe JavaScript
member("Jacques Brel").preLoadBuffer();
Voir aussi
preLoadTime
498
Chapitre 12 : Méthodes
preLoadMember()
Utilisation
-- Syntaxe Lingo
_movie.preLoadMember({réfObjActeur})
_movie.preLoadMember(nomOuNumDacteurInitial, nomOuNumDacteurFinal)
// Syntaxe JavaScript
_movie.preLoadMember({réfObjActeur});
_movie.preLoadMember(nomOuNumDacteurInitial, nomOuNumDacteurFinal);
Description
Méthode d’animation ; précharge les acteurs et arrête le préchargement lorsque la mémoire est
saturée ou que tous les acteurs spécifiés ont été préchargés.
Cette méthode renvoie le numéro du dernier acteur qu’il a été possible de charger. Pour obtenir
cette valeur, utilisez la fonction result().
En l’absence d’arguments, preLoadMember() précharge tous les acteurs de l’animation.
Si l’argument réfObjActeur est fourni, preLoadMember() ne précharge que cet acteur. Si
réfObjActeur est un nombre entier, il n’est fait référence qu’à la première distribution. Si
réfObjActeur est une chaîne, le premier acteur dont le nom correspond à la chaîne est utilisé.
Si les deux arguments (nomOuNumDacteurInitial et nomOuNumDacteurFinal) sont fournis,
précharge tous les acteurs dans la plage spécifiée par les noms ou numéros des
acteurs.
preLoadMember()
Paramètres
réfObjActeur
Facultatif. Référence à l’acteur à précharger.
nomOuNumDacteurInitial Requis si vous préchargez une plage d’acteurs. Chaîne ou nombre
entier qui spécifie le premier acteur de la plage d’acteurs à précharger.
nomOuNumDacteurFinal Requis si vous préchargez une plage d’acteurs. Chaîne ou nombre entier
qui spécifie le dernier acteur de la plage d’acteurs à précharger.
Voir aussi
Animation, preLoad() (acteur), result
preLoadMovie()
Utilisation
-- Syntaxe Lingo
_movie.preLoadMovie(chaîneNomDanimation)
// Syntaxe JavaScript
_movie.preLoadMovie(chaîneNomDanimation);
Description
Méthode d’animation ; précharge les données et les acteurs associés à la première image de
l’animation spécifiée. Le préchargement d’une animation permet de la faire démarrer plus
rapidement avec les méthodes go() ou play().
499
Si vous devez précharger des acteurs depuis une adresse URL, utilisez preloadNetThing() pour
charger les acteurs directement dans la mémoire cache ou downloadNetThing() pour charger
une animation sur un disque local, à partir duquel vous pouvez alors la charger en mémoire,
de façon à réduire le temps de téléchargement.
Paramètres
chaîneNomDanimation
Requis. Chaîne qui spécifie le nom de l’animation à précharger.
Exemple
L’instruction suivante précharge l’animation Introduction, qui est située dans le même dossier
que l’animation courante :
-- Syntaxe Lingo
_movie.preLoadMovie("Introduction")
// Syntaxe JavaScript
_movie.preLoadMovie("Introduction");
Voir aussi
downloadNetThing, go(), Animation, preloadNetThing()
preloadNetThing()
Utilisation
preloadNetThing (url)
Description
Fonction ; précharge un fichier depuis Internet dans la mémoire cache locale afin de le rendre
utilisable par la suite sans perte de temps inhérente au téléchargement. La valeur renvoyée est un
identifiant réseau à utiliser pour suivre le déroulement de l’opération.
La fonction preloadNetThing() télécharge le fichier pendant la lecture de l’animation courante.
Utilisez netDone() pour vérifier si le téléchargement est terminé.
Un élément téléchargé peut être immédiatement affiché, car il est lu à partir de la mémoire cache
locale et non à partir du réseau.
Bien que de nombreuses opérations réseau puissent être actives au même moment, l’exécution de
plus de quatre opérations simultanées réduit considérablement les performances.
La taille de la mémoire cache et l’option de vérification des documents des préférences d’un
navigateur web n’affectent pas le comportement de la commande preloadNetThing.
La fonction preloadNetThing() n’analyse pas les liens d’un fichier Director. En conséquence,
même si un fichier Director est lié aux fichiers de distribution et aux fichiers graphiques,
preloadNetThing() ne télécharge que le fichier Director. Vous devez toujours précharger
séparément les autres objets liés.
Paramètres
url Requis. Spécifie le nom d’un fichier Internet valide tel qu’une animation Director, un
graphique ou l’adresse d’un serveur FTP.
500
Chapitre 12 : Méthodes
Exemple
L’instruction suivante utilise preloadNetThing() et renvoie l’ID réseau pour l’opération :
set monIDréseau = preloadNetThing("http://www.votreServeur.fr/pageDeMenu/
monAnimation.dir")
Une fois le téléchargement terminé, vous pouvez naviguer jusqu’à l’animation avec la même
adresse URL. L’animation sera lue depuis la mémoire cache, et non depuis l’adresse URL,
puisqu’elle est chargée.
Voir aussi
netDone()
preMultiply
Utilisation
transformation1.preMultiply(transformation2)
Description
Commande 3D de transformation ; modifie une transformation en appliquant les effets de
positionnement, de rotation et de redimensionnement d’une autre transformation.
Si transformation2 décrit une rotation de 90° autour de l’axe des x et que transformation1
décrit une translation de 100 unités sur l’axe des y,
transformation1.multiply(transformation2) modifie cette transformation pour lui faire
décrire une translation suivie d’une rotation. L’instruction
transformation1.preMultiply(transformation2) modifie cette transformation pour lui
faire décrire une rotation suivie d’une translation. L’effet obtenu est l’inversement de l’ordre des
opérations.
Paramètres
transformation2 Requis. Spécifie la transformation à partir de laquelle les effets sont préappliqués à une autre transformation.
Exemple
L’instruction suivante exécute un calcul qui applique la transformation du modèle Mars à la
transformation du modèle Pluton :
member("scène").model("Pluton").transform.preMultiply\
(member("scène").model("Mars").transform)
501
preRotate
Utilisation
référenceDeTransformation.preRotate( angleX, angleY, angleZ )
référenceDeTransformation.preRotate(vecteur)
référenceDeTransformation.preRotate( vecteurDePosition, vecteurDeDirection, \
angle )
member( quelActeur ).nœud.transform.preRotate( angleX, \
angleY, angleZ )
member( quelActeur ).nœud.transform.preRotate( vecteur )
member( quelActeur ).nœud.transform.preRotate\
( vecteurDePosition, vecteurDeDirection, angle )
Description
Commande 3D de transformation ; applique une rotation avant les décalages de position,
rotation et d’échelle de la transformation. La rotation peut être spécifiée sous la forme d’un
ensemble de trois angles, chacun desquels spécifiant l’angle de rotation autour des trois axes
correspondants. Ces angles peuvent être spécifiés de façon explicite sous la forme angleX, angleY
et angleZ, ou au moyen d’un vecteur, dans lequel les composants x, y et z correspondent,
respectivement, à la rotation autour de l’axe des x, des y et des z.
La rotation peut également être spécifiée comme une rotation autour d’un axe arbitraire. Cet axe
est défini dans l’espace par vecteurDePosition et vecteurDeDirection. Le degré de rotation
autour de cet axe est spécifié par angle.
nœud
peut être une référence à un modèle, un groupe, une lumière ou une caméra.
Paramètres
angleX Requis si vous appliquez une rotation avec les axes des x, des y et des z. Spécifie l’angle de
rotation autour de l’axe des x.
angleY Requis si vous appliquez une rotation avec les axes des x, des y et des z. Spécifie l’angle de
rotation autour de l’axe des y.
angleZ Requis si vous appliquez une rotation avec les axes des x, des y et des z. Spécifie l’angle de
rotation autour de l’axe des z.
vecteur Requis si vous appliquez une rotation avec un vecteur. Spécifie le vecteur dont les angles
sont utilisés dans la rotation.
Requis si vous appliquez une rotation autour d’un axe arbitraire. Spécifie le
décalage de la position.
vecteurDePosition
vecteurDeDirection Requis si vous appliquez une rotation autour d’un axe arbitraire. Spécifie
le décalage de la direction.
Requis si vous appliquez une rotation autour d’un axe arbitraire. Spécifie le degré de
rotation autour d’un axe arbitraire.
angle
502
Chapitre 12 : Méthodes
Exemple
L’instruction suivante effectue une rotation de 20° sur chaque axe. Dans la mesure où la propriété
transform du modèle correspond à ses décalages de position, rotation et redimensionnement par
rapport à son parent et que preRotate applique la modification d’orientation avant tout effet
existant de la propriété transform de ce modèle, ce dernier subira une rotation sur place plutôt
qu’autour de son parent.
member("Scène").model("bip01").transform.preRotate(20, 20, 20)
L’instruction précédente équivaut à la suivante :
member("Scène").model("bip01").rotate(20,20,20).
preRotate() n’est généralement utile qu’avec les variables de transformation. Cette ligne fera
orbiter la caméra autour du point (100, 0, 0) dans l’espace, de 180° autour de l’axe des y.
t = transform()
t.position = member("scène").camera[1].transform.position
t.preRotate(vector(100, 0, 0), vector(0, 1, 0), 180)
member("scène").camera[1].transform = t
Voir aussi
rotate
preScale()
Utilisation
référenceDeTransformation.preScale(échelleX , échelleY , échelleZ)
référenceDeTransformation.preScale(vecteur)
member( quelActeur ).nœud.transform.preScale( échelleX, \
échelleY, échelleZ )
member( quelActeur ).nœud.transform.preScale( vecteur )
Description
Commande 3D de transformation ; applique une échelle avant d’appliquer les effets de position,
de rotation et de redimensionnement existants de la transformation en question.
nœud
peut être une référence à un modèle, un groupe, une lumière ou une caméra.
Paramètres
échelleX Requis si vous appliquez une échelle avec les axes des x, des y et des z. Spécifie l’échelle
sur l’axe des x.
échelleY Requis si vous appliquez une échelle avec les axes des x, des y et des z. Spécifie l’échelle
sur l’axe des y.
échelleZ Requis si vous appliquez une échelle avec les axes des x, des y et des z. Spécifie l’échelle
sur l’axe des z.
vecteur Requis si vous appliquez une échelle avec un vecteur. Spécifie le vecteur qui contient
l’échelle à appliquer.
503
Exemple
La ligne 1 du code Lingo suivant crée un double de la transformation de Lune1. N’oubliez pas
qu’on accède à la propriété de transformation d’un modèle par référence.
La ligne 2 applique une échelle à cette transformation avant tout effet existant de position ou de
rotation. Supposez que la transformation représente le décalage de position et l’orbite de rotation
de Lune1 par rapport à sa planète parent. Supposez également que le parent de Lune2 est le même
que celui de Lune1. Si nous utilisions ici scale() au lieu de preScale(), Lune2 serait placé deux
fois plus loin et tournerait autour de la planète deux fois plus que Lune1. Cela s’explique par le
fait que le redimensionnement serait appliqué aux décalages de position et de rotation existants de
la transformation. L’utilisation de preScale() appliquera la modification de taille sans affecter
les décalages de position et de rotation existants.
La ligne 3 applique une rotation supplémentaire de 180° autour de l’axe des x de la planète. Cela
placera Lune2 du côté opposé à l’orbite de Lune1. Veuillez noter qu’avec preRotate(), Lune2
serait resté à la même place que Lune1 et aurait été pivoté de 180° autour de son propre axe des x.
La ligne 4 affecte cette nouvelle transformation à Lune2.
t = member("scène").model("Lune1").transform.duplicate()
t.preScale(2,2,2)
t.rotate(180,0,0)
member("scène").model("Lune2").transform = t
preTranslate()
Utilisation
référenceDeTransformation.preTranslate( incrémentX, incrémentY, \
incrémentZ )
référenceDeTransformation.preTranslate(vecteur)
member( quelActeur ).nœud.transform.preTranslate\
(incrémentX, incrémentY, incrémentZ)
member( quelActeur ).nœud.transform.preTranslate( vecteur )
Description
Commande 3D de transformation ; applique une translation avant les décalages de position,
rotation et d’échelle de la transformation. La translation peut être spécifiée sous la forme d’un jeu
de trois incréments le long des trois axes correspondants. Ces incréments peuvent être spécifiés
explicitement sous la forme incrémentX, incrémentY et incrémentZ, ou par un vecteur, dont le
composant x correspond à la translation sur l’axe des x, y sur l’axe des y et z sur l’axe des y.
A la suite d’une série de transformations, réalisées dans l’ordre suivant, l’origine locale du modèle
se trouvera à (0, 0, -100), si le parent du modèle est l’univers :
model.transform.identity()
model.transform.rotate(0, 90, 0)
model.transform.preTranslate(100, 0, 0)
Si translate() avait été utilisée à la place de preTranslate(), l’origine locale du modèle aurait
été (100, 0, 0) et le modèle aurait été pivoté de 90° autour de son propre axe des y. L’instruction
model.transform.pretranslate(x, y, z) est équivalente à model.translate(x, y, z). La
propriété preTranslate() n’est généralement utile qu’avec les variables de transformation plutôt
qu’avec les références model.transform.
504
Chapitre 12 : Méthodes
Paramètres
Requis si vous appliquez une transition avec les axes des x, des y et des z. Spécifie la
translation autour de l’axe des x.
incrémentX
Requis si vous appliquez une transition avec les axes des x, des y et des z. Spécifie la
translation autour de l’axe des y.
incrémentY
Requis si vous appliquez une transition avec les axes des x, des y et des z. Spécifie la
translation autour de l’axe des z.
incrémentZ
Requis si vous appliquez une translation avec un vecteur. Spécifie le vecteur à utiliser
dans la translation.
vecteur
Exemple
t = transform()
t.transform.identity()
t.transform.rotate(0, 90, 0)
t.transform.preTranslate(100, 0, 0)
gbModèle = member("Scène").model("Mars")
gbModel.transform = t
put gbModèle.transform.position
-- vector(0.0000, 1.0000, 0.0000)
print()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.print({nomDeCible, #printingBounds})
// Syntaxe JavaScript
réfObjImageObjet.print({nomDeCible, #printingBounds});
Description
Commande ; appelle la commande ActionScript print correspondante, qui a fait son apparition
avec Flash 5. Toutes les images de l’animation Flash identifiées par #p sont imprimées. Si aucune
image individuelle n’a été libellée, toute l’animation est imprimée.
L’impression d’animations Flash étant une opération relativement complexe, il est recommandé
de lire la section consacrée à l’impression dans la documentation de Flash avant d’utiliser cette
fonction d’image-objet.
Paramètres
Facultatif. Spécifie le nom de l’animation ou du clip d'animation cible à imprimer.
Si ce paramètre est omis (si la cible a la valeur 0), l’animation Flash principale est imprimée.
nomDeCible
printingBounds Facultatif. Spécifie les options d’impression des limites. Si ce paramètre est
omis, les limites de la cible sont utilisées. S’il est spécifié, printingBounds doit avoir l’une des
valeurs suivantes :
•
•
#bframe. Avec #bframe, les limites d’impression de chaque image sont modifiées en fonction
de l’image à imprimer.
#bmax. Avec #bmax, les limites d’impression forment un cadre virtuel de dimensions
suffisantes pour contenir toutes les images à imprimer.
505
printAsBitmap()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.printAsBitmap({nomDeCible, #printingBounds})
// Syntaxe JavaScript
réfObjImageObjet.printAsBitmap({nomDeCible, #printingBounds});
Description
Commande d’image-objet Flash ; fonctionne comme la commande print, mais uniquement
avec des images-objets Flash. Cependant, la commande printAsBitmap peut être utilisée pour
imprimer des objets contenant des informations alpha.
printFrom()
Utilisation
-- Syntaxe Lingo
_movie.printFrom(nomOuNumDimageInitiale {, nomOuNumDimageFinale, redux})
// Syntaxe JavaScript
_movie.printFrom(nomOuNumDimageInitiale {, nomOuNumDimageFinale, redux});
Description
Méthode d’animation ; imprime tout le contenu de chaque image de la scène, que l’image soit
sélectionnée ou non, à partir de l’image spécifiée par nomOuNumDimageInitiale. Vous pouvez,
si vous le voulez, indiquer nomOuNumDimageFinale et la valeur de réduction (redux) : 100 %,
50 % ou 25 %.
L’image en cours d’impression n’a pas besoin d’être affichée. Cette commande imprime toujours
en orientation portrait (verticale) et à une résolution de 72 points par pouce, en transformant en
bitmaps tout le contenu de l’écran (ce qui peut parfois réduire la qualité du texte) ; de plus, elle
ignore les paramètres de format d’impression. Pour augmenter la souplesse de l’impression depuis
Director, consultez l’Xtra PrintOMatic Lite, qui se trouve sur le disque d’installation.
Paramètres
nomOuNumDimageInitiale
Requis. Chaîne ou numéro qui spécifie le nom ou le numéro de la
première image à imprimer.
Facultatif. Chaîne ou numéro qui spécifie le nom ou le numéro de la
dernière image à imprimer.
nomOuNumDimageFinale
redux Facultatif. Nombre entier qui spécifie la valeur de la réduction. Les valeurs correctes sont
100, 50 et 25.
Exemple
L’instruction suivante imprime le contenu de la scène à l’image 1 :
-- Syntaxe Lingo
_movie.printFrom(1)
// Syntaxe JavaScript
_movie.printFrom(1);
506
Chapitre 12 : Méthodes
L'instruction suivante imprime le contenu de la scène dans chaque image de l’image 10 à l'image
25. La valeur de réduction est de 50 %.
-- Syntaxe Lingo
_movie.printFrom(10, 25, 50)
// Syntaxe JavaScript
_movie.printFrom(10, 25, 50);
Voir aussi
Animation
propList()
Utilisation
-- Syntaxe Lingo
propList()
[:]
propList(chaîne1, valeur1, chaîne2, valeur2, ...)
propList(#symbole1, valeur1, #symbole2, valeur2, ...)
[#symbole1:valeur1, #symbole2:valeur2, ...]
// Syntaxe JavaScript
propList();
propList(chaîne1, valeur1, chaîne2, valeur2, ...);
Description
Fonction du niveau supérieur ; crée une liste de propriétés dont chaque élément est constitué
d’une paire nom/valeur.
Lorsque vous créez une liste en utilisant la syntaxe propList() ou [:] (Lingo uniquement), avec
ou sans paramètres, les valeurs de la liste sont indexées à partir de 1.
La longueur maximale d’une ligne de script exécutable est de 256 caractères. Il n’est pas possible
de créer des listes de propriétés importantes avec propList(). Pour créer une liste de propriétés
contenant une grande quantité de données, mettez les données entre crochets ([]), placez-les dans
un champ, puis affectez le champ à une variable. Le contenu de cette variable deviendra une liste
des données.
Paramètres
chaîne1, chaîne2, ...
Facultatif. Chaînes qui spécifient les parties nom des éléments inclus
dans la liste.
valeur1, valeur2, ... Facultatif. Valeurs qui spécifient les parties valeur des éléments inclus
dans la liste.
#symbole1, #symbole2, ... (Lingo uniquement) Facultatif. Symboles qui représentent les
parties nom des éléments inclus dans la liste.
507
Exemple
Cette instruction crée une liste de propriétés avec diverses propriétés et valeurs, puis affiche les
diverses valeurs de propriétés dans la fenêtre Messages :
-- Syntaxe Lingo
-- avec propList()
colorList = propList(#top,"rouge", #sides,"bleu", #bottom,"vert")
-- avec des crochets
colorList = [#top:"rouge", #sides:"bleu", #bottom:"vert"]
put(colorList.top) -- "rouge"
put(colorList.sides) -- "bleu"
put(colorList.bottom) -- "vert"
// Syntaxe JavaScript
var colorList = propList("top","rouge", "sides","bleu", "bottom","vert");
put(colorList.top) // rouge
put(colorList.sides) // bleu
put(colorList.bottom) // vert
Voir aussi
list()
proxyServer
Utilisation
proxyServer typeDeServeur, "adresseIP", numDePort
proxyServer()
Description
Commande ; définit les valeurs d’un serveur proxy FTP ou http.
En l’absence de paramètres, proxyServer() renvoie les réglages d’un serveur proxy FTP ou
HTTP.
Paramètres
typeDeServeur
#ftp ou #http.
Facultatif. Symbole qui spécifie le type du serveur proxy. La valeur peut être
adresseIP
Facultatif. Chaîne qui spécifie l’adresse IP.
numDePort
Facultatif. Nombre entier qui spécifie le numéro du port.
Exemple
L’instruction suivante établit un serveur proxy HTTP à l’adresse IP 197.65.208.157 avec
le port 5 :
proxyServer #http,"197.65.208.157",5
L’instruction suivante renvoie le numéro de port d’un serveur proxy HTTP :
put proxyServer(#http,#port)
Si aucun type de serveur n’est spécifié, la fonction renvoie 1.
L’instruction suivante renvoie la chaîne de l’adresse IP d’un serveur proxy HTTP :
put proxyServer(#http)
508
Chapitre 12 : Méthodes
L’instruction suivante désactive un serveur proxy FTP :
proxyServer #ftp,#stop
ptToHotSpotID()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.ptToHotSpotID(point)
// Syntaxe JavaScript
réfObjImageObjet.ptToHotSpotID(point);
Description
Fonction QuickTime VR ; renvoie l’identifiant de la zone référencée (si elle existe) présent au
point spécifié. S’il n’existe pas de zone référencée, la fonction renvoie 0.
Paramètres
point
Requis. Spécifie le point à tester.
puppetPalette()
Utilisation
-- Syntaxe Lingo
_movie.puppetPalette(palette {, vitesse} {, images})
// Syntaxe JavaScript
_movie.puppetPalette(palette {, vitesse} {, images});
Description
Méthode d’animation ; asservit la piste des palettes et permet au script d’avoir priorité sur les
paramètres de la piste des palettes du scénario, ainsi que d’affecter des palettes à l’animation.
La méthode puppetPalette() définit comme palette courante l’acteur palette spécifié par
palette. Si palette est une chaîne, celle-ci spécifie le nom d’acteur de la palette. Si palette est
un nombre entier, celui-ci spécifie le numéro d’acteur de la palette.
Pour optimiser les résultats, utilisez la méthode puppetPalette() avant de passer à l’image sur
laquelle l’effet se produira, afin que Director puisse établir une correspondance avec la palette
voulue avant de dessiner l’image suivante.
Vous pouvez faire apparaître progressivement la palette en remplaçant vitesse par un nombre
entier compris entre 1 (la plus lente) et 60 (la plus rapide). Vous pouvez aussi faire apparaître
progressivement la palette sur plusieurs images en remplaçant images par un nombre entier
correspondant au nombre d’images.
Une palette asservie reste active jusqu’à ce que vous la désactiviez avec la syntaxe
_movie.puppetPalette(0). Aucune autre modification de palette ne sera apportée dans le
scénario lorsque la palette asservie est active.
Remarque : Le navigateur web contrôle la palette pour toute la page web. Ainsi, Shockwave Player
utilise toujours la palette du navigateur.
509
Paramètres
palette
Requis. Chaîne ou numéro qui spécifie le nom ou le numéro de la nouvelle palette.
vitesse Facultatif. Nombre entier qui spécifie la vitesse d’un fondu. Les valeurs correctes sont
comprises entre 1 et 60.
images Facultatif. Nombre entier qui spécifie le nombre d’images correspondant au déroulement
du fondu.
Exemple
L’instruction suivante fait d’Arc-en-ciel la palette de l’animation :
-- Syntaxe Lingo
_movie.puppetPalette("Arc-en-ciel")
// Syntaxe JavaScript
_movie.puppetPalette("Arc-en-ciel");
L’instruction suivante fait de Niveaux de gris la palette de l’animation. La transition à la palette
Niveaux de gris se fait pendant un laps de temps de 15, et sur 20 images.
-- Syntaxe Lingo
_movie.puppetPalette("Arc-en-ciel", 15, 20)
// Syntaxe JavaScript
_movie.puppetPalette("Arc-en-ciel", 15, 20);
Voir aussi
Animation
puppetSprite()
Utilisation
-- Syntaxe Lingo
_movie.puppetSprite(entNumDimageObjet, bool)
// Syntaxe JavaScript
_movie.puppetSprite(entNumDimageObjet, bool);
Description
Méthode d’animation ; détermine si une piste d’image-objet est un esclave contrôlé par script
(TRUE) ou si, n’étant pas un esclave, elle est sous le contrôle du scénario (FALSE).
Tant que la tête de lecture reste dans la même image-objet, le fait de désactiver l’asservissement de
la piste d’image-objet au moyen de la syntaxe puppetSprite(entNumDimageObjet, FALSE) rend
à l’image-objet les propriétés définies dans le scénario.
Les propriétés initiales de la piste d’image-objet sont celles de la piste au moment de l’exécution
de la méthode puppetSprite(). Vous pouvez utiliser des scripts pour modifier les propriétés
d’image-objet comme suit :
• Si une piste d’image-objet est asservie, toute modification apportée par un script aux propriétés
d’image-objet de la piste reste en vigueur une fois la tête de lecture sortie de l’image-objet.
• Si une piste d’image-objet n’est pas asservie, toute modification apportée par un script à
l’image-objet ne dure que jusqu’à la fin de l’image-objet courante.
510
Chapitre 12 : Méthodes
La piste doit contenir une image-objet lorsque vous utilisez la méthode puppetSprite().
Le fait d’asservir la piste d’image-objet vous permet de contrôler par des scripts de nombreuses
propriétés d’image-objet, telles que member, locH et width, une fois la tête de lecture sortie de
l’image-objet.
Utilisez la syntaxe puppetSprite(entNumDimageObjet, FALSE) pour rendre le contrôle au
scénario lorsque vous avez fini de contrôler une piste d’image-objet avec des scripts et pour éviter
les résultats imprévisibles qui peuvent se produire lorsque la tête de lecture se trouve dans des
images non destinées à être asservies.
Remarque : La version 6 de Director a introduit l’asservissement automatique qui, dans la plupart
des cas, évite d’avoir à asservir explicitement une image-objet. Le contrôle explicite est toujours utile
pour conserver le contrôle complet du contenu d’une piste, même après la fin de la lecture d’une
plage d’images-objets.
Paramètres
entNumDimageObjet
Requis. Nombre entier qui spécifie la piste d’image-objet à tester.
bool Requis. Valeur booléenne qui
(TRUE) ou par le scénario (FALSE).
spécifie si une piste d’image-objet contrôlée par des scripts
Exemple
L’instruction suivante asservit l’image-objet de la piste 15 :
-- Syntaxe Lingo
_movie.puppetSprite(15, TRUE)
// Syntaxe JavaScript
_movie.puppetSprite(15, true);
L’instruction suivante libère de son état d’asservissement l’image-objet de la piste numéro i + 1 :
-- Syntaxe Lingo
_movie.puppetSprite(i + 1, FALSE)
// Syntaxe JavaScript
_movie.puppetSprite(i + 1, false);
Voir aussi
makeScriptedSprite(), Animation, Piste d’image-objet
puppetTempo()
Utilisation
-- Syntaxe Lingo
_movie.puppetTempo(entCadence)
// Syntaxe JavaScript
_movie.puppetTempo(entCadence);
Description
Méthode d’animation ; asservit la piste des cadences et règle la cadence sur le nombre d’images
spécifié.
Lorsque la piste des cadences est asservie, les scripts peuvent être prioritaires sur le paramètre de
cadence du scénario et modifier la cadence de l’animation.
511
Il n’est pas nécessaire de désactiver la cadence esclave pour que les modifications ultérieurement
apportées à la cadence dans le scénario prennent effet.
Remarque : Bien que la limite théorique des cadences d’image soit de 30 000 ips (images par
seconde) avec la méthode puppetTempo(), une telle cadence ne serait possible qu’avec très peu
d’animation et une machine très puissante.
Paramètres
entCadence
Requis. Nombre entier qui spécifie la cadence.
Exemple
L’instruction suivante fixe la cadence de l’animation à 30 images par seconde :
-- Syntaxe Lingo
_movie.puppetTempo(30)
// Syntaxe JavaScript
_movie.puppetTempo(30);
L’instruction suivante augmente l’ancienne cadence de l’animation de 10 images par seconde :
-- Syntaxe Lingo
_movie.puppetTempo(ancienneCadence + 10)
// Syntaxe JavaScript
_movie.puppetTempo(ancienneCadence + 10);
Voir aussi
Animation
puppetTransition()
Utilisation
-- Syntaxe Lingo
_movie.puppetTransition(réfObjActeur)
_movie.puppetTransition(ent {, durée} {, taille} {, zone})
// Syntaxe JavaScript
_movie.puppetTransition(réfObjActeur);
_movie.puppetTransition(ent {, durée} {, taille} {, zone});
Description
Méthode d’animation ; exécute la transition spécifiée entre l’image courante et la suivante.
Pour utiliser un acteur Xtra de transition, utilisez la syntaxe
puppetTransition(réfObjActeur).
512
Chapitre 12 : Méthodes
Pour utiliser une transition Director intégrée, remplacez ent par l’une des valeurs du tableau
suivant. Remplacez durée par le nombre de quarts de secondes utilisés pour effectuer la
transition. La valeur minimum est 0 ; la valeur maximum est 120 (30 secondes). Remplacez
taille par le nombre de pixels dans chaque bloc de la transition. La valeur minimum est 1 ; la
valeur maximum est 128. Plus les blocs sont petits, plus la transition se fait en douceur, mais plus
elle est lente.
Code
Transition
Code
Transition
01
Balayage vers la droite
27
Rangées aléatoires
02
Balayage vers la gauche
28
Colonnes aléatoires
03
Balayage vers le bas
29
Recouvrir vers le bas
04
Balayage vers le haut
30
Recouvrir vers le bas à gauche
05
Centre vers les bords,
horizontal
31
Recouvrir vers le bas à droite
06
Bords vers centre,
horizontal
32
Recouvrir vers la gauche
07
Centre vers les bords,
vertical
33
Recouvrir vers la droite
08
Bords vers centre, vertical
34
Recouvrir vers le haut
09
Centre vers les bords, carré
35
Recouvrir vers le haut à gauche
10
Bords vers centre, carré
36
Recouvrir vers le haut à droite
11
Pousser vers la gauche
37
Stores vénitiens
12
Pousser vers la droite
38
Damier
13
Pousser vers le bas
39
Bandes vers la gauche en bas
14
Pousser vers le haut
40
Bandes vers la droite en bas
15
Révéler vers le haut
41
Bandes vers le bas à gauche
16
Révéler vers le haut à droite 42
Bandes vers le haut à gauche
17
Révéler vers la droite
43
Bandes vers le bas à droite
18
Révéler vers le bas à droite
44
Bandes vers le haut à droite
19
Révéler vers le bas
45
Bandes vers la gauche sur le dessus
20
Révéler vers le bas à gauche 46
Bandes vers la droite sur le dessus
21
Révéler vers la gauche
47
Zoom ouvert
22
Révéler vers le haut à
gauche
48
Zoom fermé
23
Fondu, pixels rapides*
49
Stores verticaux
24
Fondu, rectangles carrés
50
Fondu, bits rapides*
513
Code
Transition
Code
Transition
25
Fondu, carrés
d’encadrement
51
Fondu, pixels*
26
Fondu, motifs
52
Fondu, bits*
Les transitions identifiées par un astérisque (*) ne fonctionnent pas sur les moniteurs 32 bits.
Il n’y a pas de lien direct entre une faible valeur de durée et une transition rapide. La vitesse réelle
de la transition dépend de la relation entre taille et durée. Par exemple, si taille a une valeur
de 1 pixel, la transition prend plus de temps, quelle que soit la valeur de durée, car cette opération
représente un travail intense de l’ordinateur. Pour accélérer les transitions, augmentez la taille des
blocs au lieu de réduire la durée.
Remplacez zone par une valeur qui détermine si la transition se produit uniquement dans la zone
modifiée (TRUE) ou sur toute la scène (FALSE, par défaut). La variable zone est une zone dans
laquelle les images-objets ont changé.
Paramètres
réfObjActeur Requis si vous utilisez un acteur Xtra de transition. Référence à l’acteur Xtra à
utiliser en tant que transition.
ent Requis si vous utilisez une transition intégrée à Director. Nombre entier qui spécifie le
numéro de la transition à utiliser.
Facultatif. Nombre entier qui spécifie le nombre de quarts de secondes utilisés pour
effectuer la transition. Les valeurs correctes sont comprises entre 0 et 120.
durée
taille Facultatif. Nombre entier qui spécifie le nombre de pixels dans chaque bloc de la
transition. Les valeurs correctes sont comprises entre 1 et 128.
Facultatif. Valeur booléenne qui détermine si la transition se produit uniquement dans la
zone modifiée (TRUE) ou sur toute la scène (FALSE).
zone
Exemple
L’instruction suivante effectue une transition de type balayage vers la droite. Comme aucune
valeur n’est spécifiée pour zone, la transition se produit sur toute la scène, qui correspond au
choix par défaut.
-- Syntaxe Lingo
_movie.puppetTransition(1)
// Syntaxe JavaScript
_movie.puppetTransition(1);
L’instruction suivante effectue une transition sur toute la scène, de type balayage vers la gauche,
d’une durée d’une seconde, la taille de blocs étant de 20 :
-- Syntaxe Lingo
_movie.puppetTransition(2, 4, 20, FALSE)
// Syntaxe JavaScript
_movie.puppetTransition(2, 4, 20, false);
Voir aussi
Animation
514
Chapitre 12 : Méthodes
put()
Utilisation
-- Syntaxe Lingo
put(valeur)
// Syntaxe JavaScript
put(valeur);
Description
Fonction du niveau supérieur ; évalue une expression et affiche le résultat dans la fenêtre
Messages.
La fonctionnalité de cette méthode est identique à celle de la méthode trace() du niveau
supérieur, disponible à la fois pour Lingo et la syntaxe JavaScript.
Cette méthode peut servir d’outil de débogage pour suivre la valeur des variables au cours de la
lecture d’une animation.
Paramètres
valeur
Requis. Expression à évaluer.
Exemple
L’instruction suivante affiche l’heure dans la fenêtre Messages :
-- Syntaxe Lingo
put(_system.time())
// Syntaxe JavaScript
put(_system.time());
L’instruction suivante affiche la valeur affectée à la variable Devis dans la fenêtre Messages :
-- Syntaxe Lingo
bid = "Dubois"
put(bid) -- "Dubois"
// Syntaxe JavaScript
var bid = "Dubois";
put(bid); // Dubois
Voir aussi
trace()
qtRegisterAccessKey()
Utilisation
-- Syntaaxe Lingo
qtRegisterAccessKey(chaîneDeCatégorie, chaîneClé)
// Syntaxe JavaScript
qtRegisterAccessKey(chaîneDeCatégorie, chaîneClé);
Description
Commande ; permet l’enregistrement d’une clé pour un média QuickTime chiffré.
La clé agit au niveau applicatif et non au niveau système. Une fois que l’application annule
l’enregistrement de la clé ou se ferme, le média n’est plus accessible.
515
Remarque : Pour raisons de sécurité, il est impossible d’afficher la liste de toutes les clés
enregistrées.
Voir aussi
qtUnRegisterAccessKey()
qtUnRegisterAccessKey()
Utilisation
-- Syntaxe Lingo
qtUnRegisterAccessKey(chaîneDeCatégorie, chaîneClé)
// Syntaxe JavaScript
qtUnRegisterAccessKey(chaîneDeCatégorie, chaîneClé);
Description
Commande ; permet d’annuler l’enregistrement d’une clé pour un média QuickTime chiffré.
La clé agit au niveau applicatif et non au niveau système. Une fois l’enregistrement de la clé
annulé par l’application, seules les animations chiffrées avec cette clé peuvent toujours être lues.
Les autres médias ne sont plus accessibles.
Voir aussi
qtRegisterAccessKey()
queue()
Utilisation
-- Syntaxe Lingo
réfObjPisteAudio.queue(réfObjActeur)
réfObjPisteAudio.queue(listeDesPropriétés)
// Syntaxe JavaScript
réfObjPisteAudio.queue(réfObjActeur);
réfObjPisteAudio.queue(listeDesPropriétés);
Description
Méthode de piste audio ; ajoute un acteur son à la file d’attente d’une piste audio.
Dès qu’un son est placé en file d’attente, il peut être lu immédiatement à l’aide de la méthode
play(). Ceci s’explique par le fait que Director précharge une certaine partie de chaque son placé
en file d’attente, pour éviter les délais d’attente entre la méthode play() et le début de la lecture.
Cette proportion du son préchargée s’élève par défaut à 1 500 millisecondes. Ce paramètre peut
être modifié en passant une liste des propriétés contenant un ou plusieurs paramètres, par
l’intermédiaire de la méthode queue(). Ces paramètres peuvent également être passés avec la
méthode setPlayList().
Pour un exemple d’utilisation de queue() dans une animation, reportez-vous à l’animation
Sound Control du dossier Learning/Lingo, lui-même inclus dans le dossier de Director.
Paramètres
réfObjActeur
Requis si vous spécifiez un acteur son. Référence à l’acteur son à placer en file
d’attente.
516
Chapitre 12 : Méthodes
listeDesPropriétés Requis si vous passez une liste de propriétés comme paramètres. Liste de
propriétés qui s’applique à l’acteur son à placer en file d’attente. Ces propriétés sont :
Propriété
Description
#member
L’acteur à placer en file d’attente. Cette propriété doit être spécifiée. Toutes les
autres sont facultatives.
#startTime
Position temporelle de départ de la lecture du son, en millisecondes. La valeur par
défaut est le début du son. Pour plus d’informations, consultez startTime.
#endTime
Position temporelle de fin de la lecture du son, en millisecondes. La valeur par
défaut est la fin du son. Pour plus d’informations, consultez endTime.
#loopCount
Nombre de répétitions d’une boucle défini avec #loopStartTime et #loopEndTime.
La valeur par défaut est 1. Voir loopCount.
#loopStartTime
Position temporelle de départ de la boucle, en millisecondes. Pour plus
d’informations, consultez loopStartTime.
#loopEndTime
Position temporelle de fin de la boucle, en millisecondes. Pour plus
d’informations, consultez loopEndTime.
#preloadTime
Quantité de son à placer en mémoire tampon avant la lecture, en millisecondes.
Pour plus d’informations, consultez preloadTime.
Exemple
Le gestionnaire suivant place en file d’attente et lit deux sons. Le premier son, l’acteur Carillons,
est lu dans son intégralité. Le second son, l’acteur Intro, est lu à partir du point 3 secondes,
exécute cinq lectures en boucle successives, du point 8 secondes au point 8,9 secondes, et s’arrête
au point 10 secondes.
-- Syntaxe Lingo
on playMusic
sound(2).queue(member("Carillon"))
sound(2).queue([#member:member("intro"), #startTime:3000, \
#endTime:10000, #loopCount:5, #loopStartTime:8000, #loopEndTime:8900])
sound(2).play()
end playMusic
// Syntaxe JavaScript
function playMusic() {
sound(2).queue(member("Carillon"))
sound(2).queue(propList("member",member("intro"), "startTime",3000,
"endTime",10000, "loopCount",5, "loopStartTime",8000, "loopEndTime",8900));
sound(2).play();
}
Voir aussi
endTime, loopCount, loopEndTime, loopStartTime, pause() (piste audio), play()
(piste audio), preLoadTime, setPlayList(), Piste audio, startTime, stop()
(piste audio)
517
queue() (3D)
Utilisation
member(quelActeur).model(quelModèle).bonesPlayer.queue\
(nomDeMouvement {, enBoucle, positionInitiale, positionFinale, échelle,
décalage})
member(quelActeur).model(quelModèle).keyframePlayer.\
queue(nomDeMouvement {, enBoucle, positionInitiale, positionFinale, échelle,
décalage})
Description
Commande 3D de modificateur keyframePlayer et bonesPlayer ; ajoute le mouvement
spécifié à la fin de la propriété playList du modificateur. Le mouvement est exécuté par le
modèle lorsque tous les mouvements qui le précèdent dans la liste de lecture ont été lus.
Paramètres
nomDeMouvement
enBoucle
Requis. Spécifie le nom du mouvement à ajouter.
Facultatif. Spécifie si le mouvement est lu une seule fois (FALSE) ou continuellement
(TRUE).
positionInitiale Facultatif. Ce paramètre est mesuré en millisecondes, à partir du début du
mouvement. Lorsque enBoucle a pour valeur FALSE, le mouvement démarre à la position
décalage et se termine à la positionFinale. Lorsque enBoucle a pour valeur TRUE, la première
itération de la boucle démarre à décalage et se termine à positionFinale. Toutes les répétitions
suivantes démarrent à positionInitiale et se terminent à positionFinale.
positionFinale Facultatif. Ce paramètre est mesuré en millisecondes, à partir du début du
mouvement. Lorsque enBoucle a pour valeur FALSE, le mouvement démarre à la position
décalage et se termine à la positionFinale. Lorsque enBoucle a pour valeur TRUE, la première
itération de la boucle démarre à décalage et se termine à positionFinale. Toutes les répétitions
suivantes démarrent à positionInitiale et se terminent à positionFinale. Donnez à
positionFinale la valeur -1 si le mouvement doit être lu jusqu’à la fin.
échelle Facultatif. Spécifie la cadence réelle de la lecture du mouvement. La valeur du paramètre
échelle est multipliée par la propriété playRate du modificateur #keyframePlayer ou
#bonesPlayer du modèle pour déterminer la cadence réelle de la lecture du mouvement.
décalage Facultatif. Ce paramètre est mesuré en millisecondes, à partir du début du mouvement.
Lorsque enBoucle a pour valeur FALSE, le mouvement démarre à la position décalage et se
termine à la positionFinale. Lorsque enBoucle a pour valeur TRUE, la première itération de la
boucle démarre à décalage et se termine à positionFinale. Toutes les répétitions suivantes
démarrent à positionInitiale et se terminent à positionFinale.
Exemple
La commande suivante ajoute le mouvement Chute à la fin de la liste de lecture bonesPlayer du
modèle Marcheur. Lorsque tous les mouvements précédant Chute dans la liste de lecture ont été
exécutés, Chute est lu une fois du début à la fin.
sprite(1).member.model("Marcheur").bonesPlayer.queue\
("Chute", 0, 0, -1, 1, 0)
518
Chapitre 12 : Méthodes
La commande suivante ajoute le mouvement coupDenvoi à la fin de la liste de lecture
bonesPlayer du modèle Marcheur. Lorsque tous les mouvements précédant coupDenvoi dans
la liste de lecture ont été exécutés, une section de coupDenvoi est lue en boucle. La première
itération de la boucle démarrera 2000 millisecondes à compter du début du mouvement. Toutes
les itérations suivantes de la boucle démarreront à 1000 millisecondes du début de coupDenvoi
et se termineront à 5000 millisecondes du début de coupDenvoi. La cadence de lecture sera égale
à trois fois la propriété playRate du modificateur bonesPlayer du modèle.
sprite(1).member.model("Marcheur").bonesPlayer.queue("coupDenvoi", 1, \
1000, 5000, 3, 2000)
Voir aussi
play() (3D), playNext() (3D), playRate (3D)
quickTimeVersion()
Utilisation
-- Syntaxe Lingo
quickTimeVersion()
// Syntaxe JavaScript
quickTimeVersion();
Description
Fonction ; renvoie une valeur à virgule flottante identifiant la version de QuickTime installée et
remplace la fonction QuickTimePresent précédente.
Si plusieurs versions de QuickTime 3.0 (ou plus récent) sont installées sous Windows,
quickTimeVersion() renvoie le numéro de version le plus récent. Si une version antérieure à
QuickTime 3.0 est installée, quickTimeVersion() renvoie le numéro de version 2.1.2, quelle
que soit la version installée.
Paramètres
Aucun.
Exemple
L’instruction suivante utilise quickTimeVersion() pour afficher la version de QuickTime
courante dans la fenêtre Messages :
-- Syntaxe Lingo
put(quickTimeVersion())
// Syntaxe JavaScript
put(quickTimeVersion());
519
quit()
Utilisation
-- Syntaxe Lingo
_player.quit()
// Syntaxe JavaScript
_player.quit();
Description
Méthode de lecteur ; permet de quitter Director ou une projection et de passer au bureau de
Windows ou au Finder du Macintosh.
Paramètres
Aucun.
Exemple
L’instruction suivante ordonne à l’ordinateur de quitter Director ou la projection et de passer
au bureau de Windows ou au Finder du Macintosh lorsque l’utilisateur appuie sur Ctrl+Q
(Windows) ou sur Cmd+Q (Macintosh) :
-- Syntaxe Lingo
if (_key.key = "q" and _key.commandDown) then
_player.quit()
end if
// Syntaxe JavaScript
if (_key.key == "q" && _key.commandDown) {
_player.quit();
}
Voir aussi
Lecteur
ramNeeded()
Utilisation
-- Syntaxe Lingo
_movie.ramNeeded(entImageInitiale, entImageFinale)
// Syntaxe JavaScript
_movie.ramNeeded(entImageInitiale, entImageFinale);
Description
Méthode d’animation ; détermine la mémoire requise, en octets, pour afficher une plage
d’images. Par exemple, vous pouvez tester la taille d’images contenant des illustrations en mode
32 bits : si la valeur de ramNeeded() est supérieure à celle de freeBytes(), utilisez des images
contenant des illustrations en mode 8 bits et divisez par 1 024 pour convertir les octets en kilooctets.
520
Chapitre 12 : Méthodes
Paramètres
entImageInitiale
Requis. Nombre entier qui spécifie le numéro de la première image de la
plage.
entImageFinale
Requis. Nombre entier qui spécifie le numéro de la dernière image de la plage.
Exemple
L’instruction suivante affecte à la variable tailleDimage le nombre d’octets requis pour afficher
les images 100 à 125 de l’animation :
-- Syntaxe Lingo
tailleDimage = _movie.ramNeeded(100, 125)
// Syntaxe JavaScript
var tailleDimage = _movie.ramNeeded(100, 125);
L’instruction suivante détermine si la mémoire requise pour afficher les images 100 à 125 excède
la mémoire disponible et, le cas échéant, passe à la section utilisant des acteurs qui possèdent un
nombre de couleurs inférieur :
-- Syntaxe Lingo
if (_movie.ramNeeded(100, 125) > _system.freeBytes) then
_movie.go("8 bits")
end if
// Syntaxe JavaScript
if (_movie.ramNeeded(100, 125) > _system.freeBytes) {
_movie.go("8 bits");
}
Voir aussi
freeBytes(), Animation
random()
Utilisation
-- Syntaxe Lingo
random(expressionEntière)
// Syntaxe JavaScript
random(expressionEntière);
Description
Fonction du niveau supérieur ; renvoie un nombre entier aléatoire dans la plage comprise entre 1
et une valeur spécifiée. Cette fonction peut s’utiliser pour modifier les valeurs d’une animation et
peut servir notamment à faire varier les trajectoires dans les jeux, à affecter des nombres aléatoires
ou à changer la couleur ou la position des images-objets.
Pour définir un ensemble de nombres aléatoires de façon qu’ils commencent par un nombre autre
que 1, soustrayez la quantité appropriée de la fonction random(). Par exemple, l’expression
random(n + 1) - 1 utilise une plage allant de 0 au nombre n.
Paramètres
expressionEntière
Requis. Spécifie la valeur maximum du nombre aléatoire.
521
Exemple
L’instruction suivante affecte des valeurs aléatoires à la variable dés :
-- Syntaxe Lingo
dés = (random(6) + random(6))
// Syntaxe JavaScript
var dés = (random(6) + random(6));
L’instruction suivante modifie de façon aléatoire la couleur de premier plan de l’image-objet 10 :
-- Syntaxe Lingo
sprite(10).foreColor = (random(256) - 1)
// Syntaxe JavaScript
sprite(10).foreColor = (random(256) - 1);
Le gestionnaire suivant choisit de manière aléatoire lequel des deux segments de l’animation va
être lu :
-- Syntaxe Lingo
on sélectionDeScène
if (random(2) = 2) then
_movie.go("11a")
else
_movie.go("11b")
end if
end
// Syntaxe JavaScript
function sélectionDeScène() {
if (random(2) == 1) {
_movie.go("11a");
} else {
_movie.go("11b");
}
}
L’instruction suivante produit un multiple aléatoire de cinq compris entre 5 et 100 :
-- Syntaxe Lingo
score = (5 * random(20))
// Syntaxe JavaScript
var score = (5 * random(20));
randomVector()
Utilisation
-- Syntaxe Lingo
randomVector()
// Syntaxe JavaScript
randomVector();
Description
Fonction du niveau supérieur ; renvoie un vecteur unitaire qui décrit un point choisi de manière
aléatoire à la surface d’une sphère unitaire.
522
Chapitre 12 : Méthodes
Cette fonction diffère de vector(random(10)/10.0, random(10)/10.0, random(10)/10.0,)
dans la mesure où vous êtes assuré que le vecteur résultant de l’utilisation de randomVector()
sera un vecteur unitaire.
Un vecteur unitaire a toujours une longueur égale à un.
Paramètres
Aucun.
Exemple
Les instructions suivantes créent et affichent deux vecteurs unitaires définis de manière aléatoire
dans la fenêtre Messages :
-- Syntaxe Lingo
vec1 = randomVector()
vec2 = randomVector()
put(vec1 & RETURN & vec2)
// Syntaxe
var vec1 =
var vec2 =
put(vec1 +
JavaScript
randomVector();
randomVector();
"\n" + vec2);
Voir aussi
vector()
randomVector
Utilisation
randomVector()
Description
Commande 3D ; renvoie un vecteur unitaire qui décrit un point choisi de manière aléatoire à
la surface d’une sphère unitaire. Cette méthode diffère de vector( random(10)/10.0,
random(10)/10.0, random(10)/10.0) dans la mesure où il est sûr que le vecteur résultant sera
un vecteur unitaire.
Paramètres
Aucun.
Exemple
Les instructions suivantes créent et affichent deux vecteurs unitaires définis de manière aléatoire
dans la fenêtre Messages :
vec = randomVector()
put vec
-- vector( -0.1155, 0.9833, -0.1408 )
vec2 = randomVector()
put vec2
-- vector( 0.0042, 0.8767, 0.4810 )
Voir aussi
getNormalized, generateNormals(), normalize
523
rawNew()
Utilisation
scriptParent.rawNew()
rawNew(scriptParent)
Description
Fonction ; crée un objet enfant à partir d’un script parent sans appeler son gestionnaire on new.
Cela permet la création d’objets enfants sans initialiser leurs propriétés. Cette fonction s’avère
particulièrement pratique lors de la création d’un grand nombre d’objets enfants pour une
utilisation ultérieure. Pour initialiser les propriétés de l’un de ces objets enfants bruts, appelez
son gestionnaire on new.
Paramètres
Aucun.
Exemple
L’instruction suivante crée un objet enfant appelé voitureRouge à partir du script parent
ScriptParentDeVoiture, sans initialiser ses propriétés :
voitureRouge = script("ScriptParentDeVoiture").rawNew()
L’instruction suivante initialise les propriétés de l’objet enfant voitureRouge :
voitureRouge.new()
Voir aussi
new(), script()
readChar()
Utilisation
-- Syntaxe Lingo
réfObjFileio.readChar()
// Syntaxe JavaScript
réfObjFileio.readChar();
Description
Méthode de Fileio ; lit le prochain caractère d’un fichier et renvoie son code ASCII.
Vous devez d’abord ouvrir un fichier en appelant openFile() avant d’utiliser readChar() pour
lire un caractère.
Paramètres
Aucun.
Voir aussi
Fileio, openFile()
524
Chapitre 12 : Méthodes
readFile()
Utilisation
-- Syntaxe Lingo
réfObjFileio.readFile()
// Syntaxe JavaScript
réfObjFileio.readFile();
Description
Méthode de Fileio ; lit la position courante à la fin d’un fichier spécifié et renvoie le résultat sous
forme d’une chaîne.
Vous devez d’abord ouvrir un fichier en appelant openFile() avant d’utiliser readFile() pour
lire un fichier.
Paramètres
Aucun.
Voir aussi
Fileio, openFile()
readLine()
Utilisation
-- Syntaxe Lingo
réfObjFileio.readLine()
// Syntaxe JavaScript
réfObjFileio.readLine();
Description
Méthode de Fileio ; lit la ligne suivante d’un fichier, y compris le RETURN, et la renvoie sous
forme d’une chaîne.
Vous devez d’abord ouvrir un fichier en appelant openFile() avant d’utiliser readLine() pour
lire une ligne.
Paramètres
Aucun.
Voir aussi
Fileio, openFile()
525
readToken()
Utilisation
-- Syntaxe Lingo
réfObjFileio.readToken(chaîneSauter, chaîneCouper)
// Syntaxe JavaScript
réfObjFileio.readToken(chaîneSauter, chaîneCouper);
Description
Méthode de Fileio ; lit le jeton suivant et le renvoie sous forme d’une chaîne.
Vous devez d’abord ouvrir un fichier en appelant openFile() avant d’utiliser readToken() pour
lire un jeton.
Paramètres
chaîneSauter Requis. Chaîne qui spécifie l’ensemble de caractères après lequel le jeton
commence. La chaîne chaîneSauter n’est pas incluse dans la chaîne renvoyée.
Requis. Chaîne qui spécifie l’ensemble de caractères avant lequel le jeton se
termine. La chaîne chaîneCouper n’est pas incluse dans la chaîne renvoyée.
chaîneCouper
Voir aussi
Fileio, openFile()
readWord()
Utilisation
-- Syntaxe Lingo
réfObjFileio.readWord()
// Syntaxe JavaScript
réfObjFileio.readWord();
Description
Méthode de Fileio ; lit le mot suivant d’un fichier et le renvoie sous forme d’une chaîne.
Vous devez d’abord ouvrir un fichier en appelant openFile() avant d’utiliser readWord() pour
lire un mot.
Paramètres
Aucun.
Voir aussi
Fileio, openFile()
526
Chapitre 12 : Méthodes
realPlayerNativeAudio()
Utilisation
-- Syntaxe Lingo
realPlayerNativeAudio()
// Syntaxe JavaScript
realPlayerNativeAudio();
Description
Fonction RealMedia ; permet d’obtenir ou de définir un indicateur global déterminant si la
portion audio de l’acteur RealMedia est traitée par RealPlayer (TRUE) ou par Director (FALSE).
Cette fonction renvoie la valeur précédente de l’indicateur.
Pour être efficace, cet indicateur doit être défini avant le premier chargement de RealPlayer (lors
de la rencontre du premier acteur RealMedia dans le scénario ou de la première référence Lingo
à un acteur RealMedia). Toute modification apportée à cet indicateur après le chargement de
RealPlayer sera ignorée. Cet indicateur devrait être exécuté dans un gestionnaire d’événement
prepareMovie d’un script d’animation. Cet indicateur est défini pour la session entière (à partir
du moment ou le Shockwave Player est chargé jusqu’à sa fermeture et son redémarrage), et non
uniquement pour la durée de l’animation courante.
Par défaut, cet indicateur est défini sur FALSE et le traitement audio est lancé par Director, ce
qui permet de définir la propriété soundChannel et d’utiliser les méthodes et propriétés audio
standard de Lingo pour le traitement du flux audio d’une image-objet RealMedia, par exemple le
mixage d’un élément RealAudio avec d’autres composants audio de Director. Si cet indicateur est
défini sur TRUE, le contrôle Lingo de la piste audio n’est pas réalisé et le son est traité par
RealPlayer.
Paramètres
Aucun.
Exemple
Le code suivant indique que la fonction realPlayerNativeAudio() a pour valeur FALSE, ce qui
signifie que l’audio de l’acteur RealMedia sera traitée par Director.
-- Syntaxe Lingo
put(realPlayerNativeAudio())
-- 0
// Syntaxe JavaScript
trace(realPlayerNativeAudio());
// 0
527
Le code suivant donne à la fonction realPlayerNativeAudio() la valeur TRUE, ce qui signifie
que l’audio du flux RealMedia sera traité par RealPlayer et que le contrôle du code sur la piste
audio ne sera pas pris en compte.
-- Syntaxe Lingo
realPlayerNativeAudio(TRUE)
// Syntaxe JavaScript
realPlayerNativeAudio(1);
Voir aussi
soundChannel (RealMedia)
realPlayerPromptToInstall()
Utilisation
-- Syntaxe Lingo
realPlayerPromptToInstall()
// Syntaxe JavaScript
realPlayerPromptToInstall();
Description
Fonction RealMedia ; permet d’obtenir ou de définir un indicateur global déterminant si la
détection automatique et les alertes de RealPlayer 8 sont activées (TRUE) ou non (FALSE).
Par défaut, cette fonction est définie sur TRUE, ce qui signifie que si les utilisateurs ne disposent
pas de la version 8 de RealPlayer et tentent de charger une animation contenant RealMedia, un
message s’affiche automatiquement pour leur demander s’ils veulent accéder au site web de
RealNetworks et installer RealPlayer. Vous pouvez définir cet indicateur sur FALSE si vous
souhaitez créer votre propre système de détection et d’alerte à l’aide de la fonction
realPlayerVersion(), page 529, et de code personnalisé. Si cet indicateur est défini sur FALSE
et qu’un autre système de détection et d’alerte n’est pas mis en place, les utilisateurs non équipés
de RealPlayer pourront charger des animations contenant des acteurs RealMedia, mais les imagesobjets RealMedia n’apparaîtront pas.
Cette fonction détecte la version de RealPlayer installée sur le système de l’utilisateur pour
déterminer si RealPlayer 8 est installé. Sous Windows, les numéros de version 6.0.8.132 ou
supérieure indiquent que RealPlayer 8 est installé. Sur Macintosh, les composants de base de
RealPlayer de version 6.0.7.1001 ou supérieure indiquent que RealPlayer 8 est installé.
Cet indicateur devrait être exécuté dans un gestionnaire d’événement prepareMovie d’un script
d’animation.
Cette fonction renvoie la valeur précédente de l’indicateur.
Paramètres
Aucun.
528
Chapitre 12 : Méthodes
Exemple
Le code suivant indique que la fonction realPlayerPromptToInstall() a pour valeur TRUE, ce
qui signifie que les utilisateurs qui ne possèdent pas RealPlayer seront invités à l’installer.
-- Syntaxe Lingo
put(realPlayerPromptToInstall()) -- 1
// Syntaxe JavaScript
-- Syntaxe Lingo
trace(realPlayerPromptToInstall()); // 1
Le code suivant donne à la fonction realPlayerPromptToInstall() la valeur FALSE, ce qui
signifie que les utilisateurs ne seront pas invités à installer RealPlayer à moins que vous n’ayez créé
un système de détection et d’alerte.
-- Syntaxe Lingo
realPlayerPromptToInstall(FALSE)
// Syntaxe JavaScript
realPlayerPromptToInstall(0);
realPlayerVersion()
Utilisation
-- Syntaxe Lingo
realPlayerVersion()
// Syntaxe JavaScript
realPlayerVersion();
Description
Fonction RealMedia ; renvoie une chaîne identifiant le numéro de version du logiciel RealPlayer
installé sur le système de l’utilisateur, ou une chaîne vide si RealPlayer n’est pas installé.
RealPlayer 8 ou une version ultérieure doit être installé sur votre ordinateur pour visualiser des
animations Director intégrant du contenu RealMedia. Sous Windows, les numéros de version
6.0.8.132 ou supérieure indiquent que RealPlayer 8 est installé. Sur Macintosh, les composants
de base de RealPlayer de version 6.0.7.1001 ou supérieure indiquent que RealPlayer 8 est installé.
L’objectif de cette fonction est de permettre la création de votre propre système de détection et
d’alerte RealPlayer, si vous ne souhaitez pas utiliser celui qui est fourni par la fonction
realPlayerPromptToInstall(), page 528.
Si vous choisissez de créer votre propre système de détection et d’alerte à l’aide de la fonction
effectuez les opérations suivantes :
realPlayerVersion(),
• Appelez realPlayerPromptToInstall(FALSE) (par défaut, cette fonction est définie sur
TRUE)
•
avant la référence des acteurs RealMedia dans Lingo ou leur apparition dans le scénario.
Cette fonction devrait être définie dans un gestionnaire d’événements prepareMovie d’un
script d’animation.
Utilisez la propriété système xtraList pour vérifier si l’Xtra pour RealMedia (RealMedia
Asset.x32) est répertorié dans la liste des Xtras de la boîte de dialogue Xtras de l’animation. La
fonction realPlayerVersion() ne fonctionne pas si l’Xtra pour RealMedia est absent.
Le numéro de version renvoyé par cette fonction est identique au numéro de version que vous
pouvez afficher dans RealPlayer.
529
Pour afficher le numéro de version de RealPlayer sous Windows :
1 Démarrez RealPlayer.
2 Choisissez A propos de RealPlayer dans le menu Aide.
Dans la fenêtre qui s’affiche, le numéro de version apparaît dans la partie supérieure de l’écran,
au niveau de la seconde ligne.
Pour afficher le numéro de version de RealPlayer sur Macintosh :
1 Démarrez RealPlayer.
2 Choisissez A propos de RealPlayer dans le menu Pomme.
La boîte de dialogue A propos de RealPlayer apparaît. Ignorez le numéro de version indiqué
dans la seconde ligne, dans la partie supérieure de l’écran ; il est incorrect.
3 Cliquez sur le bouton d’infos sur la version.
La boîte de dialogue d’informations de version de RealPlayer s’affiche.
4 Sélectionnez Composants de base de RealPlayer dans la liste des composants installés.
Le numéro de version affiché pour le composant de base de RealPlayer (par exemple,
6.0.8.1649) est identique à celui qui est renvoyé par realPlayerVersion().
Paramètres
Aucun.
Exemple
Le code suivant indique que le numéro de version de RealPlayer installé sur le système est
6.0.9.357.
-- Syntaxe Lingo
put(realPlayerVersion())
// Syntaxe JavaScript
put(realPlayerVersion());
recordFont
Utilisation
recordFont(quelActeur, police {[,type]} {,[tailleDesBitmaps]}
{,sousEnsembleDeCaractères} {, nouveauNom})
Description
Commande ; inclut une police TrueType ou Type 1 comme acteur. Une fois incluses, ces polices
sont disponibles à l’auteur tout comme les autres polices installées sur le système.
Vous devez créer un acteur police vide à l’aide de la commande new() avant d’utiliser
recordFont.
La commande crée une police shockée dans quelActeur en utilisant la police nommée dans le
paramètre police. La valeur renvoyée par la commande indique si l’opération a réussi. La valeur
zéro indique que l’opération a réussi.
530
Chapitre 12 : Méthodes
Paramètres
police
Requis. Spécifie le nom de la police d’origine à enregistrer.
type Facultatif. Spécifie une liste de symboles indiquant le type de la police d’origine. Les valeurs
possibles sont #plain, #bold, #italic. Si vous ne définissez aucune valeur pour ce paramètre,
c’est #plain qui sera utilisé par défaut.
Facultatif. Spécifie une liste d’entiers définissant les tailles pour lesquelles les
bitmaps doivent être enregistrés. Ce paramètre peut être vide. Si vous omettez ce paramètre,
aucun bitmap n’est généré. Ces bitmaps donnent généralement de meilleurs résultats pour les
petites tailles (inférieures à 14 points), mais occupent plus de mémoire.
tailleDesBitmaps
sousEnsembleDeCaractères Facultatif. Spécifie une chaîne de caractères à encoder. Seuls les
caractères spécifiés seront disponibles dans la police. Si ce paramètre est omis, tous les caractères
sont encodés. Si seuls certains caractères sont codés mais qu’un caractère non codé est utilisé, ce
caractère apparaît comme une case vide.
nouveauNom
Facultatif. Spécifie la chaîne utilisée comme nom de l’acteur police nouvellement
enregistré.
Exemple
L’instruction suivante crée une police shockée simple n’utilisant que les deux arguments pour
l’acteur et la police à enregistrer :
monNouvelActeurPolice = new(#font)
recordFont(monNouvelActeurPolice, "Module lunaire")
L’instruction suivante spécifie les tailles de bitmaps à générer et les caractères pour lesquels les
données de police doivent être créées :
monNouvelActeurPolice = new(#font)
recordfont(monNouvelActeur,"Module lunaire", [], [14, 18, 45], "Nom du
meilleur score du jeu Module lunaire")
Remarque : recordFont resynthétisant les données de la police au lieu de les utiliser directement, la
distribution des polices shockées n’est soumise à aucune restriction légale.
Voir aussi
newMember()
rect()
Utilisation
-- Syntaxe Lingo
rect(entGauche, entHaut, entDroite, entBas)
// Syntaxe JavaScript
rect(entGauche, entHaut, entDroite, entBas);
Description
Fonction du niveau supérieur ; définit un rectangle.
Vous pouvez exécuter des opérations arithmétiques sur les rectangles en Lingo et avec la syntaxe
JavaScript. Si vous ajoutez une seule valeur à un rectangle, Lingo et la syntaxe JavaScript
l’ajoutent à chaque élément du rectangle.
531
Vous pouvez faire référence aux composants de rectangles avec les syntaxes de liste ou de
propriétés. Par exemple, les affectations suivantes définissent largeurMonRect1 et
largeurMonRect2 sur 50:
// Syntaxe JavaScript
var monRect = rect(40,30,90,70);
var largeurMonRect1 = monRect.right - monRect.left; // 50
var largeurMonRect2 = monRect[3] - monRect[1]; // 50
Pour un exemple d’utilisation de rect() dans une animation, reportez-vous à l’animation
Imaging du dossier Learning/Lingo, lui-même inclus dans le dossier de Director.
Paramètres
Requis. Nombre entier qui spécifie le nombre de pixels entre le côté gauche du rectangle et le bord gauche de la scène.
entGauche
entHaut Requis. Nombre entier qui spécifie le nombre de pixels entre le côté supérieur du rectangle et le bord supérieur de la scène.
entDroite Requis. Nombre entier qui spécifie le nombre de pixels entre le côté droit du rectangle
et le bord droit de la scène.
entBas Requis. Nombre entier qui spécifie le nombre de pixels entre le côté inférieur du rectangle
et le bord inférieur de la scène.
Exemple
L’instruction suivante définit la variable nouvelleZone comme un rectangle dont le côté gauche
est placé à 100, le haut à 150, le côté droit à 300 et le bas à 400 pixels :
-- Syntaxe Lingo
nouvelleZone = rect(100, 150, 300, 400)
// Syntaxe JavaScript
var nouvelleZone = rect(100, 150, 300, 400);
En Lingo uniquement, l’instruction suivante définit la variable nouvelleZone comme un
rectangle défini par les points premierPoint et deuxièmePoint.
-- Syntaxe Lingo
premierPoint = point(100, 150)
deuxièmePoint = point(300, 400)
nouvelleZone = rect(premierPoint, deuxièmePoint)
En Lingo uniquement, les instructions suivantes ajoutent et soustraient des valeurs aux
rectangles :
-- Syntaxe Lingo
put(rect(0, 0, 100, 100) + rect(30, 55, 120, 95)) -- rect(30, 55, 220, 195)
put(rect(0, 0, 100, 100) -rect(30, 55, 120, 95)) -- rect(-30, -55, -20, 5)
En Lingo uniquement, l’instruction suivante ajoute 80 à chaque coordonnée d’un rectangle :
-- Syntaxe Lingo
put(rect(60, 40, 120, 200) + 80) -- rect(140, 120, 200, 280)
532
Chapitre 12 : Méthodes
En Lingo uniquement, l’instruction suivante divise chaque coordonnée d’un rectangle par 3 :
-- Syntaxe Lingo
put(rect(60, 40, 120, 200) / 3) -- rect(20, 13, 40, 66)
Voir aussi
point(), quad
registerForEvent()
Utilisation
member(quelActeur).registerForEvent(nomDévénement, \
nomDeGestionnaire, objetScript {, début, période, répétitions})
Description
Commande 3D ; déclare le gestionnaire spécifié comme étant celui à appeler lorsque l’événement
spécifié se produit à l’intérieur de l’acteur spécifié.
Les descriptions de paramètres suivantes s’appliquent aux deux commandes
registerForEvent() et registerScript().
Remarque : Vous pouvez associer l’enregistrement d’un script à un nœud particulier plutôt qu’à un
acteur, à l’aide de la commande registerScript().
Paramètres
Requis. Spécifie le nom de l’événement. Il peut s’agir de l’un des événements
prédéfinis suivants ou d’un événement personnalisé défini par vous :
nomDévénement
•
•
•
•
•
•
est un événement de collision.
#collideWith est un événement de collision impliquant ce modèle. La commande
setCollisionCallback() est un raccourci de la commande registerScript() pour
l’événement #collideWith.
#animationStarted et #animationEnded sont des événements de notification utilisés à la
lecture ou à l’arrêt d’une animation de segments ou d’images-clés. Le gestionnaire reçoit
trois arguments : nomDévénement, mouvement et position. L’argument nomDévénement a
pour valeur #animationStarted ou #animationEnded. L’argument mouvement est le nom
du mouvement démarré ou arrêté, position étant la position actuelle du mouvement.
Pour les animations en boucle, l’événement #animationStarted n’est émis que pour la
première boucle, pas pour les suivantes. Cet événement est envoyé au début de la fusion entre
deux animations.
Lorsqu’une série d’animations est placée en file d’attente pour le modèle et que la propriété
autoBlend de l’animation a pour valeur TRUE, l’événement #animationEnded peut se
produire avant la fin apparente d’un mouvement donné. En effet, la propriété autoBlend
peut encore donner une impression de mouvement alors que l’animation s’est terminée
comme prévu.
#timeMS est un événement horaire. Le premier événement #timeMS a eu lieu lorsque le
nombre de millisecondes spécifié dans le paramètre début s’est écoulé après l’appel de
registerForEvent. Le paramètre période détermine le nombre de millisecondes entre les
événements #timeMS lorsque la valeur des répétitions est supérieure à 0. Si la valeur des
répétitions est 0, l’événement #timeMS se produit indéfiniment.
#collideAny
533
nomDeGestionnaire Requis. Spécifie le nom du gestionnaire qui sera appelé lorsque l’événement
nomDévénement surviendra ; ce gestionnaire se trouve dans l’objet de script indiqué par
objetScript. Le gestionnaire reçoit les arguments suivants :
•
•
•
•
•
est toujours 0.
est le temps (en millisecondes) écoulé depuis le dernier événement #timeMS.
time est le nombre de millisecondes écoulées depuis le premier événement #timeMS.
Par exemple, avec trois itérations d’une période de 500 ms, la première itération sera 0,
la deuxième sera 500 et la troisième sera 1000.
duration est le nombre total de millisecondes écoulées entre l’appel registerForEvent et
le dernier événement #timeMS. Par exemple, avec cinq itérations d’une période de 500 ms,
la durée est 2500 ms. Pour les tâches avec des itérations illimitées, la durée est 0.
systemTime est la durée absolue, en millisecondes, depuis le début de l’animation Director.
type
delta
objetScript Requis. Spécifie l’objet de script qui contient le gestionnaire nomDeGestionnaire.
Si 0 est spécifié pour objetScript, c’est le premier gestionnaire d’événement portant le nom
donné qui est appelé.
début Facultatif. Spécifie le nombre de millisecondes écoulées
registerForEvent() et le premier événement #timeMS.
entre l’appel de
période Facultatif. Spécifie le nombre de millisecondes entre des événements #timeMS lorsque la
valeur de répétitions est supérieure à 0.
répétitions
répétitions
Facultatif. Spécifie le nombre de répétitions pour l’événement #timeMS. Si
a une valeur égalele à 0, l’événement #timeMS se produit indéfiniment.
Exemple
L’instruction suivante enregistre le gestionnaire d’événement promptUser détecté dans un script
d’animation pour un appel à deux reprises, à un intervalle de cinq secondes :
member("Scène").registerForEvent(#timeMS, #promptUser, 0, \
5000, 5000, 2)
L’instruction suivante enregistre le gestionnaire d’événement promptUser détecté dans un script
d’animation pour un appel à chaque fois qu’une collision a lieu au sein de l’acteur Scène :
member("Scène").registerForEvent(#collideAny, #promptUser, 0)
L’instruction suivante déclare que le gestionnaire on promptUser du même script que celui qui
contient la commande registerForEvent doit être appelé lorsqu’un objet entre en collision avec
le modèle Pluton dans l’acteur nommé Scène :
member("Scène").registerForEvent(#collideWith, #promptUser, me, \
member("Scène").model("Pluton"))
Voir aussi
setCollisionCallback(), registerScript(), play() (3D), playNext() (3D),
autoblend, blendTime, sendEvent, unregisterAllEvents
534
Chapitre 12 : Méthodes
registerScript()
Utilisation
member(quelActeur).model(quelModèle).registerScript(nomDévénement, \
nomDeGestionnaire, objetScript {, début, période, répétitions})
member(quelActeur).camera(quelleCaméra).registerScript(nomDévénement, \
nomDeGestionnaire, objetScript {, début, période, répétitions})
member(quelActeur).light(quelleLumière).registerScript(nomDévénement, \
nomDeGestionnaire, objetScript {, début, période, répétitions})
member(quelActeur).group(quelGroupe).registerScript(nomDévénement, \
nomDeGestionnaire, objetScript {, début, période, répétitions})
Description
Commande 3D ; enregistre le gestionnaire spécifié comme devant être appelé lorsque l’événement
spécifié se produit pour le nœud référencé.
Les descriptions de paramètres suivantes s’appliquent aux deux commandes
registerForEvent() et registerScript().
Paramètres
Requis. Spécifie le nom de l’événement. Il peut s’agir de l’un des événements
prédéfinis suivants ou d’un événement personnalisé défini par vous :
nomDévénement
•
•
•
•
est un événement de collision.
#collideWith est un événement de collision impliquant ce modèle. La commande
setCollisionCallback() est un raccourci de la commande registerScript() pour
l’événement #collideWith.
#animationStarted et #animationEnded sont des événements de notification utilisés à la
lecture ou à l’arrêt d’une animation de segments ou d’images-clés. Le gestionnaire reçoit trois
arguments : nomDévénement, mouvement et position. L’argument nomDévénement a pour
valeur #animationStarted ou #animationEnded. L’argument mouvement est le nom du
mouvement démarré ou arrêté, position étant la position actuelle du mouvement.
Pour les animations en boucle, l’événement #animationStarted n’est émis que pour la
première boucle, pas pour les suivantes. Cet événement est envoyé au début de la fusion entre
deux animations.
Lorsqu’une série d’animations est placée en file d’attente pour le modèle et que la propriété
autoBlend de l’animation a pour valeur TRUE, l’événement #animationEnded peut se
produire avant la fin apparente d’un mouvement donné. En effet, la propriété autoBlend peut
encore donner une impression de mouvement alors que l’animation s’est terminée comme
prévu.
#timeMS est un événement horaire. Le premier événement #timeMS a eu lieu lorsque le
nombre de millisecondes spécifié dans le paramètre début s’est écoulé après l’appel de
registerForEvent. Le paramètre période détermine le nombre de millisecondes entre les
événements #timeMS lorsque la valeur des répétitions est supérieure à 0. Si la valeur des
répétitions est 0, l’événement #timeMS se produit indéfiniment.
#collideAny
535
nomDeGestionnaire Requis. Spécifie le nom du gestionnaire qui sera appelé lorsque l’événement
nomDévénement surviendra ; ce gestionnaire se trouve dans l’objet de script indiqué par
objetScript. Le gestionnaire reçoit les arguments suivants :
•
•
•
•
•
est toujours 0.
est le temps (en millisecondes) écoulé depuis le dernier événement #timeMS.
time est le nombre de millisecondes écoulées depuis le premier événement #timeMS.
Par exemple, avec trois itérations d’une période de 500 ms, la première itération sera 0,
la deuxième sera 500 et la troisième sera 1000.
duration est le nombre total de millisecondes écoulées entre l’appel registerForEvent et
le dernier événement #timeMS. Par exemple, avec cinq itérations d’une période de 500 ms,
la durée est 2500 ms. Pour les tâches avec des itérations illimitées, la durée est 0.
systemTime est la durée absolue, en millisecondes, depuis le début de l’animation Director.
type
delta
objetScript Requis. Spécifie l’objet de script qui contient le gestionnaire nomDeGestionnaire.
Si 0 est spécifié pour objetScript, c’est le premier gestionnaire d’événement portant le nom
donné qui est appelé.
début Facultatif. Spécifie le nombre de millisecondes écoulées
registerForEvent() et le premier événement #timeMS
entre l’appel de
Facultatif. Spécifie le nombre de millisecondes entre des événements #timeMS lorsque
la valeur de répétitions est supérieure à 0.
période
répétitions
répétitions
Facultatif. Spécifie le nombre de répétitions pour l’événement #timeMS. Si
a une valeur égalele à 0, l’événement #timeMS se produit indéfiniment.
Exemple
L’instruction suivante enregistre le gestionnaire d’événement messageReçu, situé dans un script
d’animation à appeler lorsque le modèle Lecteur reçoit l’événement personnalisé #message défini
par l’utilisateur :
member("Scène").model("Lecteur").registerScript(#message, \
#messageReçu, 0)
L’instruction suivante enregistre le gestionnaire d’événement réponseCollision, situé dans le
même script que la commande registerScript à appeler chaque fois qu’une collision se produit
entre le modèle Lecteur et tout autre modèle utilisant le modificateur #collision :
member("Scène").model("Lecteur").registerScript(#collideWith, \
#réponseCollision, me)
Voir aussi
registerForEvent(), sendEvent, setCollisionCallback()
removeBackdrop
Utilisation
member(quelActeur).camera(quelleCaméra).removeBackdrop(index)
Description
Commande 3D ; supprime le fond situé à une position spécifiée de la liste des fonds de la caméra.
536
Chapitre 12 : Méthodes
Paramètres
index
Requis. Spécifie la position d’index du fond à supprimer de la liste des fonds.
Exemple
L’instruction suivante retire le troisième fond de la liste des fonds de la caméra 1 de l’acteur
nommé Scène. Le fond disparaîtra de la scène si des images-objets utilisent actuellement cette
caméra.
member("Scène").camera[1].removeBackdrop(3)
removeFromWorld
Utilisation
member(quelActeur).model(quelModèle).removeFromWorld()
member(quelActeur).light(quelleLumière).removeFromWorld()
member(quelActeur).camera(quelleCaméra).removeFromWorld()
member(quelActeur).group(quelGroupe).removeFromWorld()
Description
Commande 3D ; pour les modèles, les lumières, les caméras ou les groupes dont la hiérarchie
amont se termine dans l’univers, cette commande donne une valeur nulle aux parents et les retire
de l’univers.
Pour les objets dont la hiérarchie amont ne se termine pas dans l’univers, cette commande n’a
aucun effet.
Paramètres
Aucun.
Exemple
La commande suivante retire le modèle gbCyl de l’univers 3D de l’acteur Scène.
member("Scène").model("gbCyl").removeFromWorld()
removeLast()
member(quelActeur).model(quelModèle).bonesPlayer.removeLast()
member(quelActeur).model(quelModèle).keyframePlayer.\
removeLast()
Description
Commande de modificateur 3D keyframePlayer et bonesPlayer ; supprime le dernier
mouvement de la liste de lecture du modificateur.
Paramètres
Aucun.
Exemple
L’instruction suivante retire le dernier mouvement de la liste de lecture du modificateur
bonesPlayer pour le modèle Marcheur.
member("MonUnivers").model("Marcheur").bonesPlayer.removelast()
537
removeModifier
Utilisation
member(quelActeur).model(quelModèle).removeModifier.\
(#quelModificateur)
Description
Commande 3D ; supprime le modificateur spécifié du modèle spécifié.
Cette commande renvoie TRUE si elle est exécutée avec succès et FALSE si #quelModificateur
n’est pas un modificateur valide ou si le modificateur n’est pas associé au modèle.
Paramètres
quelModificateur
Requis. Spécifie le modificateur à supprimer.
Exemple
L’instruction suivante retire le modificateur #toon du modèle Boîte.
member("formes").model("Boîte").removeModifier(#toon)
Voir aussi
addModifier, modifier, modifier[], modifiers
removeOverlay
Utilisation
member(quelActeur).camera(quelleCaméra).removeOverlay(index)
Description
Commande 3D ; retire le recouvrement situé à une position spécifiée de la liste des recouvrements
de la caméra.
Paramètres
index
Requis. Spécifie la position d’index du recouvrement dans la liste des recouvrements.
Exemple
L’instruction suivante retire le premier recouvrement de la liste de recouvrements de la caméra de
l’image-objet 5. Le recouvrement disparaîtra de la scène.
sprite(5).camera.removeOverlay(1)
Voir aussi
overlay
538
Chapitre 12 : Méthodes
removeScriptedSprite()
Utilisation
-- Syntaxe Lingo
réfObjPisteDimageObjet.removeScriptedSprite()
// Syntaxe JavaScript
réfObjPisteDimageObjet.removeScriptedSprite();
Description
Méthode de piste d’image-objet ; bascule de nouveau le contrôle d’une piste d'image-objet du
script vers le scénario.
Paramètres
Aucun.
Exemple
L’instruction suivante supprime l’image-objet scriptée de la piste des images-objets 5 :
-- Syntaxe Lingo
channel(5).removeScriptedSprite()
// Syntaxe JavaScript
channel(5).removeScriptedSprite();
Voir aussi
makeScriptedSprite(), Piste d’image-objet
resetWorld
Utilisation
member(quelActeur).resetWorld()
member(quelActeurTexte).resetWorld()
Description
Commande 3D ; redonne aux propriétés de l’acteur 3D référencé les valeurs enregistrées lorsque
l’acteur a été mis en mémoire pour la première fois. La propriété state de l’acteur doit avoir la
valeur 0 (déchargé), 4 (média chargé) ou -1 (erreur) avant que cette commande ne puisse être
utilisée afin d’éviter une erreur de script.
Cette commande diffère de revertToWorldDefaults dans la mesure où les valeurs utilisées
reflètent l’état de l’acteur au moment où il a été mis en mémoire pour la première fois, plutôt
qu’au moment où il a été créé.
Paramètres
Aucun.
539
Exemple
L’instruction suivante redonne aux propriétés de l’acteur Scène les valeurs utilisées lorsque l’acteur
a été mis en mémoire pour la première fois.
member("Scène").resetWorld()
Voir aussi
revertToWorldDefaults
resolveA
Utilisation
collisionData.resolveA(bRésolution)
Description
Méthode 3D de collision ; annule le comportement de collision défini par la propriété
collision.resolve pour collisionData.modelA. N’appelez cette fonction que si vous
souhaitez remplacer le comportement défini pour modelA à l’aide de collision.resolve.
Paramètres
Requis. Indique si la collision est résolue pour modelA. Si bRésolution est TRUE,
la collision est résolue pour modelA ; si bRésolution est FALSE, la collision n’est pas résolue pour
modelA.
bRésolution
Voir aussi
collisionData, registerScript(), resolve, modelA, setCollisionCallback()
resolveB
Utilisation
collisionData.resolveB(bRésolution)
Description
Méthode 3D de collision ; annule le comportement de collision défini par la propriété
collision.resolve pour collisionData.modelB. N’appelez cette fonction que si vous
souhaitez remplacer le comportement défini pour modelB à l’aide de collision.resolve.
Paramètres
bRésolution Requis. Indique si la collision est résolue pour modelB. Si bRésolution est TRUE,
la collision est résolue pour modelB ; si bRésolution est FALSE, la collision n’est pas résolue pour
modelB.
Voir aussi
collisionData, resolve, registerScript(), modelB, setCollisionCallback()
540
Chapitre 12 : Méthodes
restart()
Utilisation
-- Syntaxe Lingo
_system.restart()
// Syntaxe JavaScript
_system.restart();
Description
Méthode du système ; ferme toutes les applications ouvertes et redémarre l’ordinateur.
Paramètres
Aucun.
Exemple
L’instruction suivante redémarre l’ordinateur lorsque l’utilisateur appuie sur la combinaison de
touches Cmd+R (Macintosh) ou Ctrl+R (Windows) :
-- Syntaxe Lingo
if (_key.key = "r" and _key.commandDown) then
_system.restart()
end if
// Syntaxe JavaScript
if (_key.key = "r" && _key.commandDown) {
_system.restart();
}
Voir aussi
Système
restore()
Utilisation
-- Syntaxe Lingo
réfObjFenêtre.restore()
// Syntaxe JavaScript
réfObjFenêtre.restore();
Description
Méthode de fenêtre ; restaure une fenêtre lorsqu’elle a été agrandie.
Utilisez cette méthode lorsque vous créez des barres de titre personnalisées pour des animations
dans une fenêtre (MIAW).
Paramètres
Aucun.
541
Exemple
Cette instruction rétablit la fenêtre agrandie intitulée Tableau de commande :
-- Syntaxe Lingo
window("Tableau de commande").restore()
// Syntaxe JavaScript
window("Tableau de commande").restore();
Voir aussi
maximize(), Fenêtre
result
Utilisation
the result
Description
Fonction ; affiche la valeur de l’expression renvoyée par le dernier gestionnaire exécuté.
La fonction result sert notamment à obtenir des valeurs provenant d’animations lues dans des
fenêtres et à suivre l’évolution de Lingo en affichant les résultats des gestionnaires dans la fenêtre
Messages pendant la lecture de l’animation.
Pour renvoyer le résultat d'un gestionnaire, affectez ce résultat à une variable, puis vérifiez la
valeur de cette dernière. Utilisez une instruction telle que set myVariable = fonction(), où
fonction() est le nom d'une fonction spécifique.
Paramètres
Aucun.
Exemple
Le gestionnaire suivant renvoie un résultat aléatoire de deux dés :
on lancerLesDés
return random(6) + random(6)
end
Dans l’exemple suivant, les deux instructions
lancerLesDés
dés = the result
sont équivalentes à l’instruction suivante :
set dés = lancerLesDés()
L’instruction set dés = lancerLesDés n’appelle pas le gestionnaire car il n’existe aucune
parenthèse après lancerLesDés ; lancerLesDés est considéré comme une référence de variable.
Voir aussi
return (mot-clé)
542
Chapitre 12 : Méthodes
resume()
Utilisation
-- Syntaxe Lingo
animGifSpriteRef.resume()
// Syntaxe JavaScript
animGifSpriteRef.resume();
Description
Méthode de GIF animé ; reprend la lecture de l’image-objet à partir de l’image suivant celle sur
laquelle elle est arrêtée. Cette commande n’a aucun effet si l’image-objet GIF animé n’est pas en
pause.
Paramètres
Aucun.
Voir aussi
rewind() (GIF animé, Flash)
returnToTitle()
Utilisation
-- Syntaxe Lingo
réfObjDvd.returnToTitle()
// Syntaxe JavaScript
réfObjDvd.returnToTitle();
Description
Méthode DVD ; reprend la lecture après l'affichage d'un menu.
Paramètres
Aucun.
Exemple
Cette instruction reprend la lecture après l'affichage d'un menu :
-- Lingo syntax
member(1).returnToTitle()
// JavaScript syntax
member(1).returnToTitle();
Voir aussi
DVD
543
revertToWorldDefaults
Utilisation
member(quelActeur).revertToWorldDefaults()
Description
Commande 3D ; redonne aux propriétés de l’acteur 3D spécifié les valeurs enregistrées lorsque
l’acteur a été créé. La propriété state de l’acteur doit avoir la valeur 4 (chargé) ou -1 (erreur)
avant que cette commande ne puisse être utilisée afin d’éviter une erreur de script.
Cette commande diffère de resetWorld dans la mesure où les valeurs utilisées reflètent l’état de
l’acteur lorsqu’il a été créé plutôt que lorsqu’il a été mis en mémoire pour la première fois.
Paramètres
Aucun.
Exemple
L’instruction suivante redonne aux propriétés de l’acteur Scène les valeurs enregistrées lorsque
l’acteur a été créé.
member("Scène").revertToWorldDefaults()
Voir aussi
resetWorld
rewind() (piste audio)
Utilisation
-- Syntaxe Lingo
réfObjPisteAudio.rewind()
// Syntaxe JavaScript
réfObjPisteAudio.rewind();
Description
Méthode de piste audio ; interrompt la lecture du son courant et la redémarre à sa position de
départ startTime.
Si le son est en pause, il reste en pause, avec la propriété currentTime définie sur la position de
départ startTime.
Paramètres
Aucun.
544
Chapitre 12 : Méthodes
Exemple
L’instruction suivante relance la lecture de l’acteur son dans la piste audio 1 depuis le début.
-- Syntaxe Lingo
sound(1).rewind()
// Syntaxe JavaScript
sound(1).rewind();
Voir aussi
Piste audio, startTime
rewind() (Windows Media)
Utilisation
-- Syntaxe Lingo
réfObjWindowsMedia.rewind()
// Syntaxe JavaScript
réfObjWindowsMedia.rewind();
Description
Méthode d’acteur ou d’image-objet Windows Media. Rembobine l’animation jusqu’à la première
image d’un acteur ou d’une image-objet Windows Media.
Cette méthode, lorsqu’elle est appelée, n’a aucun effet sur la propriété mediaStatus.
Paramètres
Aucun.
Voir aussi
mediaStatus (RealMedia, Windows Media), Windows Media
rewind() (GIF animé, Flash)
Utilisation
-- Syntaxe Lingo
animGifSpriteRef.rewind()
// Syntaxe JavaScript
animGifSpriteRef.rewind();
Description
Commande ; renvoie une image-objet animation Flash ou GIF animé à l’image 1 lorsque l’imageobjet est arrêtée ou en cours de lecture.
Paramètres
Aucun.
545
Exemple
Le script d’image suivant détermine si l’image-objet animation Flash dans laquelle le comportement était placé est en cours de lecture et, le cas échéant, continue la boucle dans la même image.
Lorsque l’animation est terminée, l’image-objet la rembobine (si bien que la première image de
l’animation apparaît sur la scène) et permet à la tête de lecture de passer à l’image suivante.
-- Syntaxe Lingo
property spriteNum
on exitFrame
if sprite(spriteNum).playing then
_movie.go(_movie.frame)
else
sprite(spriteNum).rewind()
_movie.updatestage()
end if
end
// Syntaxe JavaScript
function exitFrame() {
var plg = sprite(this.spriteNum).playing;
if (plg = 1) {
_movie.go(_movie.frame);
} else {
sprite(this.spriteNum).rewind();
_movie.updatestage();
}
}
rollOver()
Utilisation
-- Syntaxe Lingo
_movie.rollOver({intSpriteNum})
// Syntaxe JavaScript
_movie.rollOver({intSpriteNum});
Description
Méthode d’animation ; indique si le pointeur (curseur) se trouve sur le rectangle délimitant
l’image-objet spécifiée (TRUE ou 1) ou non (FALSE ou 0).
La méthode rollOver(), généralement utilisée dans les scripts d’images, est utile pour créer des
gestionnaires qui exécutent une action lorsque l’utilisateur place le pointeur sur une image-objet
spécifique.
Si l’utilisateur continue à déplacer la souris, la valeur de ()rollOver peut changer pendant qu’un
script exécute un gestionnaire et peut donner lieu à un comportement inattendu. Vous pouvez
vous assurer qu’un gestionnaire utilise une valeur de survol constante en affectant rollOver() à
une variable au moment de son démarrage.
Lorsque le pointeur survole une zone de la scène où apparaissait précédemment une image-objet,
rollOver() se produit encore et indique que l'image-objet est toujours présente. Pour éviter ce
problème, évitez d’effectuer des survols sur ces emplacements ou placez l’image-objet au-dessus de
la barre de menus avant de la supprimer.
546
Chapitre 12 : Méthodes
Paramètres
intSpriteNum
Facultatif. Nombre entier qui spécifie le numéro de l’image-objet.
Exemple
L’instruction suivante change le contenu de l’acteur champ Message en « C’est bien là » lorsque le
curseur se trouve sur l’image-objet 6 :
-- Syntaxe Lingo
if (_movie.rollOver(6)) then
member("Message").text = "C’est bien là."
end if
// Syntaxe JavaScript
if (_movie.rollOver(6)) {
member("Message").text = "C’est bien là.";
}
Le gestionnaire suivant positionne la tête de lecture sur d’autres images lorsque le curseur se
trouve sur certaines images-objets de la scène. Il affecte d’abord la valeur rollOver à une variable.
Cela permet au gestionnaire d’utiliser la valeur rollOver en vigueur au démarrage du survol, que
l’utilisateur continue à déplacer la souris ou non.
-- Syntaxe Lingo
on exitFrame
imageObjetCourante = _movie.rollOver()
case imageObjetCourante of
1: _movie.go("Gauche")
2: _movie.go("Milieu")
3: _movie.go("Droite")
end case
end exitFrame
// Syntaxe JavaScript
function exitFrame() {
var imageObjetCourante = _movie.rollOver();
switch (imageObjetCourante) {
cas 1 : _movie.go("Gauche");
break;
cas 2 : _movie.go("Milieu");
break;
cas 3 : _movie.go("Droite");
break;
}
}
Voir aussi
Animation
547
rootMenu()
Utilisation
-- Syntaxe Lingo
réfObjDvd.rootMenu()
// Syntaxe JavaScript
réfObjDvd.rootMenu();
Description
Méthode de DVD ; affiche le menu racine.
Paramètres
Aucun.
Voir aussi
DVD
rotate
Utilisation
member(quelActeur).node(quelNœud).rotate(angleX, angleY, \
angleZ {, parRapportA})
member(quelActeur).node(quelNœud).rotate(vecteurDeRotation \
{, parRapportA})
member(quelActeur).node(quelNœud).rotate(position, axe, \
angle {, parRapportA})
transformation.rotate(angleX, angleY, angleZ {, parRapportA})
transformation.rotate(vecteurDeRotation {, parRapportA})
transformation.rotate(position, axe, angle {, parRapportA})
Description
Commande 3D ; applique une rotation après les décalages de position, de rotation et d’échelle de
l’objet de transformation d’un nœud ou d’un objet de transformation directement référencé. La
rotation doit être spécifiée sous la forme d’un ensemble de trois angles, chacun desquels spécifiant
l’angle de rotation autour des trois axes correspondants. Ces angles peuvent être spécifiés de façon
explicite sous la forme angleX, angleY et angleZ, ou au moyen d’un vecteurDeRotation, où le
composant x du vecteur correspond à la rotation autour de l’axe des x, y autour de l’axe des y et z
autour de l’axe des z. La rotation peut également être spécifiée autour d’un axe arbitraire passant
par un point de l’espace.
Paramètres
angleX Requis si vous appliquez une rotation avec les axes des x, des y et des z. Spécifie l’angle de
rotation autour de l’axe des x.
angleY Requis si vous appliquez une rotation avec les axes des x, des y et des z. Spécifie l’angle de
rotation autour de l’axe des y.
angleZ Requis si vous appliquez une rotation avec les axes des x, des y et des z. Spécifie l’angle de
rotation autour de l’axe des z.
Requis si vous appliquez une rotation avec un vecteur. Spécifie le vecteur
qui contient les angles à appliquer.
vecteurDeRotation
548
Chapitre 12 : Méthodes
Requis si vous appliquez une rotation autour d’un axe arbitraire qui passe par un point
dans l’espace. Spécifie la position dans l’espace.
angle
axe Requis si vous appliquez une rotation autour d’un axe arbitraire qui passe par un point dans
l’espace. Spécifie l’axe qui passe par la position position spécifiée.
Requis si vous appliquez une rotation autour d’un axe arbitraire qui passe par un point
dans l’espace. Spécifie l’angle de rotation autour de l’axe axis.
position
parRapportA Facultatif. Spécifie les axes du système de coordonnées utilisés pour appliquer les
changements de rotation voulus. Le paramètre parRapportA peut avoir les valeurs suivantes :
•
•
•
•
applique les incréments en fonction du système de coordonnées local du nœud (les axes
des x, des y et des z spécifiés pour le modèle au cours de la programmation). Cette valeur est
utilisée comme valeur par défaut si vous utilisez la commande rotate avec une référence de
nœud et que le paramètre parRapportA n’est pas spécifié.
#parent applique les incréments par rapport au système de coordonnées du parent du nœud.
Cette valeur est utilisée comme valeur par défaut si vous utilisez la commande rotate avec une
référence de transformation et que le paramètre parRapportA n’est pas spécifié.
#world applique les incréments par rapport au système de coordonnées de l’univers. Lorsque le
parent d’un modèle est l’univers, ceci est équivalent à l’utilisation de #parent.
référenceDeNœud permet de spécifier un nœud servant de base à la rotation, la commande
appliquant les incréments en fonction du système de coordonnées du nœud spécifié.
#self
Exemple
L’exemple suivant fait d’abord pivoter le modèle Lune autour de son propre axe des z (en le
faisant pivoter sur place), puis le fait pivoter autour de son nœud parent, le modèle Terre (ce qui
entraîne le déplacement du modèle Lune en orbite autour du modèle Terre).
member("Scène").model("Lune").rotate(0,0,15)
member("Scène").model("Lune").rotate(vector(0, 0, 5),
member("Scène").model("Lune"))
L’exemple suivant fait pivoter le modèle Balle autour d’une position de l’espace occupée par le
modèle Bâton. L’effet obtenu est le déplacement du modèle Balle en orbite autour du modèle
Bâton dans le plan xy.
posBâton = member("Scène 3D").model("Bâton").worldPosition
member("Scène 3D").model("Balle").rotate(posBaton, vector(0,0,1), \
5, #world)
Voir aussi
pointAt, preRotate, rotation (transformation), rotation (matériau de gravure),
rotation (fond et recouvrement), preScale(), transform (propriété)
runMode
Utilisation
the runMode
Description
Fonction ; renvoie une chaîne indiquant le mode de lecture de l’animation. Les valeurs possibles
sont :
•
Author
– L’animation est lue dans Director.
549
•
•
– L’animation est lue en tant que projection.
BrowserPlugin – L’animation est lue en tant que module Shockwave Player ou autre
environnement de programmation tel que LiveConnect ou ActiveX.
Projector
Le moyen le plus sûr de tester des valeurs particulières de cette propriété est d’utiliser l’opérateur
contains. Cela évite les erreurs et permet les correspondances partielles.
Paramètres
Aucun.
Exemple
L’instruction suivante détermine si des paramètres externes sont disponibles et, le cas échéant, les
obtient :
-- Syntaxe Lingo
if the runMode contains "Plugin" then
-- décoder le paramètre embed
if externalParamName(swURL) = swURL then
put externalParamValue(swURL) into maVariable
end if
end if
// Syntaxe JavaScript
if (_movie.runMode.indexOf("Plugin") >=0) {
// décoder le paramètre embed
if (externalParamName(swURL) == swURL) {
maVariable = externalParamValue (swURL);
}
}
Voir aussi
environmentPropList, platform
save castLib
Utilisation
castLib(quelleDistribution).save()
save castLib quelleDistribution {,nomDuChemin&nomDeNouveauFichier}
Description
Commande ; enregistre les modifications apportées à l’acteur dans son fichier d’origine ou dans
un nouveau fichier. Les opérations ou les références ultérieures à la distribution utilisent l’acteur
enregistré.
Cette commande ne fonctionne pas avec les fichiers compressés.
La commande save CastLib ne prend pas en charge les adresses URL comme références de
fichier.
Paramètres
Facultatif. Spécifie le chemin d’accès et le nom du fichier
dans lequel vous voulez enregistrer les modifications. Si ce paramètre est omis, l’acteur d’origine
doit être lié.
nomDuChemin&nomDeNouveauFichier
550
Chapitre 12 : Méthodes
Exemple
L’instruction suivante demande à Director d’enregistrer la version révisée de la distribution
Boutons dans le nouveau fichier BoutonsActualisés au sein du même dossier :
castLib("Boutons").save(the moviePath & "BoutonsActualisés.cst")
Voir aussi
@ (chemin d’accès)
saveMovie()
Utilisation
-- Syntaxe Lingo
_movie.saveMovie({chaîneCheminDeFichier})
// Syntaxe JavaScript
_movie.saveMovie({chaîneCheminDeFichier});
Description
Méthode d’animation ; enregistre l’animation courante.
Le fait d’inclure le paramètre chaîneCheminDeFichier facultatif permet d’enregistrer
l’animation dans le fichier spécifié. Cette commande ne fonctionne pas avec les fichiers
compressés. Le nom du fichier spécifié doit comprendre l’extension .dir.
La commande saveMovie() ne supporte pas les adresses URL comme références de fichier.
Paramètres
chaîneCheminDeFichier Facultatif. Chaîne qui spécifie le chemin d’accès et le nom du fichier
dans lequel l’animation est enregistrée.
Exemple
L’instruction suivante enregistre l’animation courante dans le fichier MiseAjour :
-- Syntaxe Lingo
_movie.saveMovie(_movie.path & "MiseAjour.dir")
// Syntaxe JavaScript
_movie.saveMovie(_movie.path + "MiseAjour.dir");
Voir aussi
Animation
551
scale (commande)
Utilisation
member(quelActeur).node(quelNœud).scale(échelleX, échelleY, \
échelleZ)
member(quelActeur).node(quelNœud).scale(échelleUnifome)
transformation.scale(échelleX, échelleY, échelleZ)
transformation.scale(échelleUniforme)
Description
Commande 3D de transformation ; applique un redimensionnement après les décalages de position, de rotation et d’échelle courants d’une transformation d’un nœud référencé ou de la transformation directement référencée. Le redimensionnement doit être spécifié soit comme un
groupe de trois redimensionnements individuels des axes correspondants, soit comme un redimensionnement unique à appliquer à tous les axes. Vous pouvez spécifier un redimensionnement
individuel à l’aide des paramètres échelleX, échelleY et échelleZ, ou spécifier une valeur pour
un redimensionnement uniforme à l’aide du paramètre échelleUniforme.
Un nœud peut être un objet de caméra, groupe, lumière ou modèle. L’utilisation de la commande
scale ajuste la propriété transform.scale du nœud référencé, mais n’a aucun effet visuel sur les
lumières ou les caméras car elles ne contiennent pas de géométrie.
Les valeurs du redimensionnement doivent être supérieures à zéro.
Paramètres
échelleX
Requis si vous spécifiez trois redimensionnements. Spécifie l’échelle sur l’axe des x.
échelleY
Requis si vous spécifiez trois redimensionnements. Spécifie l’échelle sur l’axe des y.
échelleZ
Requis si vous spécifiez trois redimensionnements. Spécifie l’échelle sur l’axe des z.
échelleUnifome Requis si vous spécifiez un seul redimensionnement, uniforme. Spécifie le
redimensionnement uniforme.
Exemple
L’exemple suivant affiche d’abord la propriété transform.scale du modèle Lune,
redimensionne ensuite le modèle à l’aide de la commande scale, puis affiche la valeur
transform.scale résultante.
put member("Scène").model("Lune").transform.scale
-- vector( 1.0000, 1.0000, 1.0000 )
member("Scène").model("Lune").scale(2.0,1.0,0.5)
put member("Scène").model("Lune").transform.scale
-- vector( 2.0000, 1.0000, 0.5000 )
L’instruction suivante redimensionne le modèle nommé Pluton de façon uniforme sur les trois
axes selon la valeur 0.5, ce qui réduit de moitié la taille du modèle affiché.
member("Scène").model("Pluton").scale(0.5)
L’instruction suivante redimensionne le modèle Pluton de façon non uniforme, en le modifiant
sur l’axe des z mais pas sur celui des x ou des y.
member("Scène").model("Pluton").scale(0.0, 0.0, 0.5)
Voir aussi
transform (propriété), preScale(), scale (transformation)
552
Chapitre 12 : Méthodes
script()
Utilisation
-- Syntaxe Lingo
script(nomOuNumDacteur {, nomOuNumDeDistribution})
// Syntaxe JavaScript
script(nomOuNumDacteur {, nomOuNumDeDistribution});
Description
Fonction du niveau supérieur ; crée une référence à un acteur donné qui contient un script et,
éventuellement, spécifie la distribution qui contient l’acteur.
Une erreur est renvoyée si l’acteur donné ne contient aucun script ou s’il n’existe pas.
Paramètres
nomOuNumDacteur Requis. Chaîne qui spécifie le nom de l’acteur contenant un script ou nombre
entier qui spécifie la position d’index de cet acteur contenant le script.
nomOuNumDeDistribution Facultatif. Chaîne qui spécifie le nom de la distribution contenant
l’acteur nomOuNumDacteur ou nombre entier qui spécifie la position d’index de la distribution
contenant l’acteur nomOuNumDacteur. Si ce paramètre est omis, script() lance la recherche dans
la première distribution.
Exemple
En Lingo uniquement, les instructions suivantes vérifient si un objet enfant est une instance du
script parent Fourmi :
-- Syntaxe Lingo
if (objetInsecte.script = script("Fourmi")) then
objetInsecte.attaque()
end if
Cette instruction affecte la variable acteurAction à l’acteur de script Actions :
-- Syntaxe Lingo
acteurAction = script("Actions")
// Syntaxe JavaScript
var acteurAction = script("Actions");
scrollByLine()
Utilisation
-- Syntaxe Lingo
réfObjActeur.scrollByLine(quantité)
// Syntaxe JavaScript
réfObjActeur.scrollByLine(quantité);
Description
Commande ; fait défiler l’acteur champ ou texte spécifié vers le haut ou le bas du nombre de
lignes spécifié. Les lignes sont définies comme des lignes séparées par des retours chariot ou par
des retours à la ligne automatiques.
553
Paramètres
quantité Requis. Spécifie le nombre de lignes à faire défiler. Lorsque quantité a une valeur
positive, le champ défile vers le bas. Lorsque quantité a une valeur négative, le champ défile vers
le haut.
Exemple
L’instruction suivante fait défiler l’acteur champ Nouvelles du jour de cinq lignes vers le bas :
-- Syntaxe Lingo
member("Nouvelles du jour").scrollbyline(5)
// Syntaxe JavaScript
member("Nouvelles du jour").scrollbyline(5);
L’instruction suivante fait défiler l’acteur champ Nouvelles du jour de cinq lignes vers le haut :
-- Syntaxe Lingo
member("Nouvelles du jour").scrollByLine(-5)
// Syntaxe JavaScript
member("Nouvelles du jour").scrollByLine(-5);
scrollByPage()
Utilisation
-- Syntaxe Lingo
réfObjActeur.scrollByPage(quantité)
// Syntaxe JavaScript
réfObjActeur.scrollByPage(quantité);
Description
Commande ; fait défiler l’acteur champ ou texte spécifié vers le haut ou le bas d’un nombre de
pages spécifié. Une page correspond au nombre de lignes de texte visibles à l’écran.
Paramètres
quantité Requis. Spécifie le nombre de pages à faire défiler. Lorsque quantité a une valeur
positive, le champ défile vers le bas. Lorsque quantité a une valeur négative, le champ défile vers
le haut.
Exemple
L’instruction suivante fait défiler l’acteur champ Nouvelles du jour d’une page vers le bas :
-- Syntaxe Lingo
member("Nouvelles du jour").scrollbypage(1)
// Syntaxe JavaScript
member("Nouvelles du jour").scrollbypage(1);
554
Chapitre 12 : Méthodes
L’instruction suivante fait défiler l’acteur champ Nouvelles du jour d’une page vers le haut :
-- Syntaxe Lingo
member("Nouvelles du jour").scrollbypage(-1)
// Syntaxe JavaScript
member("Nouvelles du jour").scrollbypage(-1);
Voir aussi
scrollTop
seek()
Utilisation
-- Syntaxe Lingo
réfObjActeurOuImageObjet.seek(millisecondes)
// Syntaxe JavaScript
réfObjActeurOuImageObjet.seek(millisecondes);
Description
Méthode d’acteur ou d’image-objet RealMedia ; change l’emplacement de lecture du flux
multimédia et sélectionne l’emplacement spécifié par le nombre de millisecondes écoulées depuis
le début du flux. La valeur mediaStatus devient généralement #seeking, puis #buffering.
Vous pouvez utiliser cette méthode pour initialiser la lecture à des points autres que le début
du flux RealMedia, ou pour avancer ou reculer dans le flux. Le nombre entier spécifié dans
millisecondes correspond au nombre de millisecondes écoulées depuis le début du flux.
Ainsi, pour reculer, vous devez spécifier un nombre inférieur de millisecondes, et non un
nombre négatif.
Si la commande seek est appelée lorsque mediaStatus a pour valeur #paused, le flux repasse
en mémoire tampon et revient à la valeur #paused au nouvel emplacement spécifié par seek.
Si seek est appelé lorsque mediaStatus a pour valeur #playing, le flux repasse en tampon et sa
lecture démarre automatiquement au nouvel emplacement du flux. Si seek est appelé lorsque
mediaStatus a pour valeur #closed, rien ne se passe.
Si vous tentez de lancer une recherche au-delà de la valeur duration du flux, l’argument entier
spécifié est ajouté à la plage à partir de 0 pour la durée du flux. Vous ne pouvez pas accéder
directement à une image-objet RealMedia qui est en cours de lecture en flux continu.
L’instruction x.seek(n) est identique à l’instruction x.currentTime = n ; dans les deux cas,
le flux sera replacé en mémoire tampon.
Paramètres
millisecondes
Requis. Un nombre entier spécifiant le nombre de millisecondes à partir du
début du flux.
555
Exemple
Les exemples suivants définissent la position de lecture actuelle du flux sur 10 000 millisecondes
(10 secondes) :
-- Syntaxe Lingo
sprite(2).seek(10000)
member("Real").seek(10000)
// Syntaxe JavaScript
sprite(2).seek(10000);
member("Real").seek(10000);
Voir aussi
duration (RealMedia, SWA), currentTime (RealMedia), play() (RealMedia, SWA,
Windows Media), pause() (RealMedia, SWA, Windows Media), stop() (RealMedia,
SWA, Windows Media), mediaStatus (RealMedia, Windows Media)
selectAtLoc()
Utilisation
-- Syntaxe Lingo
réfObjDvd.selectAtLoc(point(x, y))
// Syntaxe JavaScript
réfObjDvd.selectAtLoc(point(x, y));
Description
Méthode de DVD ; déclenche le bouton sous un point spécifié.
Cette méthode a la même fonctionnalité qu’un clic de souris sur un bouton.
Paramètres
point(x, y)
Requis. Point qui spécifie l’emplacement sous lequel un bouton est déclenché.
Exemple
Cette instruction déclenche le bouton sous un point spécifié :
-- Syntaxe Lingo
member(10).selectAtLoc(point(50, 75))
// Syntaxe JavaScript
member(10).selectAtLoc(point(50, 75));
Voir aussi
DVD
556
Chapitre 12 : Méthodes
selectButton()
Utilisation
-- Syntaxe Lingo
réfObjDvd.selectButton(entBouton)
// Syntaxe JavaScript
réfObjDvd.selectButton(entBouton);
Description
Méthode de DVD ; sélectionne un bouton spécifié.
Cette méthode renvoie TRUE (1) en cas de réussite.
Paramètres
entBouton
Requis. Nombre entier qui spécifie le bouton à sélectionner.
Exemple
Cette instruction sélectionne le bouton 5 :
-- Syntaxe Lingo
sprite(11).selectButton(5)
// Syntaxe JavaScript
sprite(11).selectButton(5);
Voir aussi
DVD
selectButtonRelative()
Utilisation
-- Syntaxe Lingo
réfObjDvd.selectButtonRelative(direction)
// Syntaxe JavaScript
réfObjDvd.selectButtonRelative(direction);
Description
Méthode de DVD ; sélectionne un bouton par rapport à la position du bouton courant dans le
menu.
Paramètres
Requis. Symbole (Lingo) ou chaîne (syntaxe JavaScript) qui spécifie la direction du
déplacement par rapport à la position du bouton courant. Les valeurs correctes sont left et
right.
direction
557
Exemple
Cette instruction spécifie le bouton qui se trouve à gauche du bouton actuel :
-- Syntaxe Lingo
sprite(12).member.selectButtonRelative(#left)
// Syntaxe JavaScript
sprite(12).member.selectButtonRelative("left");
Voir aussi
DVD
selection() (fonction)
Utilisation
the selection
Description
Fonction ; renvoie une chaîne de caractères contenant la partie sélectionnée du champ modifiable
courant. Elle permet notamment de tester la sélection faite par l’utilisateur dans un champ.
La fonction selection indique uniquement la chaîne de caractères sélectionnée ; vous ne pouvez
pas utiliser selection pour sélectionner une chaîne de caractères.
Paramètres
Aucun.
Exemple
L’instruction suivante vérifie si des caractères sont sélectionnés et, à défaut, affiche le message
d’alerte « Veuillez sélectionner un mot. » :
if the selection = EMPTY then alert "Veuillez sélectionner un mot."
Voir aussi
selStart, selEnd
sendAllSprites()
Utilisation
-- Syntaxe Lingo
_movie.sendAllSprites(chaîneMessageDévénement {, args})
// Syntaxe JavaScript
_movie.sendAllSprites(chaîneMessageDévénement {, args});
Description
Méthode d’animation ; envoie un message d’événement personnalisé à toutes les images-objets, et
pas seulement à l’image-objet impliquée dans l’événement. Comme tout autre message, celui-ci
est envoyé à chaque script associé à l’image-objet, à moins que la méthode stopEvent() ne soit
utilisée.
558
Chapitre 12 : Méthodes
Pour de meilleurs résultats, n’envoyez le message qu’aux images-objets capables de le gérer
correctement par le biais de la méthode sendSprite(). Aucune erreur ne se produira si le
message est envoyé à toutes les images-objets, mais cela nuira néanmoins à la performance. La
présence d’un gestionnaire identique dans un comportement donné et pour des images-objets
différentes risquant également de poser des problèmes, il est important d’utiliser des noms
uniques pour les messages qui seront diffusés, ceci afin d’éviter tout conflit éventuel.
Une fois le message passé à tous les comportements, l’événement suit la hiérarchie de messages
classique: script d’acteur, script d’image, puis script d’animation.
Lorsque vous utilisez la méthode sendAllSprites(), effectuez les opérations suivantes :
• Remplacez chaîneMessageDévénement par le message.
• Remplacez arguments par tout argument devant être envoyé avec le message.
Si aucune image-objet ne possède de comportement associé contenant le gestionnaire donné,
sendAllSprites() renvoie la valeur FALSE.
Paramètres
chaîneMessageDévénement
Requis. Chaîne qui spécifie le message à envoyer à toutes les images-
objets.
args
Facultatif. Argument ou arguments à envoyer avec le message.
Exemple
Le gestionnaire suivant envoie le message personnalisé
toutesLesImagesObjetsDoiventAugmenterLeCompteur
et l’argument 2 à toutes les images-
objets lorsque l’utilisateur clique avec la souris :
-- Syntaxe Lingo
on mouseDown me
_movie.sendAllSprites(#toutesLesImagesObjetsDoiventAugmenterLeCompteur, 2)
end
// Syntaxe JavaScript
function mouseDown() {
_movie.sendAllSprites("toutesLesImagesObjetsDoiventAugmenterLeCompteur",
2);
}
Voir aussi
Animation, sendSprite(), stopEvent()
sendEvent
Utilisation
member(quelActeur).sendEvent(#nomDévénement, arg1, arg2,...)
Description
Commande 3D ; envoie un événement et un nombre arbitraire d’arguments à tous
les scripts enregistrés pour recevoir l'événement. Utilisez registerForEvent() ou
setCollisionCallback() pour enregistrer les scripts pour les événements.
559
Paramètres
nomDévénement
Requis. Spécifie le nom de l’événement à envoyer.
arg1, arg2, ...
nomDévénement.
Requis. Un ou plusieurs arguments qui sont envoyés avec l’événement
Exemple
La première ligne de cet exemple crée une instance d’un script parent appelé "Testeur".
La seconde ligne définit le gestionnaire de l’instance de script, sautPluton, comme gestionnaire
à appeler lorsque l’événement #saut est envoyé. La troisième ligne définit le gestionnaire d’un
script d’animation sautMars comme un autre gestionnaire à appeler lorsque l’événement #saut
est envoyé. La quatrième ligne envoie l’événement #saut. Le gestionnaire #sautMars d’un script
d’animation et le gestionnaire #sautPluton sont appelés, ainsi que tout autre gestionnaire enregistré pour l’événement #saut. Une valeur d’instance de script de 0 indique que vous enregistrez
le gestionnaire d’un script d’animation, par opposition au gestionnaire d’une instance de comportement ou de l’enfant d’un script parent.
t = new (script "Testeur")
member("Scène").registerForEvent(#saut, #sautPluton, t)
member("Scène").registerForEvent(#saut, #sautMars, 0)
member("Scène").sendEvent(#saut)
Voir aussi
registerScript(), registerForEvent(), setCollisionCallback()
sendSprite()
Utilisation
-- Syntaxe Lingo
_movie.sendSprite(nomOuNumDimageObjet, événement {, args})
// Syntaxe JavaScript
_movie.sendSprite(nomOuNumDimageObjet, événement {, args});
Description
Méthode d’animation ; envoie un message à tous les scripts associés à une image-objet spécifiée.
Les messages envoyés à l’aide de sendSprite() sont envoyés à chacun des scripts associés à
l’image-objet. Ces messages suivent ensuite la hiérarchie de messages classique : script d’acteur,
script d’image et script d’animation.
Si l’image-objet donnée ne possède pas de comportement associé contenant le gestionnaire
donné, sendSprite() renvoie la valeur FALSE.
Paramètres
nomOuNumDimageObjet Requis. Chaîne ou nombre entier qui spécifie le nom ou le numéro de
l’image-objet qui recevra l’événement.
événement
Requis. Symbole ou chaîne qui spécifie l’événement à envoyer à l’image-objet
spécifiée.
args
560
Facultatif. Argument ou arguments à envoyer avec le message.
Chapitre 12 : Méthodes
Exemple
Le gestionnaire suivant envoie le message personnalisé augmenterLeCompteur et l’argument 2 à
l’image-objet 1 lorsque l’utilisateur clique avec la souris :
-- Syntaxe Lingo
on mouseDown me
_movie.sendSprite(1, #augmenterLeCompteur, 2)
end
// Syntaxe JavaScript
function mouseDown() {
_movie.sendSprite(1, "augmenterLeCompteur", 2);
}
Voir aussi
Animation
setAlpha()
Utilisation
objetImage.setAlpha(niveauAlpha)
objetImage.setAlpha(objetImageAlpha)
Description
Fonction ; donne à la couche alpha d’une image-objet un niveauAlpha plat ou un
objetImageAlpha existant. Le niveauAlpha doit être un nombre compris entre 0 et 255.
Des valeurs inférieures font apparaître l’image plus transparente. Des valeurs supérieures
font apparaître l’image plus opaque. La valeur 255 a le même effet que la valeur 0. Pour
que le niveauAlpha puisse prendre effet, la propriété useAlpha() de l’image-objet doit être
définie sur TRUE.
L’objet image doit être de 32 bits. Si vous spécifiez un objet image alpha, il doit être de 8 bits.
Les deux images doivent avoir les mêmes dimensions. Si ces conditions ne sont pas remplies,
setAlpha() n’a aucun effet et renvoie la valeur FALSE. La fonction renvoie TRUE si elle réussit.
Exemple
L’instruction Lingo suivante rend l’image de l’acteur bitmap Premier plan opaque et désactive
simultanément la couche alpha. Cette méthode est efficace pour supprimer la couche alpha d’une
image :
member("Premier plan").image.setAlpha(255)
member("Premier plan").image.useAlpha = FALSE
L’instruction Lingo suivante récupère la couche alpha de l’acteur Lever de soleil et la place dans la
couche alpha de l’acteur Coucher de soleil :
alphaTemp = member("Lever de soleil").image.extractAlpha()
member("Coucher de soleil").image.setAlpha(alphaTemp)
Voir aussi
useAlpha, extractAlpha()
561
setaProp
Utilisation
setaProp list, propriétéDeListe, nouvelleValeur
setaProp (objetEnfant, propriétéDeListe, nouvelleValeur)
liste.propriétéDeListe = nouvelleValeur
liste[propriétéDeListe] = nouvelleValeur
objetEnfant.propriétéDeListe = nouvelleValeur
Description
Commande ; remplace la valeur affectée à propriétéDeListe par la valeur spécifiée par
nouvelleValeur. La commande setaProp fonctionne uniquement avec des listes de propriétés
et des objets enfants. L’utilisation de setaProp avec une liste linéaire produit une erreur de script.
• Pour les listes de propriétés, setaProp remplace une propriété dans la liste spécifiée par liste.
•
•
Lorsque la propriété ne se trouve pas déjà dans la liste, le code ajoute la nouvelle propriété et sa
valeur.
Pour les objets enfants, setaProp remplace une propriété de l’objet enfant. Lorsque la
propriété ne se trouve pas déjà dans l’objet, le code ajoute la nouvelle propriété et sa valeur.
La commande setaProp peut également définir des propriétés ancestor.
Paramètres
Requis. Symbole (Lingo uniquement) ou chaîne qui spécifie le nom de la
propriété dont la valeur change.
propriétéDeListe
nouvelleValeur
Requis. Nouvelle valeur de la propriété propriétéDeListe.
Exemple
Les instructions suivantes créent une liste de propriétés, puis ajoutent l’élément #c:10 à la liste :
nouvelleListe = [#a:1, #b:5]
put nouvelleListe
-- [#a:1, #b:5]
setaProp nouvelleListe, #c, 10
put nouvelleListe
L’opérateur point permet de modifier la valeur de propriété d’une propriété figurant déjà dans
une liste sans utiliser setaProp :
nouvelleListe = [#a:1, #b:5]
put nouvelleListe
-- [#a:1, #b:5]
nouvelleListe.b = 99
put nouvelleListe
-- [#a:1, #b:99]
Remarque : Pour pouvoir utiliser l’opérateur point en vue de manipuler une propriété, la propriété doit
déjà exister dans la liste, dans l’objet enfant ou dans le comportement.
Voir aussi
ancestor, property, . (opérateur point)
562
Chapitre 12 : Méthodes
setAt
Utilisation
setAt liste, numéroDordre, valeur
liste[numéroDordre] = valeur
Description
Commande ; remplace l’élément spécifié par numéroDordre par la valeur spécifiée par valeur
dans la liste spécifiée par liste. Lorsque numéroDordre est supérieur au nombre d’éléments
d’une liste de propriétés, la commande setAt renvoie une erreur de script. Lorsque
numéroDordre est supérieur au nombre d’éléments d’une liste linéaire, Director insère des
entrées vierges dans la liste pour ajouter le nombre d’emplacements spécifiés par numéroDordre.
Exemple
Le gestionnaire suivant affecte un nom à la liste [12, 34, 6, 7, 45], remplace le quatrième élément
de la liste par la valeur 10, puis affiche le résultat dans la fenêtre Messages :
on enterFrame
set vNombres = [12, 34, 6, 7, 45]
setAt vNombres, 4, 10
put vNombres
end enterFrame
Lorsque le gestionnaire est exécuté, la fenêtre Messages affiche le message suivant :
[12, 34, 6, 10, 45]
La même opération peut être exécutée en utilisant des crochets d’accès de la manière suivante :
on enterFrame
set vNombres = [12, 34, 6, 7, 45]
vNombres[4] = 10
put vNombres
end enterFrame
Lorsque le gestionnaire est exécuté, la fenêtre Messages affiche le message suivant :
[12, 34, 6, 10, 45]
Voir aussi
[ ] (crochets d’accès)
563
setCallback()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.setCallback(objetAS, nomDévénAS, #gestLingo, \
objetLingo)
// Syntaxe JavaScript
réfObjImageObjet.setCallback(objetAS, nomDévénAS, symbol(gestLingo),
objetLingo);
Description
Commande Flash ; cette commande peut être utilisée en tant qu’image-objet ou comme méthode
globale pour définir un appel de gestionnaire Lingo pour un événement particulier généré par
l’objet spécifié. Lorsque ActionScript déclenche l’événement dans l’objet, cet événement est
redirigé vers le gestionnaire Lingo spécifié, avec tous les arguments transmis avec l’événement.
Si l’objet ActionScript a été initialement créé dans une image-objet Flash, utilisez la syntaxe
réfDimageObjetFlash. Si l’objet a été créé globalement, utilisez la syntaxe globale.
Remarque : Si vous n’avez pas importé d’acteur Flash, vous devrez ajouter manuellement l’Xtra
Flash à la liste des Xtras de votre animation pour permettre aux objets Flash globaux de fonctionner
correctement. Vous pouvez ajouter les Xtras à la liste des Xtras en choisissant Modification >
Animation > Xtras. Pour plus d’informations sur la gestion des Xtras pour les animations distribuées,
consultez les rubriques Utilisation de Director dans le panneau d'aide de Director.
Paramètres
objetAS
Requis. Spécifie l’objet ActionScript qui contient l’événement nomDévénAS.
nomDévénAS
gestLingo
Requis. Spécifie l’événement ActionScript qui est survenu.
Requis. Spécifie le gestionnaire Lingo qui prend en charge l’événement nomDévénAS.
objetLingo
Requis. Spécifie l’objet script Lingo qui contient le gestionnaire gestLingo.
Exemple
L’instruction suivante définit l’appel du gestionnaire Lingo appelé monOnStatus dans l’objet de
script Lingo me lorsqu’un événement onStatus est généré par l’objet ActionScript
tObjetConnexionLocale dans l’animation Flash, au niveau de l’image-objet 3 :
-- Syntaxe Lingo
sprite(3).setCallback(tObjetConnexionLocale, "onStatus", #monOnStatus, me)
// Syntaxe JavaScript
sprite(3).setCallback(tObjetConnexionLocale, "onStatus",
symbol("monOnStatus"), me);
564
Chapitre 12 : Méthodes
Les instructions suivantes créent un nouvel objet XML global, ainsi qu’un gestionnaire d’appel
qui analyse les données XML à leur arrivée. La troisième ligne entraîne le chargement d’un fichier
XML. Le gestionnaire d’appel est inclus.
-- Syntaxe Lingo
gXMLCB = newObject("XML")
setCallback( gXMLCB, "onDonnées", #donnéesTrouvées, 0 )
gXMLCB.load( "monFichier.xml" )
-- gestionnaire d’appel appelé lors de l’arrivée des données xml
on donnéesTrouvées me, obj, source
obj.parseXML(source)
obj.loaded = 1
obj.onload(TRUE)
end donnéesTrouvées
// Syntaxe JavaScript
gXMLCB = newObject("XML");
setCallback( gXMLCB, "onDonnées", symbol("donnéesTrouvées"), 0 );
gXMLCB.load( "monFichier.xml" );
// gestionnaire d’appel appelé lors de l’arrivée des données xml
function donnéesTrouvées(me, obj, source) {
obj.parseXML(source);
obj.loaded = 1;
obj.onload(1);
}
Voir aussi
newObject(), clearAsObjects()
setCollisionCallback()
Utilisation
member(quelActeur).model(quelModèle).collision.\
setCollisionCallback (#nomDeGestionnaire, instanceDeScript)
Description
Commande de collision 3D ; enregistre un gestionnaire spécifié, dans une instance de script
donnée, à appeler lorsque quelModèle est impliqué dans une collision.
Cette commande ne fonctionne que si la propriété collision.enabled du modèle a pour valeur
TRUE. Le comportement par défaut est déterminé par la valeur de collision.resolve, que vous
pouvez remplacer en utilisant les commandes collision.resolveA et/ou
collision.resolveB. N’utilisez pas la commande updateStage dans le gestionnaire spécifié.
Cette commande est une alternative plus courte à la commande registerScript pour les
collisions, et le résultat n’est globalement pas différent. Cette commande peut être envisagée pour
exécuter une petite partie de la fonctionnalité de la commande registerScript.
Paramètres
nomDeGestionnaire
Requis. Spécifie le gestionnaire appelé lorsqu’un modèle est impliqué dans
une collision.
instanceDeScript Requis.
nomDeGestionnaire.
Spécifie l’instance de script qui contient le gestionnaire spécifié par
565
Exemple
L’instruction suivante entraîne l’appel du gestionnaire #rebond de l’acteur scriptDeCollision
lorsque le modèle Sphère entre en collision avec un autre modèle.
member("Univers 3D").model("Sphère").collision.\
setCollisionCallback\
(#rebond, member("scriptDeCollision"))
Voir aussi
collisionData, collision (modificateur), resolve, resolveA, resolveB,
registerForEvent(), registerScript(), sendEvent
setFilterMask()
Utilisation
-- Syntaxe Lingo
réfObjFileio.setFilterMask(chaîneMasque)
// Syntaxe JavaScript
réfObjFileio.setFilterMask(chaîneMasque);
Description
Méthode de Fileio ; définit le masque de filtrage pour le champ Type d’une boîte de dialogue pour
spécifier le type des fichiers affichés à l’ouverture de la boîte de dialogue.
Paramètres
chaîneMasque
Requis. Chaîne qui spécifie le masque de filtrage.
Voir aussi
Fileio
setFinderInfo()
Utilisation
-- Syntaxe Lingo
réfObjFileio.setFinderInfo(chaîneAttrs)
// Syntaxe JavaScript
réfObjFileio.setFinderInfo(chaîneAttrs)
Description
Méthode de Fileio (Macintosh uniquement) ; définit les informations du Finder pour un fichier
ouvert.
Paramètres
chaîneAttrs
Requis. Chaîne qui spécifie les informations du Finder.
Voir aussi
Fileio
566
Chapitre 12 : Méthodes
setFlashProperty()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.setFlashProperty(nomDeCible, #propriété, nouvelleValeur)
// Syntaxe JavaScript
réfObjImageObjet.setFlashProperty(nomDeCible, symbol(propriété),
nouvelleValeur);
Description
Fonction ; permet à Lingo d’invoquer la fonction script d’action Flash setProperty() dans
l’image-objet Flash donnée. Utilisez la fonction setFlashProperty() pour définir les propriétés
des propriétés des clips ou des niveaux dans une animation Flash. Cette fonction est similaire à la
définition des propriétés d’images-objets dans Director.
Pour définir une propriété globale de l’image-objet Flash, passez une ligne vide comme
les propriétés Flash globales suivantes : #focusRect et
nomDeCible. Vous pouvez définir
#spriteSoundBufferTime.
Consultez la documentation de Flash pour plus d’informations sur ces propriétés.
Paramètres
nomDeCible Requis. Spécifie le nom du clip ou du niveau de l’animation dont vous souhaitez
définir la propriété dans l’image-objet Flash donnée.
propriété Requis. Spécifie le nom de la propriété à définir. Vous pouvez définir les propriétés
suivantes : #posX, #posY, #scaleX, #scaleY, #visible, #rotate, #alpha et #name.
nouvelleValeur
Requis. Spécifie la nouvelle valeur.
Exemple
L’instruction suivante définit la valeur de la propriété #rotate du clip Etoile dans l’acteur Flash
de l’image-objet 3 sur 180.
-- Syntaxe Lingo
sprite(3).setFlashProperty("Etoile", #rotate, 180)
// Syntaxe JavaScript
sprite(3).setFlashProperty("Etoile", symbol("rotate"), 180);
Voir aussi
getFlashProperty()
567
setNewLineConversion()
Utilisation
-- Syntaxe Lingo
réfObjFileio.setNewLineConversion(entActivéDésactivé)
// Syntaxe JavaScript
réfObjFileio.setNewLineConversion(entActivéDésactivé)
Description
Méthode de Fileio (Macintosh uniquement) ; spécifie si la conversion automatique des caractères
de changement de ligne est activée ou désactivée.
Paramètres
Requis. Nombre entier qui spécifie si la conversion automatique est
activée ou désactivée. Les valeurs correctes incluent 0 (désactivé) et 1 (activé).
entActivéDésactivé
Voir aussi
Fileio
setPixel()
Utilisation
-- Syntaxe Lingo
réfObjImage.setPixel(x, y, objOuEntierCouleur)
réfObjImage.setPixel(point(x, y), objOuEntierCouleur)
// Syntaxe JavaScript
réfObjImage.setPixel(x, y, objOuEntierCouleur);
réfObjImage.setPixel(point(x, y), objOuEntierCouleur);
Description
Méthode d’image. Définit la valeur de couleur du pixel à un point spécifié dans une image
donnée.
Si vous définissez un grand nombre de pixels sur la couleur d’un autre pixel à l’aide de
getPixel(), il est plus rapide de les définir en tant que nombres entiers.
Pour obtenir des performances maximales avec les objets couleur, utilisez un objet couleur
indexée pour les images 8 bits (ou d’une qualité inférieure) et un objet couleur RVB pour des
images 16 bits (ou d’une qualité supérieure).
Cette méthode renvoie FALSE si le pixel spécifié se trouve en dehors de l'image spécifiée.
Pour un exemple d’utilisation de cette méthode dans une animation, reportez-vous à l’animation
Imaging du dossier Learning/Lingo, lui-même inclus dans le dossier de Director.
Paramètres
x Requis si vous spécifiez un pixel avec des coordonnées x et y. Entier qui spécifie la coordonnée x
du pixel.
y1 Requis si vous spécifiez un
y du pixel.
point(x, y)
568
pixel avec des coordonnées x et y. Entier qui spécifie la coordonnée
Requis si vous spécifiez un pixel en utilisant un point. Point qui spécifie le pixel.
Chapitre 12 : Méthodes
objOuEntierCouleur Requis si vous définissez la couleur sur un objet couleur ou un nombre
entier. Référence à un objet couleur qui spécifie la couleur du pixel ou nombre entier qui spécifie
la valeur de couleur du pixel.
Exemple
L’instruction Lingo suivante dessine une ligne noire horizontale de 50 pixels, de gauche à droite,
dans l’acteur 5 :
Voir aussi
color(), draw(), fill(), getPixel(), image()
setPlayList()
Utilisation
-- Syntaxe Lingo
réfObjPisteAudio.setPlayList(listeLinéaireDeListesDePropriétés)
// Syntaxe JavaScript
réfObjPisteAudio.setPlayList(listeLinéaireDeListesDePropriétés);
Description
Méthode de piste audio ; définit ou réinitialise la liste de lecture d’une piste audio.
Cette méthode est pratique pour placer plusieurs sons en file d’attente en une seule opération.
Pour un exemple d’utilisation de setPlaylist() dans une animation, reportez-vous à
l’animation Sound Control du dossier Learning/Lingo, lui-même inclus dans le dossier de
Director.
Paramètres
listeLinéaireDeListesDePropriétés Requis. Liste linéaire de listes de propriétés qui spécifie
les paramètres d’une liste de lecture. Vous pouvez définir ces paramètres pour chaque son à placer
en file d’attente :
Propriété
Description
#member
L’acteur à placer en file d’attente. Cette propriété doit être spécifiée. Toutes les
autres sont facultatives.
#startTime
Position temporelle de départ de la lecture du son, en millisecondes. La valeur
par défaut est le début du son. Pour plus d’informations, consultez startTime.
#endTime
Position temporelle de fin de la lecture du son, en millisecondes. La valeur par
défaut est la fin du son. Pour plus d’informations, consultez endTime.
#loopCount
Nombre de répétitions d’une boucle défini avec #loopStartTime et #loopEndTime.
La valeur par défaut est 1. Voir loopCount.
#loopStartTime
Position temporelle de départ de la boucle, en millisecondes. Pour plus
d’informations, consultez loopStartTime.
#loopEndTime
Position temporelle de fin de la boucle, en millisecondes. Pour plus
d’informations, consultez loopEndTime.
#preloadTime
Quantité de son à placer en mémoire tampon avant la lecture, en millisecondes.
Pour plus d’informations, consultez preloadTime.
569
Exemple
Le gestionnaire suivant place en file d’attente et lit l’acteur son Intro, à partir du point 3 secondes,
exécute cinq lectures en boucle successives, du point 8 secondes au point 8,9 secondes, et s’arrête
au point 10 secondes ;
-- Syntaxe Lingo
on playMusic
sound(2).queue([#member:member("intro"), #startTime:3000, \
#endTime:10000, #loopCount:5, #loopStartTime:8000, #loopEndTime:8900])
sound(2).play()
end playMusic
// Syntaxe JavaScript
function playMusic() {
sound(2).queue(propList("member",member("Intro"),
"startTime",3000, "endTime",10000, "loopCount",5, "loopStartTime",8000,
"loopEndTime",8900));
sound(2).play();
}
Voir aussi
endTime, getPlayList(), loopCount, loopEndTime, loopStartTime, Acteur, member,
preLoadTime, queue(), Piste audio, startTime
setPosition()
Utilisation
-- Syntaxe Lingo
réfObjFileio.setPosition(entPosition)
// Syntaxe JavaScript
réfObjFileio.setPosition(entPosition);
Description
Méthode de Fileio ; définit la position d’un fichier.
Paramètres
entPosition
Requis. Nombre entier qui spécifie la nouvelle position du fichier.
Voir aussi
Fileio
setPref()
Utilisation
-- Syntaxe Lingo
_player.setPref(chaîneNomDePréf, chaîneDePréf)
// Syntaxe JavaScript
_player.setPref(chaîneNomDePréf, chaîneDePréf);
Description
Méthode de lecteur ; écrit une chaîne donnée dans un fichier spécifié sur le disque local de
l’ordinateur. Le fichier est un fichier texte standard.
570
Chapitre 12 : Méthodes
Après l’exécution de la méthode setPref(), si l’animation est lue dans un navigateur, un dossier
nommé Prefs est créé à l’intérieur du dossier Plug-In Support. La méthode setPref() ne peut
écrire que dans ce dossier.
Si l’animation est lue dans une projection ou dans Director, un dossier est créé dans le même
dossier que l’application. Le dossier est appelé Prefs.
N’utilisez pas cette méthode pour écrire sur un média en lecture seule. Selon la plate-forme et
la version du système d’exploitation utilisé, vous pourriez rencontrer des erreurs ou autres
problèmes.
Dans un navigateur, les données écrites par setPref() ne sont pas confidentielles. Toute
animation avec un contenu Shockwave est en mesure de lire ces informations et de les télécharger
vers un serveur. Les informations confidentielles ne doivent donc pas être stockées à l’aide de la
commande setPref().
Sous Windows, la méthode setPref() échoue si l’utilisateur dispose de droits d’accès restreints.
Pour un exemple d’utilisation de setPref() dans une animation, reportez-vous à l’animation
Read and Write Text du dossier Learning/Lingo, lui-même inclus dans le dossier de Director.
Paramètres
chaîneNomDePréf Requis. Chaîne qui spécifie le fichier dans lequel les données seront enregistrées. Le paramètre chaîneNomDePréf doit être un nom de fichier valide. Pour vous assurer de sa
validité sur toutes les plates-formes, n’utilisez pas plus de huit caractères alphanumériques dans ce
nom de fichier.
chaîneDePréf
Requis. Chaîne qui spécifie le texte à écrire dans le fichier chaîneNomDePréf.
Exemple
Le gestionnaire suivant enregistre le contenu de l’acteur champ Saisie dans un fichier nommé
PréfsActuelles :
-- Syntaxe Lingo
on mouseUp me
_player.setPref("PréfsActuelles", member("Saisie").text)
end
// Syntaxe JavaScript
function mouseUp() {
_player.setPref("PréfsActuelles", member("Saisie").text);
}
Voir aussi
getPref(), Lecteur
571
setProp
Utilisation
setProp liste, propriété, nouvelleValeur
liste.propriétéDeListe = nouvelleValeur
liste[propriétéDeListe] = nouvelleValeur
Description
Commande ; dans une liste, remplace la valeur affectée à une propriété spécifiée par une nouvelle
valeur. Si la liste ne contient pas la propriété spécifiée, setProp renvoie une erreur de script.
La commande setProp fonctionne uniquement avec les listes de propriétés. L’utilisation de
avec une liste linéaire produit une erreur de script.
setProp
Cette commande est similaire à la commande setaProp, sauf que setProp renvoie une erreur
lorsque la propriété ne se trouve pas dans la liste.
Paramètres
Requis. Symbole (Lingo uniquement) ou chaîne qui spécifie la propriété dont la
valeur est remplacée par nouvelleValeur.
propriété
nouvelleValeur
Requis. Nouvelle valeur de la propriété spécifiée par propriété.
Exemple
L’instruction suivante fait passer à 11 la valeur affectée à la propriété âge de la liste de
propriétés x :
setProp x, #âge, 11
L’opérateur point permet de modifier la valeur de propriété d’une propriété figurant déjà dans
une liste, tout comme ci-dessus :
x.âge = 11
Voir aussi
setaProp
setScriptList()
Utilisation
réfDimageObjet.setScriptList(listeDeScripts)
sprite(quelleImageObjet).setScriptList(listeDeScripts)
Description
Cette commande définit la liste scriptList de l’image-objet donnée. La liste scriptList
indique les scripts attachés à l’image-objet, ainsi que les paramètres de chaque propriété de script.
La définition de cette liste permet de modifier les paramètres attachés à une image-objet ou de
modifier les propriétés de comportement.
La liste prend la forme suivante :
[ [ (quelActeurComportement), " [ #prop1: valeur, #prop2: valeur, . . . ] ",
[(quelActeurComportement), " [ #prop1: valeur, #prop2: valeur, . . . ] " ] ]
572
Chapitre 12 : Méthodes
Cette commande ne peut pas être utilisée pendant la création du scénario. Utilisez
setScriptList() pour les images-objets ajoutées pendant l’enregistrement du scénario
après la session d’enregistrement du scénario.
Paramètres
listeDeScripts
Requis. Spécifie la liste de scripts pour une image-objet donnée.
Voir aussi
scriptList, value(), string()
settingsPanel()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.settingsPanel({entierIndexPanneau})
// Syntaxe JavaScript
réfObjImageObjet.settingsPanel({entierIndexPanneau});
Description
Commande d’image-objet Flash ; invoque la boîte de dialogue des paramètres de Flash, à
l’index de panneau indiqué. Il s’agit de la même boîte de dialogue qui est accessible en cliquant
du bouton droit (Windows) ou en cliquant avec la touche Ctrl enfoncée (Macintosh) sur une
animation Flash lue dans un navigateur.
La boîte de dialogue des paramètres ne s’affiche pas si les dimensions du rectangle de l’imageobjet Flash ne peuvent s’y adapter.
Si vous souhaitez émuler le lecteur Flash en appelant la boîte de dialogue des paramètres
lorsque l’utilisateur clique du bouton droit (Windows) ou clique avec la touche Ctrl enfoncée
(Macintosh), vous pouvez utiliser cette commande dans un gestionnaire mouseDown qui teste la
propriété rightMouseDown ou controlDown.
Pour émuler Flash Player en activant la boîte de dialogue des paramètres dans une animation
Director exécutée dans un navigateur, vous devez d’abord désactiver le menu contextuel
Shockwave Player, auquel vous accédez avec un clic sur le bouton droit (Windows) ou en
cliquant avec la touche Ctrl enfoncée (Macintosh) dans une animation avec un contenu
Shockwave lue dans un navigateur. Pour plus d’informations sur la désactivation de ce menu,
consultez les rubriques Utilisation de Director dans le panneau d'aide de Director.
Paramètres
entierIndexPanneau Facultatif. Spécifie quel panneau doit être activé à l’ouverture de la boîte
de dialogue. Les valeurs correctes sont 0, 1, 2 ou 3. Toutes les quatre ouvrent la boîte de dialogue,
la valeur 0 affichant l’onglet Contrôle de l’accès, la valeur 1 l’onglet Enregistrement local, la
valeur 2 l’onglet Microphone et la valeur 3 l’onglet Caméra. L’index de panneau par défaut est 0.
573
Exemple
L’instruction suivante ouvre le panneau des paramètres de Flash, qui présente l’onglet
Enregistrement local :
-- Syntaxe Lingo
sprite(3).settingsPanel(1)
// Syntaxe JavaScript
sprite(3).settingsPanel(1);
Voir aussi
on mouseDown (gestionnaire d’événement), rightMouseDown, controlDown
setPref()
Utilisation
-- Syntaxe Lingo
_player.setPref(chaîneNomDePréf, chaîneDePréf)
// Syntaxe JavaScript
_player.setPref(chaîneNomDePréf, chaîneDePréf);
Description
Méthode de lecteur ; écrit la chaîne spécifiée par chaîneDePréf dans le fichier spécifié par
chaîneNomDePréf sur le disque local de l’ordinateur.
L’argument chaîneNomDePréf doit correspondre à un nom de fichier valide. Pour vous assurer de
sa validité sur toutes les plates-formes, n’utilisez pas plus de huit caractères alphanumériques dans
ce nom de fichier.
Après l’exécution de la méthode setPref, si l’animation est lue dans un navigateur, un dossier
nommé Prefs est créé à l’intérieur du dossier Plug-In Support. La méthode setPref() ne peut
écrire que dans ce dossier.
Si l’animation est lue dans une projection ou dans Director, un dossier est créé dans le même
dossier que l’application. Le dossier est appelé Prefs.
N’utilisez pas cette méthode pour écrire sur un média en lecture seule. Selon la plate-forme et
la version du système d’exploitation utilisé, vous pourriez rencontrer des erreurs ou autres
problèmes.
Cette méthode n’exécute pas de manipulation complexe sur les données de la chaîne ou son
formatage. Toute opération de formatage ou autre manipulation doit être effectuée parallèlement
à getPref() ; les données peuvent ensuite être traitées en mémoire et inscrites dans l’ancien
fichier par le biais de setPref().
Dans un navigateur, les données écrites par setPref() ne sont pas confidentielles. Toute
animation avec un contenu Shockwave est en mesure de lire ces informations et de les télécharger
vers un serveur. Les informations confidentielles ne doivent donc pas être stockées à l’aide de la
commande setPref().
Sous Windows, la commande setPref() échoue si l’utilisateur dispose de droits d’accès
restreints.
Pour un exemple d’utilisation de setPref() dans une animation, reportez-vous à l’animation
Read and Write Text du dossier Learning/Lingo, lui-même inclus dans le dossier de Director.
574
Chapitre 12 : Méthodes
Paramètres
chaîneNomDePréf Requis. Chaîne qui spécifie le nom du fichier
chaîneDePréf est écrite. Le fichier est un fichier texte standard.
chaîneDePréf
dans lequel la chaîne
Requis. Chaîne à écrire dans le fichier spécifié par chaîneNomDePréf.
Exemple
Le gestionnaire suivant enregistre le contenu de l’acteur champ Saisie dans un fichier nommé
PréfsActuelles :
Voir aussi
getPref(), Lecteur
setTrackEnabled()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.setTrackEnabled(quellePiste, trueOrFalse)
// Syntaxe JavaScript
réfObjImageObjet.setTrackEnabled(quellePiste, trueOrFalse);
Description
Commande ; définit si la lecture de la piste spécifiée d’une vidéo numérique est activée.
• Si setTrackEnabled a la valeur TRUE, la piste indiquée est activée et lue.
• Si setTrackEnabled a la valeur FALSE, la piste indiquée est désactivée et n’est pas lue. Pour
les vidéos numériques, cela signifie qu’elles ne seront plus mises à jour à l’écran.
Pour tester si une piste est déjà activée, testez la propriété d’image-objet trackEnabled.
Paramètres
quellePiste
Requis. Spécifie la piste à tester.
trueOuFalse
(FALSE).
Requis. Spécifie si la piste dans la vidéo numérique est activée (TRUE) ou non
Exemple
L’instruction suivante active la piste 3 de la vidéo numérique affectée à la piste d’image-objet 8 :
-- Syntaxe Lingo
sprite(8).setTrackEnabled(3, TRUE)
// Syntaxe JavaScript
sprite(8).setTrackEnabled(3, 1);
Voir aussi
trackEnabled
575
setVariable()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.setVariable(nomDeVariable, nouvelleValeur)
// Syntaxe JavaScript
réfObjImageObjet.setVariable(nomDeVariable, nouvelleValeur);
Description
Fonction ; définit la valeur de la variable spécifiée dans l’image-objet donnée. Les variables Flash
ont été introduites dans la version 4 de Flash.
Paramètres
nomDeVariable
Requis. Spécifie le nom de la variable.
nouvelleValeur
Requis. Saisissez la nouvelle valeur de la variable.
Exemple
Les instructions suivantes définissent la valeur de la variable URLcourante dans l’acteur Flash,
au niveau de l’image-objet 3. La nouvelle valeur de la variable URLcourante sera « http://
www.macromedia.com/fr/software/flash/ ».
-- Syntaxe Lingo
sprite(3).setVariable("URLCourante", \
"http://www.macromedia.com/fr/software/flash/")
// Syntaxe JavaScript
sprite(3).setVariable("URLCourante",
"http://www.macromedia.com/fr/software/flash/");
Voir aussi
hitTest(), getVariable()
shader()
Utilisation
member(quelActeur).shader(quelMatériau)
member(quelActeur).shader[index]
member(quelActeur).model(quelModèle).shader
member(quelActeur).modelResource(quelleRessDeMod).\
face[index].shader
Description
Propriété 3D d’élément, de modèle et de face ; objet utilisé pour définir l’apparence de la surface
du modèle. Le matériau est la « peau » qui entoure la ressource de modèle utilisée par le modèle.
Le matériau même n’est pas une image. Le composant visible d’un matériau est créé avec un
maximum de huit couches de textures. Ces huit couches de texture ont été créées à partir
d’acteurs bitmap ou d’objets image dans Director ou importées avec des modèles de programmes
de modélisation 3D. Pour plus d’informations, consultez texture.
Tout modèle dispose d’une liste linéaire de matériaux appelée shaderList. Le nombre d’entrées
de la liste est égal au nombre de mailles de la ressource utilisée par le modèle. Un seul matériau
peut être appliqué à chaque maille.
576
Chapitre 12 : Méthodes
L’acteur 3D a un matériau par défaut nommé DefaultShader, qui ne peut pas être supprimé. Ce
matériau est utilisé lorsque aucun matériau n’est affecté à un modèle et lorsqu’un matériau utilisé
par un modèle est supprimé.
La syntaxe member(quelActeur).model(quelModèle).shader donne accès au premier matériau de la liste des matériaux du modèle et est équivalent à member(quelActeur).
model(quelModèle).shaderList[1].
Les matériaux sont créés et supprimés avec les commandes newShader() et deleteShader().
Les matériaux sont enregistrés dans la palette des matériaux de l’acteur 3D. Ils peuvent être
référencés par nom (quelMatériau) ou par index de palette (indexDeMatériau). Un matériau
peut être utilisé par n’importe quel nombre de modèles. Les modifications apportées à un
matériau apparaissent dans tous les modèles qui l’utilisent.
Il existe quatre types de matériaux :
Les matériaux #standard présentent leurs textures de façon réaliste.
Les matériaux #painter, #engraver et #newsprint stylisent leurs textures pour qu’elles aient
l’apparence d’une peinture, d’une gravure ou d’un journal. Ils ont des propriétés spéciales en plus
des propriétés de matériau #standard.
Les matériaux utilisés par les faces individuelles des primitives #mesh peuvent être définis à
l'aide de la syntaxe member(quelActeur).modelResource(quelleRessDeMod).
face[index].shader. Pour modifier cette propriété, il est nécessaire d’appeler la commande
build().
Exemple
L’instruction suivante affecte le matériau surfaceDuMur à la propriété de matériau du modèle
Mur.
member("Pièce").model("Mur").shader = \
member("Pièce").shader("surfaceDuMur")
Voir aussi
shaderList, newShader, deleteShader, face[ ], texture()
showLocals()
Utilisation
-- Syntaxe Lingo
showLocals()
Description
Fonction du niveau supérieur (Lingo uniquement) ; affiche toutes les variables locales dans la
fenêtre Messages. Elle n’est utile que dans les gestionnaires ou les scripts parents contenant des
variables locales à afficher. Toutes les variables utilisées dans la fenêtre Messages sont automatiquement globales.
Les variables locales des gestionnaires sont supprimées après l’exécution de ces derniers. L’insertion de l’instruction showLocals() dans un gestionnaire a pour effet d’afficher les variables locales de ce gestionnaire dans la fenêtre Messages.
Cette commande est pratique pour déboguer les scripts.
577
Paramètres
Aucun.
Voir aussi
clearGlobals(), global, showGlobals()
showProps()
Utilisation
-- Syntaxe Lingo
réfObjActeurOuImageObjet.showProps()
// Syntaxe JavaScript
réfObjActeurOuImageObjet.showProps();
Description
Commande ; affiche une liste des paramètres de propriétés actuels d’une animation Flash, d’un
acteur vectoriel ou d’un son en cours de lecture dans la fenêtre Messages. Cette commande n’est
utile que pour la programmation et ne fonctionne pas dans les projections ou les animations avec
un contenu Shockwave.
Paramètres
Aucun.
Exemple
Le gestionnaire suivant accepte le nom d’une distribution comme paramètre, recherche les acteurs
animation Flash de cette distribution et affiche le nom, le numéro et les propriétés de l’acteur
dans la fenêtre Messages :
-- Syntaxe Lingo
on AfficherPropDistribution(quelleDistribution)
repeat with i = 1 to castLib(quelleDistribution).member.count
typeDeDistribution = member(i, quelleDistribution).type
if (typeDeDistribution = #flash) OR (typeDeDistribution = #vectorShape)
then
put typeDeDistribution&&"acteur" && i & " :" && member(i,
quelleDistribution).name
put RETURN
member(i ,quelleDistribution).showProps()
end if
end repeat
end
578
Chapitre 12 : Méthodes
// Syntaxe JavaScript
function AfficherPropDistribution(quelleDistribution) {
i = 1;
while( i < (castLib(quelleDistribution).member.count) +1 ) {
typeDeDistribution = member(i, quelleDistribution).type;
if ((typeDeDistribution = "flash") || (typeDeDistribution =
"vectorShape")) {
trace (typeDeDistribution + " acteur " + i + ": " + member(i,
quelleDistribution).name) + \n;
member(i ,quelleDistribution).showProps();
i++;
}
}
}
Voir aussi
queue(), setPlayList()
showGlobals()
Utilisation
-- Syntaxe Lingo
_global.showGlobals()
// Syntaxe JavaScript
_global.showGlobals();
Paramètres
Aucun.
Description
Méthode globale ; affiche toutes les variables globales dans la fenêtre Messages.
Cette méthode est pratique pour déboguer les scripts.
Exemple
L’instruction suivante affiche toutes les variables globales dans la fenêtre Messages :
-- Syntaxe Lingo
on mouseDown
_global.showGlobals()
end
// Syntaxe JavaScript
function mouseDown() {
_global.showGlobals();
}
Voir aussi
Global
579
shutDown()
Utilisation
-- Syntaxe Lingo
_system.shutDown()
// Syntaxe JavaScript
_system.shutDown();
Description
Méthode du système ; ferme toutes les applications ouvertes et éteint l’ordinateur.
Paramètres
Aucun.
Exemple
L’instruction suivante vérifie si l’utilisateur a utilisé le raccourci clavier Ctrl-S (Windows) ou
Cmd-S (Macintosh) et, le cas échéant, éteint l’ordinateur :
Voir aussi
Système
sin()
Utilisation
sin(angle)
Description
Fonction mathématique (Lingo uniquement) ; calcule le sinus de l’angle spécifié. Celui-ci doit
être exprimé en radians sous forme de nombre à virgule flottante.
Dans la syntaxe JavaScript, utilisez la fonction sin() de l’objet Math.
Paramètres
angle
Requis. Spécifie l’angle.
Exemple
L’instruction suivante calcule le sinus de pi/2 :
put sin (PI/2.0)
-- 1
Voir aussi
PI
580
Chapitre 12 : Méthodes
sort
Utilisation
liste.sort()
sort liste
Description
Commande ; trie les éléments d’une liste par ordre alphabétique.
• S’il s’agit d’une liste linéaire, elle est triée par valeurs.
• S’il s’agit d’une liste de propriétés, elle est triée alphabétiquement par propriété.
Une fois que la liste est triée, elle le reste, même si vous ajoutez des variables avec la
commande add.
Paramètres
Aucun.
Exemple
L’instruction suivante trie la liste Valeurs qui consiste en [#a: 1, #d: 2, #c: 3], par ordre
alphabétique. Le résultat apparaît sous l’instruction.
put Valeurs
-- [#a: 1, #d: 2, #c: 3]
Valeurs.sort()
put Valeurs
-- [#a: 1, #c: 3, #d: 2]
sound()
Utilisation
-- Syntaxe Lingo
sound(entPisteAudio)
// Syntaxe JavaScript
sound(entPisteAudio);
Description
Fonction du niveau supérieur ; renvoie une référence à une piste audio spécifiée.
La fonctionnalité de cette méthode est identique à celle de la méthode channel() de l’objet Son.
Paramètres
entPisteAudio
Requis. Nombre entier qui spécifie la piste audio à référencer.
581
Exemple
L’exemple suivant affecte la piste audio 1 à une variable music et lit un son.
-- Syntaxe Lingo
music = sound(1)
music.play(member("valse1"))
// Syntaxe JavaScript
var music = sound(1);
music.play(member("valse1"));
Voir aussi
channel() (audio), Piste audio
sprite()
Utilisation
-- Syntaxe Lingo
sprite(nomOuNum)
// Syntaxe JavaScript
sprite(nomOuNum);
Description
Fonction du niveau supérieur ; renvoie une référence à une image-objet donnée dans le scénario.
Si le scénario ne contient pas cette image-objet, la fonction renvoie une chaîne vide.
Paramètres
nomOuNum
Requis. Chaîne ou nombre entier qui spécifie le nom ou la position d’index de l’image-
objet.
Exemple
Cette instruction affecte la variable cetteImageObjet à l’image-objet Grotte :
-- Syntaxe Lingo
cetteImageObjet = sprite("Grotte")
// Syntaxe JavaScript
var cetteImageObjet = sprite("Grotte");
Voir aussi
Piste d’image-objet
spriteSpaceToWorldSpace
Utilisation
sprite(quelleImageObjet).camera.spriteSpaceToWorldSpace(emplacement)
sprite(quelleImageObjet).camera(index).spriteSpaceToWorldSpace(emplacement)
Description
Commande 3D ; renvoie une position d’univers située sur le plan de projection de la caméra
spécifiée, qui correspond à un emplacement dans l’image-objet référencée.
582
Chapitre 12 : Méthodes
Le plan de projection est défini par les axes des x et y de la caméra, et sa distance devant la caméra
est telle qu’un pixel représente une unité de mesure d’univers. C’est ce plan de projection qui est
utilisé pour l’affichage de l’image-objet sur la scène.
La forme camera.spriteSpaceToWorldSpace() de cette commande est un raccourci de
camera(1).spriteSpaceToWorldSpace().
Toutes les caméras utilisées par l’image-objet référencée répondront à la commande
comme si leur rectangle d’affichage était de la même taille que
l’image-objet.
spriteSpaceToWorldSpace
Paramètres
emplacement Requis. Spécifie l’emplacement dans l’image-objet référencée. Cet emplacement
doit être un point relatif au coin supérieur gauche de l’image-objet.
Exemple
L’instruction suivante indique que le point (50, 50) de l’image-objet 5 équivaut à
vector(1993.6699, 52.0773, 2263.7446) sur le plan de projection de la caméra de l’imageobjet 5.
put sprite(5).camera.spriteSpaceToWorldSpace(point(50, 50))
-- vector( -1993.6699, 52.0773, 2263.7446 )
Voir aussi
worldSpaceToSpriteSpace, rect (caméra), camera
sqrt()
Utilisation
sqrt(nombre)
the sqrt of nombre
Description
Fonction mathématique (Lingo uniquement) ; renvoie la racine carrée d’un nombre spécifié.
La valeur doit être un nombre décimal supérieur à 0. Les valeurs négatives renvoient la valeur 0.
Dans la syntaxe JavaScript, utilisez la fonction sqrt() de l’objet Math.
Paramètres
nombre Requis. Spécifie la valeur numérique. Il peut s’agir soit d’un nombre à virgule flottante
soit d’un nombre entier arrondi au nombre entier le plus proche.
Exemple
L’instruction suivante affiche la racine carrée de 3.0 dans la fenêtre Messages :
put sqrt(3.0)
-- 1.7321
583
L'instruction suivante affiche la racine carrée de 3 dans la fenêtre Messages :
put sqrt(3)
-- 2
Voir aussi
floatPrecision
stageBottom
Utilisation
the stageBottom
Description
Fonction ; utilisée conjointement à stageLeft, stageRight et stageTop, indique la position de
la scène sur le bureau. Elle renvoie la coordonnée verticale du bord inférieur de la scène, par
rapport au coin supérieur gauche de l’écran principal. La hauteur de la scène en pixels est
déterminée par la formule the stageBottom - the stageTop.
Lorsque l’animation est lue en tant qu’applet, la propriété stageBottom correspond à la hauteur
de cet applet en pixels.
Cette fonction peut être testée, mais pas définie.
Paramètres
Aucun.
Exemple
Les instructions suivantes placent l’image-objet 3 à une distance de 50 pixels à partir du bord
inférieur de la scène :
hauteurDeLaScène = the stageBottom - the stageTop
sprite(3).locV = hauteurDeLaScène - 50
Les coordonnées des images-objets sont exprimées par rapport au coin supérieur gauche de la
scène. Pour plus d'informations, consultez les rubriques Utilisation de Director dans le panneau
d'aide de Director.
Voir aussi
stageLeft, stageRight, stageTop, locH, locV
stageLeft
Utilisation
the stageLeft
Description
Fonction ; utilisée conjointement à stageRight, stageTop et stageBottom, indique la position
de la scène sur le bureau. Elle renvoie la coordonnée horizontale gauche de la scène, par rapport
au coin supérieur gauche de l’écran principal. Lorsque le bord de la scène coïncide avec le côté
gauche de l’écran principal, cette coordonnée est 0.
584
Chapitre 12 : Méthodes
Lorsque l’animation est lue sous forme d’applet, la propriété stageLeft est 0, qui correspond à
l’emplacement du côté gauche de l’applet.
Cette propriété peut être testée, mais pas définie.
Les coordonnées des images-objets sont exprimées par rapport au coin supérieur gauche de la
scène.
Paramètres
Aucun.
Exemple
L’instruction suivante vérifie si le bord gauche de la scène dépasse le bord gauche de l’écran et, le
cas échéant, appelle le gestionnaire aGaucheDuMoniteur :
if the stageLeft < 0 then aGaucheDuMoniteur
Voir aussi
stageBottom, stageRight, stageTop, locH, locV
stageRight
Utilisation
the stageRight
Description
Fonction ; utilisée conjointement à stageLeft, stageTop et stageBottom, indique la position
de la scène sur le bureau. Elle renvoie la coordonnée horizontale droite de la scène, par rapport au
coin supérieur gauche de l’écran principal. La largeur de la scène en pixels est déterminée par la
formule the stageRight - the stageLeft.
Lorsque l’animation est lue sous forme d’applet, la propriété stageRight est la largeur de
l’applet, en pixels.
Cette fonction peut être testée, mais pas définie.
Les coordonnées des images-objets sont exprimées par rapport au coin supérieur gauche de la
scène.
Paramètres
Aucun.
Exemple
Les deux instructions suivantes placent l’image-objet 3 à une distance de 50 pixels du bord droit
de la scène :
largeurDeLaScène = the stageRight - the stageLeft
sprite(3).locH = largeurDeLaScène - 50
Voir aussi
stageLeft, stageBottom, stageTop, locH, locV
585
stageToFlash()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.stageToFlash(pointDeLaScèneDeDirector)
// Syntaxe JavaScript
réfObjImageObjet.stageToFlash(pointDeLaScèneDeDirector);
Description
Fonction ; renvoie la coordonnée d’une animation Flash correspondant à une coordonnée
spécifiée sur la scène de Director. Cette fonction accepte la coordonnée de la scène Director et
renvoie la coordonnée de l’animation Flash sous la forme de valeurs de point Director : par
exemple, point (300,300).
Les coordonnées de l’animation Flash sont mesurées en pixels d’animation Flash, déterminés par
la taille d’origine de l’animation lorsqu’elle a été créée dans Flash. Le point (0,0) d’une animation
Flash est toujours placé dans son coin supérieur gauche. La propriété originPoint de l’acteur
n’intervient pas dans le calcul des coordonnées d’une animation, mais seulement pour la rotation
et la mise à l’échelle.
La fonction stageToFlash() et la fonction flashToStage() correspondante sont pratiques
pour déterminer la coordonnée d’une animation Flash se trouvant à une coordonnée spécifique
de la scène Director. Pour Flash et Director, le point (0,0) est le coin supérieur gauche de la scène
Flash ou Director. Ces coordonnées peuvent ne pas coïncider sur la scène Director si une imageobjet Flash est étirée, mise à l’échelle ou a pivoté.
Paramètres
pointDeLaScèneDeDirector
Requis. Spécifie le point sur la scène Director.
Exemple
Le gestionnaire suivant vérifie si la souris (dont l’emplacement est suivi dans les coordonnées de la
scène Director) est placée sur une coordonnée spécifique (130,10) dans une image-objet
animation Flash placée dans la piste 5. Si la souris est placée sur cette coordonnée, le script
interrompt l’animation Flash.
-- Syntaxe Lingo
on checkFlashRollover
if (sprite(5).stageToFlash(point(_mouse.mouseH, _mouse.mouseV)) =
point(130,10) then
sprite(5).stop()
end if
end
// Syntaxe JavaScript
function checkFlashRollover() {
var stf = sprite(5).stageToFlash(point(_mouse.mouseH,_mouse.mouseV));
if (stf = point(130,10)) {
sprite(5).stop();
}
}
Voir aussi
flashToStage()
586
Chapitre 12 : Méthodes
stageTop
Utilisation
the stageTop
Description
Fonction ; utilisée conjointement à stageBottom, stageLeft et stageRight, indique la position
de la scène sur le bureau. Elle renvoie la coordonnée verticale supérieure de la scène par rapport au
coin supérieur gauche de l’écran principal. Si la scène est dans le coin supérieur gauche de l’écran
principal, cette coordonnée est 0.
Lorsque l’animation est lue en tant qu’applet, la valeur de la propriété stageTop est toujours zéro,
l’emplacement du bord supérieur de l’applet.
Cette fonction peut être testée, mais pas définie.
Les coordonnées des images-objets sont exprimées par rapport au coin supérieur gauche de la
scène.
Paramètres
Aucun.
Exemple
L’instruction suivante vérifie si le bord supérieur de la scène dépasse le bord supérieur de l’écran
et, le cas échéant, appelle le gestionnaire débordementEnHaut :
if the stageTop < 0 then débordementEnHaut
Voir aussi
stageLeft, stageRight, stageBottom, locH, locV
status()
Utilisation
-- Syntaxe Lingo
réfObjFileio.status()
// Syntaxe JavaScript
réfObjFileio.status();
Description
Méthode de Fileio ; renvoie le code d’erreur de la dernière méthode appelée.
Paramètres
Aucun.
Voir aussi
Fileio
587
stop() (DVD)
Utilisation
-- Syntaxe Lingo
réfObjDvd.stop()
// Syntaxe JavaScript
réfObjDvd.stop();
Description
Méthode de DVD ; arrête la lecture.
Cette méthode renvoie TRUE (1) en cas de réussite.
Paramètres
Aucun.
Voir aussi
DVD
stop() (piste audio)
Utilisation
-- Syntaxe Lingo
réfObjPisteAudio.stop()
// Syntaxe JavaScript
réfObjPisteAudio.stop();
Description
Méthode de piste audio ; arrête le son qui est en cours de lecture sur une piste audio.
L’émission d’une méthode play() commence la lecture du premier son encore présent dans la file
d’attente de la piste audio donnée.
Pour un exemple d’utilisation de stop() dans une animation, reportez-vous à l’animation Sound
Control du dossier Learning/Lingo, lui-même inclus dans le dossier de Director.
Paramètres
Aucun.
Exemple
L’instruction suivante arrête la lecture de l’acteur son en cours de lecture dans la piste audio 1 :
-- Syntaxe Lingo
sound(1).stop()
// Syntaxe JavaScript
sound(1).stop();
Voir aussi
getPlayList(), pause() (piste audio), play() (piste audio), playNext() (piste
audio), rewind() (piste audio), Piste audio
588
Chapitre 12 : Méthodes
stop() (Flash)
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.stop()
// Syntaxe JavaScript
réfObjImageObjet.stop();
Description
Commande Flash ; interrompt une image-objet animation Flash lue dans l’image courante.
Paramètres
Aucun.
Exemple
Le script d’image suivant interrompt les images de l’animation Flash lues dans les pistes 5 à 10 :
-- Syntaxe Lingo
on enterFrame
repeat with i = 5 to 10
sprite(i).stop()
end repeat
end
// Syntaxe JavaScript
function enterFrame() {
var i = 5;
while (i < 11) {
sprite(i).stop();
i++;
}
}
Voir aussi
hold()
stop() (RealMedia, SWA, Windows Media)
Utilisation
-- Syntaxe Lingo
réfObjWindowsMedia.stop()
réfObjRealMedia.stop()
// Syntaxe JavaScript
réfObjWindowsMedia.stop();
réfObjRealMedia.stop();
Description
Méthode d’acteur ou d’image-objet Windows Media ou RealMedia. Arrête la lecture d’un acteur
ou d’une image-objet Windows Media ou RealMedia.
Paramètres
Aucun.
589
Exemple
Les exemples suivants arrêtent la lecture de l’image-objet 2 et de l’acteur Real :
-- Syntaxe Lingo
sprite(2).stop()
member("Real").stop()
// Syntaxe JavaScript
sprite(2).stop();
member("Real").stop();
Voir aussi
RealMedia, Windows Media
stopEvent()
Utilisation
-- Syntaxe Lingo
_movie.stopEvent()
// Syntaxe JavaScript
_movie.stopEvent();
Description
Méthode d’animation ; empêche les scripts de passer un message d’événement aux emplacements
suivants dans la hiérarchie de messages.
Cette méthode s’applique également aux scripts d’images-objets.
Utilisez la méthode stopEvent() pour arrêter le message dans un gestionnaire d’événement
principal ou un script d’image-objet, et rendre ainsi le message non disponible pour les scripts
d’images-objets suivants.
Par défaut, les messages sont d’abord mis à la disposition d’un gestionnaire d’événement principal
(s’il existe), puis à celle de tous les scripts associés à une image-objet impliquée dans l’événement.
Si plusieurs scripts sont associés à l’image-objet, le message est mis à la disposition de tous les
scripts de l’image-objet. Si aucun script d’image-objet ne répond au message, celui-ci passe à un
script d’acteur, puis à un script d’image et enfin à un script d’animation.
La méthode stopEvent() ne s’applique qu’à l’événement courant en cours de traitement. Elle
n’affecte pas les événements futurs. La commande stopEvent() ne s’applique qu’aux gestionnaires d’événements principaux, aux gestionnaires appelés par des gestionnaires d’événements
principaux ou à plusieurs scripts d’images-objets. Elle n’a aucun effet ailleurs.
Paramètres
Aucun.
590
Chapitre 12 : Méthodes
Exemple
L’instruction suivante montre l’événement mouseUp interrompu dans un comportement lorsque
la variable globale totalGénéral est égale à 500 :
-- Syntaxe Lingo
global totalGénéral
on mouseUp me
if (totalGénéral = 500) then
_movie.stopEvent()
end if
end
// Syntaxe JavaScript
_global.totalGénéral;
function mouseUp() {
if (_global.totalGénéral == 500) {
_movie.stopEvent();
}
}
Les autres comportements ou les scripts ultérieurs sur l’image-objet ne reçoivent pas l’événement
s’il est interrompu de cette manière.
Voir aussi
Animation
stream()
Utilisation
-- Syntaxe Lingo
réfObjActeur.stream(nombreDoctets)
// Syntaxe JavaScript
réfObjActeur.stream(nombreDoctets);
Description
Commande ; permet de faire passer manuellement en mémoire une partie d’un acteur animation
Flash spécifié.
La commande stream renvoie le nombre d’octets réellement chargés. En fonction d’un ensemble
de conditions variées (telles que la vitesse du réseau ou la disponibilité des données requises), le
nombre d’octets réellement chargés peut être inférieur au nombre d’octets requis.
Vous pouvez toujours utiliser la commande stream pour un acteur, quelle que soit sa propriété
streamMode.
Paramètres
nombreDoctets Facultatif. Nombre entier qui spécifie combien d’octets à lire en flux continu. Si
vous omettez le paramètre nombreDoctets, Director essaie de lire le nombre d’octets défini par la
propriété bufferSize de l’acteur.
591
Exemple
Le script d’image suivant vérifie si un acteur animation Flash liée a été complètement chargé en
mémoire en contrôlant sa propriété percentStreamed. Si l’acteur n’est pas chargé en mémoire à
cent pour cent, le script tente de charger 32 000 octets de l’animation en mémoire.
Le script enregistre également le nombre réel d’octets chargés dans une variable intitulée
Si le nombre d’octets chargés ne correspond pas au nombre d’octets requis, le
script met à jour un acteur texte pour indiquer le nombre d’octets réellement reçus. Le script
contraint la tête de lecture à passer en boucle dans l’image courante jusqu’à ce que l’acteur soit
complètement chargé en mémoire.
octetsReçus.
-- Syntaxe Lingo
on exitFrame
if member(10).percentStreamed < 100 then
octetsReçus = member(10).stream(32000)
if octetsReçus < 32000 then
member("Ligne de message").text = "Reçus :" && octetsReçus \
&& "sur les 32 000 demandés."
_movie.updateStage()
else
member("Ligne de message").text = "Les 32 000 octets ont été reçus."
end if
_movie.go(_movie.frame)
end if
end
// Syntaxe JavaScript
function exitFrame() {
var pctStm = member(10).percentStreamed;
if (pctStm < 100) {
var octetsReçus = member(10).stream(32000);
if (octetsReçus < 32000) {
member("Ligne de message").text = "Reçus :" + octetsReçus + " sur les
32 000 demandés.";
_movie.updateStage();
} else {
member("Ligne de message").text = "Les 32 000 octets ont été reçus.";
}
_movie.go(_movie.frame);
}
}
string()
Utilisation
string(expression)
Description
Fonction ; convertit en chaîne un nombre entier, un nombre à virgule flottante, une référence
d’objet, une liste, un symbole ou toute autre expression n’existant pas sous la forme d’une chaîne.
Paramètres
expression
592
Requis. Expression à convertir en chaîne.
Chapitre 12 : Méthodes
Exemple
L’instruction suivante additionne 2.0 + 2.5 et insère le résultat dans l’acteur champ Total :
member("Total").text = string(2.0 + 2.5)
L’instruction suivante convertit le symbole #rouge en une chaîne et l’insère dans l’acteur champ
Couleur :
member("Couleur").text = string(#rouge)
Voir aussi
value(), stringP(), float(), integer(), symbol()
stringP()
Utilisation
stringP(expression)
Description
Fonction ; détermine si une expression est une chaîne (TRUE) ou non (FALSE).
Le P de stringP signifie prédicat.
Paramètres
expression
Requis. Expression à tester.
Exemple
L’instruction suivante vérifie si 3 est une chaîne :
put stringP("3")
Le résultat est 1, équivalent numérique de TRUE.
L’instruction suivante vérifie si le nombre à virgule flottante 3,0 est une chaîne :
put stringP(3.0)
Puisque 3,0 est un nombre à virgule flottante et non une chaîne, le résultat est 0, équivalent
numérique de FALSE.
Voir aussi
floatP(), ilk(), integerP(), objectP(), symbolP()
subPictureType()
Utilisation
-- Syntaxe Lingo
réfObjDvd.subPictureType(entFlux)
// Syntaxe JavaScript
réfObjDvd.subPictureType(entFlux);
Description
Méthode de DVD ; spécifie le type d’un flux de sous-images donné.
593
Cette méthode peut renvoyer les valeurs suivantes :
Symbole
Description
#unknown
Le type de sous-image est inconnu.
#Language
La sous-image inclut un contenu lié à la langue, par exemple, des sous-titres ou
d’autres textes.
#Other
La sous-image inclut un contenu non lié à la langue, par exemple, une balle qui
rebondit entre les titres d’un karaoké.
Paramètres
entFlux
Requis. Nombre entier qui spécifie le flux à tester.
Exemple
Cette instruction renvoie le type de sous-image du flux 2 :
-- Syntaxe Lingo
sprite(12).member.subPictureType(2)
// Syntaxe JavaScript
sprite(12).member.subPictureType(2);
Voir aussi
DVD
substituteFont
Utilisation
TextMemberRef.substituteFont(policeDorigine, nouvellePolice)
substituteFont(réfDacteurTexte, policeDorigine, nouvellePolice)
Description
Commande d’acteur texte ; remplace toutes les instances d’une police par une autre police dans
un acteur texte.
Paramètres
policeDorigine
Requis. Police à remplacer.
nouvellePolice
Requis. La nouvelle police remplace la police spécifiée par policeDorigine.
Exemple
Le script suivant vérifie si la police Bonneville est disponible dans un acteur texte et, dans la
négative, la remplace par Arial :
-- Syntaxe Lingo
property spriteNum
on beginSprite me
acteurCourant = sprite(spriteNum).member
if acteurCourant.missingFonts contains "Bonneville" then
acteurCourant.substituteFont("Bonneville", "Arial")
end if
end
594
Chapitre 12 : Méthodes
// Syntaxe JavaScript
function beginSprite() {
acteurCourant = sprite(spriteNum).member;
if (acteurCourant.missingFonts contains "Bonneville") { //vérifier la
syntaxe
acteurCourant.substituteFont("Bonneville", "Arial");
}
}
Voir aussi
missingFonts
swing()
Utilisation
-- Syntaxe Lingo
réfObjImageObjet.swing(pan, inclin, champDeVue, vitesseDeMouv)
// Syntaxe JavaScript
réfObjImageObjet.swing(pan, inclin, champDeVue, vitesseDeMouv);
Description
Fonction d’image-objet QuickTime VR ; déplace une image-objet QuickTime 3 contenant un
panoramique autour de nouveaux réglages de vue. Cette fonction produit un effet de travelling
régulier.
réfObjImageObjet
désigne le numéro de l’image-objet contenant l’acteur QuickTime VR.
Cette fonction renvoie immédiatement une valeur, mais l’image-objet continue de changer de
vue jusqu’à ce que la vue finale soit atteinte. La durée requise pour arriver aux paramètres finaux
varie en fonction du type d’ordinateur, de la taille du rectangle de l’image-objet, du codage des
couleurs et d’autres paramètres affectant la performance.
Pour vérifier si le mouvement est terminé, vérifiez si la propriété pan de l’image-objet est arrivée à
la valeur finale.
Paramètres
pan
Requis. Spécifie la nouvelle position panoramique, en degrés.
inclin
Requis. Spécifie la nouvelle inclinaison, en degrés.
champDeVue
Requis. Spécifie le nouveau champ de vue, en degrés.
Requis. Spécifie la vitesse à laquelle le mouvement doit s’effectuer. Les valeurs
correctes sont comprises entre 1 (lent) et 10 (rapide).
vitesseDeMouv
595
Exemple
Ceci permet d’ajuster graduellement l’affichage de l’image-objet QuickTime VR dans une
position panoramique de 300°, une inclinaison de -15° et un champ de vue de 40°.
-- Syntaxe Lingo
sprite(1).swing(300, -15, 40, 1)
// Syntaxe JavaScript
sprite(1).swing(300, -15, 40, 1);
Voir aussi
pan (propriété QTVR)
symbol()
Utilisation
-- Syntaxe Lingo
symbol(valeurDeChaîne)
// Syntaxe JavaScript
symbol(valeurDeChaîne);
Description
Fonction du niveau supérieur ; prend une chaîne et renvoie un symbole.
Paramètres
valeurDeChaîne
Requis. Chaîne à convertir en symbole.
Exemple
L’instruction suivante affiche le symbole #bonjour :
-- Syntaxe Lingo
put(symbol("bonjour"))
// Syntaxe JavaScript
put(symbol("bonjour"));
L’instruction suivante affiche le symbole #auRevoir :
-- Syntaxe Lingo
x = "auRevoir"
put(symbol(x))
// Syntaxe JavaScript
var x = "auRevoir";
put(symbol(x));
Voir aussi
value(), string()
596
Chapitre 12 : Méthodes
symbolP()
Utilisation
expression.symbolP
symbolP(expression)
Description
Fonction ; détermine si une expression spécifiée est un symbole (TRUE) ou non (FALSE).
Le P de symbolP signifie prédicat.
Paramètres
expression
Requis. Spécifie l’expression à tester.
Exemple
L’instruction suivante vérifie si la variable maVariable est un symbole :
put maVariable.symbolP
Voir aussi
ilk()
tan()
Utilisation
tan(angle)
Description
Fonction mathématique ; renvoie la tangente de l’angle spécifié exprimée en radians sous forme
de nombre à virgule flottante.
Dans la syntaxe JavaScript, utilisez la fonction tan() de l’objet Math.
Paramètres
angle
Requis. Spécifie l’angle à partir duquel une tangente est calculée.
Exemple
La fonction suivante renvoie la tangente de pi/4 :
tan (PI/4.0) = 1
Le symbole π ne peut pas être utilisé dans une expression Lingo.
Voir aussi
PI
597
tellStreamStatus()
Utilisation
tellStreamStatus(booléenActivéOuDésactivé)
Description
Fonction ; active (TRUE) ou désactive (FALSE) le rapport de l’état de la lecture en flux continu.
La forme tellStreamStatus() détermine l’état du gestionnaire.
Lorsque streamStatusHandler a la valeur TRUE, l’activité de lecture en flux continu sur
Internet provoque des appels périodiques du script de l’animation, déclenchant le gestionnaire
streamStatusHandler. Le gestionnaire est alors exécuté, Director remplissant automatiquement
les paramètres avec des informations concernant l’évolution des téléchargements.
Paramètres
booléenActivéOuDésactivé
Facultatif. Spécifie l’état du gestionnaire.
Exemple
Le gestionnaire on prepareMovie suivant active le gestionnaire on streamStatus au démarrage
de l’animation :
-- Syntaxe Lingo
on prepareMovie
tellStreamStatus(TRUE)
end
// Syntaxe JavaScript
function prepareMovie() {
tellStreamStatus(TRUE);
}
L’instruction suivante détermine l’état du gestionnaire d’état de la lecture en flux continu :
-- Syntaxe Lingo
on mouseDown
put tellStreamStatus()
end
// Syntaxe JavaScript
function mouseDown() {
put(tellStreamStatus());
}
Voir aussi
on streamStatus
598