Utilisation des objets

ActionScript constitue ce que l’on appelle un langage de programmation orienté objet. Un langage de programmation orienté objet est une simple approche de la programmation, rien d’autre qu’une manière d’organiser le code d’un programme à l’aide d’objets.

Nous avons défini plus haut un « programme informatique » comme une série de procédures ou d’instructions que l’ordinateur effectue. Nous pouvons alors considérer qu’un programme informatique n’est qu’une longue liste d’instructions. Dans le cas de la programmation orientée objets, cependant, les instructions du programme se divisent en différents objets : le code étant rassemblé en groupes de fonctionnalités, un même conteneur réunit des types de fonctionnalités et des informations connexes.

Adobe Flash Professional

Si vous avez travaillé avec des symboles dans Flash Professional, vous savez déjà manipuler les objets. Imaginons que vous ayez défini un symbole de clip (le dessin d’un rectangle, par exemple) et vous en ayez placé une copie sur la scène. Ce symbole de clip constitue aussi un objet (au sens littéral) dans ActionScript ; il s’agit d’une occurrence de la classe MovieClip.

Vous avez la possibilité de modifier plusieurs caractéristiques du clip. Lorsqu’il est sélectionné, vous pouvez modifier certaines valeurs de l’Inspecteur des propriétés, telles que la coordonnée x ou la largeur. Vous pouvez également effectuer différents réglages de couleur comme la transparence alpha, ou encore lui appliquer un filtre d’ombre portée. D’autres outils Flash Professional permettent d’effectuer davantage de modifications, par exemple l’outil Transformation libre pour faire pivoter le rectangle. Toutes ces actions de transformation du symbole de clip disponibles dans Flash Professional le sont également dans ActionScript. Pour les utiliser, vous devez modifier les données réunies dans un ensemble appelé objet MovieClip.

Dans la programmation orientée objets que propose ActionScript, chaque classe comprend trois types de caractéristiques :

  • Propriétés

  • Méthodes

  • Evénements

Ces éléments servent à gérer les données que le programme utilise, et à déterminer les actions à exécuter ainsi que l’ordre d’exécution.

Propriétés

Une propriété représente l’une des données réunies dans un objet. Un objet song, par exemple, peut présenter des propriétés appelées artist et title. La classe MovieClip possède des propriétés telles que rotation, x, width et alpha. Les propriétés s’utilisent comme des variables individuelles. On pourrait même les envisager comme les variables « enfant » d’un objet.

Voici des exemples de code ActionScript utilisant des propriétés. Cette ligne de code déplace l’objet MovieClip nommé square vers la coordonnée x de 100 pixels :

square.x = 100;

Le code ci-après utilise la propriété rotation pour faire pivoter le MovieClip square de manière à lui donner la même orientation que le MovieClip triangle :

square.rotation = triangle.rotation;

Ce code modifie l’échelle horizontale du MovieClip square pour qu’il soit une fois et demie plus large que précédemment :

square.scaleX = 1.5;

Observez la structure commune : vous utilisez une variable (square, triangle) comme nom de l’objet, suivi d’un point() puis du nom de la propriété (x, rotation, scaleX). Le point, ou opérateur point, sert à indiquer que vous accédez à l’un des éléments enfant d’un objet. La structure dans son ensemble, « nom de variable-point-nom de propriété » est utilisée telle une variable, comme le nom d’une valeur unique dans la mémoire de l’ordinateur.

Méthodes

Une méthode est une action qui peut être effectuée par un objet. Par exemple, si vous avez élaboré, dans Flash Professional, un symbole de clip dont le scénario contient plusieurs images clés et animations, ce clip peut être lu ou arrêté, ou recevoir l’instruction de placer la tête de lecture sur une image donnée.

Le code ci-dessous indique au MovieClip nommé shortFilm de commencer la lecture :

shortFilm.play();

Cette ligne de code arrête la lecture du MovieClip shortFilm (la tête de lecture s’arrête à l’endroit où elle se trouve, comme lorsque vous mettez une vidéo en pause) :

shortFilm.stop();

Ce code-ci indique au MovieClip shortFilm de placer la tête de lecture sur Frame 1 et d’arrêter la lecture (comme si vous rembobiniez une vidéo) :

shortFilm.gotoAndStop(1);

L’accès aux méthodes, comme pour les propriétés, s’effectue en écrivant le nom de l’objet (une variable) suivi d’un point puis du nom de la méthode et de parenthèses. Les parenthèses servent à indiquer que vous appelez la méthode, c’est-à-dire, que vous demandez à l’objet d’effectuer une action. Il arrive que des valeurs (ou variables) soient placées dans ces parenthèses de manière à transmettre des informations supplémentaires nécessaires à l’exécution de l’action. On appelle ces valeurs des paramètres de méthode. Par exemple, la méthode gotoAndStop() doit savoir quelle image atteindre ; un paramètre est donc requis dans les parenthèses. D’autres méthodes, telles play() et stop(), ont une signification univoque et n’ont donc besoin d’aucune information complémentaire. Elles sont néanmoins suivies de parenthèses.

Contrairement aux propriétés (et aux variables), les méthodes ne servent pas d’espaces réservés. Certaines méthodes peuvent cependant effectuer des calculs et renvoyer des résultats pouvant servir de variables. C’est le cas de la méthode toString() de la classe Number, qui convertit une valeur numérique en une représentation textuelle :

var numericData:Number = 9; 
var textData:String = numericData.toString();

Par exemple, vous pouvez utiliser la méthode toString() si vous souhaitez afficher la valeur d’une variable Number dans un champ de texte à l’écran. La propriété text de la classe TextField (qui représente le contenu textuel réel affiché à l’écran) se définit comme une chaîne (String), de sorte qu’elle ne puisse contenir que des valeurs textuelles. Cette ligne de code convertit la valeur numérique de la variable numericData en texte, puis la fait apparaître à l’écran dans l’objet TextField nommé calculatorDisplay :

calculatorDisplay.text = numericData.toString();

Evénements

Un programme informatique est une série d’instructions que l’ordinateur exécute l’une après l’autre. Certains programmes très simples ne sont rien de plus : l’ordinateur exécute quelques procédures, puis le programme se termine. Toutefois, les programmes ActionScript sont conçus pour poursuivre leur exécution, dans l’attente d’une saisie utilisateur, par exemple. Les événements sont des mécanismes qui déterminent quelles instructions l’ordinateur doit exécuter et à quel moment.

Par essence, les événements sont des faits qui surviennent et auxquels ActionScript peut répondre parce qu’il en est conscient au moment où ils se produisent. De nombreux événements sont liés à l’interaction de l’utilisateur, par exemple un clic sur un bouton ou une pression sur une touche du clavier. Il existe néanmoins d’autres types d’événements. Par exemple, si vous utilisez ActionScript pour charger une image externe, il existe un événement capable de vous prévenir lorsque le chargement de l’image est terminé. Pendant son exécution, un programme ActionScript attend que des événements se produisent et, lorsque c’est le cas, il exécute le code ActionScript que vous avez spécifié en réponse.

Gestion des événements de base

La gestion des événements est la technique qui permet de spécifier les actions à exécuter en réponse à des événements particuliers. Lors de l’écriture de code ActionScript en vue de la gestion des événements, trois éléments importants sont à identifier :

  • Source de l’événement : quel objet sera concerné par l’événement ? Par exemple, sur quel bouton a eu lieu le clic ou quel est l’objet Loader qui charge l’image ? La source de l’événement est également appelée cible de l’événement car elle représente l’objet où l’événement est ciblé (là où l’événement a lieu).

  • Evénement : que doit-il se passer, à quel événement voulez-vous répondre? Il est important d’identifier correctement l’événement, car de nombreux objets déclenchent plusieurs événements.

  • Réponse : quelles actions doivent être exécutées lorsque l’événement se produit ?

Tout code ActionScript de gestion des événements doit contenir ces trois éléments et respecter la structure de base suivante (les éléments en gras sont des espaces réservés à remplir selon le cas envisagé) :

function eventResponse(eventObject:EventType):void 
{ 
    // Actions performed in response to the event go here. 
} 
  
eventSource.addEventListener(EventType.EVENT_NAME, eventResponse);

Ce code a un double rôle. Tout d’abord, il définit une fonction, qui est une manière de spécifier les actions à exécuter en réponse à l’événement. Ensuite, il appelle la méthode addEventListener() de l’objet source, « inscrivant » ainsi la fonction auprès de l’événement spécifié de manière que, dès que l’événement survient, les actions de la fonction aient lieu. Nous allons étudier chacun de ces rôles en détail.

Une fonction sert à regrouper des actions sous un nom unique, un raccourci qui vous permet de les exécuter. La fonction est identique à la méthode, à cette exception près qu’elle n’est pas nécessairement associée à une classe particulière (on pourrait d’ailleurs définir la méthode ainsi : une fonction associée à une classe donnée). Lorsque vous créez une fonction de gestion des événements, vous devez choisir le nom de la fonction (dans ce cas eventResponse) mais aussi spécifier un paramètre (eventObject) dans cet exemple). La spécification d’un paramètre de fonction ressemble à la déclaration de variable ; vous devez dans ce cas aussi indiquer le type de données du paramètre (EventType, dans cet exemple).

Chaque type d’événement que vous souhaitez écouter est associé à une classe ActionScript. Le type de données que vous spécifiez pour le paramètre de fonction correspond systématiquement à la classe associée à l’événement auquel vous souhaitez réagir. Par exemple, un événement click (déclenché par un clic de souris sur un élément) est associé à la classe MouseEvent. Pour écrire une fonction d’écouteur pour un événement click, vous lui associez un paramètre de type MouseEvent. Enfin, entre les accolades d’ouverture et de fermeture ({ ... }), vous placez les instructions que l’ordinateur doit exécuter lorsque l’événement a lieu.

La fonction de gestion de l’événement est écrite. Vous indiquez ensuite à l’objet source (celui qui provoque l’événement, par exemple le bouton) que cette fonction doit être appelée lorsque l’événement survient. Pour ce faire, vous appelez la méthode addEventListener() de cet objet (tous les objets liés à des événements ont également une méthodeaddEventListener()). La méthode addEventListener() réclame deux paramètres :

  • Tout d’abord, le nom de l’événement auquel vous voulez répondre. Chaque événement est affilié à une classe spécifique pour laquelle est définie une valeur propre à chacun d’eux (en quelque sorte le nom unique de l’événement). Cette valeur sert de premier paramètre.

  • Vient ensuite le nom de votre fonction de réponse à l’événement. Sachez qu’un nom de fonction est écrit sans parenthèses lors du transfert en tant que paramètre.

Processus de gestion d’événement

Vous trouverez ci-dessous une description détaillée du processus ayant lieu lorsque vous créez un écouteur d’événements. Dans ce cas, il s’agit d’un exemple illustrant la création d’une fonction d’écouteur appelée lorsque vous cliquez sur un objet myButton.

Le code écrit par le programmeur est le suivant :

function eventResponse(event:MouseEvent):void 
{ 
    // Actions performed in response to the event go here. 
} 
 
myButton.addEventListener(MouseEvent.CLICK, eventResponse);

Voici comment ce code devrait fonctionner lorsqu’il est exécuté :

  1. Lors du chargement du fichier SWF, l’ordinateur remarque qu’il existe une fonction eventResponse().

  2. Il exécute ensuite le code (notamment les lignes de code qui ne sont pas dans une fonction). Dans ce cas, il s’agit d’une seule ligne de code : l’appel de la méthode addEventListener() sur l’objet source de l’événement (myButton) et la transmission de la fonction eventResponse en tant que paramètre.

    En interne, myButton a une liste des fonctions qui écoutent chaque événement. Lorsque sa méthode addEventListener() est appelée, myButton stocke la fonction eventResponse() dans sa liste d’écouteurs d’événements.

  3. A un certain moment, l’utilisateur clique sur l’objet myButton et déclenche ainsi son événement click (identifié comme MouseEvent.CLICK dans le code).

    A ce stade, les opérations suivantes ont lieu :

    1. Un objet est créé, une occurrence de la classe associée à l’événement en question (MouseEvent dans cet exemple). Pour de nombreux événements, il s’agit d’une occurrence de la classe Event ; pour des événements de souris, une occurrence de MouseEvent et pour d’autres événements, une occurrence de la classe qui leur est associée. L’objet créé est appelé l’objet événement. Il contient des informations spécifiques sur l’événement qui s’est produit : son type, l’emplacement où il a eu lieu et toute autre information pertinente.

    2. L’ordinateur consulte ensuite la liste des écouteurs d’événements stockés par myButton. Il parcourt ces fonctions l’une après l’autre en les appelant et en transmettant l’objet événement à la fonction en tant que paramètre. Etant donné que la fonction eventResponse() est l’un des écouteurs de myButton, l’ordinateur appelle la fonction eventResponse() dans le cadre de ce processus.

    3. Lorsque la fonction eventResponse() est appelée, le code qu’elle contient est exécuté et vos actions spécifiées sont effectuées.

Exemples de gestion d’événements

Voici quelques exemples plus concrets d’événements qui vous donneront une idée des éléments les plus courants et des variations que vous pourrez utiliser lors de l’écriture de votre propre code de gestion des événements :

  • Clic sur un bouton pour lancer la lecture du clip actif. Dans l’exemple suivant, playButton est le nom d’occurrence du bouton et this est un nom spécial qui signifie « l’objet actif» :

    this.stop(); 
     
    function playMovie(event:MouseEvent):void 
    { 
        this.play(); 
    } 
     
    playButton.addEventListener(MouseEvent.CLICK, playMovie);
  • Détection de la saisie dans un champ de texte. Dans cet exemple, entryText est un champ de saisie de texte et outputText est un champ de texte dynamique :

    function updateOutput(event:TextEvent):void 
    { 
        var pressedKey:String = event.text; 
        outputText.text = "You typed: " + pressedKey; 
    } 
     
    entryText.addEventListener(TextEvent.TEXT_INPUT, updateOutput);
  • Clic sur un bouton pour atteindre une URL. Dans ce cas, linkButton est le nom d’occurrence du bouton :

    function gotoAdobeSite(event:MouseEvent):void 
    { 
        var adobeURL:URLRequest = new URLRequest("http://www.adobe.com/"); 
        navigateToURL(adobeURL); 
    } 
     
    linkButton.addEventListener(MouseEvent.CLICK, gotoAdobeSite);

Création d’occurrences d’objets

Pour utiliser un objet dans ActionScript, cet objet doit exister. La création d’un objet repose en partie sur la déclaration d’une variable. Toutefois, celle-ci crée uniquement un emplacement vide dans la mémoire de l’ordinateur. Avant d’utiliser ou de manipuler une variable, attribuez-lui toujours une valeur réelle (en créant un objet et en le stockant dans la variable). Le processus de création d’un objet est appelé instanciation de l’objet, soit la création d’une occurrence d’une classe particulière.

La création d’une occurrence d’objet peut passer par une méthode simple qui n’implique pas ActionScript. Dans Flash Professional, placez un symbole de clip, un symbole de bouton ou un champ de texte sur la scène, puis attribuez-lui un nom d’occurrence. L’application déclare automatiquement une variable dotée de ce nom d’occurrence, crée une occurrence d’objet et stocke cet objet dans la variable. Il en va de même dans Flex : vous créez un composant MXML, soit par codage d’une balise MXML, soit en plaçant le composant dans l’éditeur de Flash Builder en mode Création. Lorsque vous lui attribuez un identifiant, celui-ci devient le nom d’une variable ActionScript contenant une occurrence de ce composant.

Toutefois, il n’est pas toujours possible de créer un objet visuellement (notamment dans le cas des objets non visuels). Plusieurs méthodes permettent aussi de créer des occurrences d’objet à l’aide d’ActionScript uniquement.

A partir de plusieurs types de données ActionScript, vous pouvez créer une occurrence en utilisant une expression littérale, une valeur écrite directement dans le code ActionScript. Voici quelques exemples :

  • Valeur numérique littérale (entrez le nombre directement) :

    var someNumber:Number = 17.239; 
    var someNegativeInteger:int = -53; 
    var someUint:uint = 22;
  • Valeur de chaîne littérale (entourez le texte de doubles guillemets) :

    var firstName:String = "George"; 
    var soliloquy:String = "To be or not to be, that is the question...";
  • Valeur booléenne littérale (utilisez la valeur littérale true ou false) :

    var niceWeather:Boolean = true; 
    var playingOutside:Boolean = false;
  • Valeur de tableau littérale (placez entre crochets une liste de valeurs séparées par des virgules) :

    var seasons:Array = ["spring", "summer", "autumn", "winter"];
  • Valeur XML littérale (entrez le XML directement) :

    var employee:XML = <employee> 
            <firstName>Harold</firstName> 
            <lastName>Webster</lastName> 
        </employee>;

ActionScript définit également des expressions littérales pour les types de données Array, RegExp, Object et Function.

Pour tout type de données, le plus simple consiste à créer une occurrence d’objet à l’aide de l’opérateur new et du nom de classe, comme suit :

var raceCar:MovieClip = new MovieClip(); 
var birthday:Date = new Date(2006, 7, 9);

Pour cette méthode de création d’un objet à l’aide de l’opérateur new, on parle souvent « d’appeler le constructeur de la classe ». Un constructeur est une méthode spéciale qui est appelée dans le cadre de la création d’une occurrence de classe. Notez que lorsque vous créez une occurrence ainsi, vous placez des parenthèses après le nom de classe et spécifiez parfois des valeurs de paramètres dans les parenthèses, comme vous le faites lorsque vous appelez une méthode.

Vous pouvez utiliser l’opérateur new pour créer une occurrence d’objet, même pour les types de données qui permettent de créer des occurrences avec une expression littérale. Par exemple, ces deux lignes de code produisent le même résultat :

var someNumber:Number = 6.33; 
var someNumber:Number = new Number(6.33);

Il est important de se familiariser avec la méthode new NomClasse() de création d’objets. De nombreux types de données ActionScript ne disposent pas de représentation visuelle. Il est donc impossible de les créer en plaçant un élément sur la scène de Flash Professional ou en mode Création dans l’éditeur MXML de Flash Builder. Dans ce cas, vous pouvez uniquement créer une occurrence dans ActionScript à l’aide de l’opérateur new.

Adobe Flash Professional

Dans Flash Professional, l’opérateur new peut en outre servir à créer une occurrence d’un symbole de clip défini dans la bibliothèque sans être placé sur la scène.