DisplayObject  - AS3

Las opciones de accesibilidad actuales para este objeto de visualización. Si modifica la propiedad accessibilityProperties o alguno de los campos contenidos en accessibilityProperties, deberá llamar al método Accessibility.updateProperties() para que los cambios surtan efecto.

Nota: en el caso de un objeto creado en el entorno de edición de Flash, el valor de accessibilityProperties se rellena previamente con la información que haya introducido en el panel Accesibilidad para dicho objeto.

Elementos de API relacionados

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

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

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

tf.accessibilityProperties = accessProps;

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

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

Indica el valor de transparencia alfa del objeto especificado. Los valores válidos son los comprendidos entre 0 (totalmente transparente) y 1 (totalmente opaco). El valor predeterminado es 1. Los objetos de visualización que tienen alpha configurado con el valor 0 están activos, aunque no sean visibles.

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

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

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

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

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

Un valor de la clase BlendMode que especifica el modo de mezcla que debe utilizarse. Un mapa de bits puede dibujarse internamente de dos formas. Si tiene un modo de mezcla o una máscara de recorte externa, el mapa de bits se dibuja añadiendo una figura cuadrada rellena con un mapa de bits al procesador de vectores. Si intenta establecer esta propiedad con un valor no válido, los motores de ejecución de Flash establecerán el valor como BlendMode.NORMAL.

La propiedad blendMode afecta a cada píxel del objeto de visualización. Cada píxel consta de los tres colores primarios (rojo, verde y azul). Cada color primario tiene un valor comprendido entre 0x00 y 0xFF. Flash Player o Adobe AIR compara cada color primario de un píxel del clip de película con el color correspondiente del píxel en el fondo. Por ejemplo, si blendMode se define como BlendMode.LIGHTEN, Flash Player o Adobe AIR compara el valor de rojo del objeto de visualización con el valor de rojo del fondo y utiliza el color más claro de los dos como valor del componente rojo para el color de visualización.

La tabla siguiente describe los valores de blendMode: La clase BlendMode define los valores de cadena que puede utilizar. Las ilustraciones de la tabla muestran los valores blendMode aplicados a un objeto de visualización circular (2) superpuesto a otro objeto de visualización (1).

Constante BlendMode	Ilustración	Descripción
BlendMode.NORMAL		El objeto de visualización aparece delante del fondo. Los valores de píxel del objeto de visualización anulan a los del fondo. Cuando el objeto de visualización sea transparente, el fondo será visible.
BlendMode.LAYER		Fuerza la creación de un grupo de transparencia para el objeto de visualización. Esto significa que el objeto de visualización se compone previamente en un búfer temporal antes de proseguir su procesamiento. Esto se hace automáticamente si el objeto de visualización cuenta con un caché previo a través de caché de mapa de bits o si el objeto de visualización es un contenedor de objeto de visualización con al menos un objeto secundario que tenga una configuración de blendMode distinta de BlendMode.NORMAL. No se admite en procesamiento de GPU.
BlendMode.MULTIPLY		Multiplica los valores de los colores primarios del objeto de visualización por los del color del fondo y luego normaliza el resultado dividiéndolo por 0xFF, lo que da como resultado colores más oscuros. Este valor se suele utilizar para efectos de sombras y profundidad. Por ejemplo, si un color primario (como el rojo) de un píxel del objeto de visualización y el color correspondiente del píxel del fondo tienen ambos el valor 0x88, el resultado de la multiplicación será 0x4840. Al dividir por 0xFF el resultado es 0x48 para dicho color primario, consiguiéndose un tono más oscuro que el del objeto de visualización o el del fondo.
BlendMode.SCREEN		Multiplica el complemento (inverso) del color del objeto de visualización por el complemento del color de fondo, con lo que se obtiene un efecto de decoloración. Este valor se suele utilizar para los resaltados o para eliminar áreas de color negro del objeto de visualización.
BlendMode.LIGHTEN		Selecciona el color primario más claro del objeto de visualización y el color del fondo (los colores que tengan mayores valores). Este valor suele emplearse para el tipo de superposición. Por ejemplo, si el objeto de visualización tiene un píxel con un valor RGB de 0xFFCC33, y el píxel del fondo tiene un valor RGB de 0xDDF800, el valor RGB resultante para el píxel mostrado es de 0xFFF833 (debido a que 0xFF > 0xDD, 0xCC > 0xF8 y 0x33 > 0x00 = 33). No se admite en procesamiento de GPU.
BlendMode.DARKEN		Selecciona el color primario más oscuro del objeto de visualización y el color del fondo (los colores que tengan valores más bajos). Este valor suele emplearse para el tipo de superposición. Por ejemplo, si el objeto de visualización tiene un píxel con un valor RGB de 0xFFCC33, y el píxel del fondo tiene un valor RGB de 0xDDF800, el valor RGB resultante para el píxel mostrado es de 0xDDCC00 (debido a que 0xFF > 0xDD, 0xCC < 0xF8 y 0x33 > 0x00 = 33). No se admite en procesamiento de GPU.
BlendMode.DIFFERENCE		Compara los colores primarios del objeto de visualización con los del fondo y resta el valor más oscuro del valor más claro de los colores primarios. Este valor suele emplearse en los colores más vivos. Por ejemplo, si el objeto de visualización tiene un píxel con un valor RGB de 0xFFCC33, y el píxel del fondo tiene un valor RGB de 0xDDF800, el valor RGB resultante para el píxel mostrado es de 0x222C33 (debido a que 0xFF - 0xDD = 0x22, 0xF8 - 0xCC = 0x2C y 0x33 - 0x00 = 0x33).
BlendMode.ADD		Añade los valores de los colores primarios del objeto de visualización a los del fondo con un límite de 0xFF. Este valor suele emplearse para animar una disolución de aclarado entre dos objetos. Por ejemplo, si el objeto de visualización tiene un píxel con un valor RGB de 0xAAA633, y el píxel del fondo tiene un valor RGB de 0xDD2200, el valor RGB resultante para el píxel mostrado es de 0xFFC833 (debido a que 0xAA + 0xDD > 0xFF, 0xA6 + 0x22 = 0xC8 y 0x33 + 0x00 = 0x33).
BlendMode.SUBTRACT		Resta los valores de los colores primarios del objeto de visualización de los valores del color de fondo, aplicando un límite inferior de 0. Suele utilizarse para animar una disolución de oscurecimiento entre dos imágenes. Por ejemplo, si el objeto de visualización tiene un píxel con un valor RGB de 0xAA2233, y el píxel del fondo tiene un valor RGB de 0xDDA600, el valor RGB resultante para el píxel mostrado es de 0x338400 (debido a que 0xDD - 0xAA = 0x33, 0xA6 - 0x22 = 0x84 y 0x00 - 0x33 < 0x00).
BlendMode.INVERT		Invierte el fondo.
BlendMode.ALPHA		Aplica el valor alfa de cada píxel del objeto de visualización al fondo. Esto requiere que la configuración de blendMode del objeto de visualización principal se establezca como BlendMode.LAYER. Por ejemplo, en la ilustración, el objeto de visualización principal, un fondo blanco, tiene blendMode = BlendMode.LAYER. No se admite en procesamiento de GPU.
BlendMode.ERASE		Borra el fondo en función del valor alfa del objeto de visualización. Esto requiere que la configuración de blendMode del objeto de visualización principal se establezca como BlendMode.LAYER. Por ejemplo, en la ilustración, el objeto de visualización principal, un fondo blanco, tiene blendMode = BlendMode.LAYER. No se admite en procesamiento de GPU.
BlendMode.OVERLAY		Ajusta el color de cada píxel en función de la oscuridad del fondo. Si el fondo es más claro que un 50% de gris, los colores del objeto de visualización y del fondo se tamizan, consiguiéndose un color más claro. Si el fondo es más oscuro que un 50% de gris, los colores del clip de película y del fondo se multiplican, consiguiéndose un color más oscuro. Este valor suele emplearse para conseguir efectos de sombreado. No se admite en procesamiento de GPU.
BlendMode.HARDLIGHT		Ajusta el color de cada píxel en función de la oscuridad del objeto de visualización. Si el objeto de visualización es más claro que un 50% de gris, los colores del objeto de visualización y del fondo se tamizan, consiguiéndose un color más claro. Si el objeto de visualización es más oscuro que un 50% de gris, los colores del clip de película y del fondo se multiplican, consiguiéndose un color más oscuro. Este valor suele emplearse para conseguir efectos de sombreado. No se admite en procesamiento de GPU.
BlendMode.SHADER	N/D	Ajusta el color por medio de una rutina personalizada de sombreado. El sombreado que se utiliza se especifica como la instancia de Shader asignada a la propiedad blendShader. Establecer la propiedad blendShader de un objeto de visualización como una instancia de Shader define automáticamente la propiedad blendMode del objeto de visualización en BlendMode.SHADER. Si la propiedad blendMode se establece como BlendMode.SHADER sin definir primero la propiedad blendShader, la propiedad blendMode se establecerá como BlendMode.NORMAL. No se admite en procesamiento de GPU.

Elementos de API relacionados

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

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

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

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

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

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

Define un sombreado para utilizarlo en la mezcla del primer plano y del fondo. Si la propiedad blendMode se establece como BlendMode.SHADER, se utiliza el objeto Shader especificado para crear la salida del modo de mezcla del objeto de visualización.

Establecer la propiedad blendShader de un objeto de visualización como una instancia de Shader define automáticamente la propiedad blendMode del objeto de visualización en BlendMode.SHADER. Si la propiedad blendShader se establece (y define la propiedad blendMode en BlendMode.SHADER), el valor de la propiedad blendMode cambia. El modo de mezcla se puede restablecer para usar el sombreado de mezcla simplemente configurando la propiedad blendMode como BlendMode.SHADER. No es necesario volver a establecer la propiedad blendShader salvo para cambiar el sombreado utilizado para el modo de mezcla.

El objeto Shader asignado a la propiedad blendShader debe especificar al menos dos entradas image4. No es necesario que las entradas se especifiquen con código de la propiedad input asociada al objeto ShaderInput. El objeto de visualización en segundo plano se utiliza automáticamente como la primera entrada (la entrada con index 0). El objeto de visualización en primer plano se utiliza como la segunda entrada (la entrada con index 1). Un sombreado utilizado como sombreado de mezcla puede especificar más de dos entrada. En ese caso, cualquier entrada adicional también debe especificarse estableciendo su propiedad input de la instancia de ShaderInput.

Cuando asigna una instancia de Shader a esta propiedad, el sombreado se copia internamente. La operación de mezcla utiliza la copia interna, no una referencia al sombreado original. Todos los cambios realizados en el objeto shader, como la modificación de los valores de los parámetros, la entrada o el código de bytes, no se aplican al sombreado copiado que se utiliza en el modo de mezcla.

Elementos de API relacionados

Si se define como true, los motores de ejecución de Flash guardan en caché una representación interna de mapa de bits del objeto de visualización. Este caché puede aumentar el rendimiento de los objetos de visualización que tienen contenido vectorial complejo.

Todos los datos vectoriales de un objeto de visualización con un mapa de bits en caché se dibujan en el mapa de bits, no en la visualización principal. Si cacheAsBitmapMatrix es null o no se admite, el mapa de bits se copia en la visualización principal como píxeles no expandidos ni rotados, pero ajustados a los límites del píxel más cercano. Los píxeles se asignan de 1 a 1 con el objeto principal. Si los límites del mapa de bits cambian, el mapa de bits se vuelve a crear en lugar de expandirse.

Si cacheAsBitmapMatrix no es null y se admite, el objeto se dibuja en el mapa de bits fuera de la pantalla con dicha matriz y los resultados estirados/girados de la representación se utilizan para dibujar el objeto en la pantalla principal.

No se crea ningún mapa de bits interno a menos que la propiedad cacheAsBitmap esté definida como true.

Después de definir la propiedad cacheAsBitmap como true, la representación no varía, pero el objeto de visualización realiza automáticamente el ajuste en píxeles. La velocidad de animación puede ser notablemente mayor según la complejidad del contenido vectorial.

La propiedad cacheAsBitmap se establece automáticamente en true siempre que se aplica un filtro a un objeto de visualización (cuando su conjunto filter no está vacía) y, si un objeto de visualización tiene aplicado un filtro, cacheAsBitmap será true para ese objeto de visualización, aunque la propiedad se haya configurado como false. Si borra todos los filtros de un objeto de visualización, la configuración de cacheAsBitmap cambia a su valor anterior.

Un objeto de visualización no utiliza un mapa de bits aunque la propiedad cacheAsBitmap se haya definido como true, sino que se representa a partir de datos vectoriales en los siguientes casos:

• El mapa de bits es demasiado grande. En AIR 1.5 y en Flash Player 10, el tamaño máximo de una imagen de mapa de bits es 8.191 píxeles de anchura o de altura, y el número total de píxeles no puede superar los 16.777.215. (De modo que si una imagen de mapa de bits tiene una anchura de 8.191 píxeles, puede tener una altura máxima de 2.048.) En Flash Player 9 y en versiones anteriores, la limitación es de 2.880 píxeles de altura y 2.880 de anchura.
• El mapa de bits no puede asignarse (error de memoria insuficiente).

La propiedad cacheAsBitmap es idónea con clips de película que tienen sobre todo contenido estático y no cambian de escala ni giran con frecuencia. Con estos clips, cacheAsBitmap puede aumentar el rendimiento cuando se convierte el clip de película (cuando se modifica la posición de x e y).

Elementos de API relacionados

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

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

addChild(circle);

trace(circle.cacheAsBitmap); // false

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

trace(circle.cacheAsBitmap); // true

Si su valor no es null, este objeto Matrix define cómo un objeto de visualización se procesa cuando cacheAsBitmap se define como true. La aplicación utiliza esta matriz como una matriz de transformación que se aplica para procesar la versión de mapa de bits del objeto de visualización.

Compatibilidad con perfil de AIR: esta característica se admite en dispositivos móviles compatibles, pero no se admite en sistemas operativos de escritorio. También tiene soporte limitado en dispositivos de AIR para TV. En concreto, en dispositivos de AIR para TV, las transformaciones admitidas incluyen la escala y la traslación, pero no la rotación y el sesgo. Consulte Compatibilidad con perfil de AIR para obtener información sobre la compatibilidad de la API con varios perfiles.

Con cacheAsBitmapMatrix definido, la aplicación conserva una imagen de mapa de bits en caché con diversas transformaciones 2D, incluidas traslación, rotación y escala. Si la aplicación utiliza aceleración de hardware, el objeto se almacenará en memoria de vídeo como textura. Esto permite a la GPU aplicar las transformaciones admitidas en el objeto. La GPU es capaz de realizar estas transformaciones más rápido que la CPU.

Para usar la aceleración de hardware, establezca Procesamiento en GPU en la ficha General del cuadro de diálogo Ajustes de iPhone en Flash Professional CS5. O establezca la propiedad renderMode en gpu en el archivo descriptor de la aplicación. Hay que tener en cuenta que los dispositivos de AIR para TV utilizan automáticamente la aceleración de hardware si está disponible.

Por ejemplo, el código siguiente envía una representación de mapa de bits sin transformación del objeto de visualización a la GPU:

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

Normalmente, la matriz de identidad (new Matrix()) basta. Sin embargo, puede utilizar otra matriz (una con menor escala, por ejemplo) para cargar un mapa de bits distinto a la GPU. Por ejemplo, aquí se aplica una matriz cacheAsBitmapMatrix que se escala por 0,5 en los ejes x e y. El objeto de mapa de bits utilizado por la GPU es más pequeño, sin embargo la GPU ajusta su tamaño para coincidir con la propiedad transform.matrix del objeto de visualización:

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

Generalmente, se elige una matriz que se adapte al tamaño del objeto de visualización que aparecerá en la aplicación. Por ejemplo, si la aplicación muestra una versión de mapa de bits del elemento Sprite con la escala reducida a la mitad, utilice una matriz que reduzca su escala también a la mitad. Si la aplicación mostrará el elemento Sprite más grande que sus dimensiones actuales, utilice una matriz que aumente su escala en la misma proporción.

Nota: la propiedad cacheAsBitmapMatrix es adecuada para transformaciones 2D. Si necesita aplicar transformaciones en 3D, puede hacerlo estableciendo un propiedad 3D del objeto y manipulando su propiedad transform.matrix3D. Si la aplicación se empaqueta en modo GPU, permite transformaciones 3D aplicadas al objeto por la GPU. cacheAsBitmapMatrix se omite en objetos 3D.

Elementos de API relacionados

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

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

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

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

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

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

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

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

my_shape.transform.matrix = tempMat;

function timerHandler(evt:TimerEvent):void {

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

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

Conjunto indexado que contiene todos los objetos de filtro actualmente asociados con el objeto de visualización. El paquete flash.filters contiene varias clases que definen filtros específicos que puede utilizar.

Los filtros pueden aplicarse en tiempo de diseño en Flash Professional o en tiempo de ejecución mediante código ActionScript. Para aplicar un filtro con ActionScript, debe realizar una copia temporal de todo el conjunto filters, modificar el conjunto temporal y volver a asignar el valor del conjunto temporal al conjunto filters. Al conjunto filters no se le pueden añadir directamente objetos filter nuevos.

Para añadir un filtro con ActionScript, debe seguir estos pasos (suponiendo que el objeto de visualización de destino se denomina myDisplayObject):

1. Cree un nuevo objeto de filtro con el método constructor de la clase de filtro que haya elegido.
2. Asigne el valor del conjunto myDisplayObject.filters a un conjunto temporal, denominado por ejemplo myFilters.
3. Añada el nuevo objeto filter al conjunto temporal, myFilters.
4. Asigne el valor del conjunto temporal al conjunto myDisplayObject.filters.

Si el conjunto filters no está definida, no tendrá que utilizar un conjunto temporal. En lugar de ello, podrá asignar directamente un literal de conjunto que contenga uno o varios objetos filter que ha creado. El primer ejemplo de la sección Ejemplos añade un filtro de sombra mediante código que gestiona conjuntos filters tanto definidos como no definidos.

Para modificar un objeto de filtro existente, debe utilizar la técnica de modificación de una copia del conjunto filters:

1. Asigne el valor del conjunto filters a un conjunto temporal denominado, por ejemplo, myFilters.
2. Modifique la propiedad utilizando el conjunto temporal, myFilters. Por ejemplo, para establecer la propiedad quality del primer filtro del conjunto, podría utilizar el código siguiente: myFilters[0].quality = 1;
3. Asigne el valor del conjunto temporal al conjunto filters.

Durante la carga, si un objeto de visualización tiene un filtro asociado, se marca para guardarlo en caché como mapa de bits transparente. Desde ese momento, siempre y cuando el objeto de visualización tenga una lista de filtros válida, el reproductor guardará el objeto de visualización en caché como mapa de bits. Este mapa de bits de origen se utiliza como imagen de origen para los efectos de filtro. Normalmente, un objeto de visualización tiene dos mapas de bits: uno con el objeto de visualización de origen sin filtrar (original) y otro con la imagen final una vez filtrada. La imagen final es la que se utiliza en representaciones. Mientras el objeto de visualización no cambie, la imagen final no necesita actualización.

El paquete flash.filters incluye clases para filtros. Por ejemplo, para crear un filtro DropShadow, deberá escribir:

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

Puede utilizar el operador is para determinar el tipo de filtro asignado a cada posición de índice en el conjunto filter. Por ejemplo, el siguiente código muestra cómo determinar la posición del primer filtro del conjunto filters que es un filtro DropShadowFilter:

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

Nota: como no puede añadir directamente un nuevo objeto de filtro al conjuntoDisplayObject.filters, el siguiente código no afecta de ninguna manera al objeto de visualización de destino, denominado myDisplayObject:

     myDisplayObject.filters.push(myDropShadow);
     

Elementos de API relacionados

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.

import flash.text.TextField;

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

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

Devuelve un objeto LoaderInfo que contiene información sobre la carga del archivo al que pertenece este objeto de visualización. La propiedad loaderInfo sólo se define para el objeto de visualización raíz de un archivo SWF o para un mapa de bits cargado (no para un mapa de bits dibujado con ActionScript). Para encontrar el objeto loaderInfo asociado al archivo SWF que contiene un objeto de visualización llamado myDisplayObject, utilice myDisplayObject.root.loaderInfo.

Un archivo SWF grande puede controlar su descarga llamando a this.root.loaderInfo.addEventListener(Event.COMPLETE, func).

Elementos de API relacionados

 trace (this.loaderInfo.url);
 

El objeto de visualización que origina la llamada se enmascara mediante el objeto mask especificado. Para asegurarse de que el enmascaramiento funciona al aplicar escala al escenario, el objeto de visualización mask debe encontrarse en una parte activa de la lista de visualización. El objeto mask propiamente dicho no se dibuja. Establezca mask con el valor null para quitar la máscara.

Para permitir la aplicación de escala a un objeto de máscara, éste debe estar en la lista de visualización. Para poder arrastrar un objeto Sprite de máscara (llamando a su método startDrag()), éste debe encontrarse en la lista de visualización. Para llamar al método startDrag() para una sprite de máscara en un evento mouseDown distribuido por la sprite, establezca la propiedad buttonMode de la sprite con el valor true.

Cuando objetos de visualización se almacenan en caché estableciendo la propiedad cacheAsBitmap como true y la propiedad cacheAsBitmapMatrix como objeto Matrix, tanto la máscara como el objeto de visualización que se está enmascarando deberá formar parte de la misma mapa de bits en caché. Por consiguiente, si el objeto de visualización se almacena en la caché, la máscara debe ser un elemento secundario del objeto de visualización. Si un antecesor del objeto de visualización de la lista está en caché, la máscara debe ser un elemento secundario de dicho antecesor o uno de sus descendientes. Si se almacena en caché más de un antecesor del objeto enmascarado, la máscara debe ser un descendiente de contenedor guardado en caché más cercano al objeto enmascarado en la lista de visualización.

Nota: no se puede utilizar un solo objeto mask para enmascarar más de un objeto de visualización de llamada. Cuando se asigna el objeto mask a un segundo objeto de visualización, se quita, ya que la máscara del primer objeto y la propiedad mask del objeto pasan a ser null.

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

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

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

tf.mask = square;

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

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

Obtiene el objeto de metadatos de la instancia de DisplayObject si los metadatos se almacenaron con la instancia de este objeto DisplayObject en el archivo SWF a través de una etiqueta PlaceObject4.

Indica la coordenada x de la posición del ratón o del dispositivo de entrada del usuario, en píxeles.

Nota: en un objeto DisplayObject girado, la coordenada x devuelta reflejará el objeto sin girar.

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

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

square.addEventListener(MouseEvent.CLICK, traceCoordinates);

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

Indica la coordenada y de la posición del ratón o del dispositivo de entrada del usuario, en píxeles.

Nota: en un objeto DisplayObject girado, la coordenada y devuelta reflejará el objeto sin girar.

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

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

square.addEventListener(MouseEvent.CLICK, traceCoordinates);

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

Indica el nombre de instancia de DisplayObject. El objeto puede identificarse en la lista de elementos secundarios de su contenedor de objeto de visualización principal llamando al método getChildByName() del contenedor de objeto de visualización.

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

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

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

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

Especifica si el objeto de visualización es opaco con un determinado color de fondo. Un mapa de bits transparente contiene datos en el canal alfa y se dibuja de forma transparente. Un mapa de bits opaco no tiene canal alfa (por lo que se muestra más rápido que un mapa de bits transparente). Si el mapa de bits es opaco, deberá especificar el color de fondo.

Si se establece con un número como valor, la superficie será opaca (no transparente) y tendrá el color de fondo RGB que especifique el número. Si se establece con el valor null (el predeterminado), el objeto de visualización tendrá un fondo transparente.

La propiedad opaqueBackground está pensada principalmente para su uso con la propiedad cacheAsBitmap con el fin de optimizar la representación. En objetos de visualización en los que la propiedad cacheAsBitmap se ha establecido como true, la definición de opaqueBackground puede mejorar el rendimiento de la representación.

La región de fondo opaca no halla correspondencias al llamar al método hitTestPoint() con el parámetro shapeFlag definido en true.

La región de fondo opaca no responde a los eventos del ratón.

Elementos de API relacionados

import flash.display.Shape;

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

Indica el objeto DisplayObjectContainer que contiene este objeto de visualización. Utilice la propiedad parent para especificar una ruta de acceso relativa a los objetos de visualización que se encuentran por encima del objeto de visualización en la jerarquía de la lista de visualización.

Puede utilizar parent para subir múltiples niveles en la lista de visualización, como se muestra a continuación:

     this.parent.parent.alpha = 20;
     

import flash.display.Sprite;

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

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

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

Para un objeto de visualización en un archivo SWF cargado, la propiedadroot es el objeto de visualización de nivel más alto en la parte de la estructura de árbol de la lista de visualización representada por dicho archivo SWF. Para un objeto Bitmap que representa a un archivo de imagen cargado, la propiedad root es el objeto Bitmap en sí mismo. Para la instancia de la clase principal del primer archivo SWF cargado, la propiedad root es el objeto de visualización en sí mismo. La propiedad root del objeto Stage es el objeto Stage en sí mismo. La propiedad root se establece con el valor null para los objetos de visualización que no se hayan añadido a la lista de visualización, a no ser que se hayan añadido a un contenedor de objeto de visualización que esté fuera de la lista de visualización pero que sea un elemento secundario del objeto de visualización de nivel más alto en un archivo SWF cargado.

Por ejemplo, si crea un nuevo objeto Sprite llamando al método constructor Sprite(), su propiedad root se establece con el valor null hasta que lo añada a la lista de visualización (o a un contenedor de objeto de visualización que esté fuera de la lista de visualización pero que sea un elemento secundario del objeto de visualización de nivel más alto en un archivo SWF).

Para un archivo SWF cargado, aunque el objeto Loader utilizado para cargar el archivo puede no estar en la lista de visualización, el objeto de visualización de nivel más alto en el archivo SWF tiene configurada la propiedad root como sí mismo. El objeto Loader no tiene la propiedad root configurada hasta que se añade como elemento secundario de un objeto de visualización para el que se ha establecido la propiedad root.

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

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

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

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

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

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

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

Indica el giro de la instancia de DisplayObject, expresado en grados, con respecto a su orientación original. Los valores comprendidos entre 0 y 180 representan un giro en el sentido de las agujas del reloj, mientras que los comprendidos entre 0 y -180 representan un giro en sentido contrario al de las agujas del reloj. Los valores situados fuera de este rango se suman o restan de 360 para obtener un valor que sí esté comprendido en el rango. Por ejemplo, la sentencia my_video.rotation = 450 es igual que my_video.rotation = 90.

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

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

square.addEventListener(MouseEvent.CLICK, rotate);

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

Indica la rotación del eje x de la instancia de DisplayObject, en grados, desde su orientación original relativa al contenedor principal 3D. Los valores comprendidos entre 0 y 180 representan un giro en el sentido de las agujas del reloj, mientras que los comprendidos entre 0 y -180 representan un giro en sentido contrario al de las agujas del reloj. Los valores situados fuera de este rango se suman o restan de 360 para obtener un valor que sí esté comprendido en el rango.

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

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

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

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

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

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

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

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

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

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

Indica la rotación del eje y de la instancia de DisplayObject, en grados, desde su orientación original relativa al contenedor principal 3D. Los valores comprendidos entre 0 y 180 representan un giro en el sentido de las agujas del reloj, mientras que los comprendidos entre 0 y -180 representan un giro en sentido contrario al de las agujas del reloj. Los valores situados fuera de este rango se suman o restan de 360 para obtener un valor que sí esté comprendido en el rango.

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

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

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

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

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

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

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

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

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

Indica la rotación del eje z de la instancia de DisplayObject, en grados, desde su orientación original relativa al contenedor principal 3D. Los valores comprendidos entre 0 y 180 representan un giro en el sentido de las agujas del reloj, mientras que los comprendidos entre 0 y -180 representan un giro en sentido contrario al de las agujas del reloj. Los valores situados fuera de este rango se suman o restan de 360 para obtener un valor que sí esté comprendido en el rango.

La cuadrícula de escala aplicada actualmente. Si se establece como null, la escala de todo el objeto de visualización se aplicará normalmente cuando se aplique cualquier transformación de escala.

Cuando se define la propiedad scale9Grid, el objeto de visualización se divide en una cuadrícula con nueve regiones, basadas en el rectángulo scale9Grid, que define la región central de la cuadrícula. Las otras ocho regiones de la cuadrícula son las siguientes áreas:

• La esquina superior izquierda fuera del rectángulo
• El área situada por encima del rectángulo
• La esquina superior derecha fuera del rectángulo
• El área a la izquierda del rectángulo
• El área a la derecha del rectángulo
• La esquina inferior izquierda fuera del rectángulo
• El área situada por debajo del rectángulo
• La esquina inferior derecha fuera del rectángulo

Puede considerar las ocho regiones externas al centro (que define el rectángulo) como si fueran el marco de un cuadro con reglas especiales cuando se le aplica escala.

Cuando se establece la propiedad scale9Grid y se aplica escala a un objeto de visualización, se aplica escala a todo el texto y los degradados normalmente. Sin embargo, se aplican las reglas siguientes a otros tipos de objetos:

• El contenido de la región central se escala normalmente.
• El contenido de las esquinas no se escala.
• El contenido de las regiones superior e inferior se escala sólo en horizontal. El contenido de las regiones izquierda y derecha se escala sólo en vertical.
• Todos los rellenos (incluidos mapas de bits, vídeo y degradados) se expanden para ajustarse a su forma.

Si se gira un objeto de visualización, todo el escalado posterior será normal (y se omitirá la propiedad scale9Grid).

Por ejemplo, imagine el siguiente objeto de visualización y un rectángulo que se aplica como propiedad scale9Grid del objeto de visualización:

El objeto de visualización.

El rectángulo rojo muestra la cuadrícula scale9Grid.

Cuando el objeto de visualización cambia la escala o se expande, los objetos del interior del rectángulo cambian de escala con normalidad, pero los objetos del exterior cambian de escala según las normas de scale9Grid:

Cambio de escala al 75%:
Cambio de escala al 50%:
Cambio de escala al 25%:
Expandido horizontalmente un 150%:

Normalmente, scale9Grid se define cuando se configura un objeto de visualización que se va a utilizar como componente en el que las zonas del borde conservan la misma anchura si el componente cambia de escala.

Elementos de API relacionados

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

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

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

addChild(square);

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

var scaleFactor:Number = 1.01;

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

Indica la escala horizontal (percentage) del objeto aplicada desde el punto de registro. El punto de registro predeterminado es (0,0). 1.0 equivale al 100% de la escala.

La escala del sistema de coordenadas local afecta a los valores de las propiedades x e y, que se definen en píxeles completos.

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

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

square.addEventListener(MouseEvent.CLICK, scale);

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

Indica la escala vertical (percentage) de un objeto aplicada desde el punto de registro del objeto. El punto de registro predeterminado es (0,0). 1.0 equivale al 100% de la escala.

La escala del sistema de coordenadas local afecta a los valores de las propiedades x e y, que se definen en píxeles completos.

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

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

square.addEventListener(MouseEvent.CLICK, scale);

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

Indica la escala de profundidad (porcentaje) de un objeto aplicada desde el punto de registro del objeto. El punto de registro predeterminado es (0,0). 1.0 equivale al 100% de la escala.

Al cambiar la escala del sistema de coordenadas local, cambian los valores de las propiedades x, y y z, que se definen en píxeles completos.

Elementos de API relacionados

Los límites del rectángulo de desplazamiento del objeto de visualización. El objeto de visualización se recorta al tamaño definido por el rectángulo y se desplaza dentro del rectángulo al cambiar las propiedades x e y del objeto scrollRect.

Las propiedades del objeto Rectangle scrollRect utilizan el espacio de coordenadas del objeto de visualización y cambian de escala al igual que el resto del objeto de visualización. Los límites de esquina de la ventana recortada del objeto de visualización en desplazamiento son el origen del objeto de visualización (0,0) y el punto definido por la anchura y la altura del rectángulo. Estos no están centrados en torno al origen, sino que utilizan el origen para definir la esquina superior izquierda del área. Un objeto de visualización desplazado siempre se desplaza en incrementos de píxeles completos.

Puede desplazar un objeto a izquierda y a derecha estableciendo la propiedad x del objeto Rectangle scrollRect. Puede desplazar un objeto hacia arriba y hacia abajo estableciendo la propiedad y del objeto Rectangle scrollRect. Si el objeto de visualización se gira 90° y lo desplaza a izquierda y derecha, el objeto de visualización se desplazará realmente hacia arriba y hacia abajo.

Tenga en cuenta que los cambios en la propiedad scrollRect sólo se procesan cuando se representa el objeto. En consecuencia, los métodos como localToGlobal pueden no producir el resultado esperado si se les llama inmediatamente después de modificar scrollRect.

Nota: a partir de Flash Player 11.4 /AIR 3.4, los valores negativos para el ancho o el alto del rectángulo se han cambiado a 0.

Elementos de API relacionados

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

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

circle.addEventListener(MouseEvent.CLICK, clicked);

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

El escenario del objeto de visualización. Una aplicación en tiempo de ejecución de Flash sólo tiene un objeto Stage. Por ejemplo, puede crear y cargar varios objetos de visualización en la lista de visualización y que la propiedad stage de cada objeto de visualización haga referencia al mismo objeto Stage (aunque el objeto de visualización pertenezca a un archivo SWF cargado).

Si un objeto de visualización no se añade a la lista de visualización, su propiedad stage se establece como null.

import flash.text.TextField;

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

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

trace(stage.stageWidth);

Objeto con propiedades pertenecientes a una matriz, transformación de color y límites de píxel de un objeto de visualización. Las propiedades específicas matrix, colorTransform y tres propiedades de sólo lectura (concatenatedMatrix, concatenatedColorTransform y pixelBounds) se describen en la entrada de la clase Transform.

Cada una de las propiedades del objeto transform es un objeto en sí. Este concepto es importante porque el único modo de definir nuevos valores para objetos matrix o colorTransform es crear un nuevo objeto y copiarlo en la propiedad transform.matrix o transform.colorTransform.

Por ejemplo, para aumentar el valor tx de la matriz de un objeto de visualización, debe realizar una copia del objeto de matriz completo y después copiar el objeto nuevo en la propiedad matrix del objeto transform:

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

La propiedad tx no puede configurarse directamente. El código siguiente no tiene efecto en myDisplayObject:

    myDisplayObject.transform.matrix.tx += 10;
    

También puede copiar un objeto transform completo y asignarlo a la propiedad transform de otro objeto de visualización. Por ejemplo, el código siguiente copia el objeto transform completo de myOldDisplayObj a myNewDisplayObj:

El objeto de visualización resultante, myNewDisplayObj, tiene ahora los mismos valores de matriz, transformación de color y límites de píxel que el antiguo objeto de visualización, myOldDisplayObj.

Hay que tener en cuenta que los dispositivos de AIR para TV utilizan la aceleración de hardware, si está disponible, por transformaciones de color.

Elementos de API relacionados

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

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

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

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

square.addEventListener(MouseEvent.CLICK, transformer);

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

Indica si el objeto de visualización es visible. Los objetos de visualización que no son visibles se desactivan. Por ejemplo, si visible=false para una instancia de InteractiveObject, no es posible hacer clic en él.

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

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

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

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

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.

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

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

square.addEventListener(MouseEvent.CLICK, widen);

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

Indica la coordenada x de la instancia de DisplayObject en relación a las coordenadas locales del DisplayObjectContainer principal. Si el objeto está dentro de un DisplayObjectContainer que incluye transformaciones, estará en el sistema de coordenadas local del DisplayObjectContainer en el que está contenido. Por consiguiente, en el caso de un DisplayObjectContainer con un giro de 90° en sentido contrario al de las agujas del reloj, los elementos secundarios de DisplayObjectContainer heredarán un sistema de coordenadas con un giro de 90° en sentido contrario al de las agujas del reloj. Las coordenadas del objeto hacen referencia a la posición del punto de registro.

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

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

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

var xInc:Number = 2;

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

Indica la coordenada y de la instancia de DisplayObject en relación a las coordenadas locales del DisplayObjectContainer principal. Si el objeto está dentro de un DisplayObjectContainer que incluye transformaciones, estará en el sistema de coordenadas local del DisplayObjectContainer en el que está contenido. Por consiguiente, en el caso de un DisplayObjectContainer con un giro de 90° en sentido contrario al de las agujas del reloj, los elementos secundarios de DisplayObjectContainer heredarán un sistema de coordenadas con un giro de 90° en sentido contrario al de las agujas del reloj. Las coordenadas del objeto hacen referencia a la posición del punto de registro.

import flash.text.TextField;

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

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

Indica la posición de la coordenada z en el eje z de la instancia de DisplayObject relativa al contenedor principal 3D. La propiedad z se utiliza para trabajar con coordenadas 3D, no con coordenadas de pantalla o de píxeles.

Cuando se establece una propiedad z de un objeto de visualización en un valor distinto a su predeterminado (0), se crea automáticamente un objeto Matrix3D. para ajustar una posición y la orientación de un objeto de visualización en tres dimensiones. Cuando se trabaja con el eje z, el comportamiento existente de las propiedades x e y cambia de coordenadas de pantalla o de píxeles a las posiciones relativas al contenedor principal 3D.

Por ejemplo, un elemento secundario de _root en la posición x = 100, y = 100, z = 200 no se dibuja en la posición de píxeles (100,100). El elemento secundario se dibuja en el lugar en que lo coloque el cálculo de proyección 3D. El cálculo es el siguiente:

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

Elementos de API relacionados

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

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

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

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

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

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

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

Devuelve un rectángulo que define el área del objeto de visualización relativo al sistema de coordenadas del objeto targetCoordinateSpace. Observe el siguiente código, en el que se muestra cómo el rectángulo devuelto puede variar en función del parámetro targetCoordinateSpace que pase al método:

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

Nota: utilice localToGlobal() y globalToLocal() para convertir las coordenadas locales del objeto de visualización en coordenadas de visualización, o las coordenadas de visualización en coordenadas locales, respectivamente.

El método getBounds() es similar al método getRect(); sin embargo, el rectángulo devuelto por el método getBounds() incluye los trazos en las formas, mientras que el rectángulo devuelto por getRect() no los incluye. Para ver un ejemplo, consulte la descripción del método getRect().

Parámetros

Elementos de API relacionados

Devuelve un rectángulo que define el límite del objeto de visualización, basado en el sistema de coordenadas definido por el parámetro targetCoordinateSpace, excluyendo los trazos en las formas. Los valores devueltos por el método getRect() son iguales o menores que los devueltos por el método getBounds().

Nota:utilice los métodos localToGlobal() y globalToLocal() para convertir las coordenadas locales del objeto de visualización en coordenadas de escenario o las coordenadas de escenario en coordenadas locales, respectivamente.

Parámetros

Elementos de API relacionados

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

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

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

addChild(triangle);

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

Convierte el objeto point de las coordenadas del escenario (globales) en las coordenadas del objeto de visualización (locales).

Para utilizar este método, cree primero una instancia de la clase Point. Los valores x e y que asigne representarán coordenadas globales, ya que se refieren al origen (0,0) del área de visualización principal. Seguidamente, pase la instancia de Point como parámetro al método globalToLocal(). El método devuelve un nuevo objeto Point con valores x e y relativos al origen del objeto de visualización, no al origen del escenario.

Parámetros

Elementos de API relacionados

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

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

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

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

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

Convierte un punto bidimensional de las coordenadas (globales) del escenario en coordenadas (locales) de un objeto tridimensional.

Para utilizar este método, cree primero una instancia de la clase Point. Los valores x e y que asigne al objeto Point representarán coordenadas globales, ya que se refieren al origen (0,0) del área de visualización principal. Seguidamente, transfiera el objeto Point al método globalToLocal3D() como el parámetro point. El método devuelve coordenadas tridimensionales como un objeto Vector3D con valores x, y y z relativos al origen del objeto de visualización tridimensional.

Parámetros

Calcula el cuadro delimitador del objeto de visualización para ver si se solapa o corta con el cuadro delimitador del objeto de visualización obj.

Parámetros

import flash.display.Shape;

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

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

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

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

Evalúa el objeto de visualización para comprobar si se solapa o presenta un punto de intersección con el punto especificado por los parámetros x e y. Los parámetros x e y especifican un punto en el espacio de coordenadas del escenario, no el contenedor del objeto de visualización que contiene el objeto de visualización (a no ser que el contenedor del objeto de visualización sea el escenario).

Parámetros

Elementos de API relacionados

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

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

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

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

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

Convierte un punto tridimensional de las coordenadas (locales) del objeto de visualización tridimensional en un punto bidimensional en las coordenadas (globales) del escenario.

Por ejemplo, sólo se pueden utilizar coordenadas bidimensionales (x,y) para dibujar con los métodos display.Graphics. Para dibujar un objeto tridimensional es necesario asignar las coordenadas tridimensionales de un objeto de visualización a las coordenadas bidimensionales. En primer lugar, cree una instancia de la clase Vector3D que contenga las coordenadas x, y y z del objeto de visualización tridimensional. Seguidamente, transfiera el objeto Vector3D al método local3DToGlobal() como el parámetro point3d. El método devuelve un objeto Point bidimensional que se puede utilizar con la API Graphics para dibujar el objeto tridimensional.

Parámetros

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

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

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

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

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

            Cube();         
        }

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

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

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

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

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

Convierte el objeto point de coordenadas del objeto de visualización (locales) en coordenadas del escenario (globales).

Este método permite convertir unos valores cualesquiera de las coordenadas x e y de valores relativos al origen (0,0) de un objeto de visualización determinado (coordenadas locales) a valores relativos al origen del escenario (coordenadas globales).

Para utilizar este método, cree primero una instancia de la clase Point. Los valores x e y que asigne representarán coordenadas locales, ya que se refieren al origen del objeto de visualización.

Seguidamente, pase la instancia de Point que ha creado como parámetro al método localToGlobal(). El método devuelve un nuevo objeto Point con valores x e y relativos al origen del escenario en lugar de al origen del objeto de visualización.

Parámetros

Elementos de API relacionados

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

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

addChild(square);

square.addEventListener(MouseEvent.CLICK, traceCoordinates)

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

Se distribuye cuando un objeto de visualización se añade a la lista de visualización. Los siguientes métodos desencadenan este evento: DisplayObjectContainer.addChild(), DisplayObjectContainer.addChildAt().

Este evento tiene las propiedades siguientes:

Elementos de API relacionados

Se distribuye cuando un objeto de visualización se añade a la lista de visualización del escenario, bien directamente o a través de un subárbol que contiene el objeto de visualización. Los siguientes métodos desencadenan este evento: DisplayObjectContainer.addChild(), DisplayObjectContainer.addChildAt().

Este evento tiene las propiedades siguientes:

Elementos de API relacionados

[evento de difusión] Se distribuye cuando la cabeza lectora entra en un nuevo fotograma. Si la cabeza lectora está en movimiento, o si hay un solo fotograma, este evento se distribuye continuamente junto a la velocidad de fotogramas. Este evento es un evento de difusión, lo que significa que lo distribuyen todos los objetos de visualización con un detector registrado para este evento.

Nota: este evento no tiene ni "fase de captura" ni "fase de propagación", lo que significa que los detectores de eventos deben añadirse directamente a cualquier destino potencial, se encuentre o no en la lista de visualización.

Este evento tiene las propiedades siguientes:

[evento de difusión] Se distribuye cuando la cabeza lectora sale del fotograma actual. Se han ejecutado todos los scripts de fotograma. Si la cabeza lectora está en movimiento, o si hay un solo fotograma, este evento se distribuye continuamente junto a la velocidad de fotogramas. Este evento es un evento de difusión, lo que significa que lo distribuyen todos los objetos de visualización con un detector registrado para este evento.

Nota: este evento no tiene ni "fase de captura" ni "fase de propagación", lo que significa que los detectores de eventos deben añadirse directamente a cualquier destino potencial, se encuentre o no en la lista de visualización.

Este evento tiene las propiedades siguientes:

[evento de difusión] Se distribuye una vez ejecutados los constructores de los objetos de visualización del fotograma, pero antes de que se ejecuten los scripts de fotograma. Si la cabeza lectora está en movimiento, o si hay un solo fotograma, este evento se distribuye continuamente junto a la velocidad de fotogramas. Este evento es un evento de difusión, lo que significa que lo distribuyen todos los objetos de visualización con un detector registrado para este evento.

Nota: este evento no tiene ni "fase de captura" ni "fase de propagación", lo que significa que los detectores de eventos deben añadirse directamente a cualquier destino potencial, se encuentre o no en la lista de visualización.

Este evento tiene las propiedades siguientes:

Se distribuye cuando un objeto de visualización se va a eliminar de la lista de visualización. Los métodos de la clase DisplayObjectContainer generan este evento: removeChild() y removeChildAt().

Los siguientes métodos de un objeto DisplayObjectContainer también generan este evento si un objeto debe eliminarse para hacer sitio para el nuevo objeto: addChild(), addChildAt() y setChildIndex().

Este evento tiene las propiedades siguientes:

Se distribuye cuando un objeto de visualización se va a eliminar de la lista de visualización, bien directamente o a través de la eliminación de un subárbol que contiene el objeto de visualización. Los métodos de la clase DisplayObjectContainer generan este evento: removeChild() y removeChildAt().

Los siguientes métodos de un objeto DisplayObjectContainer también generan este evento si un objeto debe eliminarse para hacer sitio para el nuevo objeto: addChild(), addChildAt() y setChildIndex().

Este evento tiene las propiedades siguientes:

[evento de difusión] Se distribuye cuando la lista de visualización se va a actualizar y representar. Este evento proporciona la última oportunidad a los objetos detectores de este evento para que realicen cambios antes de que se muestre la lista de visualización. Debe llamar al método invalidate() del objeto Stage cada vez que quiera distribuir un evento render. Los eventos Render se distribuyen a un objeto sólo si hay confianza mutua entre éste y el objeto que originó la llamada a Stage.invalidate(). Este evento es un evento de difusión, lo que significa que lo distribuyen todos los objetos de visualización con un detector registrado para este evento.

Nota: este evento no se distribuye si no se muestra ninguna visualización. Este es el caso cuando el contenido se minimiza o se tapa.

Nota: este evento no tiene ni "fase de captura" ni "fase de propagación", lo que significa que los detectores de eventos deben añadirse directamente a cualquier destino potencial, se encuentre o no en la lista de visualización.

Este evento tiene las propiedades siguientes:

1. Se declaran propiedades de clase para el color y el tamaño del cuadrado.
2. El constructor llama al método draw(), que dibuja un cuadrado naranja en el escenario en las coordenadas predeterminadas de x = 0, y = 0.
3. Se asocian al cuadrado los siguientes métodos de detector de eventos:
   • addedHandler() detecta eventos added, distribuidos cuando se añade el cuadrado a la lista de visualización.
   • enterFrameHandler() detecta eventos enterFrame, que no tienen ningún significado real en este ejemplo.
   • removedHandler() detecta eventos removed, distribuidos cuando el cuadrado se elimina de la lista de visualización, lo que ocurre cuando se hace clic en el cuadrado.
   • clickHandler() detecta eventos click, distribuidos cuando se hace clic en el cuadrado naranja.
   • renderHandler() detecta eventos render después de que se actualiza la lista de visualización.

package {
    import flash.display.Sprite;

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

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

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

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

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

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

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

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

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

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

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