Le opzioni di accessibilità correnti di questo oggetto di visualizzazione. Se si modifica la proprietà accessibilityProperties o qualunque campo in accessibilityProperties, è necessario 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.

Vedere anche

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.

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 si dispone 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 si tenta di impostare questa proprietà su un valore non valido, Flash Player imposta il valore BlendMode.NORMAL.

Flash Player applica la proprietà blendMode su ogni singolo 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 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 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.
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).
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).
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.
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.
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.
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.

Vedere anche

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

Se è impostata su true, viene memorizzata nella cache 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. 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.

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: maggiore di 2880 pixel in entrambe le direzioni.
• 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).

Vedere anche

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

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 lo strumento di creazione di Flash in fase di progettazione o in fase di runtime utilizzando codice ActionScript. Per applicare un filtro utilizzando codice ActionScript, è necessario 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, procedere nel modo seguente (si presuppone che l'oggetto di visualizzazione di destinazione sia denominato myDisplayObject):

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

Se l'array filters è undefined, non occorre utilizzare un array temporaneo. È possibile, 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, è necessario utilizzare una tecnica che consente di modificare una copia dell'array filters:

1. Assegnare il valore dell'array filters a un array temporaneo, denominato ad esempio myFilters.
2. Modificare la proprietà mediante l'array temporaneo myFilters. Ad esempio, per impostare la proprietà quality del primo filtro dell'array, è possibile utilizzare il codice seguente: myFilters[0].quality = 1;
3. Assegnare 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, è possibile 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);
     

Vedere anche

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 si imposta 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;

A 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, utilizzare myDisplayObject.root.loaderInfo.

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

Vedere anche

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

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

Indica la coordinata x della posizione del mouse, in pixel.

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 della posizione del mouse, in pixel.

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.

Vedere anche

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

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

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 si definisce 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 si imposta la proprietà scale9Grid e si modifica 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.

Si consideri, 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.

Vedere anche

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 (percentage) dell'oggetto così come è 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 influisce sulle impostazioni delle proprietà x e y, che sono definite in pixel interi.

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 (percentage) di un oggetto così come è 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 influisce sulle impostazioni delle proprietà x e y, che sono definite in pixel interi.

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

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.

È possibile 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, impostare 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.

Vedere anche

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 Flash ha un unico oggetto Stage. Ad esempio, se si creano e si caricano 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 specifiche proprietà 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, è necessario creare una copia dell'intero oggetto matrice, quindi copiare il nuovo oggetto nella proprietà matrix dell'oggetto di trasformazione:

 var myMatrix:Object = 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; 

È inoltre possibile 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.

Vedere anche

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 si imposta 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;

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

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.

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 rettangolo che definisce l'area dell'oggetto di visualizzazione relativa al sistema di coordinate dell'oggetto targetCoordinateSpace. Osservare 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: utilizzare 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, vedere la descrizione del metodo getRect().

Parametri

Vedere anche

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

Parametri

Vedere anche

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 lineWidth:Number = 20;
var lineAlpha: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(lineWidth, color, lineAlpha, 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.1, 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, creare innanzi tutto un'istanza della classe Point. I valori x e y che si assegnano rappresentano le coordinate globali perché sono relativi all'origine (0,0) dell'area di visualizzazione principale. Quindi, passare 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

Vedere anche

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]

Valuta l'oggetto di visualizzazione per stabilire se si sovrappone o si interseca con l'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

Vedere anche

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 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, creare innanzi tutto un'istanza della classe Point. I valori x e y che si assegnano rappresentano le coordinate locali perché sono relativi all'origine dell'oggetto di visualizzazione.

Quindi, passare 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

Vedere anche

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à:

Vedere anche

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à:

Vedere anche

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. L'evento viene inviato simultaneamente a tutti gli oggetti di visualizzazione da cui viene rilevato.

Nota: questo evento non è soggetto a una "fase di cattura" e viene inviato direttamente al target, sia che il target si trovi nell'elenco di visualizzazione o meno.

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à:

Inviato quando l'elenco di visualizzazione sta per essere aggiornato e sottoposto a rendering. Questo evento fornisce l'ultima opportunità per gli oggetti che rilevano questo evento di effettuare delle modifiche prima del rendering dell'elenco di visualizzazione. Flash Player esegue il rendering dell'elenco di visualizzazione come comportamento predefinito. È necessario chiamare il metodo invalidate() dell'oggetto Stage ogni volta che si vuole inviare un evento render mediante Flash Player. 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().

Nota: questo evento non viene inviato se non viene eseguito il rendering della finestra di Flash Player, ovvero quando la finestra di Flash Player è ridotta a icona o coperta.

Nota: questo evento non è soggetto a una "fase di cattura" e viene inviato direttamente al target, sia che il target si trovi nell'elenco di visualizzazione o meno.

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