Un valor de la clase StageAlign que especifica la alineación del escenario en Flash Player o el navegador. Los valores siguientes son válidos:

La propiedad align sólo está disponible para un objeto que esté en el mismo entorno limitado de seguridad que el propietario del objeto Stage (el archivo SWF principal). Para evitar esto, el propietario de Stage puede conceder permiso al dominio del objeto que origina la llamada llamando al método Security.allowDomain() o Security.alowInsecureDomain(). Para más información, consulte el capítulo "Seguridad" de Programación con ActionScript 3.0.

Véase también

Un valor de la clase StageDisplayState que especifica el estado de visualización se utilizará. Los valores siguientes son válidos:

• StageDisplayState.FULL_SCREEN: establece Flash Player para que expanda el escenario a toda la pantalla del usuario.
• StageDisplayState.NORMAL: devuelve el reproductor al modo de visualización de escenario estándar.

El comportamiento de la escala de la película en modo de pantalla completa viene determinado por el valor scaleMode (definido por la propiedad Stage.scaleMode de los valores de etiqueta embed del archivo SWF en el archivo HTML). Si la propiedad scaleMode se define como noScale mientras Flash Player cambia a modo de pantalla completa, se actualizan las propiedades width y height del escenario y Flash Player distribuye el evento Stage.resize.

Las siguientes restricciones se aplican a los archivos SWF que se reproducen en una página HTML (no aquellos que utilizan el reproductor Flash Player autónomo):

• Para activar el modo de pantalla completa, añada el parámetro allowFullScreen a las etiquetas object y embed en la página HTML que incluye el archivo SWF, con allowFullScreen definido como "true", como se muestra en el siguiente ejemplo:

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

  Una página HTML también puede utilizar un script para generar etiquetas que incorporan SWF. Es necesario que altere el script para que inserte el parámetro allowFullScreen adecuado. Las páginas HTML generadas por Flash y FlexBuilder utilizan la función AC_FL_RunContent() para incorporar referencias a archivos SWF y necesita añadir los valores de parámetro allowFullScreen, como se muestra a continuación:

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

• El modo de pantalla completa se inicia en respuesta al clic del ratón o a la pulsación de una tecla por parte del usuario; la película no puede cambiar Stage.displayState sin una entrada del usuario. Mientras Flash Player está en modo de pantalla completa, se desactivan todas las entradas de teclado (salvo los métodos abreviados de teclado que permiten que el usuario salga del modo de pantalla completa). Cuando los usuarios entran en el modo de pantalla completa, aparece un cuadro de diálogo de Flash Player sobre la película para informar el modo en el que están y que pueden presionar la tecla Esc para salir del modo de pantalla completa.
• A partir de Flash Player Update 3 y versiones posteriores, el funcionamiento de pantalla completa es el mismo en el modo sin ventana que en el de ventana. Si establece el modo de ventana (wmode en el HTML) en Opaco sin ventanas (opaque) o Transparente sin ventanas (transparent), se puede iniciar la pantalla completa, pero la ventana será siempre opaca.

Véase también

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

El objeto interactivo que está seleccionado por el teclado; o null si no se ha establecido la selección o si el objeto seleccionado pertenece a un entorno limitado de seguridad al que el objeto que origina la llamada no dispone de acceso.

Obtiene y establece la velocidad de fotogramas del escenario. La velocidad de fotogramas se expresa en fotogramas por segundo. De manera predeterminada, la velocidad se establece con la velocidad de fotogramas del primer archivo SWF cargado. El intervalo válido de velocidades de fotogramas es de 0,01 a 1000 fotogramas por segundo.

Nota: es posible que Flash Player no pueda seguir configuraciones altas de velocidad de fotogramas, bien porque la plataforma de destino no sea lo suficientemente rápida o porque el reproductor esté sincronizado con la temporización en blanco vertical del dispositivo de visualización (normalmente 60 Hz en dispositivos LCD). En algunos casos, una plataforma de destino puede también optar por reducir la velocidad de fotogramas máxima si prevé un uso intensivo de la CPU.

Devuelve la altura del monitor que se utilizará cuando se pase al tamaño de pantalla completa, si ese estado se activa inmediatamente. Si el usuario tiene varios monitores, se emplea el que muestra la mayoría del escenario en ese momento.

Nota: si el usuario tiene la posibilidad de mover el navegador de un monitor a otro entre la recuperación del valor y el paso al tamaño de pantalla completa, el valor podría ser incorrecto. Si recupera el valor en un controlador de eventos que establece Stage.displayState en StageDisplayState.FULL_SCREEN, el valor será correcto.

Ésta es la altura en píxeles del monitor y es igual a la altura del escenario si Stage.align se establece en StageAlign.TOP_LEFT y Stage.scaleMode en StageScaleMode.NO_SCALE.

Versión del reproductor: Flash Player 9 Update 3.

Véase también

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

Establece Flash Player para que ajuste una región concreta en el modo de pantalla completa. Si está disponible, Flash Player aplica la escala de hardware, que utiliza la tarjeta gráfica y de vídeo del equipo del usuario, con lo que normalmente muestra el contenido con mayor rapidez que con la escala de software.

Cuando esta propiedad se establece en un rectángulo válido y la propiedad displayState se define en modo de pantalla completa, Flash Player ajusta el área especificada. El tamaño real del escenario expresado en píxeles dentro de ActionScript no cambia. Flash Player aplica un límite mínimo para el tamaño del rectángulo de modo que se ajuste al mensaje estándar "Press Esc to exit full-screen mode". Este límite suele ser 260 x 30 píxeles, pero puede variar según la plataforma y la versión de Flash Player.

Esta propiedad sólo se puede definir cuando Flash Player no está en modo de pantalla completa. Para utilizar correctamente esta propiedad, deberá establecerla primero, después establecer la propiedad displayState en el modo de pantalla completa, como se muestra en los ejemplos de código.

Para activar la escala, establezca la propiedad fullScreenSourceRect en un objeto rectangle:

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

Para desactivar la escala, establezca fullScreenSourceRect=null en ActionScript 3.0 y undefined en ActionScript 2.0.

  stage.fullScreenSourceRect = null;
  

El usuario final también puede seleccionar dentro de la configuración de pantalla de Flash Player la desactivación de la escala de hardware, activada de manera predeterminada. Para más información, consulte www.adobe.com/go/display_settings_es.

Versión del reproductor: Flash Player 9 Update 3.

Véase también

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 {

        }
    }
}

Devuelve el ancho del monitor que se utilizará cuando se pase al tamaño de pantalla completa, si ese estado se activa inmediatamente. Si el usuario tiene varios monitores, se emplea el que muestra la mayoría del escenario en ese momento.

Nota: si el usuario tiene la posibilidad de mover el navegador de un monitor a otro entre la recuperación del valor y el paso al tamaño de pantalla completa, el valor podría ser incorrecto. Si recupera el valor en un controlador de eventos que establece Stage.displayState en StageDisplayState.FULL_SCREEN, el valor será correcto.

Éste es el ancho en píxeles del monitor y es igual al ancho del escenario si Stage.align se establece en StageAlign.TOP_LEFT y Stage.scaleMode en StageScaleMode.NO_SCALE.

Versión del reproductor: Flash Player 9 Update 3.

Véase también

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

Indica la altura del objeto de visualización, expresada en píxeles. La anchura se calcula según los límites del contenido del objeto de visualización. Cuando define la propiedad height, la propiedad scaleY se ajusta en consecuencia, tal y como se muestra en el siguiente código:

 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;

Excepto en lo que respecta a los objetos TextField y Video, un objeto de visualización sin contenido (como un sprite vacío) tiene una altura de 0, incluso si intenta definir height en un valor diferente.

Determina si los elementos secundarios del objeto están habilitados para ratón. Si un objeto está habilitado para ratón, el usuario puede interactuar con él empleando un ratón. El valor predeterminado es true.

Esta propiedad es útil cuando se crea un botón con una instancia de la clase Sprite (en lugar de utilizar la clase SimpleButton). Cuando utilice una instancia de Sprite para crear un botón, podrá optar por decorar el botón empleando el método addChild() para añadir instancias adicionales de Sprite. Este proceso puede provocar un comportamiento inesperado con los eventos de ratón, ya que las instancias de Sprite que añada como elementos secundarios pueden convertirse en el objeto de destino de un evento de ratón cuando se espera que la instancia principal sea el objeto de destino. Para asegurarse de que la instancia principal actúa como objeto de destino de los eventos de ratón, puede establecer la propiedad mouseChildren de la instancia principal con el valor false.

No se distribuye ningún evento al establecer esta propiedad. Debe utilizar el método addEventListener() para crear funcionalidad interactiva.

Devuelve el número de elementos secundarios de este objeto.

Valor de la clase StageQuality que especifica la calidad de representación que utiliza Flash Player. Los valores siguientes son válidos:

• StageQuality.LOW: calidad de representación baja. No se suavizan ni los gráficos ni los mapas de bits.
• StageQuality.MEDIUM: calidad de representación media. Los gráficos se suavizan empleando una cuadrícula de 2 x 2 píxeles, pero los mapas de bits no se suavizan. Este ajuste resulta adecuado para películas que no incluyan texto.
• StageQuality.HIGH: calidad de representación alta. Los gráficos se suavizan empleando una cuadrícula de 4 x 4 píxeles, mientras que los mapas de bits se suavizan si la película es estática. Esta es la calidad de representación predeterminada que utiliza Flash Player.
• StageQuality.BEST: calidad de representación muy alta. Los gráficos se suavizan empleando una cuadrícula de 4 x 4 píxeles y los mapas de bits se suavizan siempre.

Véase también

Un valor de la clase StageScaleMode que especifica el modo de escala que debe utilizarse. Los valores siguientes son válidos:

• StageScaleMode.EXACT_FIT: permite ver toda la aplicación Flash en el área especificada sin distorsión, al tiempo que mantiene la proporción original de la aplicación. Es posible que aparezcan bordes a ambos lados de la aplicación.
• StageScaleMode.SHOW_ALL: hace que esté visible toda la aplicación Flash en el área especificada sin intentar mantener la proporción original. Puede ocurrir una distorsión.
• StageScaleMode.NO_BORDER: toda la aplicación Flash completa ocupa el área especificada, sin distorsión pero quizá con algún recorte, mientras se mantiene la proporción original de la aplicación.
• StageScaleMode.NO_SCALE: la aplicación Flash completa queda fija, de manera que permanezca sin cambios aunque cambie el tamaño de la ventana del reproductor. Puede producirse un recorte si la ventana del reproductor es más pequeña que el contenido.

Véase también

Especifica si deben mostrarse u ocultarse los elementos predeterminados del menú contextual de Flash Player.

Si la propiedad showDefaultContextMenu se establece con el valor true (que es el valor predeterminado), aparecerán todos los elementos del menú contextual. Si la propiedad showDefaultContextMenu se establece con el valor false, sólo aparecerán los elementos de menú Configuración y Acerca de Adobe Flash Player.

Especifica si los objetos deben mostrar un borde brillante cuando están seleccionados.

La altura actual del escenario en píxeles.

Cuando el valor de la propiedad Stage.scaleMode se establece como StageScaleMode.NO_SCALE, la propiedad stageHeight representa la altura de la ventana de Flash Player. Cuando el valor de Stage.scaleMode no se establece como StageScaleMode.NO_SCALE, stageHeight representa la altura del archivo SWF. No se puede establecer esta propiedad.

Véase también

Especifica la anchura actual del escenario en píxeles.

Cuando el valor de la propiedad scaleMode se establece como StageScaleMode.NO_SCALE, la propiedad stageWidth representa la anchura de Flash Player. Esto significa que la propiedad stageWidth variará al redimensionar la ventana de Flash Player. Cuando el valor de la propiedad scaleMode no se establece como StageScaleMode.NO_SCALE, la propiedad stageWidth representa la anchura del archivo SWF configurada durante la edición en el cuadro de diálogo Propiedades del documento. Esto significa que el valor de la propiedad stageWidth se mantiene constante al redimensionar la ventana de Flash Player. No se puede establecer esta propiedad.

Véase también

Determina si los elementos secundarios del objeto están habilitados para tabulación. Activa o desactiva la tabulación para los elementos secundarios del objeto. El valor predeterminado es true.

Devuelve un objeto TextSnapshot para esta instancia de DisplayObjectContainer.

Indica la anchura del objeto de visualización, expresada en píxeles. La anchura se calcula según los límites del contenido del objeto de visualización. Cuando define la propiedad width, la propiedad scaleX se ajusta en consecuencia, tal y como se muestra en el siguiente código:

 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;

Excepto en lo que respecta a los objetos TextField y Video, un objeto de visualización sin contenido (como un sprite vacío) tiene una anchura de 0, incluso si intenta definir width en un valor diferente.

Si añade un objeto secundario que ya tiene un contenedor de objeto de visualización diferente como elemento principal, el objeto se elimina de la lista de elementos secundarios del otro contenedor de objeto de visualización.

Parámetros

Véase también

Por ejemplo, el siguiente ejemplo muestra tres objetos de visualización, etiquetados como a, b y c, en las posiciones de índice 0, 2 y 1 respectivamente:

Si añade un objeto secundario que ya tiene un contenedor de objeto de visualización diferente como elemento principal, el objeto se elimina de la lista de elementos secundarios del otro contenedor de objeto de visualización.

Parámetros

Véase también

Una vez registrado correctamente un detector de eventos, no puede cambiar su prioridad mediante llamadas adicionales a addEventListener(). Para cambiar la prioridad de un detector, en primer lugar debe llamar a removeListener(). Seguidamente, puede volver a registrar el nuevo nivel de prioridad.

Recuerde que, una vez registrado el detector, las siguientes llamadas a addEventListener() con un valor type o useCapture distinto tendrán como resultado la creación de un registro independiente del detector. Por ejemplo, si registra primero un detector con useCapture definido como true, detectará únicamente durante la fase de captura. Si vuelve a llamar a addEventListener() con el mismo objeto detector, pero con useCapture definido como false, tendrá dos detectores independientes: uno que detecta durante la fase de captura y otro que lo hace durante las fases de destino y de propagación.

No es posible registrar un detector de eventos únicamente para la fase de destino o la fase de propagación. Dichas fases se acoplan durante el registro, ya que la propagación sólo se aplica a los ascendientes del nodo de destino.

Si ya no necesita ningún detector de eventos, elimínelo llamando a removeEventListener(); de lo contrario, podrían surgir problemas de memoria. Los objetos con detectores de eventos registrados no se eliminan automáticamente de la memoria, ya que el recolector de datos innecesarios no elimina objetos que aún tienen referencias.

Al copiar una instancia EventDispatcher no se copian los detectores de eventos asociados. (Si el nodo recién creado necesita un detector de eventos, debe asociarlo después de crear el nodo). Sin embargo, si mueve una instancia EventDispatcher, los detectores de eventos asociados se moverán también.

Si el detector de eventos se registra en un nodo mientras se procesa un evento en dicho nodo, el detector de eventos no se desencadenará durante la fase actual, aunque sí se desencadenará en una fase posterior del flujo del evento, por ejemplo, en la fase de propagación.

Si un detector de eventos se elimina de un nodo mientras se procesa un evento en dicho nodo, las acciones actual seguirán desencadenándolo. Una vez eliminado, el detector de eventos ya no se vuelve a invocar nunca más (a no ser que se registre de nuevo para otro proceso).

Parámetros

Véase también

Parámetros

La diferencia entre hasEventListener() y willTrigger() reside en que hasEventListener() examina sólo el objeto al que pertenece, mientras que willTrigger() examina todo el flujo del evento especificado por el parámetro type.

Si se llama a hasEventListener() desde un objeto LoaderInfo, sólo se tendrán en cuenta los detectores a los que puede acceder el que origina la llamada.

Parámetros

Al llamar al método invalidate(), se indica a Flash Player que avise a los objetos de visualización de la próxima oportunidad que tendrán para representar la lista de visualización (por ejemplo, cuando la cabeza lectora avanza a un nuevo fotograma). Tras llamar al método invalidate(), cuando la lista de visualización se vuelva a representar, Flash Player enviará un evento render a cada objeto de visualización que se haya registrado para detectar el evento render. Debe llamar al método invalidate() cada vez que desee que Flash Player envíe eventos render.

El evento render le da la oportunidad de realizar cambios en la lista de visualización inmediatamente antes de que se muestre. Esto le permite retrasar las actualizaciones de la lista de visualización hasta la oportunidad más reciente. Esto puede aumentar el rendimiento al eliminar actualizaciones de pantalla innecesarias.

El evento render sólo se distribuye para mostrar objetos que están en el mismo dominio de seguridad que le código que llama al método stage.invalidate() o para mostrar objetos de un dominio de seguridad al que se ha concedido permiso a través del método Security.allowDomain().

Véase también

Determina si la propiedad Stage.focus devuelve null por motivos de seguridad. Dicho de otro modo, isFocusInaccessible devuelve true si el objeto que está seleccionado pertenece a un entorno limitado de seguridad al que no tiene acceso el archivo SWF.

La recogida de datos innecesarios (garbage collector) es el proceso mediante el cual Flash Player reasigna el espacio de memoria no utilizado. Cuando deja de haber una referencia activa o un almacenamiento de una variable o un objeto en algún lugar, la recogida de datos innecesarios limpia el espacio de memoria que ocupaba si no hay ninguna otra referencia a estos.

Parámetros

Al utilizar el método setChildIndex() y especificar una posición de índice que ya está ocupada, el elemento secundario que ocupa dicha posición y todos los objetos situados por encima en la lista de elementos secundarios subirán una posición en la lista. Por ejemplo, si el contenedor de objeto secundario del ejemplo anterior se denomina container, podrá intercambiar la posición de los objetos de visualización etiquetados como a y b llamando al siguiente código:

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

Este código da como resultado la siguiente disposición de objetos:

Parámetros

Parámetros

La diferencia entre los métodos hasEventListener() y willTrigger() reside en que hasEventListener() examina sólo el objeto al que pertenece, mientras que el método willTrigger() examina todo el flujo del evento especificado por el parámetro type.

Si se llama a willTrigger() desde un objeto LoaderInfo, sólo se tendrán en cuenta los detectores a los que puede acceder la función que origina la llamada.

Parámetros

Se distribuye por Flash Player cuando el objeto Stage pasa a, o deja de estar en, modo de pantalla completa. El cambio a modo de pantalla completa se puede iniciar a través de ActionScript o cuando el usuario utiliza un método abreviado del teclado, o bien si la selección actual abandona la ventana de pantalla completa.

Este evento tiene las propiedades siguientes:

Lo distribuye el objeto Stage cuando el puntero del ratón sale del área de la ventana de Flash Player.

Este evento tiene las propiedades siguientes:

Se distribuye cuando la propiedad scaleMode del objeto Stage se establece como StageScaleMode.NO_SCALE y se cambia el tamaño del archivo SWF.

Este evento tiene las propiedades siguientes:

1. El constructor de la clase establece primero la aplicación Flash que se va a fijar, independientemente del tamaño de la ventana de Flash Player y luego añade dos detectores de eventos con los métodos activateHandler() y resizeHandler().
2. Se ejecuta el método activateHandler() cuando se hace clic en el botón izquierdo del ratón.
3. Se ejecuta el método resizeHandler() cuando cambia el tamaño del escenario.

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