DisplayObject  - AS3

Le opzioni di accessibilità correnti di questo oggetto di visualizzazione. Se modificate la proprietà accessibilityProperties o qualunque campo in accessibilityProperties, dovete chiamare il metodo Accessibility.updateProperties() per rendere attive le modifiche.

Nota: per un oggetto creato nell'ambiente di creazione di Flash, il valore di accessibilityProperties è precompilato con le informazioni eventualmente immesse nel pannello Accessibilità per quell'oggetto.

Elementi API correlati

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 il valore della trasparenza alfa dell'oggetto specificato. I valori validi sono quelli compresi tra 0 (completamente trasparente) e 1 (completamente opaco). Il valore predefinito è 1. Gli oggetti di visualizzazione con alpha impostato su 0 sono attivi, anche se invisibili.

Altri esempi

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 valore della classe BlendMode che specifica il metodo di fusione da utilizzare. Una bitmap può essere disegnata internamente in due modi. Se disponete di un metodo di fusione abilitato o di una maschera di ritaglio esterna, la bitmap viene disegnata aggiungendo una forma quadrata con riempimento bitmap al renderer dei vettori. Se tentate di impostare questa proprietà su un valore non valido, i runtime di Flash impostano il valore su BlendMode.NORMAL.

La proprietà blendMode influisce su ogni pixel dell'oggetto di visualizzazione. Ciascun pixel è composto da tre colori costituenti (rosso, verde e blu) e ciascuno di essi presenta un valore compreso tra 0x00 e 0xFF. Flash Player o Adobe AIR confronta ogni colore costituente di un pixel del clip filmato con il colore corrispondente del pixel sullo sfondo. Ad esempio, se blendMode è impostato su BlendMode.LIGHTEN, il valore rosso dell'oggetto di visualizzazione viene confrontato da Flash Player o Adobe AIR con il valore rosso dello sfondo, e il più chiaro dei due viene utilizzato come valore per la componente rossa del colore visualizzato.

Nella tabella seguente sono descritte le impostazioni blendMode. La classe BlendMode definisce i valori di stringa utilizzabili. Le illustrazioni riportate nella tabella mostrano i valori blendMode applicati a un oggetto di visualizzazione circolare (2) sovrapposto a un altro oggetto di visualizzazione (1).

Costante BlendMode	Illustrazione	Descrizione
BlendMode.NORMAL		L'oggetto di visualizzazione appare in primo piano rispetto allo sfondo. I valori di pixel dell'oggetto di visualizzazione sostituiscono quelli dello sfondo. Se l'oggetto di visualizzazione è trasparente, lo sfondo è visibile.
BlendMode.LAYER		Forza la creazione di un gruppo di trasparenza per l'oggetto di visualizzazione. In altri termini, l'oggetto di visualizzazione viene pre-composto in un buffer temporaneo prima di essere ulteriormente elaborato. Questa operazione avviene automaticamente se l'oggetto di visualizzazione viene preventivamente memorizzato nella cache mediante la funzionalità di caching bitmap oppure se si tratta di un contenitore di oggetto di visualizzazione che include almeno un oggetto secondario con un'impostazione blendMode diversa da BlendMode.NORMAL. Non è supportato nel rendering GPU.
BlendMode.MULTIPLY		Moltiplica il valore dei colori costituenti dell'oggetto di visualizzazione per quelli del colore di sfondo, quindi li normalizza dividendo per 0xFF, ottenendo colori più scuri. Questa impostazione viene comunemente utilizzata per ombre ed effetti di profondità. Ad esempio, se un colore costituente (come il rosso) di un singolo pixel dell'oggetto di visualizzazione e il colore corrispondente del pixel sullo sfondo hanno entrambi valore 0x88, il risultato moltiplicato sarà 0x4840. Dividendo per 0xFF, per quel colore costituente si ottiene il risultato 0x48, vale a dire una tonalità più scura di quella del colore dell'oggetto di visualizzazione o dello sfondo.
BlendMode.SCREEN		Moltiplica il complemento (opposto) del colore dell'oggetto di visualizzazione per il complemento del colore di sfondo, ottenendo un effetto di decolorazione. Questa impostazione è comunemente utilizzata per le luci o per rimuovere aree nere dall'oggetto di visualizzazione.
BlendMode.LIGHTEN		Seleziona il più chiaro dei colori costituenti dell'oggetto di visualizzazione e dei colori dello sfondo (i colori con i valori più alti). Viene generalmente utilizzata per la sovrimpressione di caratteri. Ad esempio, se l'oggetto di visualizzazione ha un pixel con valore RGB 0xFFCC33 e il pixel di sfondo ha un valore RGB 0xDDF800, il valore RGB risultante per il pixel visualizzato è 0xFFF833 (perché 0xFF > 0xDD, 0xCC < 0xF8 e 0x33 > 0x00 = 33). Non è supportato nel rendering GPU.
BlendMode.DARKEN		Seleziona il più scuro dei colori costituenti dell'oggetto di visualizzazione e dei colori dello sfondo (i colori con i valori più bassi). Viene generalmente utilizzata per la sovrimpressione di caratteri. Ad esempio, se l'oggetto di visualizzazione ha un pixel con valore RGB 0xFFCC33 e il pixel di sfondo ha un valore RGB 0xDDF800, il valore RGB risultante per il pixel visualizzato è 0xDDCC00 (perché 0xFF > 0xDD, 0xCC < 0xF8 e 0x33 > 0x00 = 33). Non è supportato nel rendering GPU.
BlendMode.DIFFERENCE		Confronta i colori costituenti dell'oggetto di visualizzazione con quelli dello sfondo e sottrae il più scuro dei valori dei due colori costituenti dal più chiaro. Viene generalmente utilizzata per ottenere colori più brillanti. Ad esempio, se l'oggetto di visualizzazione ha un pixel con un valore RGB di 0xFFCC33 e il pixel di sfondo ha un valore RGB di 0xDDF800, il valore RGB risultante per il pixel visualizzato è 0x222C33, perché 0xFF - 0xDD = 0x22, 0xF8 - 0xCC = 0x2C, e 0x33 - 0x00 = 0x33.
BlendMode.ADD		Aggiunge i valori dei colori costituenti dell'oggetto di visualizzazione a quelli dei colori dello sfondo, applicando un valore ceiling di 0xFF. Questa impostazione è generalmente utilizzata per animare una dissolvenza di schiarimento tra due oggetti. Ad esempio, se l'oggetto di visualizzazione ha un pixel con un valore RGB di 0xAAA633 e il pixel di sfondo ha un valore RGB di 0xDD2200, il valore RGB risultante per il pixel visualizzato è 0xFFC833 (perché 0xAA + 0xDD > 0xFF, 0xA6 + 0x22 = 0xC8 e 0x33 + 0x00 = 0x33).
BlendMode.SUBTRACT		Sottrae i valori dei colori costituenti dell'oggetto di visualizzazione da quelli del colore di sfondo, applicando un valore floor pari a 0. Questa impostazione è generalmente utilizzata per animare una dissolvenza di scurimento tra due oggetti. Ad esempio, se l'oggetto di visualizzazione ha un pixel con valore RGB 0xAA2233 e il pixel di sfondo ha un valore RGB 0xDDA600, il valore RGB risultante per il pixel visualizzato è 0x338400 (perché 0xDD - 0xAA = 0x33, 0xA6 - 0x22 = 0x84 e 0x00 - 0x33 < 0x00).
BlendMode.INVERT		Inverte lo sfondo.
BlendMode.ALPHA		Applica il valore alfa di ciascun pixel dell'oggetto di visualizzazione allo sfondo. La proprietà blendMode dell'oggetto di visualizzazione principale deve essere impostata su BlendMode.LAYER. Ad esempio, nell'illustrazione a fianco, l'oggetto di visualizzazione principale, che è uno sfondo bianco, ha un valore blendMode = BlendMode.LAYER. Non è supportato nel rendering GPU.
BlendMode.ERASE		Elimina lo sfondo in base al valore alfa dell'oggetto di visualizzazione. La proprietà blendMode dell'oggetto di visualizzazione principale deve essere impostata su BlendMode.LAYER. Ad esempio, nell'illustrazione a fianco, l'oggetto di visualizzazione principale, che è uno sfondo bianco, ha un valore blendMode = BlendMode.LAYER. Non è supportato nel rendering GPU.
BlendMode.OVERLAY		Regola il colore di ogni pixel in base al livello di scuro dello sfondo. Se lo sfondo è più chiaro del grigio al 50%, i colori dell'oggetto di visualizzazione e dello sfondo vengono retinati, ottenendo un colore più chiaro. Se lo sfondo è più scuro del grigio al 50%, i colori vengono moltiplicati, producendo un colore più scuro. Questa impostazione viene generalmente utilizzata per gli effetti di ombreggiatura. Non è supportato nel rendering GPU.
BlendMode.HARDLIGHT		Regola il colore di ogni pixel in base al livello di scuro dell'oggetto di visualizzazione. Se l'oggetto di visualizzazione è più chiaro del grigio al 50%, i suoi colori e quelli dello sfondo vengono retinati, ottenendo un colore più chiaro. Se l'oggetto di visualizzazione è più scuro del grigio al 50%, i colori vengono moltiplicati, producendo un colore più scuro. Questa impostazione viene generalmente utilizzata per gli effetti di ombreggiatura. Non è supportato nel rendering GPU.
BlendMode.SHADER	N/D	Regola il colore utilizzando una routine dello shader personalizzata. Lo shader utilizzato è specificato come istanza Shader assegnata alla proprietà blendShader. L'impostazione della proprietà blendShader di un oggetto di visualizzazione su un'istanza Shader, imposta automaticamente la proprietà blendMode dell'oggetto di visualizzazione su BlendMode.SHADER. Se impostate la proprietà blendMode su BlendMode.SHADER senza impostare prima la proprietà blendShader, la proprietà blendMode verrà invece impostata su BlendMode.NORMAL. Non è supportato nel rendering GPU.

Altri esempi

Elementi API correlati

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

Imposta uno shader utilizzato per la fusione dei colori di primo piano e sfondo. Quando la proprietà blendMode è impostata su BlendMode.SHADER, viene utilizzato l'oggetto Shader specificato per creare l'output del metodo di fusione per l'oggetto di visualizzazione.

L'impostazione della proprietà blendShader di un oggetto di visualizzazione su un'istanza Shader, imposta automaticamente la proprietà blendMode dell'oggetto di visualizzazione su BlendMode.SHADER. Se impostate la proprietà blendShader (che a sua volta imposta la proprietà blendMode su BlendMode.SHADER), quindi modificate il valore della proprietà blendMode, potete reimpostare il metodo di fusione affinché utilizzi lo shader di fusione impostando semplicemente la proprietà blendMode su BlendMode.SHADER. Non è necessario impostare di nuovo la proprietà blendShader, fatta eccezione per modificare lo shader utilizzato per il metodo di fusione.

L'oggetto Shader assegnato alla proprietà blendShader deve specificare almeno due input di tipo image4. Non è necessario specificare gli input nel codice utilizzando le proprietà input degli oggetti ShaderInput associati. L'oggetto di visualizzazione dello sfondo viene utilizzato automaticamente come primo input (ovvero l'input con index 0). L'oggetto di visualizzazione del primo piano viene utilizzato come secondo input (ovvero l'input con index 1). Uno shader utilizzato come shader di fusione può specificare più di due input. In tal caso, qualsiasi input aggiuntivo deve essere specificato mediante l'impostazione della relativa proprietà input dell'istanza ShaderInput.

Quando assegnate un'istanza Shader a questa proprietà, lo shader viene copiato internamente. L'operazione di fusione utilizza tale copia interna, non un riferimento allo shader originale. Qualsiasi modifica apportata allo shader, ad esempio la modifica del valore di un parametro, dell'input o del codice byte, non verrà applicata alla copia dello shader usata per il metodo di fusione.

Altri esempi

Elementi API correlati

Se è impostata su true, nella cache dei runtime Flash viene memorizzata una rappresentazione bitmap interna dell'oggetto di visualizzazione. In questo modo, possono essere migliorate le prestazioni degli oggetti di visualizzazione con contenuto vettoriale complesso.

Tutti i dati vettoriali di un oggetto di visualizzazione con una bitmap memorizzata nella cache vengono disegnati sulla bitmap anziché nella vista principale. Se cacheAsBitmapMatrix è null o non supportato, la bitmap viene quindi copiata nella vista principale sotto forma di pixel non allungati né ruotati, agganciati ai limiti dei pixel più vicini. I pixel vengono mappati 1 a 1 con l'oggetto principale. Se i limiti della bitmap cambiano, questa viene ricreata anziché essere allungata.

Se cacheAsBitmapMatrix è diverso da null e supportato, l'oggetto viene disegnato sulla bitmap fuori schermo utilizzando quella matrice e vengono utilizzati i risultati estesi e/o ruotati di tale rendering per disegnare l'oggetto nella visualizzazione principale.

Non viene creata alcuna bitmap interna, a meno che la proprietà cacheAsBitmap sia impostata su true.

Il rendering non viene modificato dopo l'impostazione della proprietà cacheAsBitmap su true, tuttavia l'oggetto di visualizzazione esegue automaticamente l'aggancio ai pixel. La velocità dell'animazione può essere notevolmente aumentata, a seconda della complessità del contenuto vettoriale.

La proprietà cacheAsBitmap viene impostata automaticamente su true ogni volta che si applica un filtro a un oggetto di visualizzazione (quando l'array filter dell'oggetto non è vuoto); e se a un oggetto di visualizzazione è applicato un filtro, la proprietà cacheAsBitmap risulta true anche se viene impostata su false. Se tutti i filtri di un oggetto di visualizzazione vengono rimossi, l'impostazione cacheAsBitmap ritorna all'ultimo valore impostato.

Un oggetto di visualizzazione non utilizza una bitmap anche se la proprietà cacheAsBitmap è impostata su true e, al contrario, esegue il rendering dai dati vettoriali nei seguenti casi:

• La bitmap è troppo grande. In AIR 1.5 e Flash Player 10, la dimensione massima di un'immagine bitmap è di 8.191 pixel in larghezza o altezza, mentre il numero totale di pixel non può essere superiore a 16.777.215. (Quindi, se un'immagine bitmap ha una larghezza di 8.191 pixel, può avere solo una lunghezza di 2.048 pixel.) In Flash Player 9 e versioni precedenti, la limitazione è di 2.880 pixel in altezza e 2.880 pixel in larghezza.
• L'allocazione della bitmap fallisce (errore di memoria esaurita).

L'uso della proprietà cacheAsBitmap è più adatto ai clip filmato che includono contenuto statico e non vengono modificati in scala e ruotati frequentemente. Con questo tipo di clip filmato, la proprietà cacheAsBitmap può consentire miglioramenti delle prestazioni in caso di conversione di un clip filmato (quando ne viene modificata la posizione di x e y).

Altre informazioni

Elementi API correlati

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 il valore è diverso da null, questo oggetto Matrix definisce il modo in cui viene eseguito il rendering di un oggetto di visualizzazione quando cacheAsBitmap è impostato su true. Questa applicazione utilizza questa matrice come matrice di trasformazione che viene applicata durante il rendering della versione bitmap dell'oggetto di visualizzazione.

Supporto profili AIR: questa funzionalità è supportata nei dispositivi mobili ma non nei sistemi operativi desktop. Inoltre, offre un supporto limitato nei dispositivi AIR per TV. Specificamente, nei dispositivi AIR per TV, le trasformazioni supportate includono il ridimensionamento e la traslazione, ma non la rotazione e l'inclinazione. Per ulteriori informazioni sul supporto delle API tra più profili, vedete Supporto dei profili AIR.

Con cacheAsBitmapMatrix impostato, l'applicazione mantiene una bitmap memorizzata in cache attraverso varie trasformazioni 2D, tra cui traslazione, rotazione e ridimensionamento. Se l'applicazione usa l'accelerazione hardware, l'oggetto viene memorizzato nella memoria video come texture. In questo modo la GPU può applicare le trasformazioni supportate all'oggetto. La GPU è in grado di eseguire queste trasformazioni più rapidamente della CPU.

Per utilizzare l'accelerazione hardware, impostate l'opzione Rendering su GPU nella scheda Generali della finestra di dialogo Impostazioni iPhone in Flash Professional CS5. Oppure impostate la proprietà renderMode su gpu nel file descrittore dell'applicazione. Nota: i dispositivi AIR per TV utilizzano automaticamente l'accelerazione hardware se disponibile.

Ad esempio, il codice seguente invia una rappresentazione bitmap non trasformata dell'oggetto di visualizzazione alla GPU:

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

Solitamente è sufficiente la matrice di identità (new Matrix()). Tuttavia, potete usare un'altra matrice, ad esempio una matrice ridimensionata in riduzione, per caricare una bitmap differente nella GPU. Ad esempio, l'esempio seguente applica una matrice cacheAsBitmapMatrix che è ridimensionata di 0,5 sugli assi x e y. L'oggetto bitmap utilizzato dalla GPU è più piccolo, tuttavia la GPU ne adatta le dimensioni alla proprietà transform.matrix dell'oggetto di visualizzazione:

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

In generale dovete scegliere una matrice che trasforma l'oggetto di visualizzazione per ottenere le dimensioni con cui apparirà nell'applicazione. Ad esempio, se l'applicazione visualizza la versione bitmap dello sprite ridotta a metà, utilizzate una matrice che esegua la riduzione a metà. Se l'applicazione visualizzerà lo sprite ingrandito rispetto alle dimensioni correnti, usate una matrice che esegua un ridimensionamento in base allo stesso fattore di ingrandimento.

Nota: la proprietà cacheAsBitmapMatrix è indicata per le trasformazioni 2D. Se dovete applicare trasformazioni 3D, potete farlo impostando una proprietà 3D dell'oggetto e modificandone la proprietà transform.matrix3D. Se l'applicazione è stata compilata utilizzando la modalità GPU, questo approccio permette di applicare le trasformazioni 3D all'oggetto tramite la GPU. La proprietà cacheAsBitmapMatrix viene ignorata per gli oggetti 3D.

Altre informazioni

Elementi API correlati

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

Un array indicizzato che contiene ogni oggetto filtro attualmente associato all'oggetto di visualizzazione. Il pacchetto flash.filters contiene diverse classi che definiscono dei filtri speciali.

I filtri possono essere applicati mediante Flash Professional in fase di progettazione o in fase di runtime utilizzando codice ActionScript. Per applicare un filtro utilizzando codice ActionScript, dovete creare una copia temporanea dell'intero array filters, modificare l'array temporaneo, quindi riassegnarne il valore all'array filters. Non è possibile aggiungere direttamente un nuovo oggetto filtro all'array filters.

Per aggiungere un filtro utilizzando ActionScript, procedete nel modo seguente (si presuppone che l'oggetto di visualizzazione di destinazione sia denominato myDisplayObject):

1. Create un nuovo oggetto filtro mediante il metodo di costruzione della classe di filtri scelta.
2. Assegnate il valore dell'array myDisplayObject.filters a un array temporaneo, ad esempio un array denominato myFilters.
3. Aggiungete il nuovo oggetto filtro all'array temporaneo myFilters.
4. Assegnate il valore dell'array temporaneo all'array myDisplayObject.filters.

Se l'array filters è undefined, non occorre utilizzare un array temporaneo. Potete, invece, assegnare direttamente un valore letterale di array contenente uno o più oggetti filtro personalizzati. Nel primo esempio della sezione Esempi viene aggiunto un filtro ombra esterna mediante del codice che gestisce array filters sia definiti che non definiti.

Per modificare un oggetto filtro esistente, dovete utilizzare una tecnica che consente di modificare una copia dell'array filters:

1. Assegnate il valore dell'array filters a un array temporaneo, denominato ad esempio myFilters.
2. Modificate la proprietà mediante l'array temporaneo myFilters. Ad esempio, per impostare la proprietà quality del primo filtro dell'array, potete utilizzare il codice seguente: myFilters[0].quality = 1;
3. Assegnate il valore dell'array temporaneo all'array filters.

Al momento del caricamento, se un oggetto di visualizzazione è associato a un filtro, l'oggetto viene contrassegnato in modo che sia memorizzato automaticamente nella cache come bitmap trasparente. Da questo punto in avanti, a condizione che all'oggetto di visualizzazione sia associato un elenco di filtri valido, il lettore memorizza l'oggetto di visualizzazione nella cache come bitmap. Questa bitmap di origine viene utilizzata come immagine di origine per gli effetti filtro. Ogni oggetto di visualizzazione dispone in genere di due bitmap: una con l'oggetto di visualizzazione di origine non filtrato originale e l'altra per l'immagine finale dopo l'applicazione del filtro. L'immagine finale viene utilizzata al momento del rendering. Se l'oggetto di visualizzazione non viene modificato, l'immagine finale non richiede alcun aggiornamento.

Il pacchetto flash.filters contiene classi specifiche per i filtri. Ad esempio, per creare un filtro DropShadow, potete scrivere il seguente codice:

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

L'operatore is può essere utilizzato per determinare il tipo di filtro assegnato a ogni posizione di indice nell'array filter. Ad esempio, il codice seguente mostra come determinare la posizione del primo filtro dell'array filters che corrisponde al tipo 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: poiché non è possibile aggiungere direttamente un nuovo oggetto filter all'array DisplayObject.filters, il codice seguente non ha alcun effetto sull'oggetto di visualizzazione target denominato myDisplayObject:

     myDisplayObject.filters.push(myDropShadow);
     

Elementi API correlati

Indica l'altezza dell'oggetto di visualizzazione espressa in pixel. L'altezza viene calcolata in base ai limiti del contenuto dell'oggetto di visualizzazione. Quando impostate la proprietà height, la proprietà scaleY viene impostata di conseguenza, come illustrato nel codice seguente:

    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;

Ad eccezione degli oggetti TextField e Video, un oggetto di visualizzazione senza contenuto (quale uno sprite vuoto) presenta un'altezza pari a 0, anche se si tenta di impostare height su un valore differente.

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

Restituisce un oggetto LoaderInfo contenente informazioni sul caricamento del file al quale questo oggetto di visualizzazione appartiene. La proprietà loaderInfo viene definita solo per l'oggetto di visualizzazione principale di un file SWF o per una bitmap caricata (non invece per una bitmap disegnata con ActionScript). Per trovare l'oggetto loaderInfo associato con il file SWF che contiene un oggetto di visualizzazione denominato myDisplayObject, utilizzate myDisplayObject.root.loaderInfo.

Un file SWF di grandi dimensioni può monitorare il processo di scaricamento chiamando this.root.loaderInfo.addEventListener(Event.COMPLETE, func).

Elementi API correlati

 trace (this.loaderInfo.url);
 

L'oggetto di visualizzazione chiamante viene mascherato dall'oggetto mask specificato. Per fare in modo che la mascheratura funzioni quando lo stage viene ridimensionato, l'oggetto di visualizzazione mask deve trovarsi in una parte attiva dell'elenco di visualizzazione. L'oggetto mask vero e proprio non viene disegnato. Impostate mask su null per rimuovere la maschera.

Per poter ridimensionare un oggetto mask, quest'ultimo deve essere incluso nell'elenco di visualizzazione. Allo stesso modo, per poter trascinare un oggetto Sprite mask (chiamandone il metodo startDrag()), l'oggetto deve trovarsi nell'elenco di visualizzazione. Per chiamare il metodo startDrag() per un oggetto Sprite mask basato su un evento mouseDown inviato dallo sprite, impostare la proprietà buttonMode dello sprite su true.

Quando gli oggetti di visualizzazione sono memorizzati nella cache impostando la proprietà cacheAsBitmap su true e la proprietà cacheAsBitmapMatrix su un oggetto Matrix, sia l'oggetto mask che l'oggetto di visualizzazione devono fare parte della medesima bitmap memorizzata nella cache. Di conseguenza, se l'oggetto di visualizzazione è memorizzato nella cache, la maschera dovrà essere un elemento secondario dell'oggetto di visualizzazione. Se un elemento antenato dell'oggetto di visualizzazione è memorizzato nella cache all'interno dell'elenco di visualizzazione, la maschera dovrà essere un elemento secondario di tale elemento o un suo discendente. Se nella cache sono memorizzati più antenati dell'oggetto mask, tale oggetto dovrà essere un discendente del contenitore memorizzato nell'elenco di visualizzazione nella posizione più vicina all'oggetto mask.

Nota: non potete utilizzare un singolo oggetto mask per mascherare più di un oggetto di visualizzazione chiamante. Quando assegnate mask a un secondo oggetto di visualizzazione, esso viene rimosso come maschera del primo oggetto e la proprietà maskdi quell'oggetto diventa null.

Altri esempi

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

Ottiene l’oggetto di metadati dell’istanza DisplayObject se i metadati sono stati memorizzati insieme all’istanza di questo DisplayObject nel file SWF mediante un tag PlaceObject4.

Indica la coordinata x del mouse o la posizione del dispositivo di input dell'utente, espressa in pixel.

Nota: per un DisplayObject che è stato ruotato, la coordinata x restituita corrisponderà a quella dell'oggetto non ruotato.

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 coordinata y del mouse o la posizione del dispositivo di input dell'utente, espressa in pixel.

Nota: per un DisplayObject che è stato ruotato, la coordinata y restituita corrisponderà a quella dell'oggetto non ruotato.

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 il nome dell'istanza dell'oggetto DisplayObject. L'oggetto può essere identificato nell'elenco degli elementi secondari del contenitore dell'oggetto di visualizzazione principale chiamando il metodo getChildByName() di tale contenitore.

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

Specifica se l'oggetto di visualizzazione è opaco con un determinato colore di sfondo. Una bitmap trasparente contiene i dati del canale alfa e viene disegnata in modo trasparente. Una bitmap opaca non ha un canale alfa e il suo rendering viene eseguito più rapidamente. Se la bitmap è opaca, è possibile specificarne il colore di sfondo.

Se viene impostato un valore numerico, la superficie è opaca (non trasparente) con il colore di sfondo RGB specificato dal numero. Se viene impostato su null (il valore predefinito), l'oggetto di visualizzazione ha uno sfondo trasparente.

La proprietà opaqueBackground viene utilizzata principalmente con la proprietà cacheAsBitmap per ottimizzare il rendering. Per gli oggetti di visualizzazione nei quali la proprietà cacheAsBitmap è impostata su true, l'impostazione di opaqueBackground può migliorare le prestazioni del rendering.

Per l'area dello sfondo opaco non viene eseguita la corrispondenza quando si chiama il metodo hitTestPoint() con il parametro shapeFlag impostato su true.

L'area dello sfondo opaco non risponde agli eventi del mouse.

Altri esempi

Elementi API correlati

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 l'oggetto DisplayObjectContainer che contiene questo oggetto di visualizzazione. Utilizzate la proprietà parent per specificare un percorso relativo per gli oggetti di visualizzazione che si trovano sopra l'oggetto di visualizzazione corrente nella gerarchia dell'elenco di visualizzazione.

Potete utilizzare parent per spostarsi verso l'alto di più livelli nell'elenco di visualizzazione, come illustrato di seguito:

     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

Nel caso di un oggetto di visualizzazione all'interno di un file SWF caricato, la proprietà root è l'oggetto di visualizzazione più in alto nella porzione della struttura dell'elenco di visualizzazione rappresentata da quel file SWF. Per un oggetto Bitmap che rappresenta un file di immagine caricato, la proprietà root è lo stesso oggetto Bitmap. Per l'istanza della classe principale del primo file SWF caricato, la proprietà root è lo stesso oggetto di visualizzazione. La proprietà root dell'oggetto Stage è lo stesso oggetto Stage. La proprietà root viene impostata su null per ciascun oggetto di visualizzazione che non è stato aggiunto all'elenco di visualizzazione, a meno che non sia stato aggiunto a un contenitore di oggetto di visualizzazione che è esterno all'elenco di visualizzazione ma è un elemento secondario dell'oggetto di visualizzazione di primo livello in un file SWF caricato.

Ad esempio, se si crea un nuovo oggetto Sprite chiamando il metodo di costruzione Sprite(), la sua proprietà root è null finché l'oggetto non viene aggiunto all'elenco di visualizzazione (o a un contenitore di oggetto di visualizzazione che è esterno all'elenco di visualizzazione ma è un elemento secondario dell'oggetto di visualizzazione di primo livello in un file SWF caricato).

Per un file SWF caricato, anche se l'oggetto Loader utilizzato per caricare il file potrebbe non essere incluso nell'elenco di visualizzazione, l'oggetto di visualizzazione di primo livello del file SWF ha la proprietà root impostata su se stesso. La proprietà root dell'oggetto Loader non viene impostata finché l'oggetto non viene impostato come elemento secondario di un oggetto di visualizzazione per il quale tale proprietà è impostata.

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 la rotazione dell'istanza DisplayObject, espressa in gradi, rispetto alla posizione originale. I valori da 0 a 180 rappresentano la rotazione oraria, quelli da 0 a -180 la rotazione antioraria. I valori esterni a questo intervallo vengono aggiunti o sottratti a 360 per ottenere un valore interno all'intervallo. Ad esempio, l'istruzione my_video.rotation = 450 è uguale 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 la rotazione dell'asse x dell'istanza DisplayObject, espressa in gradi, rispetto all'orientamento originale relativo al contenitore principale 3D. I valori da 0 a 180 rappresentano la rotazione oraria, quelli da 0 a -180 la rotazione antioraria. I valori esterni a questo intervallo vengono aggiunti o sottratti a 360 per ottenere un valore interno all'intervallo.

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 rotazione dell'asse y dell'istanza DisplayObject, espressa in gradi, rispetto all'orientamento originale relativo al contenitore principale 3D. I valori da 0 a 180 rappresentano la rotazione oraria, quelli da 0 a -180 la rotazione antioraria. I valori esterni a questo intervallo vengono aggiunti o sottratti a 360 per ottenere un valore interno all'intervallo.

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 rotazione dell'asse z dell'istanza DisplayObject, espressa in gradi, rispetto all'orientamento originale relativo al contenitore principale 3D. I valori da 0 a 180 rappresentano la rotazione oraria, quelli da 0 a -180 la rotazione antioraria. I valori esterni a questo intervallo vengono aggiunti o sottratti a 360 per ottenere un valore interno all'intervallo.

La griglia di modifica in scala attualmente attiva. Se è impostata su null, l'intero oggetto di visualizzazione viene modificato in scala normalmente quando viene applicata una trasformazione in scala.

Quando definite la proprietà scale9Grid, l'oggetto di visualizzazione viene suddiviso in una griglia di nove aree, in base al rettangolo scale9Grid che definisce l'area centrale della griglia. Le altre otto aree della griglia sono le seguenti:

• L'angolo superiore sinistro fuori del rettangolo
• L'area sopra il rettangolo
• L'angolo superiore destro fuori del rettangolo
• L'area a sinistra del rettangolo
• L'area a destra del rettangolo
• L'angolo inferiore sinistro fuori del rettangolo
• L'area sotto il rettangolo
• L'angolo inferiore destro fuori del rettangolo

Le otto aree esterne al centro (definito dal rettangolo) sono paragonabili alla cornice di un quadro alla quale vengono applicate regole speciali per la modifica in scala.

Quando impostate la proprietà scale9Grid e modificate in scala un oggetto di visualizzazione, tutto il testo e i gradienti vengono modificati in scala normalmente; tuttavia, per altri tipi di oggetti valgono le regole seguenti:

• Il contenuto dell'area centrale viene modificato in scala normalmente.
• Il contenuto presente negli angoli non viene modificato in scala.
• Il contenuto dell'area superiore e dell'area inferiore viene modificato in scala solo in senso orizzontale. Il contenuto dell'area sinistra e dell'area destra viene modificato in scala solo in senso verticale.
• Tutti i riempimenti (bitmap, video e con gradiente) vengono allungati per adattarne le forme.

Se un oggetto di visualizzazione viene ruotato, tutte le successive modifiche in scala sono normali e la proprietà scale9Grid viene ignorata.

Considerate, ad esempio, il seguente oggetto di visualizzazione e un rettangolo applicato come proprietà scale9Grid dell'oggetto di visualizzazione:

L'oggetto di visualizzazione.

Il rettangolo rosso mostra la proprietà scale9Grid.

Quando l'oggetto di visualizzazione viene modificato in scala o allungato, gli oggetti contenuti nel rettangolo vengono modificati in scala normalmente, mentre quelli all'esterno vengono modificati in base alle regole di scale9Grid:

Modificato in scala al 75%:
Modificato in scala al 50%:
Modificato in scala al 25%:
Allungato orizzontalmente del 150%:

Un uso comune per l'impostazione di scale9Grid consiste nel definire un oggetto di visualizzazione da utilizzare come componente, nel quale aree dei bordi mantengano la stessa larghezza quando il componente viene modificato in scala.

Altri esempi

Elementi API correlati

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 scala orizzontale (percentuale) dell'oggetto applicata dal punto di registrazione. Il punto di registrazione predefinito è (0,0). 1.0 equivale a una scala del 100%.

La modifica in scala del sistema di coordinate locale modifica i valori delle proprietà x e y, che sono definiti in pixel interi.

Altri esempi

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 scala verticale (percentuale) di un oggetto applicata dal punto di registrazione dell'oggetto. Il punto di registrazione predefinito è (0,0). 1.0 equivale a una scala del 100%.

La modifica in scala del sistema di coordinate locale modifica i valori delle proprietà x e y, che sono definiti in pixel interi.

Altri esempi

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 scala di profondità (percentuale) di un oggetto applicata dal punto di registrazione dell'oggetto. Il punto di registrazione predefinito è (0,0). 1.0 equivale a una scala del 100%.

La modifica in scala del sistema di coordinate locale modifica i valori delle proprietà x, y e z, che sono definiti in pixel interi.

Elementi API correlati

I limiti del rettangolo di scorrimento dell'oggetto di visualizzazione. L'oggetto di visualizzazione viene ritagliato in base alle dimensioni definite dal rettangolo, e scorre all'interno del rettangolo quando si modificano le proprietà x e y dell'oggetto scrollRect.

Le proprietà dell'oggetto Rectangle scrollRect utilizzano lo spazio di coordinate dell'oggetto di visualizzazione e vengono modificate in scala allo stesso modo dell'oggetto di visualizzazione. I contorni degli angoli della finestra ritagliata sull'oggetto di visualizzazione di scorrimento costituiscono l'origine dell'oggetto di visualizzazione (0,0) e il punto definito dalla larghezza e dall'altezza del rettangolo. Non sono centrati intorno all'origine, bensì la utilizzano per definire l'angolo superiore sinistro dell'area. Lo scorrimento di un oggetto di visualizzazione scorrevole viene sempre eseguito a incrementi di pixel interi.

Potete scorrere un oggetto a sinistra e a destra impostando la proprietà x dell'oggetto Rectangle scrollRect. Per farlo scorrere verso l'alto e verso il basso, impostate la proprietà y dell'oggetto Rectangle scrollRect. Se l'oggetto di visualizzazione viene ruotato di 90 gradi e fatto scorrere verso sinistra e destra, lo scorrimento avviene in realtà verso l'alto e verso il basso.

Tenete presente che le modifiche apportate alla proprietà scrollRect vengono elaborate solo quando avviene il rendering dell'oggetto. Pertanto, metodi quali localToGlobal potrebbero non produrre il risultato previsto se chiamati immediatamente dopo la modifica di scrollRect.

Nota: a partire da Flash Player 11.4/AIR 3.4, i valori negativi per la larghezza o l’altezza del rettangolo vengono sostituiti con 0.

Altri esempi

Elementi API correlati

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

Lo stage dell'oggetto di visualizzazione. Un'applicazione del runtime Flash dispone di un unico oggetto Stage. Ad esempio, se create e caricate più oggetti di visualizzazione nell'elenco di visualizzazione, la proprietà stage di ciascuno di essi fa riferimento allo stesso oggetto Stage (anche se l'oggetto appartiene a un file SWF caricato).

Se un oggetto di visualizzazione non viene aggiunto all'elenco di visualizzazione, la sua proprietà stage viene impostata su 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);

Un oggetto con proprietà relative alla matrice, alla trasformazione del colore e ai limiti di pixel di un oggetto di visualizzazione. Le proprietà specifiche matrix, colorTransform e tre proprietà di sola lettura (concatenatedMatrix, concatenatedColorTransform e pixelBounds) sono descritte nella voce relativa alla classe Transform.

Ognuna delle proprietà dell'oggetto di trasformazione è, essa stessa, un oggetto. Questo concetto è importante, poiché il solo modo per impostare nuovi valori per gli oggetti matrix o colorTransform consiste nel creare un nuovo oggetto e copiarlo nella proprietà transform.matrix o transform.colorTransform.

Ad esempio, per aumentare il valore tx della matrice di un oggetto di visualizzazione, dovete creare una copia dell'intero oggetto matrice, quindi copiare il nuovo oggetto nella proprietà matrix dell'oggetto di trasformazione:

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

Non è possibile impostare direttamente la proprietà tx. Il codice seguente non ha effetto su myDisplayObject:

    myDisplayObject.transform.matrix.tx += 10;
    

Potete inoltre copiare un intero oggetto di trasformazione e assegnarlo alla proprietà di trasformazione di un altro oggetto di visualizzazione. Ad esempio, il codice seguente copia l'intero oggetto di trasformazione da myOldDisplayObj a myNewDisplayObj:

L'oggetto di visualizzazione ottenuto, myNewDisplayObj, presenta ora gli stessi valori dell'oggetto di visualizzazione precedente (myOldDisplayObj) per la matrice, la trasformazione del colore e i limiti dei pixel.

Nota: i dispositivi AIR per TV utilizzano l'accelerazione hardware, se disponibile, per le trasformazioni di colore.

Altri esempi

Elementi API correlati

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

Determina se l'oggetto di visualizzazione è visibile o meno. Gli oggetti di visualizzazione che non sono visibili vengono disabilitati. Ad esempio, se visible=false per un'istanza InteractiveObject, non è possibile fare clic sull'istanza.

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 larghezza dell'oggetto di visualizzazione espressa in pixel. La larghezza viene calcolata in base ai limiti del contenuto dell'oggetto di visualizzazione. Quando impostate la proprietà width, la proprietà scaleX viene impostata di conseguenza, come illustrato nel codice seguente:

    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;

Ad eccezione degli oggetti TextField e Video, un oggetto di visualizzazione senza contenuto (quale uno sprite vuoto) presenta una larghezza pari a 0, anche se si tenta di impostare width su un valore differente.

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 coordinata x dell'istanza DisplayObject relativa alle coordinate locali del DisplayObjectContainer principale. Se è all'interno di un DisplayObjectContainer che presenta delle trasformazioni, l'oggetto utilizza il sistema di coordinate locali del DisplayObjectContainer in cui è racchiuso. Pertanto, se DisplayObjectContainer viene ruotato di 90 gradi in senso antiorario, l'elemento secondario di DisplayObjectContainer eredita un sistema di coordinate che è ruotato di 90 gradi in senso antiorario. Le coordinate dell'oggetto sono relative alla posizione del punto di registrazione.

Altri esempi

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 coordinata y dell'istanza DisplayObject relativa alle coordinate locali del DisplayObjectContainer principale. Se è all'interno di un DisplayObjectContainer che presenta delle trasformazioni, l'oggetto utilizza il sistema di coordinate locali del DisplayObjectContainer in cui è racchiuso. Pertanto, se DisplayObjectContainer viene ruotato di 90 gradi in senso antiorario, l'elemento secondario di DisplayObjectContainer eredita un sistema di coordinate che è ruotato di 90 gradi in senso antiorario. Le coordinate dell'oggetto sono relative alla posizione del punto di registrazione.

Altri esempi

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 posizione della coordinata z lungo l'asse z dell'istanza DisplayObject relativa al contenitore principale 3D. La proprietà z viene utilizzata per le coordinate 3D, non per quelle dello schermo o dei pixel.

Quando impostate una proprietà z per un oggetto di visualizzazione su un valore diverso da quello predefinito 0, viene creato automaticamente un oggetto Matrix3D corrispondente per modificare la posizione e l'orientamento di un oggetto di visualizzazione in tre dimensioni. Quando utilizzate l'asse z, il comportamento esistente delle proprietà x e y cambia da coordinate dello schermo o dei pixel in posizioni relative al contenitore principale 3D.

Ad esempio, un elemento secondario di _root nella posizione x = 100, y = 100, z = 200 non viene disegnato in corrispondenza della posizione in pixel (100,100). L'elemento secondario viene disegnato ovunque sia collocato dal calcolo della proiezione 3D. Il calcolo è:

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

Altri esempi

Elementi API correlati

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

Restituisce un rettangolo che definisce l'area dell'oggetto di visualizzazione relativa al sistema di coordinate dell'oggetto targetCoordinateSpace. Osservate il codice seguente, che mostra come il rettangolo restituito può variare a seconda del parametro targetCoordinateSpace passato al metodo:

     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: utilizzate i metodi localToGlobal() e globalToLocal() rispettivamente per convertire le coordinate locali dell'oggetto di visualizzazione nelle coordinate di visualizzazione e viceversa.

Il metodo getBounds() è simile a getRect(); tuttavia, il rettangolo restituito dal metodo getBounds() include gli eventuali tratti presenti sulle forme, a differenza di quello restituito da getRect(). Per un esempio, vedete la descrizione del metodo getRect().

Parametri

Elementi API correlati

Restituisce un rettangolo che definisce i bordi dell'oggetto di visualizzazione in base al sistema di coordinate definito dal parametro targetCoordinateSpace, esclusi gli eventuali tratti presenti sulle forme. I valori restituiti dal metodo getRect() sono gli stessi o minori di quelli restituiti da getBounds().

Nota: utilizzate localToGlobal() e globalToLocal() rispettivamente per convertire le coordinate locali dell'oggetto di visualizzazione nelle coordinate dello stage e viceversa.

Parametri

Elementi API correlati

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 le coordinate dello stage (globali) in quelle (locali) dell'oggetto di visualizzazione per l'oggetto point.

Per utilizzare questo metodo, create innanzi tutto un'istanza della classe Point. I valori x e y che assegnate rappresentano le coordinate globali perché sono relativi all'origine (0,0) dell'area di visualizzazione principale. Quindi, passate l'istanza Point come parametro al metodo globalToLocal(). Il metodo restituisce un nuovo oggetto Point con valori x e y relativi all'origine dell'oggetto di visualizzazione anziché dello stage.

Parametri

Altri esempi

Elementi API correlati

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 un punto bidimensionale dalle coordinate dello stage (globali) in quelle (locali) di un oggetto di visualizzazione tridimensionale.

Per utilizzare questo metodo, create innanzi tutto un'istanza della classe Point. I valori x e y che assegnate all'oggetto Point rappresentano le coordinate globali perché sono relativi all'origine (0,0) dell'area di visualizzazione principale. Passate quindi l'oggetto Point al metodo globalToLocal3D() come parametro point. Il metodo restituisce coordinate tridimensionali sotto forma di oggetto Vector3D contenente i valori x, y e z relativi all'origine dell'oggetto di visualizzazione tridimensionale.

Parametri

Valuta il riquadro di delimitazione dell'oggetto di visualizzazione per verificare se si sovrappone o si interseca con il riquadro di delimitazione dell'oggetto di visualizzazione obj.

Parametri

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

Valuta l'oggetto di visualizzazione per stabilire se si sovrappone o si interseca con il punto specificato dai parametri x e y. I parametri x e y specificano un punto nello spazio di coordinate dello stage, non il contenitore dell'oggetto di visualizzazione (a meno che tale contenitore non sia lo stage).

Parametri

Elementi API correlati

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 un punto tridimensionale delle coordinate (locali) dell'oggetto di visualizzazione tridimensionale in un punto bidimensionale nelle coordinate dello stage (globali).

Potete ad esempio utilizzare solo coordinate bidimensionali (x,y) per disegnare con i metodi display.Graphics. Per disegnare un oggetto tridimensionale, dovete mappare le coordinate tridimensionali di un oggetto di visualizzazione alle coordinate bidimensionali. Dovete innanzitutto creare un'istanza della classe Vector3D che contiene le coordinate x, y e z dell'oggetto di visualizzazione tridimensionale. Passate quindi l'oggetto Vector3D al metodo local3DToGlobal() come parametro point3d. Il metodo restituisce un oggetto Point bidimensionale che può essere utilizzato con l'API Graphics per disegnare l'oggetto tridimensionale.

Parametri

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 le coordinate dell'oggetto di visualizzazione (locali) in quelle dello stage (globali) per l'oggetto point.

Questo metodo consente di convertire qualsiasi coppia di coordinate x e y da valori relativi all'origine (0,0) di un determinato oggetto di visualizzazione (coordinate locali) a valori relativi all'origine dello stage (coordinate globali).

Per utilizzare questo metodo, create innanzi tutto un'istanza della classe Point. I valori x e y che assegnate rappresentano le coordinate locali perché sono relativi all'origine dell'oggetto di visualizzazione.

Quindi, passate l'istanza Point creata al metodo localToGlobal() come parametro. Il metodo restituisce un nuovo oggetto Point con valori x e y relativi all'origine dello stage anziché dell'oggetto di visualizzazione.

Parametri

Altri esempi

Elementi API correlati

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

Inviato quando un oggetto di visualizzazione viene aggiunto all'elenco di visualizzazione. I seguenti metodi attivano questo evento: DisplayObjectContainer.addChild(), DisplayObjectContainer.addChildAt().

Questo evento ha le seguenti proprietà:

Elementi API correlati

Inviato quando un oggetto di visualizzazione viene aggiunto all'elenco di visualizzazione sullo stage, sia direttamente o mediante l'aggiunta di una sottostruttura ad albero che contiene l'oggetto di visualizzazione. I seguenti metodi attivano questo evento: DisplayObjectContainer.addChild(), DisplayObjectContainer.addChildAt().

Questo evento ha le seguenti proprietà:

Elementi API correlati

[evento di trasmissione] Inviato quando l'indicatore di riproduzione sta entrando in un nuovo fotogramma. Se l'indicatore non è in movimento, oppure se è presente un solo fotogramma, questo evento viene inviato continuativamente in base alla frequenza dei fotogrammi. Questo è un evento di trasmissione e ciò significa che viene inviato da tutti gli oggetti di visualizzazione con un listener registrato per questo evento.

Nota: questo evento non dispone di una "fase di cattura" né di una "fase di bubbling"; ciò significa che i listener di eventi devono essere aggiunti direttamente a qualsiasi target potenziale, sia che il target si trovi o meno nell'elenco di visualizzazione.

Questo evento ha le seguenti proprietà:

[evento di trasmissione] Inviato quando l'indicatore di riproduzione sta per uscire dal fotogramma corrente. Tutti gli script di fotogramma sono stati eseguiti. Se l'indicatore non è in movimento, oppure se è presente un solo fotogramma, questo evento viene inviato continuativamente in base alla frequenza dei fotogrammi. Questo è un evento di trasmissione e ciò significa che viene inviato da tutti gli oggetti di visualizzazione con un listener registrato per questo evento.

Nota: questo evento non dispone di una "fase di cattura" né di una "fase di bubbling"; ciò significa che i listener di eventi devono essere aggiunti direttamente a qualsiasi target potenziale, sia che il target si trovi o meno nell'elenco di visualizzazione.

Questo evento ha le seguenti proprietà:

[evento di trasmissione] Inviato dopo l'esecuzione delle funzioni di costruzione degli oggetti di visualizzazione dei fotogrammi, ma prima dell'esecuzione degli script di fotogramma. Se l'indicatore non è in movimento, oppure se è presente un solo fotogramma, questo evento viene inviato continuativamente in base alla frequenza dei fotogrammi. Questo è un evento di trasmissione e ciò significa che viene inviato da tutti gli oggetti di visualizzazione con un listener registrato per questo evento.

Nota: questo evento non dispone di una "fase di cattura" né di una "fase di bubbling"; ciò significa che i listener di eventi devono essere aggiunti direttamente a qualsiasi target potenziale, sia che il target si trovi o meno nell'elenco di visualizzazione.

Questo evento ha le seguenti proprietà:

Inviato quando un oggetto di visualizzazione sta per essere rimosso dall'elenco di visualizzazione. Due metodi della classe DisplayObjectContainer generano questo evento: removeChild() eremoveChildAt().

Anche i seguenti metodi di un oggetto DisplayObjectContainer generano questo evento se un oggetto deve essere rimosso per fare spazio al nuovo oggetto: addChild(), addChildAt() e setChildIndex().

Questo evento ha le seguenti proprietà:

Inviato quando un oggetto di visualizzazione sta per essere rimosso dall'elenco di visualizzazione sullo stage, sia direttamente o mediante la rimozione di una sottostruttura ad albero che contiene l'oggetto di visualizzazione. Due metodi della classe DisplayObjectContainer generano questo evento: removeChild() eremoveChildAt().

Anche i seguenti metodi di un oggetto DisplayObjectContainer generano questo evento se un oggetto deve essere rimosso per fare spazio al nuovo oggetto: addChild(), addChildAt() e setChildIndex().

Questo evento ha le seguenti proprietà:

[evento di trasmissione] Inviato quando stanno per essere eseguiti l'aggiornamento e il rendering dell'elenco di visualizzazione. Questo evento fornisce l'ultima opportunità per gli oggetti che rilevano questo evento di effettuare delle modifiche prima del rendering dell'elenco di visualizzazione. Dovete chiamare il metodo invalidate() dell'oggetto Stage ogni volta che desiderate che venga inviato un evento render. Gli eventi Render vengono inviati a un oggetto solo se esiste un rapporto di mutua fiducia tra tale oggetto e l'oggetto che ha chiamato Stage.invalidate(). Questo è un evento di trasmissione e ciò significa che viene inviato da tutti gli oggetti di visualizzazione con un listener registrato per questo evento.

Nota: questo evento non viene inviato se non viene eseguito il rendering della visualizzazione, ovvero quando il contenuto è ridotto a icona o coperto.

Nota: questo evento non dispone di una "fase di cattura" né di una "fase di bubbling"; ciò significa che i listener di eventi devono essere aggiunti direttamente a qualsiasi target potenziale, sia che il target si trovi o meno nell'elenco di visualizzazione.

Questo evento ha le seguenti proprietà:

1. Le proprietà delle classi vengono dichiarate per il colore e le dimensioni del quadrato.
2. La funzione di costruzione chiama il metodo draw(), che disegna un quadrato arancione sullo stage in corrispondenza delle coordinate predefinite x = 0, y = 0.
3. I seguenti metodi del listener di eventi sono associati al quadrato:
   • addedHandler() intercetta gli eventi added, inviati quando il quadrato viene aggiunto all'elenco di visualizzazione.
   • enterFrameHandler() intercetta gli eventi enterFrame, che non hanno tuttavia pertinenza in questo esempio.
   • removedHandler() intercetta gli eventi removed, inviati quando il quadrato viene rimosso dall'elenco di visualizzazione, cioè quando l'utente fa clic sul quadrato.
   • clickHandler() intercetta gli eventi click, che vengono inviati quando l'utente fa clic sul quadrato arancione.
   • renderHandler() intercetta gli eventi render dopo che l'elenco di visualizzazione è stato aggiornato.

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