DisplayObject  - AS3

Options d’accessibilité actuelles de l’objet d’affichage. Si vous modifiez la propriété accessibilityProperties ou l’un de ses champs dans accessibilityProperties, vous devez appeler la méthode Accessibility.updateProperties() pour appliquer vos modifications.

Remarque : pour tout objet créé dans l’environnement de création de Flash, la valeur de accessibilityProperties est préremplie avec les informations que vous avez entrées dans le panneau Accessibilité pour cet objet.

Eléments de l’API associés

import flash.text.TextField;
import flash.accessibility.AccessibilityProperties;
import flash.accessibility.Accessibility;
import flash.system.Capabilities;

var tf:TextField = new TextField();
tf.text = "hello";

var accessProps:AccessibilityProperties = new AccessibilityProperties();
accessProps.name = "Greeting";

tf.accessibilityProperties = accessProps;

if (Capabilities.hasAccessibility) {
    Accessibility.updateProperties();
}

trace(tf.accessibilityProperties.name); // Greeting

Indique la valeur de transparence alpha de l’objet spécifié. Les valeurs gérées sont comprises entre 0 (entièrement transparent) et 1 (entièrement opaque). La valeur par défaut est 1. Les objets d’affichage où alpha est défini sur 0 sont actifs, même s’ils sont invisibles.

Plus d’exemples

import flash.display.Sprite;
import flash.events.MouseEvent;

var circle:Sprite = new Sprite();
circle.graphics.beginFill(0xFF0000);
circle.graphics.drawCircle(40, 40, 40);
addChild(circle);

circle.addEventListener(MouseEvent.MOUSE_OVER, dimObject);
circle.addEventListener(MouseEvent.MOUSE_OUT, restoreObject);

function dimObject(event:MouseEvent):void {
    event.target.alpha = 0.5;
}

function restoreObject(event:MouseEvent):void {
    event.target.alpha = 1.0;
}

Valeur de la classe BlendMode qui spécifie le mode de fondu à utiliser. Une image bitmap peut être dessinée en interne de deux manières. Si un mode de fondu ou un masque de découpage externe est activé, l’image bitmap est dessinée en ajoutant une forme carrée remplie avec l’image bitmap au rendu vectoriel. Si vous tentez de définir cette propriété sur une valeur non valide, les moteurs d’exécution de Flash la remplacent par BlendMode.NORMAL.

La propriété blendMode affecte chaque pixel de l’objet d’affichage. Chaque pixel est composé de trois couleurs élémentaires (rouge, vert et bleu), chacune de ces couleurs ayant une valeur située entre 0x00 et 0xFF. Flash Player ou Adobe AIR compare chaque couleur constituante d’un pixel dans le clip à la couleur correspondante du pixel d’arrière-plan. Par exemple si blendMode est défini sur BlendMode.LIGHTEN, Flash Player ou Adobe AIR compare la valeur rouge de l’objet d’affichage avec la valeur rouge de l’arrière-plan, et utilise la plus claire des deux comme valeur pour le composant rouge de la couleur affichée.

Le tableau suivant répertorie les réglages blendMode. La classe BlendMode définit les valeurs de chaîne que vous pouvez utiliser. Les illustrations du tableau ci-dessous présentent les valeurs blendMode appliquées à un objet d’affichage (2) circulaire superposé sur un autre objet d’affichage (1).

Constante BlendMode	Illustration	Description
BlendMode.NORMAL		L’objet d’affichage apparaît devant l’arrière-plan. Les valeurs de pixels de l’objet d’affichage écrasent celles de l’arrière-plan. Lorsque l’objet d’affichage est transparent, l’arrière-plan est visible.
BlendMode.LAYER		Impose la création d’un groupe de transparences pour l’objet d’affichage. Cela signifie que l’objet d’affichage est précomposé dans un tampon temporaire avant que son traitement ne se poursuive. Cette opération s’exécute automatiquement si l’objet d’affichage est préalablement placé en mémoire cache par le biais d’une mise en cache des bitmaps ou s’il correspond à un conteneur d’objet d’affichage qui possède au moins un objet enfant associé à un réglage blendMode autre que BlendMode.NORMAL. Pas de prise en charge sous le rendu sur GPU.
BlendMode.MULTIPLY		Multiplie les valeurs des couleurs élémentaires de l’objet d’affichage par celles de la couleur d’arrière-plan, puis les normalise en les divisant par 0xFF, ce qui donne des couleurs plus sombres. Ce réglage est souvent utilisé pour les effets d’ombre et de profondeur. Par exemple, si une couleur élémentaire (comme le rouge) d’un pixel de l’objet d’affichage et la couleur correspondante du pixel de l’arrière-plan ont toutes les deux une valeur de 0x88, le résultat de la multiplication est 0x4840. La division par 0xFF donne une valeur de 0x48 pour cette couleur élémentaire, qui est plus sombre que celle de l’objet d’affichage ou de l’arrière-plan.
BlendMode.SCREEN		Multiplie le complément (l’inverse) de la couleur de l’objet d’affichage par le complément de la couleur d’arrière-plan, ce qui donne un effet de blanchissement. Ce réglage est couramment utilisé pour la mise en valeur ou pour supprimer les parties noires de l’objet d’affichage.
BlendMode.LIGHTEN		Sélectionne les plus claires des couleurs élémentaires de l’objet d’affichage et la couleur d’arrière-plan (celles qui ont les valeurs les plus élevées). Ce réglage est généralement utilisé pour les superpositions. Par exemple, si l’objet d’affichage possède un pixel dont la valeur RVB est 0xFFCC33, et que le pixel d’arrière-plan possède une valeur RVB réglée sur 0xDDF800, la valeur RVB obtenue pour le pixel affiché est 0xFFF833 (car 0xFF > 0xDD, 0xCC < 0xF8 et 0x33 > 0x00 = 33). Pas de prise en charge sous le rendu sur GPU.
BlendMode.DARKEN		Sélectionne les plus sombres des couleurs élémentaires de l’objet d’affichage et de l’arrière-plan (celles qui ont les valeurs les plus faibles). Ce réglage est généralement utilisé pour les superpositions. Par exemple, si l’objet d’affichage possède un pixel dont la valeur RVB est 0xFFCC33, et que le pixel d’arrière-plan possède une valeur RVB réglée sur 0xDDF800, la valeur RVB obtenue pour le pixel affiché est 0xDDCC00 (car 0xFF > 0xDD, 0xCC < 0xF8 et 0x33 > 0x00 = 33). Pas de prise en charge sous le rendu sur GPU.
BlendMode.DIFFERENCE		Compare les couleurs élémentaires de l’objet d’affichage à celles de son arrière-plan et soustrait la valeur la plus sombre des deux couleurs élémentaires de la plus claire. Ce réglage est habituellement utilisé pour obtenir des couleurs plus vibrantes. Par exemple, si l’objet d’affichage possède un pixel dont la valeur RVB est 0xFFCC33, et le pixel d’arrière-plan possède une valeur RVB réglée sur 0xDDF800, la valeur RVB résultante du pixel affiché est 0x222C33 (parce que 0xFF - 0xDD = 0x22, 0xF8 - 0xCC = 0x2C et 0x33 - 0x00 = 0x33).
BlendMode.ADD		Ajoute les valeurs des couleurs élémentaires de l’objet d’affichage à celles de son arrière-plan, en appliquant un plafond de 0xFF. Ce réglage est habituellement utilisé pour animer un fondu d’éclaircissement entre deux objets. Par exemple, si l’objet d’affichage possède un pixel dont la valeur RVB est 0xAAA633, et que le pixel d’arrière-plan possède une valeur RVB réglée sur 0xDD2200, la valeur RVB résultante du pixel affiché est 0xFFC833 (parce que 0xAA + 0xDD > 0xFF, 0xA6 + 0x22 = 0xC8 et 0x33 + 0x00 = 0x33).
BlendMode.SUBTRACT		Soustrait les valeurs des couleurs élémentaires de l’objet d’affichage de celles de la couleur d’arrière-plan, en appliquant un plancher de 0. Ce réglage est habituellement utilisé pour animer un fondu de plus en plus sombre entre deux objets. Par exemple, si l’objet d’affichage possède un pixel dont la valeur RVB est 0xAA2233, et que le pixel d’arrière-plan a une valeur RVB réglée sur 0xDDA600, alors la valeur RVB obtenue pour le pixel affiché est 0x338400 (car 0xDD - 0xAA = 0x33, 0xA6 - 0x22 = 0x84 et 0x00 - 0x33 < 0x00).
BlendMode.INVERT		Inverse l’arrière-plan.
BlendMode.ALPHA		Applique la valeur alpha de chaque pixel de l’objet d’affichage à l’arrière-plan. Pour ce faire, le réglage blendMode de l’objet d’affichage parent doit être réglé sur BlendMode.LAYER. Par exemple, dans l’illustration, l’objet d’affichage parent, qui est un arrière-plan blanc, a un paramètre blendMode = BlendMode.LAYER. Pas de prise en charge sous le rendu sur GPU.
BlendMode.ERASE		Efface l’arrière-plan sur la base de la valeur alpha de l’objet d’affichage. Pour ce faire, le réglage blendMode de l’objet d’affichage parent doit être défini sur BlendMode.LAYER. Par exemple, dans l’illustration, l’objet d’affichage parent, qui est un arrière-plan blanc, a un paramètre blendMode = BlendMode.LAYER. Pas de prise en charge sous le rendu sur GPU.
BlendMode.OVERLAY		Ajuste la couleur de chaque pixel sur la base de l’obscurité de l’arrière-plan. Si l’arrière-plan est plus clair qu’un gris à 50 %, les couleurs de l’objet d’affichage et de l’arrière-plan sont masquées, ce qui donne une couleur plus claire. Si l’arrière-plan est plus foncé qu’un gris à 50 %, les couleurs sont multipliées, ce qui donne une couleur plus sombre. Ce réglage est habituellement utilisé pour les effets d’ombrage. Pas de prise en charge sous le rendu sur GPU.
BlendMode.HARDLIGHT		Ajuste la couleur de chaque pixel sur la base de l’obscurité de l’objet d’affichage. Si l’objet d’affichage est plus clair qu’un gris à 50 %, les couleurs de l’objet d’affichage et de l’arrière-plan sont masquées, ce qui permet d’obtenir une couleur plus claire. Si l’objet d’affichage est plus foncé qu’un gris à 50 %, les couleurs sont multipliées, ce qui donne une couleur plus sombre. Ce réglage est habituellement utilisé pour les effets d’ombrage. Pas de prise en charge sous le rendu sur GPU.
BlendMode.SHADER	S/O	Ajuste la couleur à l’aide d’une routine de shader personnalisée. Le shader utilisé est spécifié en tant qu’occurrence Shader affectée à la propriété blendShader. La définition de la propriété blendShader d’un objet d’affichage sur une occurrence Shader définit automatiquement la propriété blendMode de l’objet d’affichage sur BlendMode.SHADER. Si la propriété blendMode est définie sur BlendMode.SHADER sans que la propriété blendShader n’ait été définie auparavant, la propriété blendMode est définie sur BlendMode.NORMAL. Pas de prise en charge sous le rendu sur GPU.

Plus d’exemples

Eléments de l’API associés

import flash.display.Sprite;
import flash.display.BlendMode;
import flash.events.MouseEvent;

var square:Sprite = new Sprite();
square.graphics.beginFill(0xFF88CC);
square.graphics.drawRect(0, 0, 80, 80);
addChild(square);

var circle:Sprite = new Sprite();
circle.graphics.beginFill(0xAA0022);
circle.graphics.drawCircle(40, 40, 40);
addChild(circle);

circle.addEventListener(MouseEvent.MOUSE_OVER, dimObject);
circle.addEventListener(MouseEvent.MOUSE_OUT, restoreObject);

function dimObject(event:MouseEvent):void {
    event.target.blendMode = BlendMode.SUBTRACT;
}

function restoreObject(event:MouseEvent):void {
    event.target.blendMode = BlendMode.NORMAL;
}

Définit un shader utilisé pour la fusion de l’arrière-plan et du premier plan. Lorsque la propriétéblendMode est définie sur BlendMode.SHADER, le Shader spécifié est utilisé pour créer la sortie du mode fondu pour l’objet d’affichage.

La définition de la propriété blendShader d’un objet d’affichage sur une occurrence Shader définit automatiquement la propriété blendMode de l’objet d’affichage sur BlendMode.SHADER. Si la propriété blendShader est définie (ce qui définit la propriété blendMode sur BlendMode.SHADER) et que la valeur de la propriété blendMode est modifiée, le mode de fondu peut être réinitialisé pour utiliser le shader de fondu en définissant simplement la propriété blendMode sur BlendMode.SHADER. La propriété blendShader n’a plus besoin d’être définie, sauf pour modifier le shader utilisé pour définir le mode de fondu.

Le Shader affecté à la propriété blendShader doit spécifier au moins deux entrées image4. Il n’est pas nécessaire de spécifier les entrées en code à l’aide des propriétés input des objets ShaderInput. L’objet d’affichage de l’arrière-plan est automatiquement utilisé comme première entrée (l’entrée présentant un index 0). L’objet d’affichage de premier-plan est automatiquement utilisé comme seconde entrée (l’entrée présentant un index 1). Un shader utilisé comme shader de fondu peut spécifier plus de deux entrées. Dans ce cas, toute entrée supplémentaire doit être spécifiée par la définition de la propriété input de son occurrence de ShaderInput.

Lorsque vous affectez une occurrence Shader à cette propriété, le shader est copié en interne. L’opération de fondu utilise cette copie interne et non une référence au shader d’origine. Toute modification apportée au shader, par exemple la modification de la valeur d’un paramètre, l’entrée ou le pseudo-code binaire, n’est pas appliquée au shader copié qui est utilisé pour le mode de fondu.

Plus d’exemples

Eléments de l’API associés

Si la valeur true est définie, les moteurs d’exécution de Flash placent en mémoire cache une version bitmap interne de l’objet d’affichage. Cette mise en cache permet d’améliorer les performances des objets d’affichage qui intègrent du contenu vectoriel complexe.

Toutes les données vectorielles d’un objet d’affichage contenant une image bitmap en mémoire cache sont tracées sur l’image bitmap et non pas sur l’affichage principal. Si la propriété cacheAsBitmapMatrix est définie sur null ou n’est pas prise en charge, l’image bitmap est alors copiée sur l’affichage principal sous forme de pixels non étirés et non pivotés accrochés aux limites de pixels les plus proches. Les correspondances des pixels avec l’objet parent se font selon un rapport de 1 à 1. Si les limites de l’image bitmap changent, elle est recréée au lieu d’être étirée.

Si la propriété cacheAsBitmapMatrix n’est pas nulle et est prise en charge, l’objet est dessiné sur l’image bitmap hors écran à l’aide de cette matrice, et les résultats d’étirement et/ou de rotation de ce rendu sont utilisés pour dessiner l’objet sur l’affichage principal.

Aucune bitmap interne n’est créée sauf si la propriété cacheAsBitmap est définie sur true.

Après avoir défini la propriété cacheAsBitmap du bouton sur true, le rendu ne change pas, bien que l’objet d’affichage procède automatiquement à l’accrochage aux pixels. La vitesse d’animation peut être beaucoup plus importante selon la complexité du contenu vectoriel.

La propriété cacheAsBitmap est définie automatiquement sur true lorsque vous appliquez un filtre à l’objet d’affichage (lorsque son tableau filter n’est pas vide). Lorsqu’un objet d’affichage est filtré, cacheAsBitmap renvoie la valeur true pour cet objet d’affichage, même si vous l’aviez définie sur false. Si vous supprimez tous les filtres d’un objet d’affichage, le réglage cacheAsBitmap à sa position précédente.

Un objet d’affichage n’utilise pas d’image bitmap, même si la propriété cacheAsBitmap est définie sur true et procède au rendu à partir de données vectorielles dans les cas suivants :

• L’image bitmap est trop grande : dans AIR 1.5 et Flash Player 10, la taille maximale d’une image bitmap est de 8 191 pixels en largeur ou en hauteur, et le nombre total de pixels ne peut pas excéder 16 777 215 pixels (ainsi, si la largeur d’une image bitmap est de 8 191 pixels, sa hauteur maximale doit être de 2 048 pixels). Dans Flash Player 9 et versions antérieures, la limite est de 2 880 pixels de haut sur 2 880 pixels de large.
• L’image bitmap ne peut être allouée en mémoire (erreur liée à une saturation de la mémoire).

La propriété cacheAsBitmap est utilisée de préférence avec les clips dont le contenu est principalement statique et qui n’est ni redimensionné, ni pivoté de façon fréquente. Avec ce type de clip, cacheAsBitmap permet d’améliorer les performances lors de la conversion (lorsque les positions x et y sont changées).

Informations complémentaires

Eléments de l’API associés

import flash.display.Sprite;
import flash.filters.DropShadowFilter

var circle:Sprite = new Sprite();
circle.graphics.beginFill(0xAA0022);
circle.graphics.drawCircle(40, 40, 40);

addChild(circle);

trace(circle.cacheAsBitmap); // false

var filter:DropShadowFilter = new DropShadowFilter();
circle.filters = [filter];

trace(circle.cacheAsBitmap); // true

S’il n’est pas nul, cet objet Matrix définit le mode de rendu d’un objet d’affichage lorsque cacheAsBitmap est définie sur true. L’application utilise cette matrice comme matrice de transformation appliquée lors du rendu de la version bitmap de l’objet d’affichage.

Prise en charge du profil AIR : cette fonctionnalité est prise en charge sur les périphériques mobiles, mais ne l’est pas sur les systèmes d’exploitation de bureau. Il possède également une prise en charge limitée sur les périphériques AIR pour TV. Plus précisément, sur les périphériques AIR pour TV, la prise en charge des transformations inclut la mise à l’échelle et la translation, mais pas la rotation ni l’inclinaison. Voir Prise en charge du profil AIR pour plus d’informations sur la prise en charge de l’API dans plusieurs profils.

Si la propriété cacheAsBitmapMatrix est définie, l’application conserve une image bitmap mise en cache lors de diverses transformations 2D, notamment la translation, la rotation et la mise à l’échelle. Si l’application utilise l’accélération matérielle, l’objet est stocké dans la mémoire vidéo comme texture. Ceci permet au GPU d’appliquer à l’objet les transformations prises en charge. Le processeur graphique peut effectuer ces transformations plus rapidement que l’unité centrale.

Pour utiliser l’accélération matérielle, définissez le rendu sur GPU dans l’onglet Général de la boîte de dialogue Paramètres iPhone de Flash Professional CS5. Vous pouvez également définir la propriété renderMode sur gpu dans le fichier descripteur de l’application. Notez que les périphériques AIR pour TV font automatiquement appel à l’accélération matérielle, si elle est disponible.

Par exemple, le code suivant envoie une représentation bitmap non transformée de l’objet d’affichage au GPU :

matrix:Matrix = new Matrix(); // creates an identity matrix 
     mySprite.cacheAsBitmapMatrix = matrix; 
     mySprite.cacheAsBitmap = true;

Généralement, la matrice d’identité (new Matrix()) suffit. Cependant, vous pouvez utiliser une autre matrice, notamment une matrice réduite, pour charger une autre image bitmap dans le GPU. Par exemple, l’exemple suivant applique une matrice cacheAsBitmapMatrix mise à l’échelle 0,5 sur les axes x et y. L’objet bitmap qu’utilise le processeur graphique est plus petit ; néanmoins, ce dernier ajuste la taille de l’objet en fonction de la propriété transform.matrix de l’objet d’affichage :

matrix:Matrix = new Matrix(); // creates an identity matrix 
     matrix.scale(0.5, 0.5); // scales the matrix 
     mySprite.cacheAsBitmapMatrix = matrix; 
     mySprite.cacheAsBitmap = true;

En règle générale, vous devez sélectionner une matrice permettant de dimensionner l’objet d’affichage à la taille à laquelle il apparaîtra dans l’application. Par exemple, si votre application affiche la version bitmap du sprite réduit de moitié, utilisez une matrice qui réduit de moitié. Si votre application affiche le sprite plus grand que ses dimensions actuelles, utilisez une matrice qui effectue une augmentation à l’aide de ce facteur.

Remarque : la propriété cacheAsBitmapMatrix convient aux transformations 2D. Si vous devez appliquer des transformations en 3D, définissez une propriété 3D de l’objet et manipulez sa propriété transform.matrix3D. Si l’application est mise en package à l’aide du mode GPU, les transformations 3D sont appliquées à l’objet via le GPU. La propriété cacheAsBitmapMatrix est ignorée pour les objets 3D.

Informations complémentaires

Eléments de l’API associés

import flash.geom.Matrix;
import flash.display.*;
import flash.utils.Timer;

var my_shape:MovieClip = new MovieClip();
my_shape.graphics.beginFill(0xCCFF00);
my_shape.graphics.drawRect(200, 0, 100, 100);
addChild(my_shape);

var my_timer:Timer = new Timer(250);
my_timer.start();
my_timer.addEventListener(TimerEvent.TIMER, timerHandler);

// make sure this Display Object remains cached for all 2D transforms
my_shape.cacheAsBitmap = true;
my_shape.cacheAsBitmapMatrix = new Matrix();

// rotation variables
const initAngle:Number = 0;
const pi:Number = 3.142;
const incrAngle:Number = pi/10;

// scaling variables
const initScale:Number = 0.25;
const incrScale: Number = 1.1;
var initHeight : Number = my_shape.height;
var initWidth : Number = my_shape.width;

// translation variables
var incrX : Number = root.width / 20;
var incrY : Number = root.height / 10;

// do some initial transforms
var tempMat : Matrix = my_shape.transform.matrix;
tempMat.rotate(initAngle);
tempMat.scale(initScale, initScale);

my_shape.transform.matrix = tempMat;

function timerHandler(evt:TimerEvent):void {

    tempMat = my_shape.transform.matrix;
    
    tempMat.rotate(incrAngle);
    tempMat.translate(incrX, incrY);
    tempMat.scale(incrScale, incrScale);
    
    my_shape.transform.matrix = tempMat;
    
    // ensure we are still in a reasonable state or reset 
    if(my_shape.height > stage.stageHeight/2)
    {
        my_shape.height = initHeight;
    }
    
    if(my_shape.width > stage.stageWidth/2)
    {
        my_shape.width = initWidth;
    }
                              
    if(my_shape.x > stage.stageWidth)
    {
        my_shape.x = 0;
    }
    else if (my_shape.x < 0)
    {
        my_shape.x = stage.stageWidth;
    }

    
    if(my_shape.y > stage.stageHeight)
    {
        my_shape.y = 0;
    }
    else if (my_shape.y < 0)
    {
        my_shape.y = stage.stageHeight;
    }
    
}

Tableau indexé contenant tous les objets filtre actuellement associés à l’objet d’affichage. Le package flash.filters contient plusieurs classes qui définissent des filtres spécifiques.

Ces filtres peuvent s’appliquer dans Flash Professional pendant la phase de conception ou d’exécution à l’aide du code ActionScript. Pour appliquer un filtre avec ActionScript, vous devez créer une copie temporaire de l’intégralité du tableau filters, modifier le tableau temporaire, puis reporter les valeurs de ce tableau temporaire dans le tableau filters. Vous ne pouvez pas ajouter directement un nouvel objet filtre au tableau filters.

Pour ajouter un filtre à l’aide du code ActionScript, exécutez les opérations suivantes (supposons que l’objet d’affichage cible est appelé myDisplayObject) :

1. Créez un objet filtre avec la méthode constructeur de la classe de filtre choisie.
2. Assignez la valeur du tableau myDisplayObject.filters à un tableau temporaire, tel que celui qui est nommé myFilters.
3. Ajoutez le nouvel objet filtre au tableau temporaire, myFilters.
4. Affectez la valeur du tableau temporaire au tableau myDisplayObject.filters.

Si le tableau filters n’est pas défini, il n’est pas nécessaire d’utiliser un tableau temporaire. Par contre, vous pouvez affecter directement un littéral de tableau contenant un ou plusieurs des objets filtre que vous avez créés. Le premier exemple de la section Exemples ajoute un filtre d’ombre portée à l’aide du code qui traite à la fois les tableaux de filters définis et non définis.

Pour modifier un objet filtre, vous devez utiliser la technique de modification d’une copie du tableau filters :

1. Assignez la valeur du tableau filters à un tableau temporaire, tel que celui qui est nommé myFilters.
2. Modifiez la propriété avec le tableau temporaire, myFilters. Par exemple, pour définir la propriété quality du premier filtre du tableau, utilisez le code suivant : myFilters[0].quality = 1;
3. Affectez la valeur du tableau temporaire au tableau filters.

Lors du chargement, si un objet d’affichage est associé à un filtre, ce bouton se place en mémoire cache en tant qu’image bitmap transparente. A partir de ce stade, tant que le clip possède une liste de filtres valide, le lecteur place le clip en mémoire cache au format bitmap. Cette image bitmap source est ensuite reprise en tant qu’image source pour les effets de filtrage. Tout objet d’affichage comporte généralement deux bitmaps : le premier avec l’objet d’affichage source non filtré d’origine et un autre pour l’image finale après filtrage. L’image finale est utilisée pour le rendu. Tant que l’objet d’affichage ne change pas, l’image source ne nécessite aucune mise à jour.

Le package flash.filters contient des classes de filtres. Par exemple, pour créer un filtre DropShadow, vous devez écrire le code suivant :

     import flash.filters.DropShadowFilter
     var myFilter:DropShadowFilter = new DropShadowFilter (distance, angle, color, alpha, blurX, blurY, quality, inner, knockout)
     

Vous pouvez utiliser l’opérateur is pour déterminer le type de filtre affecté à chaque position d’index dans le tableau filter. Par exemple, le code suivant indique comment déterminer la position du premier filtre dans le tableau filters qui est DropShadowFilter :

     import flash.text.TextField;
     import flash.filters.*;
     var tf:TextField = new TextField();
     var filter1:DropShadowFilter = new DropShadowFilter();
     var filter2:GradientGlowFilter = new GradientGlowFilter();
     tf.filters = [filter1, filter2];
     
     tf.text = "DropShadow index: " + filterPosition(tf, DropShadowFilter).toString(); // 0
     addChild(tf)
     
     function filterPosition(displayObject:DisplayObject, filterClass:Class):int {
         for (var i:uint = 0; i < displayObject.filters.length; i++) {
             if (displayObject.filters[i] is filterClass) {
                 return i;
             }
         }
         return -1;
     }
     

Remarque : comme vous ne pouvez pas appliquer directement un nouvel objet filtre au tableau DisplayObject.filters, le code suivant n’a pas d’effet sur l’objet d’affichage cible, appelé myDisplayObject :

     myDisplayObject.filters.push(myDropShadow);
     

Eléments de l’API associés

Indique la hauteur de l’objet d’affichage, en pixels. La hauteur est calculée en fonction des limites du contenu de l’objet d’affichage. Lorsque vous définissez la propriété height, la propriété scaleY est ajustée en conséquence, comme illustré dans le code suivant :

    var rect:Shape = new Shape();
    rect.graphics.beginFill(0xFF0000);
    rect.graphics.drawRect(0, 0, 100, 100);
    trace(rect.scaleY) // 1;
    rect.height = 200;
    trace(rect.scaleY) // 2;

A l’exception des objets TextField et Video, un objet d’affichage sans contenu (comme un sprite vide) a une hauteur de 0, même si vous essayez de définir height sur une valeur différente.

import flash.text.TextField;

var tf1:TextField = new TextField();
tf1.text = "Text Field 1";
tf1.border = true;
tf1.wordWrap = true;
tf1.width = 40;
tf1.height = tf1.textHeight + 5;
addChild(tf1);

var tf2:TextField = new TextField();
tf2.text = "Text Field 2";
tf2.border = true;
tf2.wordWrap = true;
tf2.width = 40;
tf2.height = tf2.textHeight + 5;
tf2.y = tf1.y + tf1.height + 5;
addChild(tf2);

Renvoie un objet LoaderInfo qui contient des informations relatives au chargement du fichier auquel appartient cet objet d’affichage. La propriété loaderInfo est définie uniquement pour l’objet d’affichage racine d’un fichier SWF ou d’une image bitmap chargée (et non pas d’une image bitmap dessinée avec le code ActionScript). Pour trouver l’objet loaderInfo associé avec le fichier SWF qui contient un objet d’affichage myDisplayObject, utilisez myDisplayObject.root.loaderInfo.

Un grand fichier SWF peut superviser son téléchargement en appelant this.root.loaderInfo.addEventListener(Event.COMPLETE, func).

Eléments de l’API associés

 trace (this.loaderInfo.url);
 

L’objet d’affichage appelant est masqué par l’objet mask spécifié. Afin de vous assurer que le masquage fonctionne lorsque la scène est redimensionnée, l’objet d’affichage mask doit figurer dans la section active de la liste d’affichage. L’objet mask en tant que tel n’est pas dessiné. Réglez mask sur null pour supprimer le masque.

Pour pouvoir redimensionner un objet masque, il doit figurer dans la liste d’affichage. Pour faire glisser un objet Sprite de masque (à l’aide de sa méthode startDrag()), vous devez placer ce dernier dans la liste d’affichage. Pour appeler la méthode startDrag() d’un sprite de masque en fonction d’un événement mouseDown en cours de distribution par le sprite, définissez la propriété buttonMode du sprite sur true.

Lorsque les objets d’affichage sont mis en cache en définissant la propriété cacheAsBitmap sur true et la propriété cacheAsBitmapMatrix sur un objet Matrix, le masque et l’objet d’affichage en cours de masquage doivent appartenir à la même image bitmap en mémoire cache. Par conséquent, si l’objet d’affichage est mis en cache, le masque doit être un enfant de l’objet d’affichage. Si un ancêtre de l’objet d’affichage sur la liste d’affichage est mis en cache, le masque doit être un enfant de cet ancêtre ou de l’un de ses descendants. Si plusieurs ancêtres de l’objet masqué sont mis en cache, le masque doit être un descendant du conteneur mis en cache le plus proche de l’objet masqué dans la liste d’affichage.

Remarque : un seul objet mask ne peut être utilisé pour masquer plusieurs objets d’affichage appelants. Lorsque mask est affecté à un deuxième objet d’affichage, il est supprimé du masque du premier objet et la propriété mask de cet objet devient null.

Plus d’exemples

import flash.text.TextField;
import flash.display.Sprite;
import flash.events.MouseEvent;

var tf:TextField = new TextField();
tf.text = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, " 
            + "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. "
tf.selectable = false;
tf.wordWrap = true;
tf.width = 150;
addChild(tf);

var square:Sprite = new Sprite();
square.graphics.beginFill(0xFF0000);
square.graphics.drawRect(0, 0, 40, 40);
addChild(square);

tf.mask = square;

tf.addEventListener(MouseEvent.MOUSE_DOWN, drag);
tf.addEventListener(MouseEvent.MOUSE_UP, noDrag);

function drag(event:MouseEvent):void {
    square.startDrag();
}
function noDrag(event:MouseEvent):void {
    square.stopDrag();
}

Obtient les données d’objet de métadonnées de l’occurrence DisplayObject si les données d’meta a été stockée près de la l’occurrence de cette DisplayObject dans le fichier SWF à l’aide d’une balise de4 PlaceObject.

Indique la coordonnée x de la souris ou ou la position du périphérique de saisie utilisateur, en pixels.

Remarque : si vous avez fait pivoter un objet DisplayObject, la coordonnée x renvoyée reflète l’objet non pivoté.

import flash.display.Sprite;
import flash.events.MouseEvent;

var square:Sprite = new Sprite();
square.graphics.beginFill(0xFF0000);
square.graphics.drawRect(0, 0, 200, 200);
addChild(square);

square.addEventListener(MouseEvent.CLICK, traceCoordinates);

function traceCoordinates(event:MouseEvent):void {
    trace(square.mouseX, square.mouseY);
}

Indique la coordonnée y de la souris ou la position du périphérique de saisie utilisateur, en pixels.

Remarque : si vous avez fait pivoter un objet DisplayObject, la coordonnée y renvoyée reflète l’objet non pivoté.

import flash.display.Sprite;
import flash.events.MouseEvent;

var square:Sprite = new Sprite();
square.graphics.beginFill(0xFF0000);
square.graphics.drawRect(0, 0, 200, 200);
addChild(square);

square.addEventListener(MouseEvent.CLICK, traceCoordinates);

function traceCoordinates(event:MouseEvent):void {
    trace(square.mouseX, square.mouseY);
}

Indique le nom d’occurrence de DisplayObject. L’objet peut être identifié dans la liste d’enfants de son conteneur d’objet d’affichage parent en appelant la méthode getChildByName() du conteneur de l’objet d’affichage.

import flash.display.Sprite;
import flash.events.MouseEvent;

var circle1:Sprite = new Sprite();
circle1.graphics.beginFill(0xFF0000);
circle1.graphics.drawCircle(40, 40, 40);
circle1.name = "circle1";
addChild(circle1);
circle1.addEventListener(MouseEvent.CLICK, traceName);

var circle2:Sprite = new Sprite();
circle2.graphics.beginFill(0x0000FF);
circle2.graphics.drawCircle(140, 40, 40);
circle2.name = "circle2";
addChild(circle2);
circle2.addEventListener(MouseEvent.CLICK, traceName);

function traceName(event:MouseEvent):void {
    trace(event.target.name);
}

Indique si l’objet d’affichage est opaque avec une couleur d’arrière-plan spécifique. Une image bitmap transparente contient des données de canal alpha et est dessinée de façon transparente. Une image bitmap opaque ne comporte pas de canal alpha (et procède au rendu plus rapidement qu’avec une image bitmap transparente). Si l’image bitmap est opaque, vous spécifiez la couleur d’arrière-plan à utiliser.

Si elle est réglée sur une valeur numérique, la surface est opaque (et non transparente) et la couleur d’arrière-plan RVB correspond au nombre spécifié. Si défini sur null (la valeur par défaut), l’objet d’affichage a un arrière-plan transparent.

La propriété opaqueBackground est conçue principalement pour l’utilisation avec la propriété cacheAsBitmap, pour l’optimisation du rendu. Pour les objets d’affichage dont la propriété cacheAsBitmap est définie sur true, le paramètre opaqueBackground peut améliorer les performances de rendu.

La zone opaque d’arrière-plan n’est pas prise comme référence lors de l’appel de la méthode hitTestPoint() avec le paramètre shapeFlag défini sur true.

La zone d’arrière-plan opaque ne réagit pas aux événements de souris.

Plus d’exemples

Eléments de l’API associés

import flash.display.Shape;

var circle:Shape = new Shape();
circle.graphics.beginFill(0x0000FF);
circle.graphics.drawCircle(40, 40, 40);
circle.opaqueBackground = 0xFF0000;
addChild(circle);

Indique l’objet DisplayObjectContainer qui contient l’objet d’affichage. Appliquez la propriété parent pour spécifier un chemin relatif vers les objets d’affichage qui figurent au-dessus de l’objet d’affichage actuel dans la hiérarchie de liste d’affichage.

Vous pouvez utiliser parent pour remonter de plusieurs niveaux dans l’arborescence de la liste d’affichage, comme dans l’exemple suivant :

     this.parent.parent.alpha = 20;
     

import flash.display.Sprite;

var sprite1:Sprite = new Sprite();
sprite1.name = "sprite1";
var sprite2:Sprite = new Sprite();
sprite2.name = "sprite2";
var sprite3:Sprite = new Sprite();
sprite3.name = "sprite3";

sprite1.addChild(sprite2);
sprite2.addChild(sprite3);

trace(sprite2.parent.name); // sprite1
trace(sprite3.parent.name); // sprite2
trace(sprite3.parent.parent.name); // sprite1

Pour un objet d’affichage résidant dans un fichier SWF chargé, la propriété root correspond à l’objet d’affichage de premier niveau dans la partie de la structure arborescente de la liste d’affichage représentée par ce fichier. Pour un objet Bitmap représentant un fichier d’image chargé, la propriété root correspond à l’objet Bitmap lui-même. Pour l’occurrence de la classe principale du premier fichier SWF chargé, la propriété root correspond à l’objet d’affichage lui-même. La propriété root de l’objet Stage correspond à l’objet Stage en tant que tel. La propriété root est définie sur null pour tout objet d’affichage qui n’a pas été ajouté à la liste d’affichage, sauf s’il a été ajouté à un conteneur d’objet d’affichage qui ne rentre pas dans le cadre de la liste d’affichage, mais qui est un enfant de l’objet d’affichage de plus haut niveau dans un fichier SWF chargé.

Par exemple, si vous créez un nouvel objet Sprite en appelant la méthode de constructeur Sprite(), sa propriété root reste null jusqu’à ce qu’elle soit ajoutée à la liste d’affichage (ou pour un conteneur d’objet d’affichage qui ne rentre pas dans le cadre de la liste d’affichage, mais qui est un enfant de l’objet d’affichage de plus haut niveau dans un fichier SWF chargé).

Pour un fichier SWF chargé, même si l’objet Loader utilisé pour charger le fichier ne figure pas dans la liste d’affichage, l’objet d’affichage de plus haut niveau du fichier SWF voit sa propriété root définie sur lui-même. La propriété root de l’objet Loader n’est pas définie tant qu’elle n’est pas ajoutée en tant qu’enfant de l’objet d’affichage pour lequel la propriété root est définie.

import flash.display.Loader;
import flash.net.URLRequest;
import flash.events.Event;

trace(stage.root); // [object Stage]

var ldr:Loader = new Loader();
trace (ldr.root); // null

addChild(ldr); 
trace (ldr.root); // [object ...]

var urlReq:URLRequest = new URLRequest("example.jpg");
ldr.load(urlReq);

ldr.contentLoaderInfo.addEventListener(Event.COMPLETE, loaded);

function loaded(event:Event):void {
    trace(ldr.content.root); // [object Bitmap]
}

Indique la rotation de l’occurrence de DisplayObject, en degrés, à partir de son orientation d’origine. Les valeurs comprises entre 0 et 180 représentent la rotation en sens horaire ; les valeurs comprises entre 0 et -180 représentent la rotation en sens anti-horaire. Les valeurs hors de cette plage sont ajoutées ou soustraites de 360 pour obtenir une valeur comprise dans la plage. Par exemple, l’instruction my_video.rotation = 450 correspond à my_video.rotation = 90.

import flash.display.Sprite;
import flash.events.MouseEvent;

var square:Sprite = new Sprite();
square.graphics.beginFill(0xFFCC00);
square.graphics.drawRect(-50, -50, 100, 100);
square.x = 150;
square.y = 150;
addChild(square);

square.addEventListener(MouseEvent.CLICK, rotate);

function rotate(event:MouseEvent):void {
        square.rotation += 15;
}

Indique la rotation de l’axe des x de l’occurrence DisplayObject, en degrés, à partir de son orientation d’origine par rapport au conteneur 3D parent. Les valeurs comprises entre 0 et 180 représentent la rotation en sens horaire ; les valeurs comprises entre 0 et -180 représentent la rotation en sens anti-horaire. Les valeurs hors de cette plage sont ajoutées ou soustraites de 360 pour obtenir une valeur comprise dans la plage.

package {
    import flash.display.MovieClip;
    import flash.display.Shape;
    import flash.geom.*;
    import flash.display.Graphics;
    import flash.events.TimerEvent;
    import flash.utils.Timer;

    public class RotationExample1 extends MovieClip {
        private var ellipse:Shape = new Shape();
        private var speed:int = 10;
        private var ellipse1:Shape;
        private var ellipse2:Shape;
        
        public function RotationExample1():void {

            ellipse1 = drawEllipse(-50, -40, (this.stage.stageWidth / 2), 
                                    (this.stage.stageHeight / 2));
            
            ellipse2 = drawEllipse(30, 40, (this.stage.stageWidth / 2), 
                                          (this.stage.stageHeight / 2));

            this.addChild(ellipse1);
            this.addChild(ellipse2);

            var t:Timer = new Timer(50);
            t.addEventListener(TimerEvent.TIMER, timerHandler);
            t.start();
        }

        private function drawEllipse(x1, y1, x2, y2):Shape {
        
            var e:Shape = new Shape();
            e.graphics.beginFill(0xFF0000);
            e.graphics.lineStyle(2);
            e.graphics.drawEllipse(x1, y1, 100, 80);
            e.graphics.endFill();

            e.x  = x2;  
            e.y  = y2;
            e.z = 1;
            return e;
        }

        private function timerHandler(event:TimerEvent):void {
            ellipse1.rotationY += speed;    
            ellipse1.rotationX -= speed;

            ellipse2.rotationY += speed;    
            ellipse2.rotationX -= speed;
        }
    }
}

//Requires:
//  - Slider control UI component in Flash library.
//  - Publish for Flash Player 10.
//
 
[SWF(width="400", height="300")]
 
import fl.controls.Slider;
import fl.controls.SliderDirection;
import fl.events.SliderEvent;
 
var slider:Slider = new Slider();
slider.direction = SliderDirection.HORIZONTAL;
slider.minimum = 0;
slider.maximum = 360;
slider.value = 45;
slider.tickInterval = 45;
slider.snapInterval = 1;
slider.liveDragging = true;
slider.addEventListener(SliderEvent.CHANGE, slider_change);
slider.move(10, 10);
addChild(slider);
 
var spr:Sprite = new Sprite();
spr.graphics.lineStyle(2, 0xFF0000);
spr.graphics.drawRect(0, 0, 100, 80);
spr.x = Math.round((stage.stageWidth - spr.width)/2);
spr.y = Math.round((stage.stageHeight - spr.height)/2);
spr.rotationX = 45;
addChild(spr);
 
function slider_change(evt:SliderEvent):void {
    spr.rotationX = evt.value;
}

Indique la rotation de l’axe des y de l’occurrence DisplayObject, en degrés, à partir de son orientation d’origine par rapport au conteneur 3D parent. Les valeurs comprises entre 0 et 180 représentent la rotation dans le sens des aiguilles d’une montre ; les valeurs comprises entre 0 et -180 représentent la rotation dans le sens inverse des aiguilles d’une montre. Les valeurs hors de cette plage sont ajoutées ou soustraites de 360 pour obtenir une valeur comprise dans la plage.

package {
    import flash.display.MovieClip;
    import flash.display.Shape;
    import flash.geom.*;
    import flash.display.Graphics;
    import flash.events.TimerEvent;
    import flash.utils.Timer;

    public class RotationExample1 extends MovieClip {
        private var ellipse:Shape = new Shape();
        private var speed:int = 10;
        private var ellipse1:Shape;
        private var ellipse2:Shape;
        
        public function RotationExample1():void {

            ellipse1 = drawEllipse(-50, -40, (this.stage.stageWidth / 2), 
                                    (this.stage.stageHeight / 2));
            
            ellipse2 = drawEllipse(30, 40, (this.stage.stageWidth / 2), 
                                          (this.stage.stageHeight / 2));

            this.addChild(ellipse1);
            this.addChild(ellipse2);

            var t:Timer = new Timer(50);
            t.addEventListener(TimerEvent.TIMER, timerHandler);
            t.start();
        }

        private function drawEllipse(x1, y1, x2, y2):Shape {
        
            var e:Shape = new Shape();
            e.graphics.beginFill(0xFF0000);
            e.graphics.lineStyle(2);
            e.graphics.drawEllipse(x1, y1, 100, 80);
            e.graphics.endFill();

            e.x  = x2;  
            e.y  = y2;
            e.z = 1;
            return e;
        }

        private function timerHandler(event:TimerEvent):void {
            ellipse1.rotationY += speed;    
            ellipse1.rotationX -= speed;

            ellipse2.rotationY += speed;    
            ellipse2.rotationX -= speed;
        }
    }
}

Indique la rotation de l’axe des z de l’occurrence DisplayObject, en degrés, à partir de son orientation d’origine par rapport au conteneur 3D parent. Les valeurs comprises entre 0 et 180 représentent la rotation dans le sens des aiguilles d’une montre ; les valeurs comprises entre 0 et -180 représentent la rotation dans le sens inverse des aiguilles d’une montre. Les valeurs hors de cette plage sont ajoutées ou soustraites de 360 pour obtenir une valeur comprise dans la plage.

Grille de mise à l’échelle en vigueur. Si la valeur est définie sur null, tout l’objet d’affichage est alors dimensionné normalement lorsqu’une transformation par redimensionnement est appliquée.

Lorsque vous définissez une propriété scale9Grid, l’objet d’affichage est divisé dans une grille comportant neuf zones, en fonction du rectangle scale9Grid, qui définit le centre de la grille. La grille est constituée des huit autres zones suivantes :

• le coin supérieur gauche, en dehors du rectangle,
• la zone située au-dessus du rectangle,
• le coin supérieur droit, en dehors du rectangle,
• la zone située à gauche du rectangle,
• la zone située à droite du rectangle,
• le coin inférieur gauche, en dehors du rectangle,
• la zone située au-dessous du rectangle,
• le coin inférieur droit, en dehors du rectangle.

Les huit zones entourant la partie centrale (définie par le rectangle) peuvent être conçues comme un cadre qui bénéficie de règles spécifiques de redimensionnement.

Lorsque la propriété scale9Grid est définie et qu’un objet d’affichage est redimensionné, la totalité du texte et les dégradés sont dimensionnés normalement ; toutefois, les règles suivantes s’appliquent pour les autres types d’objets :

• Le contenu de la zone centrale est redimensionné normalement.
• Le contenu apparaissant dans les coins n’est pas redimensionné.
• Le contenu des zones supérieures et inférieures est redimensionné horizontalement uniquement. Le contenu apparaissant dans les zones de gauche et de droite est redimensionné verticalement uniquement.
• Tous les remplissages (ce qui inclut les bitmaps, les vidéos et les dégradés) sont étirés pour remplir leur forme.

Si vous faites pivoter un objet d’affichage, tout redimensionnement effectué ultérieurement est normal et la propriété scale9Grid est ignorée.

Par exemple, considérez l’objet d’affichage suivant et un rectangle qui lui est appliqué en tant que propriété scale9Grid :

Objet d’affichage.

Le rectangle rouge représente la zone couverte par scale9Grid.

Lorsque l’objet d’affichage est redimensionné ou étiré, les objets placés dans le rectangle se redimensionnent normalement. Par contre, les objets situés en dehors du rectangle sont redimensionnés selon les règles de scale9Grid :

Redimensionné à 75 % :
Redimensionné à 50 % :
Redimensionné à 25 % :
Etiré à l’horizontal à 150 % :

L’une des principales utilisations de scale9Grid consiste à définir un objet d’affichage en tant que composant où les zones de bordure conservent la même largeur lorsque le composant est redimensionné.

Plus d’exemples

Eléments de l’API associés

import flash.display.Shape;
import flash.display.GradientType;
import flash.display.SpreadMethod;
import flash.display.InterpolationMethod;
import flash.geom.Matrix;
import flash.geom.Rectangle;
import flash.utils.Timer;
import flash.events.TimerEvent;

var square:Shape = new Shape();
square.graphics.lineStyle(20, 0xFFCC00);
var gradientMatrix:Matrix = new Matrix();
gradientMatrix.createGradientBox(15, 15, Math.PI, 10, 10);
square.graphics.beginGradientFill(GradientType.RADIAL, 
            [0xffff00, 0x0000ff], 
            [100, 100], 
            [0, 0xFF], 
            gradientMatrix, 
            SpreadMethod.REFLECT, 
            InterpolationMethod.RGB, 
            0.9);
square.graphics.drawRect(0, 0, 100, 100);

var grid:Rectangle = new Rectangle(20, 20, 60, 60);
square.scale9Grid = grid ;

addChild(square);

var tim:Timer = new Timer(100);
tim.start();
tim.addEventListener(TimerEvent.TIMER, scale);

var scaleFactor:Number = 1.01;

function scale(event:TimerEvent):void {
    square.scaleX *= scaleFactor;
    square.scaleY *= scaleFactor;
    
    if (square.scaleX > 2.0) {
        scaleFactor = 0.99;
    }
    if (square.scaleX < 1.0) {
        scaleFactor = 1.01;
    }
}

Indique l’échelle horizontale (pourcentage) de l’objet telle qu’elle est appliquée à partir du point d’alignement. Le point d’alignement par défaut est (0,0). 1.0 correspond à une échelle 100 %.

La mise à l’échelle du système de coordonnées local modifie les valeurs des propriétés x et y définies en pixels.

Plus d’exemples

import flash.display.Sprite;
import flash.events.MouseEvent;

var square:Sprite = new Sprite();
square.graphics.beginFill(0xFFCC00);
square.graphics.drawRect(0, 0, 100, 100);
addChild(square);

square.addEventListener(MouseEvent.CLICK, scale);

function scale(event:MouseEvent):void {
    square.scaleX *= 1.10;
    square.scaleY *= 1.10;
}

Indique l’échelle verticale (pourcentage) de l’objet telle qu’elle est appliquée à partir du point d’alignement. Le point d’alignement par défaut est (0,0). 1.0 correspond à une échelle 100 %.

La mise à l’échelle du système de coordonnées local modifie les valeurs des propriétés x et y définies en pixels.

Plus d’exemples

import flash.display.Sprite;
import flash.events.MouseEvent;

var square:Sprite = new Sprite();
square.graphics.beginFill(0xFFCC00);
square.graphics.drawRect(0, 0, 100, 100);
addChild(square);

square.addEventListener(MouseEvent.CLICK, scale);

function scale(event:MouseEvent):void {
    square.scaleX *= 1.10;
    square.scaleY *= 1.10;
}

Indique l’échelle de profondeur (pourcentage) de l’objet tel qu’elle est appliquée à partir du point d’alignement. Le point d’alignement par défaut est (0,0). 1.0 correspond à une échelle 100 %.

La mise à l’échelle du système de coordonnées local modifie les valeurs des propriétés x, y et z définies en pixels.

Eléments de l’API associés

Cadre de sélection du défilement de l’objet d’affichage. L’objet d’affichage est recadré en fonction de la taille définie par le rectangle et il défile au sein de ce dernier lorsque vous modifiez les propriétés x et y de l’objet scrollRect.

Les propriétés de l’objet rectangle scrollRect reprennent l’espace de coordonnées de l’objet d’affichage et sont redimensionnées tout comme l’objet d’affichage global. Les angles de la fenêtre recadrée de l’objet d’affichage avec défilement correspondent à l’origine de l’objet d’affichage (0,0) et le point défini par la largeur et la hauteur du rectangle. Ils ne sont pas centrés autour de l’origine, mais utilisent cette dernière pour définir le coin supérieur gauche de la zone. L’objet d’affichage avec défilement se fait toujours par pixels entiers.

Vous pouvez faire défiler un objet vers la gauche ou la droite en définissant la propriété x de l’objet rectangle scrollRect. Vous pouvez faire défiler un objet vers le haut ou le bas en définissant la propriété y de l’objet rectangle scrollRect. Si l’objet d’affichage subit une rotation de 90° et que vous le faites défiler vers la gauche ou vers la droite, il défile en fait vers le haut ou vers le bas.

Notez que les modifications apportées à la propriété scrollRect sont uniquement traitées lors du rendu de l’objet. Par conséquent, les méthodes comme localToGlobal risquent de ne pas produire les résultats escomptés si elles sont appelées immédiatement après la modification de scrollRect.

Remarque : à partir de Flash Player 11.4 /AIR 3.4, les valeurs négatives de largeur ou de hauteur du rectangle sont automatiquement définies sur 0.

Plus d’exemples

Eléments de l’API associés

import flash.display.Sprite;
import flash.geom.Rectangle;
import flash.events.MouseEvent;

var circle:Sprite = new Sprite();
circle.graphics.beginFill(0xFFCC00);
circle.graphics.drawCircle(200, 200, 200);
circle.scrollRect = new Rectangle(0, 0, 200, 200);
addChild(circle);

circle.addEventListener(MouseEvent.CLICK, clicked);

function clicked(event:MouseEvent):void {
    var rect:Rectangle = event.target.scrollRect;
    rect.y -= 5;
    event.target.scrollRect = rect;
}

Scène de l’objet d’affichage. L’application d’un moteur d’exécution de Flash ne possède qu’un seul objet Stage. Par exemple, vous pouvez créer et charger plusieurs objets d’affichage dans la liste d’affichage. La propriété stage de chaque objet d’affichage se rapporte au même objet Stage (même si l’objet d’affichage appartient à un fichier SWF chargé).

Si un objet d’affichage n’est pas ajouté à la liste d’affichage, sa propriété stage est définie sur null.

import flash.text.TextField;

var tf1:TextField = new TextField();
tf1.text = "Text Field 1";
tf1.border = true;
tf1.x = 10;
addChild(tf1);
tf1.width = tf1.stage.stageWidth / 2 - 10;

var tf2:TextField = new TextField();
tf2.text = "Text Field 2";
tf2.border = true;
tf2.x = tf1.x + tf1.width + 5;
addChild(tf2);
tf2.width = tf2.stage.stageWidth / 2 - 10;

trace(stage.stageWidth);

Objet dont les propriétés se rapportent à la matrice, à la transformation des couleurs et aux limites des pixels d’un objet d’affichage. Les propriétés spécifiques, telles que matrix, colorTransform et trois propriétés en lecture seule (concatenatedMatrix, concatenatedColorTransform et pixelBounds) sont décrites dans la section relative à la classe Transform.

Chacune des propriétés de l’objet transform constitue un objet. Ce concept est important dans la mesure où la seule façon de définir de nouvelles valeurs pour les objets matrix ou colorTransform consiste à créer un objet et à le copier dans la propriété transform.matrix ou transform.colorTransform.

Par exemple, pour augmenter la valeur tx d’une matrice d’objet d’affichage, vous devez copier l’ensemble de l’objet de la matrice, puis copier le nouvel objet dans la propriété matrix de l’objet transform :

    var myMatrix:Matrix = myDisplayObject.transform.matrix;  
    myMatrix.tx += 10; 
    myDisplayObject.transform.matrix = myMatrix;  
    

Vous ne pouvez pas définir directement la propriété tx. Le code suivant n’a pas d’effet sur myDisplayObject :

    myDisplayObject.transform.matrix.tx += 10;
    

Vous pouvez copier un objet transform et l’associer à la propriété transform d’un autre objet d’affichage. Par exemple, le code suivant copie l’objet transform dans son intégralité, de myOldDisplayObj à myNewDisplayObj :

Le nouvel objet d’affichage qui en résulte, myNewDisplayObj, dispose désormais des mêmes valeurs pour ses paramètres de matrice, transformation de couleurs et limites de pixels que l’ancien objet d’affichage, myOldDisplayObj.

Notez que les périphériques AIR pour TV font appel à l’accélération matérielle, si elle est disponible, pour les transformations de couleur.

Plus d’exemples

Eléments de l’API associés

import flash.display.Sprite;
import flash.geom.ColorTransform;
import flash.geom.Matrix;
import flash.geom.Transform;
import flash.events.MouseEvent;

var square:Sprite = new Sprite();
square.graphics.lineStyle(20, 0xFF2200);
square.graphics.beginFill(0x0000DD);
square.graphics.drawRect(0, 0, 100, 100);
addChild(square);

var resultColorTransform:ColorTransform = new ColorTransform();
resultColorTransform.alphaMultiplier = 0.5;
resultColorTransform.redOffset = 155;
resultColorTransform.greenMultiplier = 0.5;

var skewMatrix:Matrix = new Matrix(1, 1, 0, 1);

square.addEventListener(MouseEvent.CLICK, transformer);

function transformer(event:MouseEvent):void {
    var transformation:Transform = square.transform;
    var tempMatrix:Matrix = square.transform.matrix;
    tempMatrix.concat(skewMatrix);
    square.transform.colorTransform = resultColorTransform;
    
    square.transform.matrix = tempMatrix;
}

Indique si l’objet d’affichage est visible ou non. Les objets d’affichage qui ne sont pas visibles sont désactivés. Par exemple, si visible=false pour une occurrence InteractiveObject, il est impossible de cliquer sur cette dernière.

import flash.text.TextField;
import flash.utils.Timer;
import flash.events.TimerEvent;

var tf:TextField = new TextField();
tf.text = "Hello.";
addChild(tf);

var tim:Timer = new Timer(250);
tim.start();
tim.addEventListener(TimerEvent.TIMER, blinker);

function blinker(event:TimerEvent):void {
    tf.visible = !tf.visible;
}

Indique la largeur de l’objet d’affichage, en pixels. La largeur est calculée en fonction des limites du contenu de l’objet d’affichage. Lorsque vous définissez la propriété width, la propriété scaleX est ajustée en conséquence, comme illustré dans le code suivant :

    var rect:Shape = new Shape();
    rect.graphics.beginFill(0xFF0000);
    rect.graphics.drawRect(0, 0, 100, 100);
    trace(rect.scaleX) // 1;
    rect.width = 200;
    trace(rect.scaleX) // 2;

A l’exception des objets TextField et Video, un objet d’affichage sans contenu (comme un sprite vide) a une largeur de 0, même si vous essayez de définir width sur une valeur différente.

import flash.display.Sprite;
import flash.events.MouseEvent;

var square:Sprite = new Sprite();
square.graphics.beginFill(0xFF0000);
square.graphics.drawRect(0, 0, 100, 100);
addChild(square);

square.addEventListener(MouseEvent.CLICK, widen);

function widen(event:MouseEvent):void {
    square.width += 10;
}

Indique la coordonnée x de l’occurrence de DisplayObject par rapport aux coordonnées locales de l’objet DisplayObjectContainer parent. Si l’objet figure dans un objet DisplayObjectContainer qui dispose de transformations, ce dernier figure dans le système de coordonnées locales de l’objet DisplayObjectContainer qui l’englobe. Ainsi, dans le cas d’un objet DisplayObjectContainer qui a subi une rotation de 90 ° dans le sens inverse des aiguilles d’une montre, les enfants de DisplayObjectContainer héritent d’un système de coordonnées ayant effectué une rotation à 90 ° dans le sens inverse des aiguilles d’une montre. Les coordonnées de l’objet renvoient à la position du point d’alignement.

Plus d’exemples

import flash.display.Sprite;
import flash.utils.Timer;
import flash.events.TimerEvent;

var circle:Sprite = new Sprite();
circle.graphics.beginFill(0xFF0000);
circle.graphics.drawCircle(100, 100, 100);
addChild(circle);

var tim:Timer = new Timer(50);
tim.start();
tim.addEventListener(TimerEvent.TIMER, bounce);

var xInc:Number = 2;

function bounce(event:TimerEvent):void {
    circle.x += xInc;
    if (circle.x > circle.width) {
        xInc = -2;
    }
    if (circle.x < 0) {
        xInc = 2;
    }
}

Indique la coordonnée y de l’occurrence de DisplayObject par rapport aux coordonnées locales de l’objet DisplayObjectContainer parent. Si l’objet figure dans un objet DisplayObjectContainer qui dispose de transformations, ce dernier figure dans le système de coordonnées locales de l’objet DisplayObjectContainer qui l’englobe. Ainsi, dans le cas d’un objet DisplayObjectContainer qui a subi une rotation de 90 ° dans le sens inverse des aiguilles d’une montre, les enfants de DisplayObjectContainer héritent d’un système de coordonnées ayant effectué une rotation à 90 ° dans le sens inverse des aiguilles d’une montre. Les coordonnées de l’objet renvoient à la position du point d’alignement.

Plus d’exemples

import flash.text.TextField;

var tf1:TextField = new TextField();
tf1.text = "Text Field 1";
tf1.border = true;
tf1.wordWrap = true;
tf1.width = 40;
tf1.height = tf1.textHeight + 5;
addChild(tf1);

var tf2:TextField = new TextField();
tf2.text = "Text Field 2";
tf2.border = true;
tf2.wordWrap = true;
tf2.width = 40;
tf2.height = tf2.textHeight + 5;
tf2.y = tf1.y + tf1.height + 5;
addChild(tf2);

Indique la position de coordonnée z le long de l’axe z de l’occurrence de DisplayObject par rapport au conteneur 3D parent. La propriété z est utilisée avec des coordonnées 3D et non avec des coordonnées d’écran ou de pixel.

Lorsque vous réglez la propriété z d’un objet d’affichage sur une valeur autre que la valeur par défaut, à savoir 0, l’objet Matrix3D correspondant est automatiquement créé pour régler la position et l’orientation 3D d’un objet d’affichage. Lorsque l’on utilise l’axe des z, le comportement existant des propriétés x et y passe des coordonnées d’écran ou pixel aux positions par rapport au conteneur 3D parent.

Par exemple, un enfant de _root dont la position est x = 100, y = 100, z = 200 n’est pas dessiné à l’emplacement du pixel (100,100). L’enfant est dessiné à l’endroit où les calculs de projection 3D le placent. Ce calcul est :

(x*cameraFocalLength/cameraRelativeZPosition, y*cameraFocalLength/cameraRelativeZPosition)

Plus d’exemples

Eléments de l’API associés

package {
    import flash.display.MovieClip;
    import flash.display.Shape;
    import flash.display.Graphics;
    import flash.events.Event;
    import flash.geom.*;

    public class ZAxisExample1 extends MovieClip {
        private var ellipse1Back:int = 1;
        private var ellipse2Back:int = 1;
        private var depth:int = 1000;
        
        public function ZAxisExample1():void {
            
            var ellipse1 = drawEllipse((this.stage.stageWidth / 2) - 100, 
                                      (this.stage.stageHeight / 2), 100, 80, 10);
            var ellipse2 = drawEllipse((this.stage.stageWidth / 2) + 100, 
                                      (this.stage.stageHeight / 2), 100, 80, 300);

            this.addChild(ellipse1);
            this.addChild(ellipse2);
            
            ellipse1.addEventListener(Event.ENTER_FRAME, ellipse1FrameHandler);
            ellipse2.addEventListener(Event.ENTER_FRAME, ellipse2FrameHandler);
        }

        private function drawEllipse(x:Number, y:Number, w:Number, h:Number, z:Number):Shape {
            var s:Shape = new Shape();                            
            s.z = z;
            s.graphics.beginFill(0xFF0000);
            s.graphics.lineStyle(2);
            s.graphics.drawEllipse(x, y, w, h);
            s.graphics.endFill();
            return s;
        }

        private function ellipse1FrameHandler(e:Event):void {
            ellipse1Back = setDepth(e, ellipse1Back);
            e.currentTarget.z += ellipse1Back * 10;
        }

        private function ellipse2FrameHandler(e:Event):void {
            ellipse2Back = setDepth(e, ellipse2Back);
            e.currentTarget.z += ellipse2Back * 20;
        }

        private function setDepth(e:Event, d:int):int {
            if(e.currentTarget.z > depth) {
                e.currentTarget.z = depth; 
                d = -1;
            }else if (e.currentTarget.z <  0) {
                e.currentTarget.z = 0;
                d = 1;
            }
            return d;
        }
    }
}

Renvoie un rectangle qui définit la zone de l’objet d’affichage relativement au système de coordonnées de l’objet targetCoordinateSpace. Consultez le code suivant, qui indique comment le rectangle renvoyé peut varier en fonction du paramètre targetCoordinateSpace que vous transmettez à la méthode :

     var container:Sprite = new Sprite();
     container.x = 100;
     container.y = 100;
     this.addChild(container);
     var contents:Shape = new Shape();
     contents.graphics.drawCircle(0,0,100);
     container.addChild(contents);
     trace(contents.getBounds(container));
      // (x=-100, y=-100, w=200, h=200)
     trace(contents.getBounds(this));
      // (x=0, y=0, w=200, h=200)
     

Remarque : utilisez les méthodes localToGlobal() et globalToLocal() pour convertir les coordonnées locales de l’objet d’affichage en coordonnées d’affichage, ou pour convertir les coordonnées d’affichage en coordonnées locales.

La méthode getBounds() est semblable à la méthode getRect(). Cependant, le rectangle renvoyé par la méthode getBounds() inclut les traits appliqués aux formes, contrairement au rectangle renvoyé par la méthode getRect(). Pour consulter un exemple d’utilisation de la méthode getRect(), reportez-vous à la description correspondante.

Paramètres

Eléments de l’API associés

Renvoie un rectangle qui définit les limites de l’objet d’affichage, en se basant sur le système de coordonnées défini par le paramètre targetCoordinateSpace, moins tout trait appliqué aux formes. Les valeurs renvoyées par la méthode getRect() sont inférieures ou égales à celles qui sont renvoyées par la méthode getBounds().

Remarque : utilisez les méthodes localToGlobal() et globalToLocal() pour convertir les coordonnées locales de l’objet d’affichage en coordonnées de scène, ou pour convertir les coordonnées de scène en coordonnées locales.

Paramètres

Eléments de l’API associés

import flash.display.CapsStyle;
import flash.display.JointStyle;
import flash.display.LineScaleMode;
import flash.display.Sprite;
import flash.geom.Rectangle;

var triangle:Sprite = new Sprite();
var color:uint = 0xFF0044;
var width:Number = 20;
var alpha:Number = 1.0;
var pixelHinting:Boolean = true;
var scaleMode:String = LineScaleMode.NORMAL;
var caps:String = CapsStyle.SQUARE;
var joints:String = JointStyle.MITER;
triangle.graphics.lineStyle(width, color, alpha, pixelHinting, scaleMode, caps, joints);

var triangleSide:Number = 100;
triangle.graphics.moveTo(0, 0);
triangle.graphics.lineTo(0, triangleSide);
triangle.graphics.lineTo(triangleSide, triangleSide);
triangle.graphics.lineTo(0, 0);

addChild(triangle);

trace(triangle.getBounds(this)); // (x=-10, y=-24.1, w=134.10000000000002, h=134.1)
trace(triangle.getRect(this));     // (x=0, y=0, w=100, h=100)

Convertit l’objet point des coordonnées de scène (globales) vers les coordonnées de l’objet d’affichage (locales).

Pour utiliser cette méthode, commencez par créer une occurrence de la classe Point. Les valeurs x et y que vous affectez représentent des coordonnées globales dans la mesure où elles se référent à l’origine (0,0) de la zone d’affichage principal. Passez ensuite l’occurrence Point en tant que paramètre à la méthode globalToLocal(). La méthode renvoie un nouvel objet Point avec des valeurs x et y qui se rapportent à l’origine de l’objet d’affichage et non pas à l’origine de la scène.

Paramètres

Plus d’exemples

Eléments de l’API associés

import flash.display.Shape;
import flash.geom.Point;

var circle:Shape = new Shape();
circle.graphics.beginFill(0x0000FF);
circle.graphics.drawCircle(40, 40, 40);
circle.x = 10;
addChild(circle);

var point1:Point = new Point(0, 0);
trace(circle.hitTestPoint(point1.x, point1.y, true)); // false
trace(circle.hitTestPoint(point1.x, point1.y, false)); // false
trace(circle.globalToLocal(point1)); // [x=-10, y=0]

var point2:Point = new Point(10, 1);
trace(circle.hitTestPoint(point2.x, point2.y, true)); // false
trace(circle.hitTestPoint(point2.x, point2.y, false)); // true
trace(circle.globalToLocal(point2)); // [x=0, y=1]

var point3:Point = new Point(30, 20);
trace(circle.hitTestPoint(point3.x, point3.y, true)); // true
trace(circle.hitTestPoint(point3.x, point3.y, false)); // true
trace(circle.globalToLocal(point3)); // [x=20, y=20]

Convertit un point bidimensionnel à partir des coordonnées de scène (globales) vers les coordonnées d’un objet d’affichage tridimensionnel (locales).

Pour utiliser cette méthode, commencez par créer une occurrence de la classe Point. Les valeurs x et y que vous affectez à l’objet Point représentent des coordonnées globales dans la mesure où elles se rapportent à l’origine (0,0) de la zone d’affichage principale. Transmettez ensuite l’objet Point à la méthode globalToLocal3D() en tant que paramètre point. La méthode renvoie les coordonnées tridimensionnelles en tant qu’objet Vector3D contenant les valeurs x, y et z relatives à l’origine de l’objet d’affichage tridimensionnel.

Paramètres

Evalue le cadre de sélection de l’objet d’affichage pour savoir s’il recouvre ou recoupe le cadre de sélection de l’objet d’affichage obj.

Paramètres

import flash.display.Shape;

var circle1:Shape = new Shape();
circle1.graphics.beginFill(0x0000FF);
circle1.graphics.drawCircle(40, 40, 40);
addChild(circle1);

var circle2:Shape = new Shape();
circle2.graphics.beginFill(0x00FF00);
circle2.graphics.drawCircle(40, 40, 40);
circle2.x = 50;
addChild(circle2);

var circle3:Shape = new Shape();
circle3.graphics.beginFill(0xFF0000);
circle3.graphics.drawCircle(40, 40, 40);
circle3.x = 100;
circle3.y = 67;
addChild(circle3);

trace(circle1.hitTestObject(circle2)); // true
trace(circle1.hitTestObject(circle3)); // false
trace(circle2.hitTestObject(circle3)); // true

Evalue l’objet d’affichage pour savoir s’il recouvre ou recoupe le point spécifié par les paramètres x et y. Les paramètres x et y spécifient un point dans l’espace de coordonnées de la scène et non pas le conteneur d’objet d’affichage qui contient l’objet d’affichage (sauf si ce conteneur correspond à la scène).

Paramètres

Eléments de l’API associés

import flash.display.Shape;
import flash.geom.Point;

var circle:Shape = new Shape();
circle.graphics.beginFill(0x0000FF);
circle.graphics.drawCircle(40, 40, 40);
circle.x = 10;
addChild(circle);

var point1:Point = new Point(0, 0);
trace(circle.hitTestPoint(point1.x, point1.y, true)); // false
trace(circle.hitTestPoint(point1.x, point1.y, false)); // false
trace(circle.globalToLocal(point1)); // [x=-10, y=0]

var point2:Point = new Point(10, 1);
trace(circle.hitTestPoint(point2.x, point2.y, true)); // false
trace(circle.hitTestPoint(point2.x, point2.y, false)); // true
trace(circle.globalToLocal(point2)); // [x=0, y=1]

var point3:Point = new Point(30, 20);
trace(circle.hitTestPoint(point3.x, point3.y, true)); // true
trace(circle.hitTestPoint(point3.x, point3.y, false)); // true
trace(circle.globalToLocal(point3)); // [x=20, y=20]

Convertit un point tridimensionnel des coordonnées de l’objet d’affichage tridimensionnel (locales) vers un point bidimensionnel dans les coordonnées de scène (globales).

Par exemple, vous pouvez utiliser uniquement des coordonnées bidimensionnelles (x,y) pour dessiner à l’aide des méthodes display.Graphics. Pour dessiner un objet tridimensionnel, vous devez mapper les coordonnées tridimensionnelles d’un objet d’affichage sur les coordonnées bidimensionnelles. Commencez par créer une occurrence de la classe Vector3D contenant les coordonnées x, y, et z de l’objet d’affichage tridimensionnel. Transmettez ensuite l’objet Vector3D à la méthode local3DToGlobal() en tant que paramètre point3d. La méthode renvoie un objet Point bidimensionnel pouvant être utilisé avec l’API graphique pour dessiner l’objet tridimensionnel.

Paramètres

package {
    import flash.display.MovieClip;
    import flash.display.Sprite;
    import flash.display.Graphics;
    import flash.geom.*;

    public class Local3DToGlobalExample extends MovieClip {
        private var myCube:Sprite = new Sprite();
        private var v8:Vector.<Vector3D> = new Vector.<Vector3D>(8);

        public function Local3DToGlobalExample():void {
            this.x = -(this.stage.stageWidth / 2);
            this.y = -(this.stage.stageWidth / 2);

            v8[0] = new Vector3D(-40,-40,-40);
            v8[1] = new Vector3D(40,-40,-40);
            v8[2] = new Vector3D(40,-40,40);
            v8[3] = new Vector3D(-40,-40,40);
            v8[4] = new Vector3D(-40,100,-40);
            v8[5] = new Vector3D(40,100,-40);
            v8[6] = new Vector3D(40,100,40);
            v8[7] = new Vector3D(-40,100,40);

            myCube.x = (this.stage.stageWidth / 2);
            myCube.y = (this.stage.stageWidth / 2);
            myCube.z = 1;
            addChild(myCube);

            Cube();         
        }

        private function Cube():void {
            var ps:Point = new Point(0,0);

            myCube.graphics.lineStyle(2,0xFF0000);

            ps = myCube.local3DToGlobal(v8[0]);
            myCube.graphics.moveTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[1]);
            myCube.graphics.lineTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[2]);
            myCube.graphics.lineTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[3]);
            myCube.graphics.lineTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[0]);
            myCube.graphics.lineTo(ps.x, ps.y);

            ps = myCube.local3DToGlobal(v8[4]);
            myCube.graphics.moveTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[5]);
            myCube.graphics.lineTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[6]);
            myCube.graphics.lineTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[7]);
            myCube.graphics.lineTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[4]);
            myCube.graphics.lineTo(ps.x, ps.y);

            ps = myCube.local3DToGlobal(v8[0]);
            myCube.graphics.moveTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[4]);
            myCube.graphics.lineTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[1]);
            myCube.graphics.moveTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[5]);
            myCube.graphics.lineTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[2]);
            myCube.graphics.moveTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[6]);
            myCube.graphics.lineTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[3]);
            myCube.graphics.moveTo(ps.x, ps.y);
            ps = myCube.local3DToGlobal(v8[7]);
            myCube.graphics.lineTo(ps.x, ps.y);
        }
    }
}

Convertit l’objet point des coordonnées de l’objet d’affichage (locales) vers les coordonnées de la scène (globales).

Cette méthode permet de convertir les coordonnées x et y des valeurs qui se rapportent à l’origine (0,0) d’un objet d’affichage spécifique (coordonnées locales) en valeurs qui se rapportent à l’origine de la scène (coordonnées globales).

Pour utiliser cette méthode, commencez par créer une occurrence de la classe Point. Les valeurs x et y que vous affectez représentent des coordonnées locales dans la mesure où elles se référent à l’origine de l’objet d’affichage principal.

Vous transmettez ensuite l’occurrence de Point que vous avez créée en tant que paramètre à la méthode localToGlobal(). La méthode renvoie un nouvel objet Point avec des valeurs x et y qui se rapportent à l’origine de la scène et non pas à l’origine de l’objet d’affichage.

Paramètres

Plus d’exemples

Eléments de l’API associés

import flash.display.Sprite;
import flash.events.MouseEvent;
import flash.geom.Point;

var square:Sprite = new Sprite();
square.graphics.beginFill(0xFFCC00);
square.graphics.drawRect(0, 0, 100, 100);
square.x = 100;
square.y = 200;

addChild(square);

square.addEventListener(MouseEvent.CLICK, traceCoordinates)

function traceCoordinates(event:MouseEvent):void {
    var clickPoint:Point = new Point(square.mouseX, square.mouseY);
    trace("display object coordinates:", clickPoint);
    trace("stage coordinates:", square.localToGlobal(clickPoint));
}

Distribué lorsqu’un objet d’affichage est ajouté à la liste d’affichage. Les méthodes suivantes déclenchent cet événement : DisplayObjectContainer.addChild(), DisplayObjectContainer.addChildAt().

Les propriétés de cet événement sont les suivantes :

Eléments de l’API associés

Envoyé lorsqu’un objet d’affichage est ajouté dans la liste d’affichage de la scène, directement ou par l’intermédiaire d’une arborescence secondaire qui contient l’objet d’affichage. Les méthodes suivantes déclenchent cet événement : DisplayObjectContainer.addChild(), DisplayObjectContainer.addChildAt().

Les propriétés de cet événement sont les suivantes :

Eléments de l’API associés

[événement de diffusion] Distribué lorsque la tête de lecture est placée sur une nouvelle image. Lorsque la tête de lecture ne bouge pas ou lorsqu’il n’existe qu’une seule image, cet événement est distribué de façon continue, en fonction de la cadence. Cet événement est un événement de diffusion, ce qui signifie qu’il est distribué par tous les objets d’affichage avec un écouteur enregistré pour cet événement.

Remarque : cet événement n’a ni « phase de capture », ni « phase de propagation », ce qui signifie que des écouteurs d’événement doivent être ajoutés directement aux cibles potentielles, que la cible soit dans la liste d’affichage ou non.

Les propriétés de cet événement sont les suivantes :

[événement de diffusion] Distribué lorsque la tête de lecture quitte l’image en cours. Tous les scripts d’image ont été exécutés. Lorsque la tête de lecture ne bouge pas ou lorsqu’il n’existe qu’une seule image, cet événement est distribué de façon continue, en fonction de la cadence. Cet événement est un événement de diffusion, ce qui signifie qu’il est distribué par tous les objets d’affichage avec un écouteur enregistré pour cet événement.

Remarque : cet événement n’a ni « phase de capture », ni « phase de propagation », ce qui signifie que des écouteurs d’événement doivent être ajoutés directement aux cibles potentielles, que la cible soit dans la liste d’affichage ou non.

Les propriétés de cet événement sont les suivantes :

[événement de diffusion] Distribué après l’exécution des constructeurs des objets d’affichage d’image, mais avant celle des scripts d’image. Lorsque la tête de lecture ne bouge pas ou lorsqu’il n’existe qu’une seule image, cet événement est distribué de façon continue, en fonction de la cadence. Cet événement est un événement de diffusion, ce qui signifie qu’il est distribué par tous les objets d’affichage avec un écouteur enregistré pour cet événement.

Remarque : cet événement n’a ni « phase de capture », ni « phase de propagation », ce qui signifie que des écouteurs d’événement doivent être ajoutés directement aux cibles potentielles, que la cible soit dans la liste d’affichage ou non.

Les propriétés de cet événement sont les suivantes :

Distribué lorsqu’un objet d’affichage est sur le point d’être supprimé de la liste d’affichage. Les deux méthodes de la classe DisplayObjectContainer génèrent cet événement : removeChild() et removeChildAt().

Les méthodes suivantes d’un objet DisplayObjectContainer génèrent également cet événement lorsqu’un objet doit être supprimé pour céder la place au nouvel objet : addChild(), addChildAt() et setChildIndex().

Les propriétés de cet événement sont les suivantes :

Distribué lorsqu’un objet d’affichage est sur le point d’être supprimé de la liste d’affichage de la scène, directement ou par l’intermédiaire de la suppression d’une arborescence secondaire qui contient l’objet d’affichage. Les deux méthodes de la classe DisplayObjectContainer génèrent cet événement : removeChild() et removeChildAt().

Les méthodes suivantes d’un objet DisplayObjectContainer génèrent également cet événement lorsqu’un objet doit être supprimé pour céder la place au nouvel objet : addChild(), addChildAt() et setChildIndex().

Les propriétés de cet événement sont les suivantes :

[événement de diffusion] Distribué lorsque la liste d’affichage est sur le point d’être mise à jour et restituée. Cet événement offre une dernière possibilité de modification des objets qui écoutent cet événement avant le rendu de la liste d’affichage. Vous devez appeler la méthode invalidate() de l’objet Stage chaque fois que vous souhaitez distribuer un événement render. Les événements Render ne sont distribués à un objet que s’il existe un lien d’approbation entre ce dernier et l’objet qui a appelé Stage.invalidate(). Cet événement est un événement de diffusion, ce qui signifie qu’il est distribué par tous les objets d’affichage avec un écouteur enregistré pour cet événement.

Remarque : cet événement n’est pas distribué si l’affichage n’effectue pas de rendu. Tel est le cas lorsque le contenu est réduit en icône ou masqué.

Remarque : cet événement n’a ni « phase de capture », ni « phase de propagation », ce qui signifie que des écouteurs d’événement doivent être ajoutés directement aux cibles potentielles, que la cible soit dans la liste d’affichage ou non.

Les propriétés de cet événement sont les suivantes :

1. Les propriétés de classe sont déclarées pour la couleur et la taille du carré.
2. Le constructeur appelle la méthode draw() qui dessine un carré orange sur la scène aux coordonnées par défaut x = 0, y = 0.
3. Les méthodes d’écouteur d’événements suivantes sont associées au carré :
   • addedHandler() écoute les événements added, appelés lorsque le carré est ajouté à la liste d’affichage.
   • enterFrameHandler() écoute les événements enterFrame, qui n’ont aucune signification réelle dans cet exemple.
   • removedHandler() écoute les événements removed, distribués lorsque le carré est supprimé de la liste d’affichage, ce qui se produit lorsque l’utilisateur clique sur le carré.
   • clickHandler() écoute les événements click, qui sont distribués lorsque l’utilisateur clique sur le carré orange.
   • renderHandler() écoute les événements render une fois la liste d’affichage mise à jour.

package {
    import flash.display.Sprite;

    public class DisplayObjectExample extends Sprite {
        public function DisplayObjectExample() {
            var child:CustomDisplayObject = new CustomDisplayObject();
            addChild(child);
        }
    }
}

import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.display.Stage;
import flash.display.StageAlign;
import flash.display.StageScaleMode;
import flash.events.*;

class CustomDisplayObject extends Sprite {
    private var bgColor:uint = 0xFFCC00;
    private var size:uint    = 80;

    public function CustomDisplayObject() {
        draw();
        addEventListener(Event.ADDED, addedHandler);
        addEventListener(Event.ENTER_FRAME, enterFrameHandler);
        addEventListener(Event.REMOVED, removedHandler);
        addEventListener(MouseEvent.CLICK, clickHandler);
        addEventListener(Event.RENDER, renderHandler);
    }

    private function draw():void {
        graphics.beginFill(bgColor);
        graphics.drawRect(0, 0, size, size);
        graphics.endFill();
    }

    private function clickHandler(event:MouseEvent):void {
        trace("clickHandler: " + event);
        parent.removeChild(this);
    }

    private function addedHandler(event:Event):void {
        trace("addedHandler: " + event);
        stage.scaleMode = StageScaleMode.NO_SCALE;
        stage.align = StageAlign.TOP_LEFT;
        stage.addEventListener("resize", resizeHandler);
    }

    private function enterFrameHandler(event:Event):void {
        trace("enterFrameHandler: " + event);
        removeEventListener("enterFrame", enterFrameHandler);
    }

    private function removedHandler(event:Event):void {
        trace("removedHandler: " + event);
        stage.removeEventListener("resize", resizeHandler);
    }

    private function renderHandler(event:Event):void {
        trace("renderHandler: " + event);
    }

    private function resizeHandler(event:Event):void {
        trace("resizeHandler: " + event);
    }
}