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 d’ActionScript 3.0.

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 Flash Player de façon à exploiter toute la largeur de l'écran.
• 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é scaleMode est définie sur noScale pendant la transition de Flash Player vers le mode plein écran, les propriétés width et height sont mises à jour. Ensuite, Flash Player distribue l'événement Stage.resize.

Les restrictions suivantes s'appliquent aux fichiers SWF qui s'exécutent au sein d'une page HTML (non pas ceux qui utilisent le lecteur 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 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. Lorsque Flash Player est en mode plein écran, toutes les entrées du clavier sont désactivées (sauf les raccourcis clavier qui désactivent le mode plein écran). 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.
• À partir de Flash Player Mise à jour 3 et les versions ultérieures, le mode plein écran fonctionne comme dans le mode sans fenêtre et dans le mode fenêtre. Si vous définissez le mode Fenêtre (wmode dans le 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 plein écran demeurera opaque.

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 : Flash Player 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 plateforme cible peut également réduire la cadence d'images maximale si elle anticipe une forte charge du processeur.

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.

Player Version : Flash Player 9 Mise à jour 3.

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 Échap 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.

Player Version : Flash Player 9 Mise à jour 3.

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

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.

Player Version : Flash Player 9 Mise à jour 3.

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

Renvoie le nombre d'enfants de l’objet.

Valeur de la classe StageQuality qui spécifie la qualité de rendu utilisée par Flash Player. 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.
• 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.
• 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.

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 — Spécifie que l’application Flash entière 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.SHOW_ALL — Rend tout le contenu Flash visible dans la zone spécifiée sans essayer de préserver les proportions d'origine. Une distorsion risque de se produire.
• StageScaleMode.NO_BORDER — Spécifie que l’application Flash 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 Flash 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.

Lorsque la valeur de la propriété Stage.scaleMode est définie sur StageScaleMode.NO_SCALE, la propriété stageHeight détermine la largeur de Flash Player. Lorsque la valeur de Stage.scaleMode n'est pas définie sur StageScaleMode.NO_SCALE, stageHeight représente la hauteur du fichier SWF. Cette propriété ne peut pas être définie.

Voir aussi

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

Lorsque la valeur de la propriété scaleMode est définie sur StageScaleMode.NO_SCALE, la propriété stageWidth détermine la largeur de Flash Player. Ainsi, la propriété stageWidth varie au fur et à mesure que vous redimensionnez la fenêtre Flash Player. Lorsque la valeur de la propriété scaleMode n'est pas définie sur StageScaleMode.NO_SCALE, la propriété stageWidth représente la largeur du fichier SWF tel qu'il a été défini pendant la procédure de création dans la boîte de dialogue Propriétés du document. Ainsi, la valeur de la propriété stageWidth reste constante pendant que vous redimensionnez la fenêtre Flash Player. Cette propriété ne peut pas être définie.

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.

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

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

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énements 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 a besoin d'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

Voir aussi

Paramètres

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.

Le nettoyeur de mémoire correspond au processus de réaffectation de l’espace mémoire inutilisé par Flash Player. 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

Si vous utilisez la méthode setChildIndex() et que vous spécifiez une position d'index déjà occupée, l'enfant associée à cette position et tous les objets de niveau supérieur sont décalés d’une position vers le haut dans la liste d’enfants. 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

Paramètres

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é par Flash Player 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 fenêtre Flash.

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