DisplayObject  - AS3

As opções de acessibilidade atuais para este objeto de exibição. Se você modificar a propriedade accessibilityProperties ou qualquer um dos campos em accessibilityProperties, deverá chamar o método Accessibility.updateProperties() para que as alterações sejam efetivadas.

Observação: Para um objeto criado no ambiente de autoria do Flash, o valor de accessibilityProperties é pré-preenchido com todas as informações inseridas no painel Acessibilidade desse objeto.

Elementos da 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 o valor de transparência alfa do objeto especificado. Os valores válidos são de 0 (totalmente transparente) a 1 (totalmente opaco). O valor padrão é 1. Objetos de exibição com a propriedade alpha definida como 0 são ativos, mesmo estando invisíveis.

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

Um valor a partir da classe BlendMode que especifica o modo de mesclagem a ser usado. Um bitmap pode ser desenhado internamente de duas maneiras. Se você tiver um modo de mesclagem ativado ou uma máscara de corte externa, o bitmap será desenhado adicionando-se uma forma de quadrado com preenchimento de bitmap ao renderizador de vetor. Se você tentar definir essa propriedade como um valor inválido, tempo de execução do Flash definirá o valor como BlendMode.NORMAL.

A propriedade modoMesclagem afeta cada pixel do objeto de exibição. Cada pixel é formado por três cores constituintes (vermelho, verde e azul) e cada uma dessas cores tem um valor entre 0x00 e 0xFF. O Flash Player ou o Adobe AIR compara cada cor constituinte de um pixel no clipe de filme com a cor correspondente do pixel no plano de fundo. Por exemplo, se a propriedade modoMesclagem estiver definida como BlendMode.LIGHTEN, o Flash Player ou o Adobe AIR irá comparar o valor de vermelho do objeto de exibição com o valor de vermelho do plano de fundo e usará o mais claro como o valor para o componente vermelho da cor exibida.

A tabela a seguir descreve as configurações de modoMesclagem. A classe BlendMode define valores de string que você pode usar. As ilustrações na tabela mostra valores de modoMesclagem aplicados a um objeto de exibição circular (2) superimposto em outro objeto de exibição (1).

Constante de BlendMode	Ilustração	Descrição
BlendMode.NORMAL		O objeto de exibição aparece na frente do plano de fundo. Os valores de pixel do objeto de exibição substituem os do plano de fundo. Nos pontos em que o objeto de exibição for transparente, o plano de fundo será visível.
BlendMode.LAYER		Força a criação de um grupo de transparências para o objeto de exibição. Isso significa que o objeto de exibição é pré-composto em um buffer temporário antes de continuar a ser processado. Isso será feito automaticamente se o objeto de exibição for pré-armazenado em cache usando o cache de bitmap ou se o objeto de exibição for um contêiner de objetos de exibição com pelo menos um objeto filho com uma configuração de blendMode diferente de BlendMode.NORMAL. Sem suporte na renderização pela GPU.
BlendMode.MULTIPLY		Multiplica os valores das cores constituintes do objeto de exibição pelas cores da cor do plano de fundo e normaliza dividindo por 0xFF, o que resulta em cores mais escuras. Essa configuração costuma ser usada para sombras e efeitos de profundidade. Por exemplo, se uma cor constituinte (como vermelho) de um pixel no objeto de exibição e a cor correspondente do pixel no plano de fundo tiverem ambas o valor 0x88, o resultado multiplicado será 0x4840. A divisão por 0xFF gera um valor de 0x48 para essa cor constituinte, que é uma sombra mais escura do que a cor do objeto de exibição ou a cor do plano de fundo.
BlendMode.SCREEN		Multiplica o complemento (inverso) da cor do objeto de exibição pelo complemento da cor de plano de fundo, resultando em um efeito de branqueamento. Essa configuração costuma ser usada para realces ou para remover áreas pretas do objeto de exibição.
BlendMode.LIGHTEN		Seleciona a mais clara das cores constituintes do objeto de exibição e a cor do plano de fundo (as cores com os maiores valores). Essa configuração costuma ser usada para o tipo de superimposição. Por exemplo, se o objeto de exibição tiver um pixel com valor RGB 0xFFCC33 e o pixel do plano de fundo tiver o valor RGB 0xDDF800, o valor RGB resultante para o pixel exibido será 0xFFF833 (porque 0xFF > 0xDD, 0xCC < 0xF8 e 0x33 > 0x00 = 33). Sem suporte na renderização pela GPU.
BlendMode.DARKEN		Seleciona a mais escura das cores constituintes do objeto de exibição e as cores do plano de fundo (as cores com os menores valores). Essa configuração costuma ser usada para o tipo de superimposição. Por exemplo, se o objeto de exibição tiver um pixel com valor RGB 0xFFCC33 e o pixel do plano de fundo tiver o valor RGB 0xDDF800, o valor RGB resultante para o pixel exibido será 0xDDCC00 (porque 0xFF > 0xDD, 0xCC < 0xF8 e 0x33 > 0x00 = 33). Sem suporte na renderização pela GPU.
BlendMode.DIFFERENCE		Compara as cores constituintes do objeto de exibição com as cores do seu plano de fundo e subtrai o mais escuro dos valores das duas cores constituintes do valor mais claro. Essa configuração costuma ser usada para cores mais vibrantes. Por exemplo, se o objeto de exibição tiver um pixel com um valor RGB de 0xFFCC33 e o pixel do plano de fundo tiver um valor RGB de 0xDDF800, o valor RGB resultante para o pixel exibido será 0x222C33 (porque 0xFF - 0xDD = 0x22, 0xF8 - 0xCC = 0x2C e 0x33 - 0x00 = 0x33).
BlendMode.ADD		Adiciona os valores das cores constituintes do objeto de exibição às cores do seu plano de fundo, aplicando um limite superior de 0xFF. Essa configuração costuma ser usada para animar uma desincorporação de clareamento entre dois objetos. Por exemplo, se o objeto de exibição tiver um pixel com um valor RGB de 0xAAA633 e o pixel do plano de fundo tiver um valor RGB de 0xDD2200, o valor RGB resultante para o pixel exibido será 0xFFC833 (porque 0xAA + 0xDD > 0xFF, 0xA6 + 0x22 = 0xC8 e 0x33 + 0x00 = 0x33).
BlendMode.SUBTRACT		Subtrai os valores das cores constituintes no objeto de exibição dos valores da cor do plano de fundo, aplicando um limite inferior de 0. Essa configuração costuma ser usada para animar uma desincorporação de escurecimento entre dois objetos. Por exemplo, se o objeto de exibição tiver um pixel com um valor RGB de 0xAA2233 e o pixel do plano de fundo tiver um valor RGB de 0xDDA600, o valor RGB resultante para o pixel exibido será 0x338400 (porque 0xDD - 0xAA = 0x33, 0xA6 - 0x22 = 0x84 e 0x00 - 0x33 < 0x00).
BlendMode.INVERT		Inverte o plano de fundo.
BlendMode.ALPHA		Aplica o valor alfa de cada pixel do objeto de exibição ao plano de fundo. Isso requer que a configuração de modoMesclagem do objeto de exibição-pai seja definida como BlendMode.LAYER. Por exemplo, na ilustração, o objeto de exibição pai, que é um plano de fundo branco, tem blendMode = BlendMode.LAYER. Sem suporte na renderização pela GPU.
BlendMode.ERASE		Apaga o plano de fundo com base no valor alfa do objeto de exibição. Isso requer que a configuração de modoMesclagem do objeto de exibição-pai seja definida como BlendMode.LAYER. Por exemplo, na ilustração, o objeto de exibição pai, que é um plano de fundo branco, tem blendMode = BlendMode.LAYER. Sem suporte na renderização pela GPU.
BlendMode.OVERLAY		Ajusta a cor de cada pixel com base na escuridão do plano de fundo. Se o plano de fundo for mais claro do que 50% cinza, as cores do objeto de exibição e do plano de fundo serão filtradas, resultando em uma cor mais clara. Se o plano de fundo for mais escuro do que 50% cinza, as cores serão multiplicadas, resultando em uma cor mais escura. Essa configuração costuma ser usada para efeitos de sombreamento. Sem suporte na renderização pela GPU.
BlendMode.HARDLIGHT		Ajusta a cor de cada pixel com base na escuridão do objeto de exibição. Se o objeto de exibição for mais claro do que 50% cinza, as cores do objeto de exibição e do plano de fundo serão filtradas, resultando em uma cor mais clara. Se o objeto de exibição for mais escuro do que 50% cinza, as cores serão multiplicadas, resultando em uma cor mais escura. Essa configuração costuma ser usada para efeitos de sombreamento. Sem suporte na renderização pela GPU.
BlendMode.SHADER	N/D	Ajusta a cor usando uma rotina de shader personalizada. O shader usado é especificado como sendo a ocorrência de Shader atribuída à propriedade blendShader. A definição da propriedade blendShader como de um objeto de exibição como uma ocorrência de Shader define automaticamente a propriedade blendMode como BlendMode.SHADER. Caso a propriedade blendMode seja definida como BlendMode.SHADER sem que a propriedade blendShader seja definido antes disso, a propriedade blendMode será definida como BlendMode.NORMAL. Sem suporte na renderização pela GPU.

Elementos da 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 um shader usado para mesclar o primeiro plano e o segundo plano. Quando a propriedade blendMode está definida como BlendMode.SHADER, o Shader especificado é usado para criar a saída no modo de mesclagem para o objeto de exibição.

A definição da propriedade blendShader como de um objeto de exibição como uma ocorrência de Shader define automaticamente a propriedade blendMode como BlendMode.SHADER. Caso a propriedade blendShader seja definida (definindo a propriedade blendMode como BlendMode.SHADER), o valor da propriedade blendMode é alterado e você pode redefinir o modo de mesclagem para usar o shader de mesclagem simplesmente definindo a propriedade blendMode como BlendMode.SHADER. A propriedade blendShader não precisa ser definida novamente senão para alterar o shader usado no modo de mesclagem.

O Shader atribuído à propriedade blendShader deve especificar pelo menos duas entradas image4. As entradas não precisam ser especificadas no código usando as propriedades input dos objetos ShaderInput. O objeto de exibição do segundo plano é usado automaticamente como sendo a primeira entrada (a entrada com index 0). O objeto de exibição do primeiro plano é usado como sendo a segunda entrada (a entrada com index 1). Um shader usado como um shader de mesclagem pode especificar mais de duas entradas. Nesse caso, qualquer entrada adicional deve ser especificada definindo a propriedade input da ocorrência de ShaderInput.

Quando você atribui uma ocorrência de Shader a essa propriedade, o shader é copiado internamente. A operação de mesclagem usa essa cópia interna, e não uma referência ao shader original. Todas as alterações feitas no shader como, por exemplo, alterar o valor de um parâmetro, entrada ou código de bytes, não são aplicadas ao shader copiado usado no modo de mesclagem.

Elementos da API relacionados

Se definido como true, tempo de execução do Flash, armazenará em cachê uma representação interna em bitmap do objeto de exibição. Esse cachê pode aumentar o desempenho para objetos de exibição que têm conteúdo de vetor complexo.

Todos os dados de vetor para um objeto de exibição que possui bitmap em cache são desenhados no bitmap e não na exibição principal. Se cacheAsBitmapMatrix for nulo ou não suportado, o bitmap então será copiado para a exposição principal como não esticado; os pixéis não girados ajustam-se aos limites de pixel mais próximos. Os pixels são mapeados 1 a 1 com o objeto-pai. Se os limites do bitmap forem alterados, o bitmap será recriado em vez de ser esticado.

Se cacheAsBitmapMatrix for não nula e suportada, o objeto será desenhado para o bitmap fora da tela usando a matriz, e os resultados esticados e/ou girados desta renderização serão usado para desenhar o objeto para a exibição principal.

Nenhum bitmap inteiro será criado, a não ser que a propriedade cacheAsBitmap seja definida como true.

Depois de definir a propriedade cacheAsBitmap como true, a renderização não será alterada, mas o objeto de exibição realizará o encaixe de pixels automaticamente. A velocidade de animação pode aumentar significativamente dependendo da complexidade do conteúdo de vetor.

A propriedade cacheAsBitmap é automaticamente definida como true sempre que você aplica um filtro a um objeto de exibição (quando sua matriz filter não está vazia) e, se um objeto de exibição tiver um filtro aplicado, cacheAsBitmap será relatado como true para esse objeto de exibição, mesmo que você defina a propriedade como false. Se você limpar todos os filtros para um objeto de exibição, a configuração de cacheAsBitmap será alterada para o estado anterior mais recente.

Um objeto de exibição não usará um bitmap mesmo que a propriedade cacheAsBitmap seja definida como true e, em vez disso, renderizará a partir de dados de vetor nos seguintes casos:

• O bitmap é muito grande. No AIR 1.5 e no Flash Player 10, o tamanho máximo de uma imagem bitmap é de 8.191 pixels de largura ou de altura, e o número total de pixels não pode exceder 16.777.215 pixels. (Dessa forma, caso uma imagem bitmap tenha 8.191 pixels de largura, ela só pode ter 2.048 pixels de altura.) No Flash Player 9 e anteriores, a limitação é de 2.880 pixels de altura e 2.880 pixels de largura.
• O bitmap não consegue ser alocado (erro de falta de memória).

A propriedade cacheAsBitmap é melhor utilizada com clipes de filme que têm conteúdo estático predominantemente e que não são dimensionados e girados com frequência. Com esses clipes de filme, cacheAsBitmap pode resultar em aumentos de desempenho quando o clipe de filme é convertido (quando suas posições x e y são alteradas).

Elementos da 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

Se não nulo, este objeto Matrix definirá como um objeto de exibição será renderizado quando cacheAsBitmap for definido como true. O aplicativo usa esta matriz como uma matriz de transformação que é aplicada ao renderizar a versão de bitmap do objeto de exibição.

Suporte a perfil do AIR: esse recurso possui suporte para dispositivos móveis, mas não tem suporte para sistemas operacionais de computador. Também limitou o suporte em dispositivos AIR for TV. Especificamente, em dispositivos AIR for TV, as transformações com suporte incluem dimensionamento e conversão, mas não rotação e inclinação. Consulte Suporte a perfil do AIR para obter mais informações sobre o suporte de API através de múltiplos perfis.

Com cacheAsBitmapMatrix definido, o aplicativo conserva uma imagem em bitmap em cache por meio de várias transformações em 2D, inclusive translação, rotação e escala. Se o aplicativo usar aceleração de, o objeto será armazenado na memória de vídeo como uma textura. Isso permite que a GPU aplique as transformações suportadas ao objeto. AGPU pode executar estas transformações mais rápido do que a CPU.

Para usar a aceleração de hardware, defina Renderização para GPU na guia Geral da caixa de diálogo de Configurações do iPhone no Flash Professional CS5. Ou defina a propriedade renderMode como gpu no arquivo descritor do aplicativo. Observe que dispositivos AIR for TV usam a aceleração por hardware automaticamente, se estiver disponível.

Por exemplo, o seguinte código envia uma representação de bitmap não transformada do objeto de exposição à GPU:

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

Normalmente, a matriz de identidade ( new Matrix () ) é suficiente. Contudo, você pode usar outra matriz, tal como uma matriz escalonada, para carregar um bitmap diferente para a GPU. Por exemplo, o exemplo a seguir aplica uma matriz cacheAsBitmapMatrix , que é escalada de 0,5 em 0,5 nos eixos x e y. O objeto de bitmap que a GPU usa é menor; contudo, a GPU ajusta o seu tamanho para corresponder à propriedade transform.matrix do objeto de exposição:

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

Geralmente, você deve optar por usar uma matriz que transforme o objeto de exibição para o tamanho a ser exibido no aplicativo. Por exemplo, se o seu aplicativo exibir a versão de bitmap da entidade gráfica escalonada de meio em meio, use uma matriz escalonada de meio em meio. Se o aplicativo exibirá a entidade gráfico maior do que as suas dimensões atuais, use uma matriz escalonada por aquele fator.

Nota: a propriedade cacheAsBitmapMatrix é apropriada para transformações em 2D. Se você precisara aplicar transformações em 3D, poderá fazê-lo configurando uma propriedade 3D do objeto e processando sua propriedade transform.matrix3D. Se o aplicativo estiver configurado para o modo GPU, isso permitirá que as transformações em 3D sejam aplicadas ao objeto pela GPU. A cacheAsBitmapMatrix é ignorada para objetos 3D.

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

Uma matriz indexada que contém cada objeto de filtro atualmente associado ao objeto de exibição. O pacote flash.filters contém várias classes que definem filtros específicos que você pode usar.

Os filtros podem ser aplicados na ferramenta de autoria do Flash Professional durante o design ou a execução usando o código ActionScript. Para aplicar um filtro usando ActionScript, é necessário fazer uma cópia temporária da matriz de filters inteira, modificar a matriz temporária e então atribuir o valor da matriz temporária de volta para a matriz filters. Não é possível adicionar diretamente um novo objeto de filtro à matriz de filters.

Para adicionar um filtro usando o ActionScript, realize as etapas a seguir (suponha que o nome do objeto de exibição seja myDisplayObject):

1. Crie um novo objeto de filtro usando o método de construtor da sua classe de filtro escolhida.
2. Atribua o valor da matriz myDisplayObject.filters a uma matriz temporária, como myFilters.
3. Adicione o novo objeto de filtro à matriz temporária myFilters.
4. Atribua o valor da matriz temporária à matriz myDisplayObject.filters.

Se a matriz de filters for indefinida, não será necessário usar uma matriz temporária. Em vez disso, é possível atribuir diretamente um literal de matriz que contenha um ou mais objetos de filtro que você criar. O primeiro exemplo na seção Exemplos adiciona um filtro de sombra projetada usando um código que lida com matrizes de filters definidas e indefinidas.

Para modificar um objeto de filtro existente, use a técnica de modificar uma cópia da matriz de filters:

1. Atribua o valor da matriz de filters a uma matriz temporária, como myFilters.
2. Modifique a propriedade usando a matriz temporária, myFilters. Por exemplo, para definir a propriedade "quality" do primeiro filtro da matriz, é possível usar o código a seguir: myFilters[0].quality = 1;
3. Atribua o valor da matriz temporária à matriz de filters.

Em tempo de carregamento, se um objeto de exibição tiver um filtro associado, ele será marcado para se armazenar em cache como bitmap transparente. Deste ponto em diante, desde que o objeto de exibição tenha uma lista de filtros válida, o player armazenará em cache o objeto de exibição como um bitmap. Esse bitmap de origem é usado como imagem de origem para os efeitos de filtro. Cada objeto de exibição geralmente tem dois bitmaps: um com o objeto original de exibição de origem e outro para a imagem final, após a filtragem. A imagem final é usada no momento da renderização. Desde que o objeto de exibição não seja alterado, a imagem final não precisa de atualização.

O pacote flash.filters inclui classes para filtros. Por exemplo, para criar um filtro de sombra projetada, grave o seguinte:

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

O operador is pode ser usado para determinar o tipo de filtro atribuído a cada posição de índice na matriz de filters. Por exemplo, o código a seguir mostra como determinar a posição do primeiro filtro na matriz de filters que é 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;
     }
     

Observação:Como não é possível adicionar diretamente um novo objeto de filtro à matriz DisplayObject.filters, o código a seguir não tem efeito sobre o objeto de exibição de destino, denominado myDisplayObject:

     myDisplayObject.filters.push(myDropShadow);
     

Elementos da API relacionados

Indica a altura do objeto de exibição, em pixels. A altura é calculada com base nos limites do conteúdo do objeto de exibição. Quando você define a propriedade height, a propriedade scaleY é ajustada de acordo, como mostra o código a seguir:

    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;

Exceto para objetos TextField e Video, um objeto de exibição sem conteúdo (como uma entidade gráfica vazia) tem uma altura de 0, mesmo que você tente definir height como um 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);

Retorna um objeto LoaderInfo contendo informações sobre o carregamento do arquivo ao qual esse objeto de exibição pertence. A propriedade loaderInfo é definida apenas para o objeto de exibição raiz de um arquivo SWF ou para um Bitmap carregado (e não para um Bitmap desenhado com ActionScript). Para descobrir o objeto loaderInfo associado ao arquivo SWF que contém um objeto de exibição denominado myDisplayObject, use myDisplayObject.root.loaderInfo.

Um arquivo SWF grande pode monitorar seu download chamando this.root.loaderInfo.addEventListener(Event.COMPLETE, func).

Elementos da API relacionados

 trace (this.loaderInfo.url);
 

O objeto de exibição de chamada é mascarado pelo objeto mask especificado. Para garantir que o mascaramento funcione quando o Palco for dimensionado, o objeto de exibição mask precisa estar em uma parte ativa da lista de exibição. O objeto mask propriamente dito não é desenhado. Defina mask como null para remover a máscara.

Para poder dimensionar um objeto de máscara, ele deve estar na lista de exibição. Para poder arrastar um objeto Sprite "mask" (chamando seu método startDrag()), ele deve estar na lista de exibição. Para chamar o método startDrag() para uma entidade gráfica de máscara em um evento mouseDown que está sendo despachado pela entidade gráfica, defina a propriedade buttonMode dessa entidade como true.

Quando os objetos de exibição são armazenados em cache por meio da definição da propriedade cacheAsBitmap como true e a propriedade cacheAsBitmapMatrix como um objeto Matrix, tanto a máscara quanto o objeto de exibição que está sendo mascarado devem fazer parte do mesmo bitmap armazenado em cache. Assim, se o objeto de exibição estiver armazenado em cache, a máscara deverá ser filha do objeto de exibição. Se um ancestral do objeto de exibição na lista de exibição estiver armazenado em cache, a máscara deverá ser filha desse ancestral ou de um dos seus descendentes. Se mais de um ancestral do objeto mascarado estiver armazenado em cache, a máscara deverá ser descendente do contêiner armazenado em cache mais próximo do objeto mascarado na lista de exibição.

Observação: não é possível usar um objeto mask único para mascarar mais de um objeto de exibição de chamada. Quando se atribui mask a um segundo objeto de exibição, ele é removido como máscara do primeiro objeto, e a propriedade mask do objeto, torna-se 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();
}

Obtém o objeto de metadados da instância DisplayObject se os metadados forem armazenados juntamente com a instância desse DisplayObject no arquivo SWF por uma marca PlaceObject4.

Indica a coordenada x da posição do dispositivo do mouse ou de entrada do usuário, em pixels.

Observação: Para um DisplayObject que foi girado, a coordenada x retornada refletirá o objeto não girado.

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 a coordenada y da posição do dispositivo do mouse ou de entrada do usuário, em pixels.

Observação: Para um DisplayObject que foi girado, a coordenada y retornada refletirá o objeto não girado.

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 o nome da ocorrência de DisplayObject. O objeto pode ser identificado na lista de filhos do seu contêiner de objetos de exibição-pai, chamando o método getChildByName() desse contêiner.

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 se o objeto de exibição é opaco com uma certa cor de plano de fundo. Um bitmap transparente contém dados de canal alfa e é desenhado transparentemente. Um bitmap opaco não tem canal alfa (e é renderizado mais rapidamente que um bitmap transparente). Se o bitmap for opaco, você poderá especificar sua própria cor de plano de fundo a ser usada.

Se definida como um valor numérico, a superfície será opaca (não transparente), com a cor de plano de fundo RGB especificada pelo número. Se definido como null (o valor padrão), o objeto de exibição terá um plano de fundo transparente.

A propriedade opaqueBackground serve principalmente para uso com a propriedade cacheAsBitmap, para otimização da renderização. Para objetos de exibição nos quais a propriedade cacheAsBitmap está definida como "true", a definição de opaqueBackground pode melhorar o desempenho de renderização.

A região de plano de fundo opaca não é correspondida ao chamar o método hitTestPoint() com o parâmetro sinalizadorForma definido como true.

A região de plano de fundo opaca não responde a eventos do mouse.

Elementos da 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 o objeto DisplayObjectContainer que contém esse objeto de exibição. Use a propriedade parent de modo a especificar um caminho relativo para objetos de exibição que estão acima do objeto de exibição atual na hierarquia da lista de exibição.

Você pode usar parent para mover-se vários níveis acima na lista de exibição, como a seguir:

     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 um objeto de exibição em um arquivo SWF carregado, a propriedade root é o objeto de exibição na extremidade superior, na parte da estrutura em árvore da lista de exibição representada por esse arquivo SWF. Para um objeto Bitmap representando um arquivo de imagem carregado, a propriedade root é o próprio objeto. Para a ocorrência da classe principal do primeiro arquivo SWF carregado, a propriedade root é o próprio objeto de exibição. A propriedade root do objeto Stage é o próprio objeto Stage. A propriedade root é definida como null para qualquer objeto de exibição que não tenha sido adicionado à lista de exibição, a não ser que tenha sido adicionado a um contêiner de objetos de exibição que esteja fora da lista de exibição, mas que seja filho do objeto de exibição em posição superior em um arquivo SWF carregado.

Por exemplo, se você criar um novo objeto Sprite chamando o método do construtor Sprite(), sua propriedade root será null até você adicioná-lo à lista de exibição (ou a um contêiner de objetos de exibição que esteja fora da lista de exibição, mas que seja filho do objeto de exibição em posição superior em um arquivo SWF).

Para um arquivo SWF carregado, mesmo que o objeto Loader usado para carregar o arquivo possa não estar na lista de exibição, o objeto de exibição em posição superior nesse arquivo SWF tem sua propriedade root definida como si mesma. O objeto Loader não terá sua propriedade root definida até que seja adicionado como filho de um objeto de exibição para o qual a propriedade root esteja definida.

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 o giro da ocorrência de DisplayObject, em graus, a partir da sua orientação original. Os valores de 0 a 180 representam o giro em sentido horário, enquanto os valores de 0 a -180 representam o giro em sentido anti-horário. Os valores fora dessa faixa são adicionados a ou subtraídos de 360 para obter um valor dentro da faixa. Por exemplo, a instrução my_video.rotation = 450 equivale a 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 a rotação do eixo x da ocorrência DisplayObject, em graus, a partir da sua orientação original referente ao contêiner 3D parent. Os valores de 0 a 180 representam o giro em sentido horário, enquanto os valores de 0 a -180 representam o giro em sentido anti-horário. Os valores fora dessa faixa são adicionados a ou subtraídos de 360 para obter um valor dentro da faixa.

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 a rotação do eixo y da ocorrência DisplayObject, em graus, a partir da sua orientação original referente ao contêiner 3D parent. Os valores de 0 a 180 representam o giro em sentido horário, enquanto os valores de 0 a -180 representam o giro em sentido anti-horário. Os valores fora dessa faixa são adicionados a ou subtraídos de 360 para obter um valor dentro da faixa.

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 a rotação do eixo z da ocorrência DisplayObject, em graus, a partir da sua orientação original referente ao contêiner 3D parent. Os valores de 0 a 180 representam o giro em sentido horário, enquanto os valores de 0 a -180 representam o giro em sentido anti-horário. Os valores fora dessa faixa são adicionados a ou subtraídos de 360 para obter um valor dentro da faixa.

A grade de dimensionamento atual que está em vigor. Se definida como null, o objeto de exibição inteiro será dimensionado normalmente quando qualquer transformação de escala for aplicada.

Quando você define a propriedade scale9Grid, o objeto de exibição é dividido em uma grade com nove regiões com base no retângulo de scale9Grid, que define a região central da grade. As oito outras regiões da grade são as seguintes áreas:

• O canto superior esquerdo fora do retângulo
• A área acima do retângulo
• O canto superior direito fora do retângulo
• A área à esquerda do retângulo
• A área à direita do retângulo
• O canto inferior esquerdo fora do retângulo
• A área abaixo do retângulo
• O canto inferior direito fora do retângulo

Imagine as oito regiões fora do centro (definidas pelo retângulo) como sendo uma moldura de imagem que possui regras especiais aplicadas ao ser dimensionada.

Quando a propriedade scale9Grid está definida e um objeto de exibição é dimensionado, todos os gradientes e textos são dimensionados normalmente. Entretanto, para os outros tipos de objetos, as seguintes regras se aplicam:

• O conteúdo na região central é dimensionado normalmente.
• O conteúdo nos cantos não é dimensionado.
• O conteúdo nas regiões superior e inferior é dimensionado apenas horizontalmente. O conteúdo nas regiões esquerda e direita são dimensionados apenas verticalmente.
• Todos os preenchimentos (incluindo bitmaps, vídeo e gradientes) são esticados para encaixar suas formas.

Se um objeto de exibição for girado, todo o dimensionamento subsequente será normal (e a propriedade scale9Grid será ignorada).

Por exemplo, considere o objeto de exibição a seguir e um retângulo aplicado como scale9Grid do objeto de exibição:

O objeto de exibição.

O retângulo vermelho mostra scale9Grid.

Quando o objeto de exibição é dimensionado ou esticado, os objetos dentro do retângulo são dimensionados normalmente, mas os objetos fora dele são dimensionados de acordo com as regras de scale9Grid:

Dimensionado em 75%:
Dimensionado em 50%:
Dimensionado em 25%:
Esticado horizontalmente 150%:

Um uso comum para a definição scale9Grid é configurar um objeto de exibição a ser usado como componente, no qual as regiões da borda mantêm a mesma largura quando o componente é dimensionado.

Elementos da 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 a escala horizontal (porcentagem) do objeto aplicada a partir do ponto de registro. O ponto de registro padrão é (0,0). 1.0 equivale a uma escala de 100%.

O dimensionamento do sistema de coordenadas local altera os valores das propriedades x e y, que são definidas em pixels inteiros.

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 a escala vertical (porcentagem) de um objeto aplicada a partir do ponto de registro desse objeto. O ponto de registro padrão é (0,0). 1.0 equivale a uma escala de 100%.

O dimensionamento do sistema de coordenadas local altera os valores das propriedades x e y, que são definidas em pixels inteiros.

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 a escala de profundidade (porcentagem) de um objeto aplicada a partir do ponto de registro desse objeto. O ponto de registro padrão é (0,0). 1.0 equivale a uma escala de 100%.

O dimensionamento do sistema de coordenadas local altera os valores das propriedades x, y e z, que são definidas em pixels inteiros.

Elementos da API relacionados

Os limites do retângulo de rolagem do objeto de exibição. O objeto de exibição é cortado com base no tamanho definido pelo retângulo e rola dentro do retângulo quando você altera as propriedades x e y do objeto scrollRect.

As propriedades do objeto Rectangle scrollRect usam o espaço de coordenadas do objeto de exibição e são dimensionadas como o objeto de exibição geral. Os limites de cantos da janela cortada no objeto de exibição de rolagem são a origem do objeto de exibição (0,0) e o ponto definido pela altura e largura do retângulo. Eles não são centralizados ao redor da origem, mas usam essa origem para definir o canto superior esquerdo da área. Um objeto de exibição rolado sempre rola em incrementos de pixels inteiros.

Você pode rolar um objeto para a esquerda e para a direita definindo a propriedade x do objeto Rectangle scrollRect. Você pode rolar um objeto para cima e para baixo definindo a propriedade y do objeto Rectangle scrollRect. Se o objeto de exibição for girado em 90° e for rolado para a esquerda e a direita, ele irá rolar na verdade para cima e para baixo.

Observe que as modificações à propriedade scrollRect só são processadas quando o objeto é renderizado. Assim, os métodos como localToGlobal podem não produzir o resultado esperado se chamados imediatamente depois de modificarscrollRect.

Observe: ao Iniciar o Flash Player 11.4/AIR 3.4, os valores negativos da largura ou da altura do retângulo alteram-se para 0.

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

O Palco do objeto de exibição. Um aplicativo de tempo de execução do Flash tem apenas um objeto Stage. Por exemplo, você pode criar e carregar vários objetos de exibição na lista de exibição, e a propriedade stage de cada objeto de exibição faz referência ao mesmo objeto Stage (mesmo que o objeto de exibição pertença a um arquivo SWF carregado).

Se um objeto de exibição não for adicionado à lista de exibição, sua propriedade stage será definida 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);

Um objeto com propriedades relacionadas aos limites de pixels, matriz e transformação de cores de um objeto de exibição. As propriedades específicas — matrix, colorTransform e três propriedades somente leitura (concatenatedMatrix, concatenatedColorTransform e pixelBounds) — são descritas na entrada da classe Transform.

Cada uma das propriedades do objeto "transform" é por si só um objeto. Esse conceito é importante uma vez que a única maneira de definir novos valores para objetos matrix ou colorTransform é criar um novo objeto e copiá-lo na propriedade transform.matrix ou transform.colorTransform.

Por exemplo, para aumentar o valor tx da matriz de uma objeto de exibição, é preciso fazer uma cópia do objeto "matrix" inteiro e então copiar o novo objeto na propriedade "matrix" do objeto "transform":

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

Não é possível definir a propriedade tx diretamente. O código a seguir não tem efeito em myDisplayObject:

    myDisplayObject.transform.matrix.tx += 10;
    

Também é possível copiar um objeto "transform" inteiro e atribuí-lo à propriedade "transform" de outro objeto de exibição. Por exemplo, o código a seguir copia o objeto de transformação inteiro de myOldDisplayObj em myNewDisplayObj:

O objeto de exibição resultante, myNewDisplayObj, tem agora os mesmos valores para os seus limites de pixel, transformação de cores e matriz que o objeto de exibição antigo, myOldDisplayObj.

Observe que os dispositivos AIR for TV usam a aceleração por hardware, se disponível, para transformações de cores.

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

Se o objeto de exibição está ou não visível. Os objetos de exibição que não estiverem visíveis serão desativados. Por exemplo, se visible=false para uma ocorrência de InteractiveObject, não será possível clicar nessa ocorrência.

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 a largura do objeto de exibição, em pixels. A largura é calculada com base nos limites do conteúdo do objeto de exibição. Quando você define a propriedade width, a propriedade scaleX é ajustada de acordo, como mostra o código a seguir:

    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;

Exceto para objetos TextField e Video, um objeto de exibição sem conteúdo (como uma entidade gráfica vazia) tem uma largura de 0, mesmo que você tente definir width como um 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 a coordenada x da ocorrência de DisplayObject com relação às coordenadas locais do DisplayObjectContainer-pai. Se o objeto estiver dentro de um DisplayObjectContainer que possui transformações, ele estará no sistema de coordenadas local do DisplayObjectContainer delimitador. Portanto, no caso de um DisplayObjectContainer com giro de 90° em sentido anti-horário, os filhos de DisplayObjectContainer herdam um sistema de coordenadas que é girado 90° em sentido anti-horário. As coordenadas do objeto fazem referência à posição do ponto 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 a coordenada y da ocorrência de DisplayObject com relação às coordenadas locais do DisplayObjectContainer-pai. Se o objeto estiver dentro de um DisplayObjectContainer que possui transformações, ele estará no sistema de coordenadas local do DisplayObjectContainer delimitador. Portanto, no caso de um DisplayObjectContainer com giro de 90° em sentido anti-horário, os filhos de DisplayObjectContainer herdam um sistema de coordenadas que é girado 90° em sentido anti-horário. As coordenadas do objeto fazem referência à posição do ponto 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 a posição da coordenada z ao longo do eixo z da ocorrência DisplayObject em relação ao contêiner 3D pai. A propriedade z é usada com coordenadas 3D, e não com coordenadas de tela ou de pixel.

Quando você define uma propriedade z para um objeto de exibição como um valor diferente de 0, o objeto Matrix3D correspondente é automaticamente criado. para ajustar uma posição ou orientação do objeto de exibição em três dimensões. Ao funcionar com o eixo z, o comportamento existente das propriedades x e y muda das coordenadas de tela ou pixel para as posições referentes ao contêiner 3D parent.

Por exemplo, um filho de _root na posição x = 100, y = 100, z = 200 não é desenhado no local do pixel (100,100). O filho é desenhado sempre que o cálculo da projeção 3D o coloca. O cálculo é:

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

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

Retorna um retângulo que define a área do objeto de exibição com relação ao sistema de coordenadas do objeto targetCoordinateSpace. Considere o código a seguir, que mostra como o retângulo retornado pode variar dependendo do parâmetro espaçoCoordenadasDestino transmitido ao 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)
     

Observação:Use os métodos localToGlobal() e globalToLocal() para converter as coordenadas locais do objeto de exibição em coordenadas de exibição ou as coordenadas de exibição em coordenadas locais, respectivamente.

O método getBounds() é semelhante ao método getRect(). Entretanto, o retângulo retornado pelo método getBounds() inclui traçados em formas, o que não ocorre com o retângulo retornado pelo método getRect(). Para obter um exemplo, consulte a descrição do método getRect().

Parâmetros

Elementos da API relacionados

Retorna um retângulo que define o limite do objeto de exibição, com base no sistema de coordenadas definido pelo parâmetro espaçoCoordenadasDestino, excluindo quaisquer traçados em formas. Os valores retornados pelo método getRect() são os mesmos ou menores do que os retornados pelo método getBounds().

Observação:Use os métodos localToGlobal() e globalToLocal() para converter as coordenadas locais do objeto de exibição em coordenadas do Palco ou as coordenadas do Palco em coordenadas locais, respectivamente.

Parâmetros

Elementos da 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)

Converte o objeto de ponto a partir de coordenadas de Palco (globais) em coordenadas do objeto de exibição (locais).

Para usar esse método, crie primeiro uma ocorrência da classe Point. Os valores x e y que você atribuir representam coordenadas globais porque estão relacionados à origem (0,0) da área de exibição principal. Em seguida, transmita a ocorrência de Point como parâmetro para o método globalToLocal(). O método retorna um novo objeto Point com os valores x e y que estão relacionados à origem do objeto de exibição em vez da origem do Palco.

Parâmetros

Elementos da 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]

Converte um ponto bidimensional das coordenadas do Palco (globais) em coordenadas do objeto de exibição tridimensional (locais).

Para usar esse método, crie primeiro uma ocorrência da classe Point. Os valores x e y que você atribui ao objeto Point representam as coordenadas globais, porque eles são relativos à origem (0,0) da área de exibição principal. Em seguida, passe o objeto Point para o método globalToLocal3D() como o parâmetro point. O método retorna coordenadas tridimensionais como um objeto Vector3D contendo valores x, y e z relativos à origem do objeto tridimensional de exibição .

Parâmetros

Avalia a caixa delimitadora do objeto de exibição para ver se ela sobrepõe ou faz interseção com a caixa delimitadora do objeto de exibição 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

Avalia o objeto de exibição para ver se ele sobrepõe ou faz interseção com o ponto especificado pelos parâmetros x e y. Os parâmetros x e y especificam um ponto no espaço de coordenadas do Palco e não do contêiner de objetos de exibição que mantém o objeto de exibição (a menos que esse contêiner seja o Palco).

Parâmetros

Elementos da 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]

Converte um ponto tridimensional das coordenadas (locais) do objeto de exibição tridimensional em ponto bidimensional das coordenadas (globais) do Palco.

Por exemplo, você só pode usar coordenadas bidimensionais (x,y) para desenhar com os métodos display.Graphics. Para desenhar um objeto tridimensional, é necessário mapear as coordenadas tridimensionais de um objeto de exibição para as coordenadas bidimensionais. Primeiramente, crie uma ocorrência da classe Vector3D que contém as coordenadas x, y e z do objeto de exibição tridimensional. Em seguida, passe o objeto Vector3D para o método local3DToGlobal() como o parâmetro point3d. O método retorna um objeto Point bidimensional que pode ser usado com a API de Gráficos para desenhar o 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);
        }
    }
}

Converte o objeto de point a partir das coordenadas do objeto de exibição (locais) em coordenadas do Palco (globais).

Esse método permite converter quaisquer coordenadas x e y especificadas de valores relativos à origem (0,0) de um objeto de exibição específico (coordenadas locais) em valores relativos à origem do Palco (coordenadas globais).

Para usar esse método, crie primeiro uma ocorrência da classe Point. Os valores x e y que você atribuir representam coordenadas locais porque estão relacionados à origem do objeto de exibição.

Em seguida, transmita a ocorrência de Point criada como parâmetro para o método localToGlobal(). O método retorna um novo objeto Point com os valores x e y que estão relacionados à origem do Palco em vez da origem do objeto de exibição.

Parâmetros

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

Despachado quando um objeto de exibição é adicionado à lista de exibição. Os métodos a seguir acionam esse evento: DisplayObjectContainer.addChild(), DisplayObjectContainer.addChildAt().

Esse evento tem as seguintes propriedades:

Elementos da API relacionados

Despachado quando um objeto de exibição é adicionado à lista de exibição no palco, seja diretamente ou através da adição de uma subárvore na qual esse objeto de exibição está contido. Os métodos a seguir acionam esse evento: DisplayObjectContainer.addChild(), DisplayObjectContainer.addChildAt().

Esse evento tem as seguintes propriedades:

Elementos da API relacionados

[evento de transmissão] Despachado quando o indicador de reprodução está entrando em um novo quadro. Se o indicador de reprodução não estiver se movendo ou se houver apenas um quadro, esse evento será despachado continuamente em conjunto com a velocidade de projeção. Esse é um evento de transmissão, ou seja, ele é despachado por todos os objetos de exibição com um ouvinte registrado para esse evento.

Observação: Esse evento não tem uma "fase de captura" nem "fase de bubble", significando que os ouvintes de evento precisam ser adicionados diretamente a qualquer destino possível que esteja ou não na lista de exibição.

Esse evento tem as seguintes propriedades:

[evento de transmissão] Despachado quando o indicador de reprodução está deixando o quadro atual. Todos os scripts do quadro foram executados. Se o indicador de reprodução não estiver se movendo ou se houver apenas um quadro, esse evento será despachado continuamente em conjunto com a velocidade de projeção. Esse é um evento de transmissão, ou seja, ele é despachado por todos os objetos de exibição com um ouvinte registrado para esse evento.

Observação: Esse evento não tem uma "fase de captura" nem "fase de bubble", significando que os ouvintes de evento precisam ser adicionados diretamente a qualquer destino possível que esteja ou não na lista de exibição.

Esse evento tem as seguintes propriedades:

[evento de transmissão] Despachado depois que são executados os construtores dos objetos de exibição de quadro, mas antes dos scripts. Se o indicador de reprodução não estiver se movendo ou se houver apenas um quadro, esse evento será despachado continuamente em conjunto com a velocidade de projeção. Esse é um evento de transmissão, ou seja, ele é despachado por todos os objetos de exibição com um ouvinte registrado para esse evento.

Observação: Esse evento não tem uma "fase de captura" nem "fase de bubble", significando que os ouvintes de evento precisam ser adicionados diretamente a qualquer destino possível que esteja ou não na lista de exibição.

Esse evento tem as seguintes propriedades:

Despachado quando um objeto de exibição está prestes a ser removido da lista de exibição. Dois métodos da classe DisplayObjectContainer geram este evento: removeChild() e removeChildAt().

Os métodos a seguir de um objeto DisplayObjectContainer também irão gerar este evento se um objeto precisar ser removido para dar espaço ao novo objeto: addChild(), addChildAt() e setChildIndex().

Esse evento tem as seguintes propriedades:

Despachado quando um objeto de exibição está prestes a ser removido da lista de exibição, seja diretamente ou através da remoção de uma subárvore na qual esse objeto de exibição está contido. Dois métodos da classe DisplayObjectContainer geram este evento: removeChild() e removeChildAt().

Os métodos a seguir de um objeto DisplayObjectContainer também irão gerar este evento se um objeto precisar ser removido para dar espaço ao novo objeto: addChild(), addChildAt() e setChildIndex().

Esse evento tem as seguintes propriedades:

[evento de transmissão] Despachado quando a lista de exibição está prestes a ser atualizada e renderizada. Esse evento fornece a última oportunidade para que os objetos que ouvem esse evento façam alterações antes da renderização da lista de exibição. É necessário chamar o método invalidate() do objeto Stage sempre que desejar que um evento render seja despachado. Os eventos Render só são despachados para um objeto se houver confiança mútua entre ele e o objeto que chamou Stage.invalidate(). Esse é um evento de transmissão, ou seja, ele é despachado por todos os objetos de exibição com um ouvinte registrado para esse evento.

Observação: Este evento não será despachado se a exibição não estiver renderizando. Este é o caso em que o conteúdo está minimizado ou obscurecido.

Observação: Esse evento não tem uma "fase de captura" nem "fase de bubble", significando que os ouvintes de evento precisam ser adicionados diretamente a qualquer destino possível que esteja ou não na lista de exibição.

Esse evento tem as seguintes propriedades:

1. As propriedades da classe são declaradas para a cor e o tamanho do quadrado.
2. O construtor chama o método draw(), que desenha um quadrado laranja no Palco, nas coordenadas padrão de x = 0, y = 0.
3. Os seguintes métodos de ouvinte de eventos são anexados ao quadrado:
   • addedHandler() ouve eventos added, despachados quando o quadrado é adicionado à lista de exibição.
   • enterFrameHandler() ouve eventos enterFrame, que não têm significado real nesse exemplo.
   • removedHandler() ouve eventos removed, despachados quando o quadrado é removido da lista de exibição, o que acontece quando o usuário clica nele.
   • clickHandler() ouve eventos click, despachados quando o usuário clica no quadrado laranja.
   • renderHandler() ouve eventos render após a atualização da lista de exibição.

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