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, consultez le chapitre « Sécurité » du manuel Programmation avec ActionScript 3.0.

Voir aussi

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

Utilisez la propriété Stage.colorCorrectionSupport pour déterminer si la correction de couleur est disponible sur le système et l'état par défaut actuels. Si la correction de couleur 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 de couleur. Aucune correction de couleur 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.

De façon générale, les avantages de l'activation de la gestion des couleurs sont 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 de couleur affecte les performances de Flash Player. La correction de couleur de Flash Player 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 à Flash Player de corriger les couleurs au mieux lorsqu'il affiche la séquence SWF (document) dans l'espace de couleur d'affichage. Flash Player n'effectue de compensation que pour les différences entre les écrans, pas pour les différences entre les périphériques d'entrée (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 de couleur que le système hôte est utilisée.
• "on" : les couleurs sont toujours corrigées.
• "off" : les couleurs ne sont jamais corrigées.

Voir aussi

Indique si Flash Player est exécuté sur un système d'exploitation qui prend en charge la correction de couleur, et si Flash Player est capable de lire et de comprendre le profil de couleur de l'écran principal. Cette propriété renvoie également l'état par défaut de la correction de couleur 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 de couleur n'est pas disponible.
• "defaultOn" : les couleurs sont toujours corrigées.
• "defaultOff" : les couleurs ne sont jamais corrigées.

Voir aussi

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

• StageDisplayState.FULL_SCREEN Définit une application AIR ou Flash Player de sorte que la scène couvre la totalité de l'écran de l'utilisateur, avec la saisie au clavier désactivée.
• StageDisplayState.FULL_SCREEN_INTERACTIVE Définit l'application AIR de sorte que la scène couvre la totalité de l'écran de l'utilisateur, en autorisant la saisie au clavier. (Non disponible pour le contenu s'exécutant dans Flash Player.)
• StageDisplayState.NORMAL Rétablit le mode d'affichage standard du lecteur.

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. Ensuite, la scène distribue l'événement resize.

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

• 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 et FlexBuilder utilisent la fonction AC_FL_RunContent() pour imbriquer des références aux fichiers SWF, et vous devez ajouter le paramètre allowFullScreen, comme dans l'exemple suivant :

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

• Le mode plein écran est initié en réponse à un clic de souris ou une pression de touche de l'utilisateur, le clip ne peut pas modifier Stage.displayState sans interaction de l'utilisateur. Flash Player limite 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. Les raccourcis clavier qui permettent de désactiver le mode plein écran sont les suivants : Echap (Windows, Linux et Mac), Ctrl+W (Windows), Commande+W (Mac) et Alt+F4.

  La boîte de dialogue Flash Player se superpose au clip lorsque les utilisateurs activent le mode plein écran pour informer les utilisateurs que le mode plein écran est actif et qu'ils peuvent appuyer sur la touche Echap pour mettre fin au mode plein écran.

• 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.

Ces restrictions ne sont pas présentes pour le contenu SWF s'exécutant dans l'application Flash Player autonome ou dans AIR. AIR prend en charge un mode plein écran interactif qui permet la saisie clavier.

Pour le contenu AIR s'exécutant en mode plein écran, les options d'économiseur d'écran système et de mise en veille sont désactivées lorsque le contenu vidéo est lu et jusqu'à ce que la vidéo s'arrête ou que le mode plein écran soit désactivé.

Voir aussi

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.

Extrait et définit la cadence d'images de la scène. soit le nombre d'images par seconde. Par défaut, cette valeur est définie sur la cadence d'images 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 d'image élevées, soit parce que la plate-forme 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 plate-forme cible peut également réduire la cadence d'images 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 d'images 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.

Voir aussi

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 Flash Player pour qu'il redimensionne une zone spécifique de la scène en mode plein écran. Lorsque cela est possible, Flash Player 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, Flash Player redimensionne la zone spécifiée. La taille réelle de la scène en pixels dans ActionScript ne change pas. Flash Player 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 de Flash Player.

Cette propriété ne peut être définie que lorsque Flash Player 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.

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 de détails, consultez www.adobe.com/go/display_settings_fr.

Voir aussi

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.

Voir aussi

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 ou non en charge la souris. Si tel est le cas, un utilisateur peut le manipuler à l'aide de la souris. 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 définir 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.

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. Dans Flash Player (contenu s'exécutant dans un navigateur), cette propriété est null.

Renvoie le nombre d'enfants de l'objet.

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 anti-aliasées et les bitmaps ne sont pas lissées. Ce paramètre n'est pas pris en charge dans Adobe AIR.
• StageQuality.MEDIUM — Qualité de rendu moyenne. Les images sont anti-aliasées selon une grille de 2 x 2 pixels, mais les bitmaps ne sont pas lissées. Ce niveau de qualité convient aux animations qui ne contiennent pas de texte. Ce paramètre n'est pas pris en charge dans Adobe AIR.
• StageQuality.HIGH — Qualité de rendu supérieure. Les images sont anti-aliasées en appliquant une grille de 4 x 4 pixels et les bitmaps sont lissées lorsque l'animation est statique. 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 graphiques sont anti-aliasés selon une grille de 4 x 4 pixels et les bitmaps sont toujours lissés.

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 d'images.

Pour le contenu s'exécutant dans Adobe AIR, 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).

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).

Voir aussi

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 les proportions 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 rapport largeur/hauteur 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 rapport largeur/hauteur 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.

Voir aussi

Spécifie l'affichage ou le masquage des éléments par défaut dans le menu contextuel de Flash Player.

Si la propriété showDefaultContextMenu est défini sur true (valeur par défaut), tous les éléments du menu contextuel s'affichent. Si la propriété showDefaultContextMenu est réglée sur false, seuls les éléments Paramètres et A propos de Adobe Flash Player s'affichent.

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 de pixels réelle de la fenêtre Flash Player redimensionnée. L'écouteur d'événement vous permet de contrôler comment le contenu de l'écran est ajusté lorsque l'utilisateur redimensionne la fenêtre.

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.

Voir aussi

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 SWF0.) 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 de pixels réelle de la fenêtre Flash Player redimensionnée. L'écouteur d'événement vous permet de contrôler comment le contenu de l'écran est ajusté lorsque l'utilisateur redimensionne la fenêtre.

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.

Voir aussi

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.

Renvoie un objet TextSnapshot pour l'occurrence de DisplayObjectContainer.

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.

Ajoute une occurrence enfant de DisplayObject à cette occurrence de 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 possède déjà un autre conteneur d'objet d'affichage en tant que parent, il est supprimé de la liste des enfants du premier conteneur d'objet d'affichage.

Paramètres

Voir aussi

Ajoute une occurrence enfant de DisplayObject à cette occurrence de 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 possède déjà un autre conteneur d'objet d'affichage en tant que parent, il est supprimé de la liste des enfants du premier conteneur d'objet d'affichage.

Paramètres

Voir aussi

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énements, 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 pour la phase cible ou la phase de propagation vers le haut (bubbling) uniquement. Ces deux phases sont associées pendant l'enregistrement car la propagation vers le haut (bubbling) 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 objets associés à des écouteurs d'événement enregistrés ne sont pas automatiquement supprimés de la mémoire, car le nettoyeur de mémoire n'efface pas les objets auxquels il est toujours fait référence.

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 votre nouveau nœud nécessite un écouteur d'événements, 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

Voir aussi

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

Voir aussi

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 l'emplacement auquel 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 avoir appelé la méthode invalidate() et suite au premier rendu de la liste d'affichage, Flash Player 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 Flash Player 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().

Voir aussi

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

Modifie la position d'un enfant existant dans le conteneur d'objet d'affichage. L'ordre des objets enfants 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

Intervertit l'ordre z (ordre d'empilement du premier plan vers l'arrière-plan) des objets enfants aux deux positions d'index spécifiées dans la liste d'enfants. Tous les autres objets enfants 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 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 de la souris sort de la zone de scène.

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

Distribué lorsque la propriété scaleMode de l'objet Stage est définie sur StageScaleMode.NO_SCALE et lorsque le fichier SWF est redimensionné.

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

1. Le constructeur de classe définit au préalable l'application Flash à corriger, quelle que soit la taille de la fenêtre de Flash Player, puis ajoute deux écouteurs d'événement avec les méthodes activateHandler() et resizeHandler().
2. La méthode activateHandler() s'exécute lorsque vous cliquez avec le bouton gauche de la souris.
3. La méthode resizeHandler() s'exécute lorsque la scène est redimensionnée.

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);
        }
    }
}