Stage  - AS3

Une valeur de la classe StageAlign qui détermine l’alignement de la scène dans Flash Player ou dans le navigateur. Les valeurs suivantes sont prises en charge :

La propriété align est uniquement disponible pour les objets qui appartiennent au même sandbox de sécurité que le propriétaire de l’objet Stage (le fichier SWF principal). Pour éviter cette situation, le propriétaire de l’objet Stage peut accorder une autorisation au domaine de l’objet qui effectue l’appel en exécutant la méthode Security.allowDomain() ou Security.alowInsecureDomain(). Pour plus d’informations, voir le chapitre « Sécurité » du Guide du développeur d’ActionScript 3.0.

Eléments de l’API associés

Indique si cette scène permet l’utilisation du mode plein écran.

Indique si cette scène autorise l’utilisation du plein écran avec le mode de saisie de texte

Indique si la scène change automatiquement d’orientation lorsque l’orientation du périphérique change.

La valeur initiale de cette propriété provient de l’élément autoOrients du descripteur d’application et la valeur par défaut est false. Lorsque vous modifiez la valeur de la propriété et la définissez sur false, le comportement n’est pas garanti. Sur certains périphériques, la scène conserve l’orientation actuelle. Sur d’autres, la scène adopte l’orientation standard définie par un périphérique, puis ne change plus.

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 ou sur les périphériques AIR pour TV. Vous pouvez tester la prise en charge lors de l’exécution à l’aide de la propriété Stage.supportsOrientantionChange. Voir Prise en charge du profil AIR pour plus d’informations sur la prise en charge de l’API dans plusieurs profils.

Informations complémentaires

Eléments de l’API associés

Indique le facteur de zoom du navigateur. Une modification du facteur de zoom du navigateur affecte le facteur de mise à l’échelle de la scène.

Couleur d'arrière-plan du fichier SWF.

Valeurs par défaut de la couleur d'arrière-plan de la scène, telles que définies par l'étiquette SWF SetBackgroundColor.

Contrôle la correction des couleurs du moteur d’exécution de Flash pour les affichages. La correction des couleurs ne fonctionne que si un profil colorimétrique ICC valide est affecté à l’écran principal (profil spécifiant les attributs de couleur particuliers du périphérique). Par défaut, le moteur d’exécution de Flash tente d’adopter la correction des couleurs de son hôte (généralement, un navigateur).

Utilisez la propriété Stage.colorCorrectionSupport pour déterminer si la correction des couleurs est disponible sur le système et l’état par défaut actuels. Si la correction des couleurs est disponible, toutes les couleurs de la scène sont supposées appartenir à l’espace chromatique standard RVB, c’est-à-dire à l’espace chromatique le plus courant. Les profils source des périphériques d’entrée ne sont pas pris en compte lors de la correction des couleurs. Aucune correction des couleurs n’est appliquée en entrée ; seule la sortie de la scène est mise en correspondance avec le profil de couleur ICC de l’écran principal.

En règle générale, les avantages de l’activation de la gestion des couleurs sont les suivants : une couleur prévisible et cohérente, une meilleure conversion, un contrôle plus précis et un résultat inter-supports plus efficace. N’oubliez pas cependant que la gestion des couleurs n’effectue pas des conversions parfaites car la gamme de couleurs ou les images d’origine des différents périphériques diffèrent. La gestion des couleurs n’élimine pas non plus le besoin de profils personnalisés ou modifiés. Les profils de couleurs dépendent des navigateurs, des systèmes d’exploitation et de leurs extensions, des périphériques de sortie et de la prise en charge des applications.

L’application d’une correction des couleurs affecte les performances du moteur d’exécution de Flash. La correction des couleurs du moteur d’exécution de Flash est une correction de couleur de style document, car toutes les séquences SWF sont considérées comme des documents avec profils sRVB implicites. Utilisez la propriété Stage.colorCorrectionSupport pour indiquer au moteur d’exécution de Flash de corriger les couleurs lors de l’affichage du fichier SWF (document) dans l’espace colorimétrique de l’affichage. Les moteurs d’exécution de Flash n’effectuent de compensation que pour les différences entre les écrans, pas pour les différences entre les périphériques de saisie (appareil photo, scanner, etc.).

Les trois valeurs possibles sont les chaînes possédant les constantes correspondantes dans la classe flash.display.ColorCorrection :

• "default" : la même correction des couleurs que le système hôte est utilisée.
• "on" : les couleurs sont toujours corrigées.
• "off" : les couleurs ne sont jamais corrigées.

Eléments de l’API associés

function addHandler(add_event:Event) {
    switch(stage.colorCorrection) {
        case ColorCorrection.ON:
            stage.colorCorrection = ColorCorrection.OFF;
            lblCMEnableState.text = "State: " + stage.colorCorrection;
            break;
        case ColorCorrection.OFF:
            stage.colorCorrection = ColorCorrection.DEFAULT;
            lblCMEnableState.text = "State: " + stage.colorCorrection;
            break;
        case ColorCorrection.DEFAULT:
            stage.colorCorrection = ColorCorrection.ON;
            lblCMEnableState.text = "State: " + stage.colorCorrection;
            break;
        default:
            lblCMEnableState.text = "Error.";
            break;
}

Indique si le moteur d’exécution de Flash est exécuté sur un système d’exploitation qui prend en charge la correction des couleurs, et si le moteur d’exécution de Flash est capable de lire et de comprendre le profil colorimétrique de l’écran principal. Cette propriété renvoie également l’état par défaut de la correction des couleurs sur le système hôte (généralement, le navigateur). Actuellement, les valeurs renvoyées peuvent être les suivantes :

Les trois valeurs possibles sont les chaînes possédant les constantes correspondantes dans la classe flash.display.ColorCorrectionSupport :

• "unsupported" : la correction des couleurs n’est pas disponible.
• "defaultOn" : les couleurs sont toujours corrigées.
• "defaultOff" : les couleurs ne sont jamais corrigées.

Eléments de l’API associés

function addHandler(add_event:Event) {
    if (stage.colorCorrectionSupport == ColorCorrectionSupport.DEFAULT_ON || stage.colorCorrectionSupport == ColorCorrectionSupport.DEFAULT_OFF) {
           lblHasCM.text = "stage.colorCorrectionSupport: " + stage.colorCorrectionSupport;
    } 
    else {
        lblHasCM.text = "stage.colorCorrectionSupport: unsupported";
    }
}

Spécifie le facteur de mise à l’échelle de la scène, en pixels effectifs. Cette valeur est égale à 1 sur les écrans standard et HiDPI (écran Retina). Lorsque le rendu de la scène est effectué sur des écrans HiDPI, la résolution (en pixels) est doublée, et ce même si le mode de mise à l’échelle de la scène est défini sur StageScaleMode.NO_SCALE. Les paramètres Stage.stageWidth et Stage.stageHeight sont toujours indiqués en pixels classiques.

Orientation physique du périphérique.

Sur les périphériques équipés d’un clavier coulissant, c’est l’état du clavier qui détermine en premier lieu l’orientation du périphérique et non la rotation détectée par l’accéléromètre. Par conséquent, sur un périphérique de forme verticale équipé d’un clavier latéral, la propriété deviceOrientation indique ROTATED_LEFT lors de l’ouverture du clavier, quelle que soit la façon dont l’utilisateur tient le périphérique.

Utilisez les constantes définies dans la classe StageOrientation lors de la définition ou de la comparaison des valeurs de cette propriété.

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 ou sur les périphériques AIR pour TV. Vous pouvez tester la prise en charge lors de l’exécution à l’aide de la propriété Stage.supportsOrientationChange. Voir Prise en charge du profil AIR pour plus d’informations sur la prise en charge de l’API dans plusieurs profils.

Informations complémentaires

Eléments de l’API associés

Une valeur de la classe StageDisplayState qui spécifie l’état d’affichage à utiliser. Les valeurs suivantes sont prises en charge :

• StageDisplayState.FULL_SCREEN Indique à l’application AIR ou au contenu dans Flash Player d’étendre la scène sur la totalité de l’écran de l’utilisateur. La saisie clavier est désactivée, à l’exception d’un ensemble limité de touches hors impression.
• StageDisplayState.FULL_SCREEN_INTERACTIVE Définit l’application de sorte que la scène couvre la totalité de l’écran de l’utilisateur, en autorisant la saisie au clavier. (Disponible dans AIR et Flash Player, à partir de Flash Player 11.3.)
• StageDisplayState.NORMAL Rétablit le mode standard d’affichage de la scène.

Le comportement de mise à l’échelle du clip en mode plein écran est déterminé par le paramètre scaleMode (défini à l’aide de la propriété Stage.scaleMode ou des paramètres de la balise embed du fichier HTML). Lorsque la propriété scaleModeest définie sur noScale pendant la transition de l’application vers le mode plein écran, les propriétés de scène width et height sont mises à jour. La scène distribue ensuite un événement resize. Si un autre mode de mise à l’échelle est défini, la scène et son contenu sont mis à l’échelle de façon à occuper les dimensions du nouvel écran. L’objet Stage conserve ses valeurs width et height d’origine et ne distribue pas d’événement resize.

Les restrictions suivantes s’appliquent aux fichiers SWF lus dans une page HTML (pas à ceux utilisant l’application AIR ou le moteur d’exécution Flash Player autonome) :

• Pour activer le mode plein écran, ajoutez le paramètre allowFullScreen aux balises object et embed de la page HTML qui inclut le fichier SWF, avec allowFullScreen défini sur "true", comme indiqué dans l’exemple suivant :

  <param name="allowFullScreen" value="true" />
            ...
      <embed src="example.swf" allowFullScreen="true" ... >

  Une page HTML peut également utiliser un script pour générer des balises d’imbrication de fichiers SWF. Vous devez modifier le script de façon à insérer les paramètres allowFullScreen appropriés. Les pages HTML générées par Flash Professional et Flash Builder utilisent la fonction AC_FL_RunContent() pour incorporer des références aux fichiers SWF ; en outre vous devez ajouter le paramètre allowFullScreen, comme dans l’exemple suivant :

  AC_FL_RunContent( ... "allowFullScreen", "true", ... )

• Le mode plein écran est initié lorsque l’utilisateur clique sur la souris ou appuie sur une touche ; le clip ne peut pas modifier Stage.displayState sans interaction de l’utilisateur. Les moteurs d’exécution de Flash limitent la saisie clavier en mode plein écran. Les touches disponibles sont les suivantes : raccourcis clavier permettant de désactiver le mode plein écran, ainsi que les touches hors impression, telles que les touches fléchées, la touche espace, la touche Maj et la touche de tabulation. (Utilisez le mode interactif plein écran pour prendre en charge la saisie avec d’autres touches.) Les raccourcis clavier qui permettent de désactiver le mode plein écran sont les suivants : Échap (Windows, Linux et Mac), Ctrl+W (Windows), Commande+W (Mac) et Alt+F4.
• A partir de Flash Player 9.0.115.0, le mode plein écran fonctionne de la même façon en mode sans fenêtre et en mode fenêtre. Si vous définissez le mode Fenêtre (wmode dans le code HTML) sur Opaque sans fenêtre (opaque) ou sur Transparent sans fenêtre (transparent), le mode plein écran peut être lancé, mais la fenêtre en plein écran demeurera opaque.
• Pour activer le mode interactif plein écran, qui prend en charge l’interactivité avec le clavier, ajoutez le paramètre allowFullScreenInteractive aux balises object et embed de la page HTML qui inclut le fichier SWF, en définissant allowFullScreenInteractive sur "true", comme indiqué dans l’exemple suivant :

  <param name="allowFullScreenInteractive" value="true" />
            ...

Ces restrictions ne sont pas présentes pour le contenu SWF s’exécutant dans l’application Flash Player autonome ou dans AIR.

Lors de l’accès au mode plein écran, le moteur d’exécution de Flash affiche une brève notification sur le contenu SWF pour informer les utilisateurs qu’ils sont en mode plein écran et qu’ils peuvent appuyer sur la touche Echap pour quitter ce mode.

Lors de l’accès au mode interactif plein écran, Flash Player affiche une boîte de dialogue de confirmation sur le contenu SWF afin de permettre aux utilisateurs d’accéder à la saisie clavier étendue (y compris aux touches d’impression) et les informer qu’ils peuvent appuyer sur la touche Echap pour quitter le mode interactif plein écran. L’aspect et l’emplacement de cette boîte de dialogue de confirmation peuvent varier. Vous pouvez indiquer si les utilisateurs peuvent accéder à la saisie clavier étendue en écoutant l’événement FullScreenEvent.FULL_SCREEN_INTERACTIVE_ACCEPTED.

Pour le contenu AIR s’exécutant en mode plein écran, les options d’économiseur d’écran et de mise en veille du système sont désactivées lors de la lecture du contenu vidéo et jusqu’à l’arrêt de la vidéo ou la désactivation du mode plein écran.

Sous Linux, la définition de displayState sur StageDisplayState.FULL_SCREEN ou sur StageDisplayState.FULL_SCREEN_INTERACTIVE est une opération asynchrone.

Plus d’exemples

Eléments de l’API associés

package {
    import flash.display.Sprite;
    import flash.display.Stage;
    import flash.events.*;
    import flash.net.NetConnection;
    import flash.net.NetStream;
    import flash.media.Video;
    
    public class FullScreenExample extends Sprite
    {
        private var videoURL:String = "testVideo.flv";
        private var connection:NetConnection;
        private var stream:NetStream;
        private var video:Video;        
        
        public function FullScreenExample() {
            connection = new NetConnection();
            connection.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler);
            connection.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
            connection.connect(null);
            
            loaderInfo.addEventListener(Event.INIT, createMouseListener);            
        }

        private function createMouseListener(event:Event):void {
            stage.addEventListener(MouseEvent.CLICK,toggleFullScreen);
        }        
        
        private function toggleFullScreen(event:MouseEvent):void {
            switch(stage.displayState) {
                case "normal":
                    stage.displayState = "fullScreen";    
                    break;
                case "fullScreen":
                default:
                    stage.displayState = "normal";    
                    break;
            }
        }    
        
        // Video related:
        private function netStatusHandler(event:NetStatusEvent):void {
            switch (event.info.code) {
                case "NetConnection.Connect.Success":
                    connectStream();
                    break;
                case "NetStream.Play.StreamNotFound":
                    trace("Unable to locate video: " + videoURL);
                    break;
            }
        }
        private function connectStream():void {
            var stream:NetStream = new NetStream(connection);
            stream.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler);
            stream.addEventListener(AsyncErrorEvent.ASYNC_ERROR, asyncErrorHandler);

            video = new Video(stage.stageWidth,stage.stageHeight);
            video.attachNetStream(stream);
            stream.play(videoURL);
            addChild(video);
        }
        private function securityErrorHandler(event:SecurityErrorEvent):void {
            trace("securityErrorHandler: " + event);
        }
        private function asyncErrorHandler(event:AsyncErrorEvent):void {
            // ignore AsyncErrorEvent events.
        }            
    }
}

L’objet interactif qui a le focus clavier ou null si le focus n’est pas défini ou si l’objet avec focus appartient à un sandbox de sécurité auquel l’objet effectuant l’appel n’a pas accès.

var myTF:TextField = new TextField();
myTF.border =true;
myTF.type = TextFieldType.INPUT;

addChild(myTF);
stage.focus= myTF;

Extrait et définit la cadence de la scène. soit le nombre d’images par seconde. Par défaut, cette valeur est définie sur la cadence du premier fichier SWF chargé. Les plages valides vont de 0,01 à 1 000 images par seconde.

Remarque : une application risque de ne pas pouvoir traiter les cadences élevées, soit parce que la plateforme cible n’est pas assez rapide ou parce que le lecteur n’est pas synchronisé avec la cadence des blancs verticaux de l’écran (généralement 60 Hz sur les périphériques avec écrans à cristaux liquides). Dans certains cas, une plateforme cible peut également réduire la cadence maximale si elle anticipe une forte charge du processeur.

Pour le contenu s’exécutant dans Adobe AIR, le réglage de la propriété frameRate d’un objet Stage change la cadence pour tous les objets Stage (utilisés par différents objets NativeWindow).

Renvoie la hauteur de l’écran qui sera utilisée lors du passage en plein écran, si cet état est entré immédiatement. Si l’utilisateur utilise plusieurs écrans, l’écran choisi est celui sur lequel se trouve la majorité de la scène au moment du passage en plein écran.

Remarque : si l’utilisateur a la possibilité de déplacer le navigateur d’un écran à l’autre entre la récupération de la valeur et le passage en plein écran, la valeur peut être incorrecte. Si vous récupérez la valeur dans un gestionnaire d’événement qui définit Stage.displayState sur StageDisplayState.FULL_SCREEN, la valeur sera correcte.

Hauteur du pixel, qui correspond également à celle de la scène si Stage.align est défini sur StageAlign.TOP_LEFT et Stage.scaleMode sur StageScaleMode.NO_SCALE.

Eléments de l’API associés

import flash.display.Sprite;
import flash.display.Stage;
import flash.display.StageDisplayState;
import flash.events.MouseEvent;
import flash.geom.Rectangle;
 
// cover the stage with a green rectangle
var greenRect:Sprite = new Sprite();
greenRect.graphics.beginFill(0x00FF00);
greenRect.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight);
addChild(greenRect);
 
// create red square on stage, turn it into a button for going to full screen
var redSquare:Sprite = new Sprite();
redSquare.graphics.beginFill(0xFF0000);
redSquare.graphics.drawRect(0, 0, 300, 300);
redSquare.x = 50;
redSquare.y = 50;
redSquare.addEventListener(MouseEvent.CLICK, enterFullScreen);
redSquare.buttonMode = true;
addChild(redSquare);
 
function enterFullScreen(e:MouseEvent):void
{
    // we will go to full screen zoomed in on the red square
    var redSquare:Sprite = e.target as Sprite;
    var fullScreenRect:Rectangle = new Rectangle(redSquare.x, redSquare.y, redSquare.width, redSquare.height);
 
    // calculate aspect ratio of the red square
    var rectAspectRatio:Number = fullScreenRect.width / fullScreenRect.height;
 
    // calculate aspect ratio of the screen
    var screenAspectRatio:Number = stage.fullScreenWidth / stage.fullScreenHeight;
  
    // change the fullScreenRect so that it covers the entire screen, keeping it centered on the redSquare
    // try commenting out this section to see what happens if you do not fix the aspect ratio.
    if (rectAspectRatio > screenAspectRatio) {
         var newHeight:Number = fullScreenRect.width / screenAspectRatio;
         fullScreenRect.y -= ((newHeight - fullScreenRect.height) / 2);
        fullScreenRect.height = newHeight;
    } else if (rectAspectRatio < screenAspectRatio) {
        var newWidth:Number = fullScreenRect.height * screenAspectRatio;
        fullScreenRect.x -= ((newWidth - fullScreenRect.width) / 2);
        fullScreenRect.width = newWidth;
    }
 
    // go to full screen
    stage.fullScreenSourceRect = fullScreenRect;
    stage.displayState = StageDisplayState.FULL_SCREEN;
}

Définit le moteur d’exécution de Flash de façon à ce qu’il redimensionne une zone spécifique de la scène en mode plein écran. Lorsque cela est possible, le moteur d’exécution de Flash effectue le redimensionnement dans le matériel, à l’aide de la carte graphique de l’ordinateur de l’utilisateur, ce qui affiche généralement le contenu plus rapidement qu’avec un redimensionnement logiciel.

Lorsque cette propriété est définie sur un rectangle valide et la propriété displayState sur le mode plein écran, le moteur d’exécution de Flash redimensionne la zone spécifiée. La taille réelle de la scène en pixels dans ActionScript ne change pas. Le moteur d’exécution de Flash impose une taille limite au rectangle en fonction de la taille du message standard « Appuyez sur la touche Echap pour quitter le mode plein écran ». Cette limite est généralement d’environ 260 sur 30 pixels, mais peut varier en fonction de la plate-forme et de la version du moteur d’exécution de Flash.

Cette propriété ne peut être définie que lorsque le moteur d’exécution de Flash n’est pas en mode plein écran. Pour utiliser cette propriété correctement, définissez d’abord cette propriété, puis la propriété displayState sur le mode plein écran, comme dans les exemples de code. Remarque : dans Flash Player 15 et les versions ultérieures, cette propriété peut être définie même lorsque le moteur d’exécution Flash est en mode plein écran.

Pour activer la mise à l’échelle, définissez la propriété fullScreenSourceRect sur un objet rectangle :

  
     // valid, will enable hardware scaling
     stage.fullScreenSourceRect = new Rectangle(0,0,320,240); 
     

Pour activer la mise à l’échelle, définissez fullScreenSourceRect=null dans ActionScript 3.0, et undefined dans ActionScript 2.0.

     stage.fullScreenSourceRect = null;
     

L’utilisateur final peut également désactiver la mise à l’échelle matérielle, activée par défaut, dans les paramètres d’affichage de Flash Player. Pour plus d’informations, voir www.adobe.com/go/display_settings_fr.

Eléments de l’API associés

 
import flash.geom.*; 
{
  stage.fullScreenSourceRect = new Rectangle(0,0,320,240);
  stage.displayState = StageDisplayState.FULL_SCREEN;
}

package {
    import flash.display.Sprite;
    import flash.display.StageDisplayState;
    import flash.media.Video;
    import flash.net.NetConnection;
    import flash.net.NetStream;
    import flash.events.NetStatusEvent;
    import flash.events.AsyncErrorEvent;
    import flash.events.SecurityErrorEvent;
    import flash.events.MouseEvent;
    import flash.events.Event;
    import flash.geom.Rectangle;
    
    public class Stage_fullScreenSourceRectExample2 extends Sprite {
        private var videoURL:String = "testVideo1.flv";
        private var connection:NetConnection;
        private var stream:NetStream;
        private var myVideo:Video;        
        private    var savedWidth:uint;
        private    var savedHeight:uint;
 
        public function Stage_fullScreenSourceRectExample2() {
    
            connection = new NetConnection();
             connection.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler);    
            connection.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
            connection.connect(null);

            loaderInfo.addEventListener(Event.INIT, createMouseListener);            
        }

        private function createMouseListener(event:Event):void {
            stage.addEventListener(MouseEvent.CLICK, toggleFullScreen);
        }        

        private function toggleFullScreen(event:MouseEvent):void {

            if(stage.displayState == StageDisplayState.NORMAL) {
                myVideo.width = myVideo.videoWidth;
                  myVideo.height = myVideo.videoHeight;

                try {
                    stage.fullScreenSourceRect = new Rectangle(myVideo.x, myVideo.y, 
                                                           myVideo.width, myVideo.height);
                     stage.displayState = StageDisplayState.FULL_SCREEN;

                 } catch (e:SecurityError) {
                     trace ("A security error occurred while switching to full screen: " + event);
                    myVideo.width = savedWidth;
                    myVideo.height = savedHeight;
                 }

            }else {
                myVideo.width = savedWidth;
                myVideo.height = savedHeight;
                stage.displayState = StageDisplayState.NORMAL;
            }
        }    

       private function netStatusHandler(event:NetStatusEvent):void {
            switch (event.info.code) {
                case "NetConnection.Connect.Success":
                    connectStream();
                    break;
                case "NetStream.Play.StreamNotFound":
                    trace ("Unable to locate video: " + videoURL);
                    break;
            }
        }

       private function connectStream():void {
            var stream:NetStream = new NetStream(connection);
            stream.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler);
            stream.addEventListener(AsyncErrorEvent.ASYNC_ERROR, asyncErrorHandler);     

             myVideo = new Video();
            myVideo.attachNetStream(stream);
            stream.play(videoURL);

            savedWidth = myVideo.width;
            savedHeight = myVideo.height;

            addChild(myVideo);
        }
       
        private function securityErrorHandler(event:SecurityErrorEvent):void {
            trace("securityErrorHandler: " + event);    
        }
        
        private function asyncErrorHandler(event:AsyncErrorEvent):void {
            
        }            
    }
}

Renvoie la largeur de l’écran utilisée lors du passage en plein écran, si cet état est entré immédiatement. Si l’utilisateur utilise plusieurs écrans, l’écran choisi est celui sur lequel se trouve la majorité de la scène au moment du passage en plein écran.

Remarque : si l’utilisateur a la possibilité de déplacer le navigateur d’un écran à l’autre entre la récupération de la valeur et le passage en plein écran, la valeur peut être incorrecte. Si vous récupérez la valeur dans un gestionnaire d’événement qui définit Stage.displayState sur StageDisplayState.FULL_SCREEN, la valeur sera correcte.

Largeur du pixel, qui correspond également à celle de la scène si Stage.align est défini sur StageAlign.TOP_LEFT et Stage.scaleMode sur StageScaleMode.NO_SCALE.

Eléments de l’API associés

import flash.display.Sprite;
import flash.display.Stage;
import flash.display.StageDisplayState;
import flash.events.MouseEvent;
import flash.geom.Rectangle;
 
// cover the stage with a green rectangle
var greenRect:Sprite = new Sprite();
greenRect.graphics.beginFill(0x00FF00);
greenRect.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight);
addChild(greenRect);
 
// create red square on stage, turn it into a button for going to full screen
var redSquare:Sprite = new Sprite();
redSquare.graphics.beginFill(0xFF0000);
redSquare.graphics.drawRect(0, 0, 300, 300);
redSquare.x = 50;
redSquare.y = 50;
redSquare.addEventListener(MouseEvent.CLICK, enterFullScreen);
redSquare.buttonMode = true;
addChild(redSquare);
 
function enterFullScreen(e:MouseEvent):void
{
    // we will go to full screen zoomed in on the red square
    var redSquare:Sprite = e.target as Sprite;
    var fullScreenRect:Rectangle = new Rectangle(redSquare.x, redSquare.y, redSquare.width, redSquare.height);
 
    // calculate aspect ratio of the red square
    var rectAspectRatio:Number = fullScreenRect.width / fullScreenRect.height;
 
    // calculate aspect ratio of the screen
    var screenAspectRatio:Number = stage.fullScreenWidth / stage.fullScreenHeight;
  
    // change the fullScreenRect so that it covers the entire screen, keeping it centered on the redSquare
    // try commenting out this section to see what happens if you do not fix the aspect ratio.
    if (rectAspectRatio > screenAspectRatio) {
         var newHeight:Number = fullScreenRect.width / screenAspectRatio;
         fullScreenRect.y -= ((newHeight - fullScreenRect.height) / 2);
        fullScreenRect.height = newHeight;
    } else if (rectAspectRatio < screenAspectRatio) {
        var newWidth:Number = fullScreenRect.height * screenAspectRatio;
        fullScreenRect.x -= ((newWidth - fullScreenRect.width) / 2);
        fullScreenRect.width = newWidth;
    }
 
    // go to full screen
    stage.fullScreenSourceRect = fullScreenRect;
    stage.displayState = StageDisplayState.FULL_SCREEN;
}

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.

Détermine si les enfants de l’objet prennent en charge la souris ou les périphériques de saisie utilisateur. Si tel est le cas, un utilisateur peut manipuler l’objet à l’aide de la souris ou du périphérique de saisie utilisateur. La valeur par défaut est true.

Cette propriété s’avère utile lorsque vous créez un bouton avec une occurrence de la classe Sprite (au lieu d’utiliser la classe SimpleButton). Si vous utilisez une occurrence de Sprite pour créer un bouton, vous pouvez le décorer à l’aide de la méthode addChild() pour ajouter d’autres occurrences de Sprite. Ce processus risque d’associer un comportement imprévu aux événements de souris, car les occurrences de Sprite ajoutées en tant qu’enfants peuvent devenir l’objet cible d’un événement de souris alors que vous vous attendiez à ce que ce dernier corresponde à l’occurrence parent. Pour vous assurer que l’occurrence parent serve d’objet cible pour les événements de souris, vous pouvez régler la propriété mouseChildren de l’occurrence parent sur false.

Définir cette propriété ne distribue aucun événement. La méthode addEventListener() vous permet de créer une fonctionnalité interactive.

Définissez cette propriété sur true pour activer le verrouillage de la souris. L’activation du verrouillage de la souris désactive le curseur et permet de déplacer la souris sans aucune limite. Vous pouvez verrouiller la souris uniquement sur des applications de bureau en mode plein écran. Le verrouillage de la souris sur des applications dans un autre mode d’affichage ou sur des applications mobiles renvoie une exception.

Le verrouillage de la souris est automatiquement désactivé et le curseur de la souris est à nouveau visible lorsque :

• l’utilisateur quitte le mode plein écran à l’aide de la touche Echap (toutes les plates-formes), Contrôle+W (Windows), Commande+W (Mac) ou Alt+F4 (Windows) ;
• la fenêtre de l’application perd le focus ;
• la totalité de l’interface de paramétrage est visible, y compris les boîtes de dialogue de confidentialité ;
• une boîte de dialogue native est affichée, notamment une boîte de dialogue de téléchargement de fichier.

Lorsque vous quittez le mode plein écran, cette propriété est automatiquement définie sur false.

Les événements associés au mouvement de la souris, tels que l’événement mouseMove, font appel à la classe MouseEvent pour représenter l’objet de l’événement. Lorsque le verrouillage de la souris est désactivé, utilisez les propriétés MouseEvent.localX et MouseEvent.localY pour déterminer l’emplacement de la souris. Lorsque le verrouillage de la souris est activé, utilisez les propriétés MouseEvent.movementX et MouseEvent.movementY pour déterminer l’emplacement de la souris. Les propriétés movementX et movementY contiennent les changements de position de la souris depuis le dernier événement plutôt que les coordonnées absolues de l’emplacement de la souris.

Remarque : lorsque l’application est en mode plein écran, les écouteurs d’événements de souris associés aux objets d’affichage autres que l’objet Stage ne sont pas distribués. Par conséquent, pour recevoir les valeurs delta de la souris et autres événements de souris lorsque la propriété mouseLock est définie sur true, associez les écouteurs d’événements de souris à l’objet Stage.

Eléments de l’API associés

Une référence à l’objet NativeWindow contenant cette scène.

La fenêtre représente la fenêtre du système d’exploitation native ; la scène représente le contenu de la fenêtre. Cette propriété est valide uniquement pour le contenu s’exécutant dans AIR sur des plates-formes prenant en charge la classe NativeWindow. Sur d’autres plates-formes, cette propriété est null. Dans Flash Player (contenu s’exécutant dans un navigateur), cette propriété est également null.

Renvoie le nombre d’enfants de l’objet.

Orientation actuelle de la scène. Cette propriété est définie sur l’une des quatre valeurs, définies comme constantes dans la classe StageOrientation :

Pour définir l’orientation de la scène, utilisez la méthode setOrientation().

Important : la propriété orientation est prise en charge sur les périphériques Android à partir de l’espace de noms 2.6.

Informations complémentaires

Eléments de l’API associés

Valeur de la classe StageQuality qui spécifie la qualité de rendu utilisée. Les valeurs suivantes sont prises en charge :

• StageQuality.LOW — Qualité de rendu inférieure. Les images ne sont pas anticrènelées et les bitmaps ne sont pas lissés, mais le moteur d’exécution utilise toujours le mip-mapping.
• StageQuality.MEDIUM — Qualité de rendu moyenne. Les images sont anticrènelées selon une grille de 2 x 2 pixels ; le lissage des bitmaps dépend du paramètre Bitmap.smoothing. Les moteurs d’exécution utilisent le mip-mapping. Ce niveau de qualité convient aux animations qui ne contiennent pas de texte.
• StageQuality.HIGH — Qualité de rendu supérieure. Les images sont anticrènelées selon une grille de 4 x 4 pixels ; le lissage des bitmaps dépend du paramètre Bitmap.smoothing. Les moteurs d’exécution utilisent le mip-mapping. Il s’agit du réglage de qualité de rendu par défaut de Flash Player.
• StageQuality.BEST — Très haute qualité de rendu. Les images sont anticrènelées selon une grille de 4 x 4 pixels. Si Bitmap.smoothing est true, le moteur d’exécution utilise un algorithme de qualité supérieure pour la réduction de la résolution qui produit moins d’artefacts (l’utilisation de StageQuality.BEST avec Bitmap.smoothing paramétré sur true ralentit toutefois sensiblement les performances et n’est pas recommandée).

Des paramètres de qualité supérieurs produisent un meilleur rendu des bitmaps redimensionnées. Néanmoins, des paramètres de qualité supérieurs sont plus chers. Notamment, lors du rendu de vidéo redimensionnée, l’utilisation de paramètres de qualité supérieurs peut réduire la cadence.

La méthode BitmapData.draw() utilise la valeur de la propriété Stage.quality. Vous pouvez également utiliser la méthode BitmapData.drawWithQuality(), qui permet d’indiquer le paramètre quality de la méthode en ignorant la valeur actuelle de Stage.quality.

Dans le profil de bureau d’Adobe AIR, le paramètre quality peut être défini sur StageQuality.BEST ou StageQuality.HIGH (et la valeur par défaut est StageQuality.HIGH). Si vous tentez de le définir sur une autre valeur, il ne se passe rien (et la propriété reste inchangée). Dans le profil mobile d’AIR, les quatre paramètres de qualité sont disponibles. La valeur par défaut sur les périphériques mobiles est StageQuality.MEDIUM.

Pour le contenu s’exécutant dans Adobe AIR, le réglage de la propriété quality d’un objet Stage change la qualité de rendu pour tous les objets Stage (utilisés par différents objets NativeWindow).

Eléments de l’API associés

Valeur de la classe StageScaleMode qui spécifie le mode d’échelle à utiliser. Les valeurs suivantes sont prises en charge :

• StageScaleMode.EXACT_FIT — Rend tout le contenu visible dans la zone spécifiée sans tenter de préserver le format d’origine. Une distorsion peut se produire, et l’application peut sembler étirée ou compressée.
• StageScaleMode.SHOW_ALL — Spécifie que toute l’application est visible dans la zone spécifiée, sans distorsion, tout en conservant le format d’origine de l’application. Des bordures peuvent apparaître de part et d’autre de l’application.
• StageScaleMode.NO_BORDER — Spécifie que l’application entière remplit la zone spécifiée, sans distorsion mais avec un recadrage éventuel, tout en conservant le format d’origine de l’application.
• StageScaleMode.NO_SCALE — Toute l’application est ajustée, de façon à pouvoir rester inchangée, même si la taille de la fenêtre d’affichage change. Un recadrage risque de se produire si la fenêtre du lecteur est plus petite que le contenu.

Plus d’exemples

Eléments de l’API associés

Détermine si les éléments par défaut du menu contextuel du moteur d’exécution de Flash doivent être affichés ou masqués.

Si la propriété showDefaultContextMenu est définie sur true (valeur par défaut), toutes les options du menu contextuel s’affichent. Si la propriété showDefaultContextMenu est définie sur false, seules les options des menus Paramètres et A propos de... s’affichent.

Rectangle qui spécifie la zone de la scène actuellement occupée par un clavier logiciel. Les composants du rectangle sont (0,0,0,0) lorsque le clavier logiciel n’apparaît pas.

Eléments de l’API associés

Liste des objets Stage3D disponibles pour l’affichage du contenu 3D.

Seul un nombre limité d’objets Stage3D peut être utilisé simultanément. Le nombre d’objets Stage3D disponibles dépend de la plate-forme et du matériel disponible.

Un objet Stage3D dessine devant un objet StageVideo et derrière la liste d’affichage de Flash.

Eléments de l’API associés

Spécifie si les objets affichent ou non une bordure rayonnante lorsqu’ils disposent du focus.

Hauteur actuelle, en pixels, de la scène.

Si la valeur de la propriété Stage.scaleMode est définie sur StageScaleMode.NO_SCALE lorsque l’utilisateur redimensionne la fenêtre, le contenu Stage conserve sa taille définie lorsque la propriété stageHeight change pour refléter la nouvelle hauteur de la zone d’écran occupée par le fichier SWF (dans les autres modes d’échelle, la propriété stageHeight reflète toujours la hauteur d’origine du fichier SWF0). Vous pouvez ajouter un écouteur d’événement pour l’événement resize, puis utiliser la propriété stageHeight de la classe Stage pour déterminer la dimension réelle (en pixels) de la fenêtre redimensionnée du moteur d’exécution de Flash. L’écouteur d’événements vous permet de contrôler comment le contenu de l’écran est ajusté lorsque l’utilisateur redimensionne la fenêtre.

Les périphériques AIR pour TV se comportent de manière légèrement différente que les périphériques de bureau lorsque vous définissez la propriété stageHeight. Si la propriété Stage.scaleMode est définie sur StageScaleMode.NO_SCALE et que vous définissez la propriété stageHeight, la hauteur de la scène ne change pas jusqu’à l’image suivante du fichier SWF.

Remarque : dans une page HTML hébergeant le fichier SWF, les attributs height des balises object et embed doivent être définis sur un pourcentage (tel que 100%), et non sur des pixels. Si les réglages sont générés par le code JavaScript, le paramètre height de la méthode AC_FL_RunContent() doit être défini sur un pourcentage également. Ce pourcentage s’applique à la valeur stageHeight.

Eléments de l’API associés

Liste des objets StageVideo disponibles pour la lecture de vidéos externes.

Seul un nombre limité d’objets StageVideo peut être utilisé simultanément. Lorsque l’exécution d’un fichier SWF commence, le nombre d’objets StageVideo disponible dépend de la plate-forme et du matériel disponible.

Pour utiliser un objet StageVideo, affectez un membre de l’objet vectoriel stageVideos à la variable StageVideo.

Tous les objets StageVideo s’affichent sur la scène derrière les objets d’affichage. Les objets StageVideo s’affichent sur la scène dans l’ordre dans lequel ils apparaissent dans l’objet vectoriel stageVideos. Par exemple, si l’objet vectoriel stageVideos contient trois entrées :

1. L’objet StageVideo dans l’index 0 de l’objet vectoriel stageVideos s’affiche derrière tous les objets StageVideo.
2. L’objet StageVideo à l’index 1 s’affiche à l’avant-plan de l’objet StageVideo à l’index 0.
3. L’objet StageVideo à l’index 2 s’affiche à l’avant-plan de l’objet StageVideo à l’index 1.

Utilisez la propriété StageVideo.depth pour modifier cet ordre.

Remarque : les périphériques AIR pour TV ne prennent en charge qu’un seul objet StageVideo.

Eléments de l’API associés

 
var stageVideo:StageVideo;

if ( stage.stageVideos.length >= 1 ) {
    stageVideo = stage.stageVideos[0];
}

Spécifie la largeur actuelle, en pixels, de la scène.

Si la valeur de la propriété Stage.scaleMode est définie sur StageScaleMode.NO_SCALE lorsque l’utilisateur redimensionne la fenêtre, le contenu Stage conserve sa taille définie lorsque la propriété stageWidth change pour refléter la nouvelle largeur de la zone d’écran occupée par le fichier SWF (dans les autres modes d’échelle, la propriété stageWidth reflète toujours la largeur d’origine du fichier SWF). Vous pouvez ajouter un écouteur d’événement pour l’événement resize, puis utiliser la propriété stageWidth de la classe Stage pour déterminer la dimension réelle (en pixels) de la fenêtre redimensionnée du moteur d’exécution de Flash. L’écouteur d’événements vous permet de contrôler comment le contenu de l’écran est ajusté lorsque l’utilisateur redimensionne la fenêtre.

Les périphériques AIR pour TV se comportent de manière légèrement différente que les périphériques de bureau lorsque vous définissez la propriété stageWidth. Si la propriété Stage.scaleMode est définie sur StageScaleMode.NO_SCALE et que vous définissez la propriété stageWidth, la largeur de la scène ne change pas jusqu’à l’image suivante du fichier SWF.

Remarque : dans une page HTML hébergeant le fichier SWF, les attributs width des balises object et embed doivent être définis sur un pourcentage (tel que 100%), et non sur des pixels. Si les réglages sont générés par le code JavaScript, le paramètre width de la méthode AC_FL_RunContent() doit être défini sur un pourcentage également. Ce pourcentage s’applique à la valeur stageWidth.

Eléments de l’API associés

Orientations prises en charge par le périphérique actuel.

Vous pouvez utiliser les chaînes d’orientation qui figurent dans cette liste comme paramètres de la méthode setOrientation(). La définition d’une orientation non prise en charge échoue sans renvoyer d’erreur.

Les orientations prises en charge sont les suivantes :

Eléments de l’API associés

Indique si l’application prend en charge les modifications au niveau de l’orientation de la scène (et de la rotation du périphérique). Actuellement, cette propriété est uniquement définie sur true dans les applications AIR s’exécutant sur des périphériques mobiles.

Eléments de l’API associés

Détermine si les enfants de l’objet prennent ou non en charge la tabulation. Active ou désactive la sélection des enfants de l’objet avec la touche de tabulation. La valeur par défaut est true.

Remarque : n’utilisez pas cette propriété tabChildren avec Flex. Utilisez plutôt la propriété mx.core.UIComponent.hasFocusableChildren.

Renvoie un objet TextSnapshot pour l’occurrence de DisplayObjectContainer.

Cela représente l’état actuel du vsync de la solution graphique sous-jacente. Nous pouvons activer/désactiver vsync de façon à effectuer un rendu immédiat sans attendre l’état suivant de synchronisation vsync. La lecture de la propriété est valide à tout moment. Toutefois, la définition de la propriété n’est valide que lorsque l’évenement VsyncStateChangeAvailabilityEvent est déclenché.

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.

Indique si la composition GPU est disponible et en cours d’utilisation. La valeur wmodeGPU est true uniquement lorsque les trois conditions suivantes sont remplies :

• La composition GPU a été sollicitée.
• La composition GPU est disponible.
• La composition GPU est en cours d’utilisation.

Concrètement, la propriété wmodeGPU peut indiquer plusieurs choses :

1. La composition GPU n’a pas été sollicitée ou n’est pas disponible. Dans ce cas, la valeur de la propriété wmodeGPU est false.
2. La composition GPU a été sollicitée (s’il y a lieu et si disponible), mais l’environnement est exécuté en « mode de secours » (rendu non optimal) en raison des limites du contenu. Dans ce cas, la valeur de la propriété wmodeGPU est true.
3. La composition GPU a été sollicitée (s’il y a lieu et si disponible) et l’environnement est exécuté dans le mode qui convient le mieux. Dans ce cas, la valeur de propriété wmodeGPU est également true.

En d’autres termes, la propriété wmodeGPU identifie la capacité et l’état de l’environnement de rendu. Pour les moteurs d’exécution qui ne prennent pas en charge la composition GPU, tels que AIR 1.5.2, la valeur est toujours false : la valeur est true uniquement lorsque la composition GPU a été sollicitée, est disponible et est en cours d’utilisation (comme indiqué ci-dessus).

La propriété wmodeGPU est utile pour déterminer, à l’exécution, si la composition GPU est en cours d’utilisation. La valeur de la propriété wmodeGPU indique si le contenu va être ou non mis à l’échelle par le matériel afin que vous puissiez présenter les images à la taille appropriée. Vous pouvez par ailleurs déterminer si vous souhaitez ou non procéder à un rendu dans un chemin rapide afin de pouvoir ajuster la complexité de votre contenu en conséquence.

Pour Flash Player dans un navigateur, la composition GPU peut être sollicitée par la valeur de gpu pour le paramètre HTML wmode dans la page qui héberge le fichier SWF. Pour d’autres configurations, la composition GPU peut être sollicitée dans l’en-tête d’un fichier SWF (défini à l’aide d’outils de création SWF).

Toutefois, la propriété wmodeGPU n’identifie pas les performances de rendu actuelles. Même si la composition GPU est « en cours d’utilisation », le processus de rendu peut ne pas être exécuté dans le mode le mieux approprié. Pour ajuster votre contenu en vue d’obtenir un rendu optimal, utilisez une version de débogage du moteur d’exécution de Flash et définissez DisplayGPUBlendsetting dans votre fichier mm.cfg.

Remarque : cette propriété est toujours définie sur false si elle est référencée à partir du code ActionScript exécuté avant que le moteur d’exécution n’effectue sa première opération de rendu. Par exemple, si vous examinez la propriété wmodeGPU à partir d’un script dans l’image 1 d’Adobe Flash Professional et que votre fichier SWF est le premier fichier SWF chargé dans une nouvelle occurrence du moteur d’exécution, la valeur de la propriété wmodeGPU est false. Pour obtenir une valeur exacte, attendez qu’au moins une opération de rendu ait eu lieu. Si vous programmez un écouteur d’événement pour l’événement exitFrame d’un objet DisplayObject, la propriété wmodeGPU est définie sur la valeur correcte.

Eléments de l’API associés

mySprite.addEventListener(EXIT_FRAME, exithandler):

function exithandler(exiteventobject:Event):void {
                trace(stage.wmodeGPU);
}

Ajoute une occurrence DisplayObject enfant à cette occurrence DisplayObjectContainer. L’enfant est ajouté devant (par-dessus) tous les autres enfants dans cette occurrence de DisplayObjectContainer (pour ajouter un enfant à une position d’index spécifique, utilisez la méthode addChildAt()).

Si vous ajoutez un objet enfant qui est déjà doté d’un autre conteneur d’objet d’affichage en tant que parent, il est supprimé de la liste d’enfants de cet autre conteneur d’objet d’affichage.

Remarque : la commande stage.addChild() risque de poser certains problèmes avec un fichier SWF publié, notamment des problèmes de sécurité et des conflits avec d’autres fichiers SWF chargés. Il n’existe qu’une seule scène au sein d’une occurrence du moteur d’exécution de Flash, quel que soit le nombre de fichiers SWF que vous chargez dans le moteur d’exécution. Ainsi, en règle générale, les objets ne devraient pas être ajoutés à la scène directement. Le seul objet que la scène devrait contenir est l’objet racine. Créez un objet DisplayObjectContainer qui contienne tous les éléments de la liste d’affichage. Le cas échéant, ajoutez ensuite cette occurrence de DisplayObjectContainer sur la scène.

Paramètres

Plus d’exemples

Informations complémentaires

Ajoute une occurrence DisplayObject enfant à cette occurrence DisplayObjectContainer. L’enfant est placé à la position d’index spécifiée. La position d’index 0 représente la fin (le bas) de la liste d’affichage pour cet objet DisplayObjectContainer.

Ainsi, l’exemple suivant illustre trois objets d’affichage appelés a, b et c, qui occupent respectivement les positions d’index 0, 2 et 1 :

Si vous ajoutez un objet enfant qui est déjà doté d’un autre conteneur d’objet d’affichage en tant que parent, il est supprimé de la liste d’enfants de cet autre conteneur d’objet d’affichage.

Paramètres

Plus d’exemples

Informations complémentaires

Enregistre un objet écouteur d’événement auprès d’un objet EventDispatcher afin que l’écouteur soit averti d’un événement. Vous pouvez enregistrer les écouteurs d’événement dans tous les nœuds de la liste d’affichage pour un type spécifique d’événement, de phase et de priorité.

Après l’enregistrement d’un écouteur d’événement, vous ne pouvez plus modifier sa priorité par d’autres appels de addEventListener(). Pour modifier la priorité d’un écouteur, vous devez d’abord appeler removeListener(). Vous pouvez ensuite réenregistrer l’écouteur avec le nouveau niveau de priorité.

N’oubliez pas qu’une fois l’écouteur enregistré, tous les prochains appels de addEventListener() avec une valeur type ou useCapture différente entraîneront la création d’un autre enregistrement d’écouteur. Si, par exemple, vous enregistrez un écouteur dans lequel la propriété useCapture est définie sur true, il écoute uniquement pendant la phase de capture. Si vous appelez addEventListener() à l’aide du même objet écouteur, mais en définissant useCapture sur false, vous obtenez deux écouteurs distincts : l’un qui écoute pendant la phase de capture et l’autre qui écoute pendant les phases cible et de propagation vers le haut (bubbling).

Il est impossible d’enregistrer un écouteur d’événement uniquement pour la phase cible ou la phase de propagation vers le haut. Ces deux phases sont associées pendant l’enregistrement car la propagation vers le haut s’applique uniquement aux ancêtres du nœud cible.

Si vous n’avez plus besoin d’un écouteur d’événements, supprimez-le en appelant removeEventListener(), afin d’éviter tout problème de mémoire. Les écouteurs d’événement ne sont pas automatiquement supprimés de la mémoire, car le nettoyeur de mémoire ne supprime pas l’écouteur tant que l’objet de distribution existe (à moins que le paramètre useWeakReference ne soit défini sur true).

Lors de la copie d’une occurrence d’EventDispatcher, les écouteurs d’événement qui lui sont associés ne sont pas pris en compte (si le nouveau nœud nécessite un écouteur d’événement, vous devez associer celui-ci après la création du nœud). Toutefois, si vous déplacez une occurrence d’EventDispatcher, les écouteurs d’événement qui lui sont associés la suivent.

Si un écouteur d’événement est enregistré sur un nœud alors qu’un événement est en cours de traitement sur ce nœud, l’écouteur n’est pas déclenché pendant la phase actuelle, mais il peut l’être pendant une phase ultérieure du flux d’événements, telle que la phase de propagation vers le haut (bubbling).

Si un écouteur d’événement est supprimé d’un nœud sur lequel un événement est en cours de traitement, il est cependant déclenché par les actions en cours. Une fois supprimé, l’écouteur d’événement n’est plus jamais appelé (à moins d’être réenregistré à des fins de traitement ultérieur).

Paramètres

function(evt:Event):void

Informations complémentaires

Définit le focus du clavier sur l’objet interactif spécifié par objectToFocus, avec la direction du focus spécifiée par le paramètre direction.

Le concept de direction de focus doit être défini par l’application (ou le logiciel intégré de l’application). Aucun tri de focus intrinsèque d’objets interactifs n’existe, bien que vous puissiez utiliser d’autres propriétés disponibles pour établir un principe d’ordre. Par exemple, vous pouvez trier des objets interactifs selon leurs positions sur la scène ou dans la liste d’affichage. Appeler assignFocus() équivaut à définir la propriété Stage.focus, avec la possibilité supplémentaire d’indiquer la direction à partir de laquelle le focus est réglé.

Le objectToFocus distribue un événement focusIn à la réception du focus. La propriété direction de l’objet FocusEvent signale le réglage du paramètre direction.

Si vous affectez un objet HTMLLoader au paramètre objectToFocus, l’objet HTMLLoader sélectionne l’objet approprié qui peut recevoir le focus dans le DOM HTML, en fonction de la valeur du paramètre direction. S’il s’agit de FocusDirection.BOTTOM, l’objet pouvant recevoir le focus dans le DOM HTML situé à la fin de l’ordre de lecture obtient le focus. S’il s’agit de FocusDirection.TOP, l’objet pouvant recevoir le focus dans le DOM HTML situé au début de l’ordre de lecture obtient le focus. S’il s’agit de NONE, l’objet HTMLLoader reçoit le focus sans que l’élément qui a actuellement le focus ne soit modifié.

Paramètres

Eléments de l’API associés

Distribue un événement dans le flux d’événements. La cible de l’événement est l’objet EventDispatcher sur lequel la méthode dispatchEvent() est appelée.

Paramètres

Vérifie si des écouteurs sont enregistrés auprès de l’objet EventDispatcher pour un type spécifique d’événement. Vous pouvez ainsi déterminer précisément où un objet EventDispatcher a modifié la gestion d’un type d’événement dans la hiérarchie du flux d’événements. Pour savoir si un type d’événement spécifique déclenche réellement un écouteur d’événements, utilisez willTrigger().

La différence entre les méthodes hasEventListener() et willTrigger() est la suivante : hasEventListener() examine uniquement l’objet auquel elle appartient, tandis que willTrigger() recherche dans la totalité du flux d’événements l’événement spécifié par le paramètre type.

Lorsque hasEventListener() est appelé à partir d’un objet LoaderInfo, seuls les écouteurs auxquels l’appelant a accès sont pris en compte.

Paramètres

L’appel de la méthode invalidate() force Flash Player à alerter les objets lorsqu’il a la possibilité de rendre la liste d’affichage (par exemple, lorsque la tête de lecture passe à une nouvelle image). Après l’appel de la méthode invalidate() et après le rendu de la liste d’affichage, le moteur d’exécution de Flash envoie un événement render à l’ensemble des objets d’affichage enregistrés pour l’écoute de l’événement render. Vous devez appeler la méthode invalidate() pour que le moteur d’exécution de Flash envoie des événements render.

L’événement render permet d’apporter des modifications à la liste d’affichage immédiatement avant de procéder à son rendu. Vous pouvez ainsi différer les mises à jour de la liste d’affichage de façon à les appliquer au moment de votre choix. L’élimination de mises à jour d’écran superflues améliore parfois les performances.

L’événement render est distribué uniquement pour afficher les objets qui appartiennent au même domaine de sécurité que le code qui appelle la méthode stage.invalidate() ou pour afficher des objets provenant d’un domaine de sécurité dont les autorisations ont été accordées par la méthode Security.allowDomain().

Eléments de l’API associés

Détermine si la propriété Stage.focus doit renvoyer null pour des raisons de sécurité. En d’autres termes, isFocusInaccessible renvoie true si l’objet qui possède le focus appartient à un sandbox de sécurité auquel le fichier SWF n’a pas accès.

Supprime une occurrence enfant de DisplayObject de la position d’index spécifiée dans la liste d’enfants de DisplayObjectContainer. La propriété parent de l’enfant supprimé est réglée sur null et l’objet est nettoyé s’il n’existe aucune autre référence à l’enfant. Les positions d’index de tout objet d’affichage placé au-dessus de l’enfant dans DisplayObjectContainer sont diminuées d’une unité.

Le processus de nettoyage de la mémoire réaffecte l’espace mémoire non utilisé. Lorsqu’une variable ou un objet n’est plus référencé ou stocké de façon active, le nettoyeur de mémoire vide toutes ses références en mémoire qui ne sont plus utilisées.

Paramètres

Définit la scène sur une orientation avec les proportions spécifiées.

Si l'orientation de l'objet Stage change à la suite de l'appel de méthode, l'objet Stage distribue un événement orientationChange.

Pour savoir si l’orientation du périphérique est prise en charge, vérifiez la valeur de la propriété Stage.supportsOrientantionChange.

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 ou sur les périphériques AIR pour TV. Vous pouvez tester la prise en charge lors de l’exécution à l’aide de la propriété Stage.supportsOrientantionChange. Voir Prise en charge du profil AIR pour plus d’informations sur la prise en charge de l’API dans plusieurs profils.

Paramètres

Eléments de l’API associés

Modifie la position d’un enfant existant dans le conteneur d’objet d’affichage. L’ordre des objets enfant est alors affecté. Ainsi, l’exemple suivant illustre trois objets d’affichage appelés a, b et c, qui occupent respectivement les positions d’index 0, 1 et 2 :

Lorsque vous utilisez la méthode setChildIndex() et spécifiez une position d’index déjà occupée, les seules positions qui changent sont celles situées entre l’ancienne et la nouvelle position de l’objet d’affichage. Toutes les autres positions restent identiques. Si un enfant est déplacé sur un index INFERIEUR à son index actuel, tous les enfants situés entre les deux sont AUGMENTES de 1 pour leur référence d’index. Si un enfant est déplacé sur un index SUPERIEUR à son index actuel, tous les enfants situés entre les deux sont DIMINUES de 1 pour leur référence d’index. Par exemple, si le conteneur d’objet d’affichage de l’exemple précédent s’appelle container, vous pouvez permuter la position des objets d’affichage a et b en appelant le code suivant :

container.setChildIndex(container.getChildAt(1), 0);

Ce code entraîne la réorganisation suivante des objets :

Paramètres

Définit la scène sur l’orientation spécifiée.

Définissez le paramètre newOrientation sur l’une des quatre valeurs définies comme constantes dans la classe StageOrientation :

Ne définissez pas le paramètre sur StageOrientation.UNKNOWN ou sur une autre valeur de chaîne autre que celles énumérées dans le tableau.

Pour savoir si la modification de l’orientation du périphérique est prise en charge, vérifiez la valeur de la propriété Stage.supportsOrientantionChange. Vérifiez la liste fournie par la propriété supportedOrientations pour déterminer quelles orientations sont prises en charge par le périphérique actif.

Définir l’orientation est une opération asynchrone. Il est possible qu’elle ne soit pas terminée immédiatement après l’appel de la méthode setOrientation(). Ajoutez un écouteur d’événement pour l’événement orientationChange afin de savoir quand s’est terminé le changement d’orientation.

Important : la méthode setOrientation() n’était pas prise en charge sur les périphériques Android avant AIR 2.6.

Paramètres

Eléments de l’API associés

Intervertit l’ordre z (ordre d’empilement du premier plan vers l’arrière-plan) des objets enfant aux deux positions d’index spécifiées dans la liste d’enfants. Tous les autres objets enfant du conteneur d’objet d’affichage conservent leur position d’index.

Paramètres

Vérifie si un écouteur d’événement est enregistré auprès de cet objet EventDispatcher ou de ses ancêtres pour le type d’événement spécifié. Cette méthode renvoie true si un écouteur d’événement est déclenché pendant toute phase du flux d’événements lorsqu’un événement du type spécifié est distribué à cet objet EventDispatcher ou à l’un de ses descendants.

La différence entre les méthodes hasEventListener() et willTrigger() est la suivante : hasEventListener() examine uniquement l’objet auquel elle appartient, tandis que willTrigger() recherche dans la totalité du flux d’événements celui qui est spécifié par le paramètre type.

Lorsque willTrigger() est appelée à partir d’un objet LoaderInfo, seuls les écouteurs auxquels l’appelant a accès sont pris en compte.

Paramètres

Distribué lorsque la propriété browserZoomFactor de l’objet Stage est modifiée.

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

Distribué lorsque l’objet Stage active ou désactive le mode plein écran. Toute modification du mode plein écran peut se faire à l’aide du code ActionScript, ou d’un raccourci clavier de l’utilisateur, ou lorsque le focus quitte la fenêtre en mode plein écran.

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

Distribué par l’objet Stage lorsque le pointeur sort de la zone de scène. Si l’utilisateur appuie sur le bouton de la souris, l’événement n’est pas distribué.

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

Distribué par l’objet Stage lorsque l’orientation de la scène change.

Des changements d’orientation peuvent se produire lorsque l’utilisateur fait pivoter le périphérique ou ouvre un clavier coulissant, ou lors de l’appel de setAspectRatio().

Remarque : si la propriété autoOrients est définie sur false, l’orientation de la scène ne change pas lors de la rotation d’un périphérique. Par conséquent, les événements StageOrientationEvents ne sont distribués que pour la rotation du périphérique lorsque autoOrients est définie sur true.

Informations complémentaires

Distribué par l’objet Stage lorsque l’orientation de la scène commence à changer.

Important : les événements orientationChanging ne sont pas distribués sur les périphériques Android.

Remarques :

• Si la propriété autoOrients est définie sur false, l’orientation de la scène ne change pas lors de la rotation d’un périphérique. Par conséquent, les événements StageOrientationEvents ne sont distribués que pour la rotation du périphérique lorsque autoOrients est définie sur true.
• Lorsque vous définissez l’orientation par voie de programmation avec la méthode setOrientation(),, l’événement orientationChanging n’est pas distribué.

Informations complémentaires

Distribué lorsque la propriété scaleMode de l’objet Stage est définie sur StageScaleMode.NO_SCALE et lorsque le fichier SWF est redimensionné. Egalement distribué lorsque l’orientation de l’écran change alors que vous êtes en mode plein écran dans Flash Player 15 ou version ultérieure.

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

Distribué par l’objet Stage lorsque l’état de la propriété stageVideos change.

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

package {
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.events.Event;

    public class StageExample extends Sprite {

        public function StageExample() {
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
            stage.addEventListener(Event.ACTIVATE, activateHandler);
            stage.addEventListener(Event.RESIZE, resizeHandler);
        }

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

        private function resizeHandler(event:Event):void {
            trace("resizeHandler: " + event);
            trace("stageWidth: " + stage.stageWidth + " stageHeight: " + stage.stageHeight);
        }
    }
}

Distribué par l’objet Stage lorsque l’état de la propriété vsync change.

Définit la valeur de la propriété type d’un objet événement VsyncStateChangeAvailabilityEvent.

package {
    import flash.display.Sprite;
    import flash.events.VsyncStateChangeAvailabilityEvent
    public class VsyncExample extends Sprite {
        public function VsyncExample()
        { stage.addEventListener(VsyncStateChangeAvailabilityEvent.VSYNC_STATE_CHANGE_AVAILABILITY, onVsyncStateChangeAvailability); }
        public function onVsyncStateChangeAvailability(event:VsyncStateChangeAvailabilityEvent):void
        {
            if (event.available)
            {
                // vsyncEnabled is now changeable and can be turned off.
                stage.vsyncEnabled = false; // Now, AS can change VSYNC state because event.available is true
                trace("vsyncEnabled of Stage object is changeable");
            }
            else
            {
                // vsyncEnabled is not changeable now. This could be due to fallback to software rendering, for example.
                stage.vsyncEnabled = false; // This will be ignored because event.available is now false
                trace("vsyncEnabled of Stage object is read-only");
                trace("Current value of vsyncEnabled of Stage object is "+ stage.vsyncEnabled);
            }
        }
    }
}