Pacchetto | flash.display |
Classe | public class Stage |
Ereditarietà | Stage DisplayObjectContainer InteractiveObject DisplayObject EventDispatcher Object |
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Per il contenuto SWF in esecuzione nel browser (in Flash® Player), lo stage rappresenta l'intera area in cui viene visualizzato il contenuto Flash. Per il contenuto in esecuzione in AIR nei sistemi operativi desktop, ogni oggetto NativeWindow ha un oggetto Stage corrispondente.
L'oggetto Stage non è accessibile globalmente. Per accedervi, dovete utilizzare la proprietà stage
di un'istanza DisplayObject.
La classe Stage ha varie classi antenate (DisplayObjectContainer, InteractiveObject, DisplayObject e EventDispatcher) dalle quali eredita le proprietà e i metodi. Molti di questi metodi e proprietà sono inapplicabili agli oggetti Stage oppure richiedono controlli di sicurezza quando vengono chiamati su un oggetto Stage. Le proprietà e i metodi che richiedono controlli di sicurezza sono documentati nella voce della classe Stage.
Inoltre, le seguenti proprietà ereditate non sono applicabili agli oggetti Stage. Se tentate di impostarle, viene generato un errore IllegalOperationError. Queste proprietà possono essere sempre lette, ma poiché non possono essere impostate, conterranno sempre i valori predefiniti.
-
accessibilityProperties
-
alpha
-
blendMode
-
cacheAsBitmap
-
contextMenu
-
filters
-
focusRect
-
loaderInfo
-
mask
-
mouseEnabled
-
name
-
opaqueBackground
-
rotation
-
scale9Grid
-
scaleX
-
scaleY
-
scrollRect
-
tabEnabled
-
tabIndex
-
transform
-
visible
-
x
-
y
Alcuni eventi che potreste ritenere parte della classe Stage, ad esempio enterFrame
, exitFrame
, frameConstructed
e render
, non possono essere eventi Stage poiché non può essere garantita la presenza di un riferimento all'oggetto Stage in ogni situazione in cui vengono utilizzati questi eventi. Poiché questi eventi non possono essere inviati dall'oggetto Stage, vengono inviati da ogni istanza DisplayObject; ciò significa che potete aggiungere un listener di eventi a una qualsiasi istanza DisplayObject per intercettare questi eventi. Questi eventi, che fanno parte della classe DisplayObject, sono definiti eventi di trasmissione per distinguerli dagli eventi destinati a un'istanza DisplayObject specifica. Altri due eventi di trasmissione, activate
e deactivate
, appartengono alla superclasse EventDispatcher di DisplayObject. Il comportamento degli eventi activate
e deactivate
è analogo a quello degli eventi di trasmissione di DisplayObject, salvo il fatto che questi due eventi non vengono inviati solo da tutte le istanze DisplayObject, bensì anche da tutte le istanze EventDispatcher e dalle istanze della di altre sottoclassi di EventDispatcher. Per ulteriori informazioni sugli eventi di trasmissione, vedete la classe DisplayObject.
Altri esempi
Lettura dell'elenco di visualizzazione
Controllo della modifica in scala dello stage
Uso della modalità a schermo intero
Altre informazioni
Programmazione degli elementi visivi
Elementi fondamentali della programmazione degli elementi visivi
Classi di visualizzazione di base
Operazioni con gli oggetti di visualizzazione
Impostazione delle proprietà dello stage
Gestione degli eventi per gli oggetti di visualizzazione
Orientamento dello stage
Elementi API correlati
Proprietà | Definito da | ||
---|---|---|---|
accessibilityImplementation : AccessibilityImplementation
L'implementazione di accessibilità corrente (AccessibilityImplementation) di questa istanza InteractiveObject. | InteractiveObject | ||
accessibilityProperties : AccessibilityProperties
Le opzioni di accessibilità correnti di questo oggetto di visualizzazione. | DisplayObject | ||
align : String
Un valore della classe StageAlign che specifica l'allineamento dello stage in Flash Player o nel browser. | Stage | ||
allowsFullScreen : Boolean [sola lettura]
Specifica se questo stage consente l'uso della modalità a tutto schermo.
| Stage | ||
allowsFullScreenInteractive : Boolean [sola lettura]
Specifica se questo stage consente l’uso della modalità di immissione del testo a tutto schermo.
| Stage | ||
alpha : Number
Indica il valore della trasparenza alfa dell'oggetto specificato. | DisplayObject | ||
autoOrients : Boolean
Specifica se l'orientamento dello stage cambia automaticamente quando cambia l'orientamento del dispositivo. | Stage | ||
blendMode : String
Un valore della classe BlendMode che specifica il metodo di fusione da utilizzare. | DisplayObject | ||
blendShader : Shader [sola scrittura]
Imposta uno shader utilizzato per la fusione dei colori di primo piano e sfondo. | DisplayObject | ||
browserZoomFactor : Number [sola lettura]
Specifica il fattore di zoom del browser. | Stage | ||
cacheAsBitmap : Boolean
Se è impostata su true, nella cache dei runtime Flash viene memorizzata una rappresentazione bitmap interna dell'oggetto di visualizzazione. | DisplayObject | ||
cacheAsBitmapMatrix : Matrix
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. | DisplayObject | ||
color : uint
Il colore dello sfondo del file SWF. | Stage | ||
colorCorrection : String
Verifica la correzione dei colori del runtime Flash per le visualizzazioni. | Stage | ||
colorCorrectionSupport : String [sola lettura]
Specifica se il runtime Flash è in esecuzione su un sistema operativo che supporta la correzione dei colori e se il profilo colore del monitor principale (primario) può essere letto e decodificato dal runtime Flash. | Stage | ||
constructor : * | Stage | ||
contentsScaleFactor : Number [sola lettura]
Specifica il fattore di scala dei pixel effettivo dello stage. | Stage | ||
contextMenu : NativeMenu
Specifica il menu di scelta rapida associato all'oggetto. | InteractiveObject | ||
deviceOrientation : String [sola lettura]
L'orientamento fisico del dispositivo. | Stage | ||
displayState : String
Un valore della classe StageDisplayState che specifica lo stato di visualizzazione da utilizzare. | Stage | ||
doubleClickEnabled : Boolean
Specifica se l'oggetto riceve gli eventi doubleClick. | InteractiveObject | ||
filters : Array
Un array indicizzato che contiene ogni oggetto filtro attualmente associato all'oggetto di visualizzazione. | DisplayObject | ||
focus : InteractiveObject
L'oggetto interattivo attivato mediante la tastiera, oppure null se l'attivazione non è impostata o se l'oggetto attivo appartiene a una sicurezza sandbox alla quale l'oggetto chiamante non ha accesso. | Stage | ||
focusRect : Object
Specifica se l'oggetto visualizza un rettangolo di attivazione. | InteractiveObject | ||
frameRate : Number
Ottiene e imposta la frequenza di fotogrammi dello stage. | Stage | ||
fullScreenHeight : uint [sola lettura]
Restituisce l'altezza del monitor che verrà utilizzata per la modalità a schermo intero, se tale stato viene attivato immediatamente. | Stage | ||
fullScreenSourceRect : Rectangle
Imposta il runtime Flash affinché modifichi in scala un'area specifica dello stage alla modalità a schermo intero. | Stage | ||
fullScreenWidth : uint [sola lettura]
Restituisce la larghezza del monitor che verrà utilizzata per la modalità a schermo intero, se tale stato viene attivato immediatamente. | Stage | ||
height : Number [override]
Indica l'altezza dell'oggetto di visualizzazione espressa in pixel. | Stage | ||
loaderInfo : LoaderInfo [sola lettura]
Restituisce un oggetto LoaderInfo contenente informazioni sul caricamento del file al quale questo oggetto di visualizzazione appartiene. | DisplayObject | ||
mask : DisplayObject
L'oggetto di visualizzazione chiamante viene mascherato dall'oggetto mask specificato. | DisplayObject | ||
metaData : Object
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. | DisplayObject | ||
mouseChildren : Boolean [override]
Determina se gli elementi secondari dell'oggetto sono abilitati o meno per il mouse o per il dispositivo di input dell'utente. | Stage | ||
mouseEnabled : Boolean
Specifica se questo oggetto riceve messaggi del mouse o di altri dispositivi di input dell'utente. | InteractiveObject | ||
mouseLock : Boolean
Impostate su true per abilitare il blocco del mouse. | Stage | ||
mouseX : Number [sola lettura]
Indica la coordinata x del mouse o la posizione del dispositivo di input dell'utente, espressa in pixel. | DisplayObject | ||
mouseY : Number [sola lettura]
Indica la coordinata y del mouse o la posizione del dispositivo di input dell'utente, espressa in pixel. | DisplayObject | ||
name : String
Indica il nome dell'istanza dell'oggetto DisplayObject. | DisplayObject | ||
nativeWindow : NativeWindow [sola lettura]
Un riferimento all'oggetto NativeWindow che contiene questo stage. | Stage | ||
needsSoftKeyboard : Boolean
Specifica se deve essere visualizzata una tastiera virtuale (una tastiera software a video) quando questa istanza InteractiveObject riceve lo stato di attivazione. | InteractiveObject | ||
numChildren : int [override] [sola lettura]
Restituisce il numero di elementi secondari di questo oggetto. | Stage | ||
opaqueBackground : Object
Specifica se l'oggetto di visualizzazione è opaco con un determinato colore di sfondo. | DisplayObject | ||
orientation : String [sola lettura]
L'orientamento attuale dello stage. | Stage | ||
parent : DisplayObjectContainer [sola lettura]
Indica l'oggetto DisplayObjectContainer che contiene questo oggetto di visualizzazione. | DisplayObject | ||
quality : String
Un valore della classe StageQuality che specifica la qualità di rendering utilizzata da Flash Player. | Stage | ||
root : DisplayObject [sola lettura]
Nel caso di un oggetto di visualizzazione all'interno di un file SWF caricato, la proprietà principale è l'oggetto di visualizzazione più in alto nella porzione della struttura dell'elenco di visualizzazione rappresentata da quel file SWF. | DisplayObject | ||
rotation : Number
Indica la rotazione dell'istanza DisplayObject, espressa in gradi, rispetto alla posizione originale. | DisplayObject | ||
rotationX : Number
Indica la rotazione dell'asse x dell'istanza DisplayObject, espressa in gradi, rispetto all'orientamento originale relativo al contenitore principale 3D. | DisplayObject | ||
rotationY : Number
Indica la rotazione dell'asse y dell'istanza DisplayObject, espressa in gradi, rispetto all'orientamento originale relativo al contenitore principale 3D. | DisplayObject | ||
rotationZ : Number
Indica la rotazione dell'asse z dell'istanza DisplayObject, espressa in gradi, rispetto all'orientamento originale relativo al contenitore principale 3D. | DisplayObject | ||
scale9Grid : Rectangle
La griglia di modifica in scala attualmente attiva. | DisplayObject | ||
scaleMode : String
Un valore della classe StageScaleMode che specifica la modalità scala da utilizzare. | Stage | ||
scaleX : Number
Indica la scala orizzontale (percentuale) dell'oggetto applicata dal punto di registrazione. | DisplayObject | ||
scaleY : Number
Indica la scala verticale (percentuale) di un oggetto applicata dal punto di registrazione dell'oggetto. | DisplayObject | ||
scaleZ : Number
Indica la scala di profondità (percentuale) di un oggetto applicata dal punto di registrazione dell'oggetto. | DisplayObject | ||
scrollRect : Rectangle
I limiti del rettangolo di scorrimento dell'oggetto di visualizzazione. | DisplayObject | ||
showDefaultContextMenu : Boolean
Specifica se visualizzare o nascondere le voci predefinite del menu di scelta rapida del runtime Flash. | Stage | ||
softKeyboard : String
Controlla l'aspetto della tastiera software. | InteractiveObject | ||
softKeyboardInputAreaOfInterest : Rectangle
Definisce l’area che deve rimanere visibile sullo schermo quando è visualizzata una tastiera virtuale (non disponibile in iOS). | InteractiveObject | ||
softKeyboardRect : Rectangle [sola lettura]
Un rettangolo che specifica l'area dello stage attualmente coperta da una tastiera software. | Stage | ||
stage : Stage [sola lettura]
Lo stage dell'oggetto di visualizzazione. | DisplayObject | ||
stage3Ds : Vector.<Stage3D> [sola lettura]
Un elenco di oggetti Stage3D disponibili per la visualizzazione del contenuto tridimensionale. | Stage | ||
stageFocusRect : Boolean
Specifica se viene visualizzato o meno un bordo luminoso intorno agli oggetti che vengono attivati. | Stage | ||
stageHeight : int
L'altezza corrente dello stage, in pixel. | Stage | ||
stageVideos : Vector.<StageVideo> [sola lettura]
Un elenco di oggetti StageVideo disponibili per la riproduzione di video esterni. | Stage | ||
stageWidth : int
Specifica la larghezza corrente dello stage, in pixel. | Stage | ||
supportedOrientations : Vector.<String> [sola lettura]
Gli orientamenti supportati dal dispositivo corrente. | Stage | ||
supportsOrientationChange : Boolean [statico] [sola lettura]
Indica se l'applicazione supporta le modifiche apportate all'orientamento dello stage (e alla rotazione del dispositivo). | Stage | ||
tabChildren : Boolean [override]
Determina se gli elementi secondari dell'oggetto sono abilitati per la tabulazione. | Stage | ||
tabEnabled : Boolean
Specifica se questo oggetto è incluso nell'ordine di tabulazione. | InteractiveObject | ||
tabIndex : int
Specifica l'ordine di tabulazione degli oggetti in un file SWF. | InteractiveObject | ||
textSnapshot : flash.text:TextSnapshot [override] [sola lettura]
Restituisce un oggetto TextSnapshot per questa istanza DisplayObjectContainer. | Stage | ||
transform : flash.geom:Transform
Un oggetto con proprietà relative alla matrice, alla trasformazione del colore e ai limiti di pixel di un oggetto di visualizzazione. | DisplayObject | ||
visible : Boolean
Determina se l'oggetto di visualizzazione è visibile o meno. | DisplayObject | ||
vsyncEnabled : Boolean
Rappresenta lo stato corrente di vsync della soluzione delle immagini sottostanti. È possibile attivare/disattivare vsync, quindi possiamo eseguire immediatamente il rendering senza attendere lo stato successivo VSYNC. | Stage | ||
width : Number [override]
Indica la larghezza dell'oggetto di visualizzazione espressa in pixel. | Stage | ||
wmodeGPU : Boolean [sola lettura]
Indica se la creazione di effetti compositi basata su GPU è disponibile e in uso. | Stage | ||
x : Number
Indica la coordinata x dell'istanza DisplayObject relativa alle coordinate locali del DisplayObjectContainer principale. | DisplayObject | ||
y : Number
Indica la coordinata y dell'istanza DisplayObject relativa alle coordinate locali del DisplayObjectContainer principale. | DisplayObject | ||
z : Number
Indica la posizione della coordinata z lungo l'asse z dell'istanza DisplayObject relativa al contenitore principale 3D. | DisplayObject |
Metodo | Definito da | ||
---|---|---|---|
[override]
Aggiunge un'istanza secondaria DisplayObject a questa istanza DisplayObjectContainer. | Stage | ||
[override]
Aggiunge un'istanza secondaria DisplayObject a questa istanza DisplayObjectContainer. | Stage | ||
addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void [override]
Registra un oggetto listener di eventi con un oggetto EventDispatcher, in modo che il listener riceva la notifica di un evento. | Stage | ||
Indica se le restrizioni di sicurezza possono determinare l'omissione di eventuali oggetti di visualizzazione dall'elenco restituito dalla chiamata al metodo DisplayObjectContainer.getObjectsUnderPoint() con il punto specificato. | DisplayObjectContainer | ||
Rende attivabile mediante tastiera l'oggetto interattivo specificato da objectToFocus, con la direzione dell'attivazione specificata dal parametro direction. | Stage | ||
Determina se l'oggetto di visualizzazione specificato è un elemento secondario dell'istanza DisplayObjectContainer oppure è l'istanza stessa. | DisplayObjectContainer | ||
[override]
Invia un evento nel flusso di eventi. | Stage | ||
Restituisce un rettangolo che definisce l'area dell'oggetto di visualizzazione relativa al sistema di coordinate dell'oggetto targetCoordinateSpace. | DisplayObject | ||
Restituisce l'istanza dell'oggetto di visualizzazione secondario che si trova in corrispondenza della posizione di indice specificata. | DisplayObjectContainer | ||
Restituisce l'oggetto di visualizzazione secondario al quale corrisponde il nome specificato. | DisplayObjectContainer | ||
Restituisce la posizione di indice di un'istanza DisplayObject secondaria. | DisplayObjectContainer | ||
Restituisce un array di oggetti che si trovano sotto il punto specificato e sono elementi secondari (di uno o più livelli inferiori) di questa istanza DisplayObjectContainer. | DisplayObjectContainer | ||
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. | DisplayObject | ||
Converte le coordinate dello stage (globali) in quelle (locali) dell'oggetto di visualizzazione per l'oggetto Point. | DisplayObject | ||
Converte un punto bidimensionale dalle coordinate dello stage (globali) in quelle (locali) di un oggetto di visualizzazione tridimensionale. | DisplayObject | ||
[override]
Verifica se per l'oggetto EventDispatcher sono presenti listener registrati per un tipo specifico di evento. | Stage | ||
Indica se per un oggetto è definita una proprietà specifica. | Object | ||
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. | DisplayObject | ||
Valuta l'oggetto di visualizzazione per stabilire se si sovrappone o si interseca con il punto specificato dai parametri x e y. | DisplayObject | ||
Una chiamata al metodo invalidate() segnala ai runtime Flash di inserire un avviso per gli oggetti di visualizzazione alla prima opportunità di eseguire il rendering dell'elenco di visualizzazione (ad esempio, quando l'indicatore di riproduzione si sposta su un nuovo fotogramma). | Stage | ||
Determina se la proprietà Stage.focus restituisce null per motivi di sicurezza. | Stage | ||
Indica se un'istanza della classe Object si trova nella catena di prototipi dell'oggetto specificato come parametro. | Object | ||
Converte un punto tridimensionale delle coordinate (locali) dell'oggetto di visualizzazione tridimensionale in un punto bidimensionale nelle coordinate dello stage (globali). | DisplayObject | ||
Converte le coordinate dell'oggetto di visualizzazione (locali) in quelle dello stage (globali) per l'oggetto Point. | DisplayObject | ||
Indica se la proprietà specificata esiste ed è enumerabile. | Object | ||
Rimuove l'istanza DisplayObject secondaria specificata dall'elenco degli elementi secondari dell'istanza DisplayObjectContainer. | DisplayObjectContainer | ||
[override]
Rimuove un'istanza DisplayObject secondaria dalla posizione di indice specificata nell'elenco degli elementi secondari di DisplayObjectContainer. | Stage | ||
Rimuove tutte le istanze DisplayObject secondarie dall'elenco degli elementi secondari dell'istanza DisplayObjectContainer. | DisplayObjectContainer | ||
Rimuove un listener dall'oggetto EventDispatcher. | EventDispatcher | ||
Alza una tastiera virtuale. | InteractiveObject | ||
Imposta lo stage su un orientamento con il rapporto proporzionale specificato. | Stage | ||
[override]
Cambia la posizione di un elemento secondario nel contenitore di oggetto di visualizzazione. | Stage | ||
Imposta lo stage sull'orientamento specificato. | Stage | ||
Imposta la disponibilità di una proprietà dinamica per le operazioni cicliche. | Object | ||
Interrompe in modo ricorsivo l’esecuzione della linea temporale di qualsiasi MovieClips che ha origine in questo oggetto. | DisplayObjectContainer | ||
Scambia lo z-order (ordine di profondità) degli oggetti secondari specificati. | DisplayObjectContainer | ||
[override]
Scambia lo z-order (ordine di profondità) degli oggetti secondari nelle due posizioni di indice specificate nell'elenco degli elementi secondari. | Stage | ||
Restituisce la rappresentazione in formato stringa di questo oggetto, formattato in base alle convenzioni specifiche per le versioni localizzate. | Object | ||
Restituisce la rappresentazione in formato stringa dell'oggetto specificato. | Object | ||
Restituisce il valore di base dell'oggetto specificato. | Object | ||
[override]
Verifica se un listener di eventi è registrato con questo oggetto EventDispatcher o qualsiasi suo antenato per il tipo di evento specificato. | Stage |
Evento | Riepilogo | Definito da | ||
---|---|---|---|---|
[evento di trasmissione] Inviato quando Flash Player o l'applicazione AIR ottiene lo stato di attivazione del sistema operativo ed entra nello stato attivo. | EventDispatcher | |||
Inviato quando un oggetto di visualizzazione viene aggiunto all'elenco di visualizzazione. | DisplayObject | |||
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. | DisplayObject | |||
Inviato quando la proprietà browserZoomFactor dell’oggetto Stage viene modificata. | Stage | |||
Inviato quando l'utente sceglie "Cancella" (o "Elimina") dal menu di scelta rapida per il testo. | InteractiveObject | |||
Inviato quando l'utente preme e rilascia il pulsante principale del dispositivo di puntamento sopra lo stesso InteractiveObject. | InteractiveObject | |||
Inviato quando un'azione dell'utente causa la visualizzazione del menu di scelta rapida associato a questo oggetto interattivo in un'applicazione AIR. | InteractiveObject | |||
Inviato quando l'utente attiva la combinazione di tasti di scelta rapida specifici della piattaforma per un'operazione che consente di tagliare oppure sceglie "Taglia" dal menu di scelta rapida per il testo. | InteractiveObject | |||
Inviato quando l'utente attiva la combinazione di tasti di scelta rapida specifici della piattaforma per un'operazione che consente di tagliare oppure sceglie "Taglia" dal menu di scelta rapida testuale. | InteractiveObject | |||
[evento di trasmissione] Inviato quando Flash Player o l'applicazione AIR perde l'attivazione del sistema operativo e sta entrando nello stato inattivo. | EventDispatcher | |||
Inviato quando l'utente preme e rilascia il pulsante principale di un dispositivo di puntamento due volte in rapida successione sopra la stessa istanza InteractiveObject quando il flag doubleClickEnabled dell'oggetto è impostato su true. | InteractiveObject | |||
[evento di trasmissione] Inviato quando l'indicatore di riproduzione sta entrando in un nuovo fotogramma. | DisplayObject | |||
[evento di trasmissione] Inviato quando l'indicatore di riproduzione sta per uscire dal fotogramma corrente. | DisplayObject | |||
Inviato dopo che un oggetto di visualizzazione ha ricevuto lo stato di attivazione. | InteractiveObject | |||
Inviato dopo che un oggetto di visualizzazione ha perso lo stato di attivazione. | InteractiveObject | |||
[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. | DisplayObject | |||
Inviato quando l'oggetto Stage entra o esce dalla modalità a schermo intero. | Stage | |||
Inviato quanto l’utente crea un punto di contatto lungo il bordo della superficie di contatto con un’istanza di InteractiveObject (ad esempio toccando bordo della superficie di contatto in Siri Remote per Apple TV). Alcuni dispositivi possono inoltre interpretare questo contatto come una combinazione di più eventi touch. | InteractiveObject | |||
Inviato quanto l'utente preme due punti di contatto sulla stessa istanza InteractiveObject su un dispositivo abilitato per il tocco (ad esempio, preme e rilascia due dita su un oggetto di visualizzazione disponibile su un cellulare o su un Tablet PC con touch screen). | InteractiveObject | |||
Inviato quanto l'utente sposta un punto di contatto sull'istanza InteractiveObject su un dispositivo abilitato per il tocco (ad esempio, sposta un dito da sinistra a destra su un oggetto di visualizzazione disponibile su un cellulare o su un Tablet PC con touch screen). | InteractiveObject | |||
Inviato quanto l'utente esegue un'operazione di rotazione in corrispondenza di un punto di contatto con un'istanza InteractiveObject (ad esempio, tocca lo schermo con due dita e le ruota su un oggetto di visualizzazione disponibile su un cellulare o su un Tablet PC con touch screen). | InteractiveObject | |||
Inviato quanto l'utente esegue un'operazione di tocco in corrispondenza di un punto di contatto con un'istanza InteractiveObject (ad esempio, tocca lo schermo con tre dita e quindi le sposta parallelamente su un oggetto di visualizzazione disponibile su un cellulare o su un Tablet PC con touch screen). | InteractiveObject | |||
Inviato quanto l'utente crea un punto di contatto con un'istanza InteractiveObject, quindi tocca un dispositivo abilitato per il tocco (ad esempio, posiziona più dita su un oggetto di visualizzazione per aprire un menu e quindi tocca con un dito per selezionare una voce di menu su un cellulare o su un Tablet PC con touch screen). | InteractiveObject | |||
Inviato quanto l'utente esegue un'operazione di zoom in corrispondenza di un punto di contatto con un'istanza InteractiveObject (ad esempio, tocca lo schermo con due dita e allontana velocemente le dita su un oggetto di visualizzazione disponibile su un cellulare o su un Tablet PC con touch screen). | InteractiveObject | |||
Questo evento viene inviato a qualsiasi applicazione client che supporti input in linea con un IME. | InteractiveObject | |||
Inviato quando l'utente preme un tasto. | InteractiveObject | |||
Inviato quando l'utente tenta di cambiare l'elemento attivo utilizzando la tastiera. | InteractiveObject | |||
Inviato quando l'utente rilascia un tasto. | InteractiveObject | |||
Inviato quando l'utente preme e rilascia il pulsante centrale del dispositivo di puntamento sopra lo stesso InteractiveObject. | InteractiveObject | |||
Inviato quando un utente preme il pulsante centrale del dispositivo di puntamento su un'istanza InteractiveObject. | InteractiveObject | |||
Inviato quando un utente rilascia il pulsante del dispositivo di puntamento su un'istanza InteractiveObject. | InteractiveObject | |||
Inviato quando un utente preme il pulsante del dispositivo di puntamento su un'istanza InteractiveObject. | InteractiveObject | |||
Inviato quando l'utente tenta di cambiare l'elemento attivo utilizzando un dispositivo di puntamento. | InteractiveObject | |||
Inviato dall'oggetto Stage quando il puntatore esce dall'area dello stage. | Stage | |||
Inviato quando l'utente sposta il dispositivo di puntamento mentre si trova sopra un'istanza InteractiveObject. | InteractiveObject | |||
Inviato quando l'utente allontana un dispositivo di puntamento da un'istanza InteractiveObject. | InteractiveObject | |||
Inviato quando l'utente sposta un dispositivo di puntamento sopra un'istanza InteractiveObject. | InteractiveObject | |||
Inviato quando un utente rilascia il pulsante del dispositivo di puntamento su un'istanza InteractiveObject. | InteractiveObject | |||
Inviato quando si fa ruotare la rotella del mouse su un'istanza InteractiveObject. | InteractiveObject | |||
Inviato dall'iniziatore del trascinamento InteractiveObject quando l'utente rilascia il trascinamento. | InteractiveObject | |||
Inviato dall'InteractiveObject di destinazione quando un oggetto trascinato viene rilasciato su di esso e il rilascio è stato accettato con una chiamata a DragManager.acceptDragDrop(). | InteractiveObject | |||
Inviato da un InteractiveObject quando un trascinamento entra nei suoi limiti. | InteractiveObject | |||
Inviato da un InteractiveObject quando un trascinamento esce dai propri limiti. | InteractiveObject | |||
Inviato continuamente da un InteractiveObject mentre un'azione di trascinamento rimane all'interno dei suoi limiti. | InteractiveObject | |||
Inviato all'inizio di un'operazione di trascinamento dall'InteractiveObject che è specificato come iniziatore del trascinamento nella chiamata a DragManager.doDrag(). | InteractiveObject | |||
Inviato durante un'operazione di trascinamento dall'InteractiveObject che è specificato come iniziatore del trascinamento nella chiamata a DragManager.doDrag(). | InteractiveObject | |||
Inviato dall'oggetto Stage quando l'orientamento dello stage cambia. | Stage | |||
Inviato dall'oggetto Stage all'inizio della modifica dell'orientamento dello stage. | Stage | |||
Inviato quando l'utente attiva la combinazione di tasti di scelta rapida specifici della piattaforma per un'operazione che consente di incollare oppure sceglie "Incolla" dal menu di scelta rapida testuale. | InteractiveObject | |||
Inviato quando l'utente abbassa uno stilo attivo oltre la soglia di rilevamento della prossimità dello schermo. | InteractiveObject | |||
Inviato quando l'utente solleva uno stilo attivo sopra la soglia di rilevamento della prossimità dello schermo. | InteractiveObject | |||
Inviato quando l'utente sposta uno stilo attivo sullo schermo rimanendo entro la soglia di rilevamento della prossimità. | InteractiveObject | |||
Inviato quando l'utente allontana uno stilo attivo da questo InteractiveObject rimanendo tuttavia entro la soglia di rilevamento della prossimità dello schermo. | InteractiveObject | |||
Inviato quando l'utente sposta uno stilo attivo direttamente sopra questo InteractiveObject rimanendo tuttavia entro la soglia di rilevamento della prossimità dello schermo. | InteractiveObject | |||
Inviato quando l'utente allontana uno stilo attivo da questo InteractiveObject o da qualsiasi suo elemento secondario rimanendo tuttavia entro la soglia di rilevamento della prossimità dello schermo. | InteractiveObject | |||
Inviato quando l'utente sposta uno stilo attivo sopra questo InteractiveObject dall'esterno della struttura di discendenti dell'oggetto nell'elenco di visualizzazione (rimanendo entro la soglia di rilevamento della prossimità dello schermo). | InteractiveObject | |||
Inviato quando un utente rilascia il pulsante del dispositivo di puntamento dopo averlo premuto sopra un’istanza InteractiveObject e aver quindi spostato il dispositivo di puntamento fuori dell’istanza stessa. | InteractiveObject | |||
Inviato quando un oggetto di visualizzazione sta per essere rimosso dall'elenco di visualizzazione. | DisplayObject | |||
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. | DisplayObject | |||
[evento di trasmissione] Inviato quando stanno per essere eseguiti l'aggiornamento e il rendering dell'elenco di visualizzazione. | DisplayObject | |||
Inviato quando la proprietà scaleMode dell'oggetto Stage viene impostata su StageScaleMode.NO_SCALE e il file SWF viene ridimensionato. | Stage | |||
Inviato quando l'utente preme e rilascia il pulsante destro del dispositivo di puntamento sopra lo stesso InteractiveObject. | InteractiveObject | |||
Inviato quando un utente preme il pulsante del dispositivo di puntamento su un'istanza InteractiveObject. | InteractiveObject | |||
Inviato quando un utente rilascia il pulsante del dispositivo di puntamento su un'istanza InteractiveObject. | InteractiveObject | |||
Inviato quando l'utente allontana un dispositivo di puntamento da un'istanza InteractiveObject. | InteractiveObject | |||
Inviato quando l'utente sposta un dispositivo di puntamento sopra un'istanza InteractiveObject. | InteractiveObject | |||
Inviato quando l'utente attiva la combinazione di tasti di scelta rapida specifici della piattaforma per un'operazione che consente di selezionare tutto oppure sceglie "Seleziona tutto" dal menu di scelta rapida testuale. | InteractiveObject | |||
Inviato immediatamente dopo la visualizzazione della tastiera software. | InteractiveObject | |||
Inviato immediatamente prima della visualizzazione della tastiera software. | InteractiveObject | |||
Inviato immediatamente dopo la chiusura della tastiera software. | InteractiveObject | |||
Inviato dall'oggetto Stage quando lo stato della proprietà stageVideos cambia. | Stage | |||
Inviato quando cambia il valore del flag tabChildren dell'oggetto. | InteractiveObject | |||
Inviato quando cambia il flag tabEnabled dell'oggetto. | InteractiveObject | |||
Inviato quando cambia il valore della proprietà tabIndex dell'oggetto. | InteractiveObject | |||
Inviato quando un utente immette uno o più caratteri di testo. | InteractiveObject | |||
Inviato quanto l'utente stabilisce per la prima volta un contatto con un dispositivo abilitato per il tocco (ad esempio, tocca con un dito un cellulare o un Tablet PC con touch screen). | InteractiveObject | |||
Inviato quanto l'utente rimuove il contatto con un dispositivo abilitato per il tocco (ad esempio, solleva un dito da un cellulare o un Tablet PC con touch screen). | InteractiveObject | |||
Inviato quando l'utente tocca il dispositivo, e viene inviato in modo continuativo finché il punto di contatto non viene rimosso. | InteractiveObject | |||
Inviato quanto l'utente sposta il punto di contatto lontano da un'istanza InteractiveObject su un dispositivo abilitato per il tocco (ad esempio, trascina un dito da un oggetto di visualizzazione a un altro disponibile su un cellulare o su un Tablet PC con touch screen). | InteractiveObject | |||
Inviato quanto l'utente sposta il punto di contatto su un'istanza InteractiveObject su un dispositivo abilitato per il tocco (ad esempio, trascina un dito da un punto esterno a un oggetto di visualizzazione a un punto su un oggetto di visualizzazione disponibile su un cellulare o su un Tablet PC con touch screen). | InteractiveObject | |||
Inviato quanto l'utente sposta il punto di contatto lontano da un'istanza InteractiveObject su un dispositivo abilitato per il tocco (ad esempio, trascina un dito da un oggetto di visualizzazione a un punto esterno a un oggetto di visualizzazione disponibile su un cellulare o su un Tablet PC con touch screen). | InteractiveObject | |||
Inviato quanto l'utente sposta il punto di contatto su un'istanza InteractiveObject su un dispositivo abilitato per il tocco (ad esempio, trascina un dito da un punto esterno a un oggetto di visualizzazione a un punto su un oggetto di visualizzazione disponibile su un cellulare o su un Tablet PC con touch screen). | InteractiveObject | |||
Inviato quanto l'utente solleva il punto di contatto sulla stessa istanza InteractiveObject in corrispondenza della quale è stato iniziato il contatto su un dispositivo abilitato per il tocco (ad esempio, preme e rilascia un dito da un oggetto di visualizzazione disponibile su un cellulare o su un Tablet PC con touch screen). | InteractiveObject | |||
Inviato dall’oggetto Stage quando lo stato della proprietà vsync cambia. | Stage |
align | proprietà |
align:String
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Un valore della classe StageAlign che specifica l'allineamento dello stage in Flash Player o nel browser. I valori validi sono i seguenti:
Valore | Allineamento verticale | Orizzontale |
---|---|---|
StageAlign.TOP | In alto | Al centro |
StageAlign.BOTTOM | In basso | Al centro |
StageAlign.LEFT | Al centro | Sinistra |
StageAlign.RIGHT | Al centro | Destra |
StageAlign.TOP_LEFT | In alto | Sinistra |
StageAlign.TOP_RIGHT | In alto | Destra |
StageAlign.BOTTOM_LEFT | In basso | Sinistra |
StageAlign.BOTTOM_RIGHT | In basso | Destra |
La proprietà align
è disponibile solo a un oggetto che si trova nella stessa funzione di sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio dell'oggetto chiamante chiamando il metodo Security.allowDomain()
o Security.alowInsecureDomain()
. Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
Implementazione
public function get align():String
public function set align(value:String):void
Elementi API correlati
allowsFullScreen | proprietà |
allowsFullScreenInteractive | proprietà |
allowsFullScreenInteractive:Boolean
[sola lettura] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | Flash Player 11.3, AIR 1.0 |
Specifica se questo stage consente l’uso della modalità di immissione del testo a tutto schermo.
Implementazione
public function get allowsFullScreenInteractive():Boolean
autoOrients | proprietà |
autoOrients:Boolean
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 2 |
Specifica se l'orientamento dello stage cambia automaticamente quando cambia l'orientamento del dispositivo.
Il valore iniziale di questa proprietà viene derivato dall'elemento autoOrients
del descrittore dell'applicazione ed è false
per impostazione predefinita. Se si modifica l'impostazione della proprietà su false
, il comportamento non è garantito. Su alcuni dispositivi, viene mantenuto l'orientamento attuale dello stage. Su altri dispositivi, l'orientamento dello stage cambia in base all'orientamento "standard" definito dal dispositivo, dopo di che l'orientamento dello stage rimarrà invariato.
Supporto profili AIR: questa funzionalità è supportata nei dispositivi mobili ma non nei sistemi operativi desktop o nei dispositivi AIR per TV. È possibile verificare se la funzionalità è supportata in fase runtime utilizzando la proprietà Stage.supportsOrientantionChange
. Per ulteriori informazioni sul supporto delle API tra più profili, vedete Supporto dei profili AIR.
Implementazione
public function get autoOrients():Boolean
public function set autoOrients(value:Boolean):void
Altre informazioni
Elementi API correlati
browserZoomFactor | proprietà |
browserZoomFactor:Number
[sola lettura] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 15 |
Specifica il fattore di zoom del browser. Una modifica del fattore di zoom del browser altera anche il fattore di scala di stage.
Implementazione
public function get browserZoomFactor():Number
color | proprietà |
colorCorrection | proprietà |
colorCorrection:String
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | Flash Player 10, AIR 1.5 |
Verifica la correzione dei colori del runtime Flash per le visualizzazioni. La correzione del colore funziona solo se al monitor principale è assegnato un profilo di colore ICC valido, che specifica gli attributi di colore particolari del dispositivo. Per impostazione predefinita, il runtime Flash tenta di riprodurre la correzione dei colori dell'host (in genere un browser).
Utilizzate la proprietà Stage.colorCorrectionSupport
per determinare se la correzione dei colori è disponibile nel sistema corrente e nello stato predefinito. Se la correzione del colore è disponile, tutti i colori sullo stage sono considerati come appartenenti allo spazio colore sRGB, che corrisponde allo spazio colore standard più comune. I profili di origine dei dispositivi di input non vengono considerati durante la correzione dei colori. Non viene applicata alcuna correzione del colore di input; solo l'output sullo stage viene mappato al profilo di colore ICC del monitor principale.
In generale, i vantaggi dell'attivazione della gestione dei colori comprendono colori prevedibili e coerenti, una migliore conversione, una prova colore accurata e un output più efficiente per supporti diversi. Tenete tuttavia presente che la gestione dei colori non fornisce conversioni perfette, a causa delle differenze della gamma di colori tra i diversi dispositivi o rispetto alle immagini originali. Inoltre, la gestione dei colori non cambia la necessità di disporre di profili personalizzati o modificati. I profili di colore dipendono da browser, sistemi operativi (SO), estensioni di SO, dispositivi di output e supporto delle applicazioni.
L'applicazione della correzione dei colori influisce negativamente sulle prestazioni del runtime Flash. La correzione dei colori del runtime Flash è la correzione dei colori degli stili di un documento, in quanto tutti i filmati SWF sono considerati documenti con profili sRBG impliciti. Utilizzate la proprietà Stage.colorCorrectionSupport
per indicare al runtime Flash di correggere i colori quando il file (documento) SWF viene riprodotto nell'area di visualizzazione dei colori. La compensazione viene applicata dal runtime Flash solo per le differenze tra monitor, non per quelle tra dispositivi di input (fotocamera, scanner e così via).
I tre valori possibili sono stringhe con costanti corrispondenti nella classe flash.display.ColorCorrection:
"default"
: utilizza la stessa correzione dei colori del sistema host."on"
: esegue sempre la correzione dei colori."off"
: non esegue mai la correzione dei colori.
Implementazione
public function get colorCorrection():String
public function set colorCorrection(value:String):void
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
Stage.colorCorrection
non appartiene alla classe ColorCorrection, il gestore segnala un errore.
function addHandler(add_event:Event) { switch(stage.colorCorrection) { case ColorCorrection.ON: stage.colorCorrection = ColorCorrection.OFF; lblCMEnableState.text = "State: " + stage.colorCorrection; break; case ColorCorrection.OFF: stage.colorCorrection = ColorCorrection.DEFAULT; lblCMEnableState.text = "State: " + stage.colorCorrection; break; case ColorCorrection.DEFAULT: stage.colorCorrection = ColorCorrection.ON; lblCMEnableState.text = "State: " + stage.colorCorrection; break; default: lblCMEnableState.text = "Error."; break; }
colorCorrectionSupport | proprietà |
colorCorrectionSupport:String
[sola lettura] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | Flash Player 10, AIR 1.5 |
Specifica se il runtime Flash è in esecuzione su un sistema operativo che supporta la correzione dei colori e se il profilo colore del monitor principale (primario) può essere letto e decodificato dal runtime Flash. Questa proprietà restituisce anche lo stato predefinito della correzione dei colori nel sistema host (in genere il browser). I valori restituiti correnti possono essere:
I tre valori possibili sono stringhe con costanti corrispondenti nella classe flash.display.ColorCorrectionSupport:
"unsupported"
: la correzione dei colori non è disponibile."defaultOn"
: esegue sempre la correzione dei colori."defaultOff"
: non esegue mai la correzione dei colori.
Implementazione
public function get colorCorrectionSupport():String
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
stage.colorCorrectionSupport
per verificare se è DEFAULT_ON
o DEFAULT_OFF
(valori della classe ColorCorrectionSupport). Se la proprietà corrisponde a uno dei due valori, nel campo di testo viene visualizzato il valore corrente. In caso contrario, se il valore non è né DEFAULT_ON
né DEFAULT_OFF
, nel campo di testo viene visualizzato "unsupported".
function addHandler(add_event:Event) { if (stage.colorCorrectionSupport == ColorCorrectionSupport.DEFAULT_ON || stage.colorCorrectionSupport == ColorCorrectionSupport.DEFAULT_OFF) { lblHasCM.text = "stage.colorCorrectionSupport: " + stage.colorCorrectionSupport; } else { lblHasCM.text = "stage.colorCorrectionSupport: unsupported"; } }
constructor | proprietà |
contentsScaleFactor | proprietà |
contentsScaleFactor:Number
[sola lettura] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 11.5 |
Specifica il fattore di scala dei pixel effettivo dello stage. Questo valore corrisponde a 1 sugli schermi standard e HiDPI (display retina). Quando viene eseguito il rendering dello stage su schermi HiDPI, la risoluzione dei pixel viene raddoppiata, anche se la modalità di modifica in scala dello stage è impostata su StageScaleMode.NO_SCALE. Stage.stageWidth e Stage.stageHeight continuano a essere indicati in unità di pixel classiche.
Implementazione
public function get contentsScaleFactor():Number
deviceOrientation | proprietà |
deviceOrientation:String
[sola lettura] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 2 |
L'orientamento fisico del dispositivo.
Nei dispositivi con tastiera scorrevole, lo stato della tastiera ha una priorità più alta nel determinare l'orientamento del dispositivo rispetto alla rotazione rilevata dall'accelerometro. Di conseguenza, su un dispositivo con orientamento verticale e con tastiera montata lateralmente, la proprietà deviceOrientation
segnalerà ROTATED_LEFT
quando la tastiera è aperta, a prescindere da come l'utente sta tenendo il dispositivo.
Utilizzate le costanti definite nella classe StageOrientation per impostare o confrontare i valori per questa proprietà:
Supporto profili AIR: questa funzionalità è supportata nei dispositivi mobili ma non nei sistemi operativi desktop o nei dispositivi AIR per TV. È possibile verificare se la funzionalità è supportata in fase runtime utilizzando la proprietà Stage.supportsOrientationChange
. Per ulteriori informazioni sul supporto delle API tra più profili, vedete Supporto dei profili AIR.
Implementazione
public function get deviceOrientation():String
Altre informazioni
Elementi API correlati
displayState | proprietà |
displayState:String
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9.0.28.0, Flash Lite 4 |
Un valore della classe StageDisplayState che specifica lo stato di visualizzazione da utilizzare. I valori validi sono i seguenti:
StageDisplayState.FULL_SCREEN
imposta l’applicazione AIR o il contenuto di Flash Player in modo da espandere lo stage fino a occupare l’intero schermo dell’utente. L’input da tastiera è disattivato, con l’eccezione di una serie limitata di tasti non di stampa.StageDisplayState.FULL_SCREEN_INTERACTIVE
: imposta l’applicazione affinché espanda lo stage fino a occupare l’intero schermo dell’utente, consentendo l’input da tastiera. (Disponibile in AIR e Flash Player, a partire da Flash Player 11.3.)StageDisplayState.NORMAL
- Riporta lo stage alla modalità di visualizzazione standard.
Il comportamento di ridimensionamento del filmato nella modalità a schermo intero è determinato dall'impostazione scaleMode
(definita mediante la proprietà Stage.scaleMode
o le impostazioni del tag embed
del file SWF all'interno del file HTML). Se la proprietà scaleMode
è impostata su noScale
mentre l'applicazione passa alla modalità a schermo intero, le proprietà width
e height
dello stage vengono aggiornate e lo stage invia l'evento resize.
Se la proprietà scaleMode è impostata su un valore diverso, lo stage e il relativo contenuto verranno adattati alle nuove dimensioni dello schermo. L'oggetto Stage conserva i valori di larghezza
e altezza
originali e non invia un evento resize
.
Le limitazioni seguenti valgono per i file SWF che vengono riprodotti all’interno di una pagina HTML (non quelli che utilizzano il lettore autonomo Flash Player o il runtime di AIR):
- Per attivare la modalità a schermo intero, aggiungete il parametro
allowFullScreen
ai tagobject
eembed
nella pagina HTML che include il file SWF, conallowFullScreen
impostato su"true"
, come mostrato nell'esempio seguente:<param name="allowFullScreen" value="true" /> ... <embed src="example.swf" allowFullScreen="true" ... >
Una pagina HTML può anche usare uno script per generare tag di incorporamento SWF. Dovete modificare lo script in modo da inserire le impostazioni
allowFullScreen
corrette. Le pagine HTML generate da Flash Professional e Flash Builder impiegano la funzioneAC_FL_RunContent()
per incorporare riferimenti a file SWF; l'utente deve aggiungere le impostazioni del parametroallowFullScreen
come indicato di seguito:AC_FL_RunContent( ... "allowFullScreen", "true", ... )
- La modalità a schermo intero viene attivata in risposta a un clic del mouse o a una pressione di un tasto da parte dell'utente; il filmato non può cambiare la proprietà
Stage.displayState
senza l'intervento dell'utente. I runtime Flash limitano l'input da tastiera in modalità a schermo intero. I tasti accettabili includono i tasti di scelta rapida e i tasti non stampabili come i tasti freccia, spazio, Maiusc e tabulazione. (Utilizzate la modalità interattiva a schermo intero per supportare l’input da tasti aggiuntivi.) I tasti di scelta rapida che consentono di chiudere la modalità a schermo intero sono Esc (Windows, Linux e Mac), Control+W (Windows), Comando+W (Mac) e Alt+F4. - A partire da Flash Player 9.0.115.0, la modalità a schermo intero funziona sia nella modalità senza finestra che nella modalità finestra. Se impostate la modalità finestra (
wmode
nell'HTML) su Opaca senza finestra (opaque
) o Trasparente senza finestra (transparent
), potete avviare la modalità a schermo intero, ma la finestra rimane sempre opaca. - Per attivare la modalità interattiva a schermo intero, che supporta l’interattività con la tastiera, aggiungete il parametro
allowFullScreenInteractive
ai tagobject
eembed
nella pagina HTML che include il file SWF, conallowFullScreenInteractive
impostato su"true"
, come mostrato nell’esempio seguente:<param name="allowFullScreenInteractive" value="true" /> ...
Queste limitazioni non si applicano al contenuto SWF in esecuzione nel lettore autonomo Flash Player o in AIR.
Quando viene attivata la modalità interattiva a schermo intero, il runtime Flash visualizza una notifica sopra il contenuto SWF per informare l’utente che la allowFullScreenInteractive è stata attivata e può essere chiusa premendo il tasto Esc.
Quando viene attivata la modalità interattiva a schermo intero, Flash Player visualizza una richiesta di conferma sopra il contenuto SWF, che permette all’utente di accedere all’input da tastiera esteso (compresi i tasti di stampa) e gli segnala che può premere il tasto Esc per uscire dalla modalità interattiva a schermo intero. Non è possibile fare previsioni sull’aspetto e sulla visualizzazione della richiesta di conferma. Potete determinare se gli utenti hanno accesso all’input da tastiera avanzato intercettando l’evento FullScreenEvent.FULL_SCREEN_INTERACTIVE_ACCEPTED
.
Per il contenuto AIR in esecuzione in modalità a schermo intero, le opzioni di sistema per il salvaschermo e il risparmio di energia vengono disabilitate durante la riproduzione del contenuto e fino a quando il video viene arrestato o si esce dalla modalità a schermo intero.
In Linux, l'impostazione di displayState
su StageDisplayState.FULL_SCREEN
o su StageDisplayState.FULL_SCREEN_INTERACTIVE
è un'operazione asincrona.
Implementazione
public function get displayState():String
public function set displayState(value:String):void
Genera
SecurityError — Una chiamata alla proprietà displayState di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0. Se tentate di impostare la proprietà displayState mentre è visualizzata la finestra di dialogo delle impostazioni, senza risposta da parte dell'utente, oppure se per il tag HTML param o embed l'attributo allowFullScreen non è impostato su true , viene generato un errore di sicurezza.
|
Altri esempi
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
displayState
. Nota: a causa delle restrizioni di sicurezza, lo schermo intero può essere attivato solo in determinate situazioni, ad esempio quando l'utente fa clic o preme un tasto. Quando viene eseguita in un browser, la proprietà allowFullScreen deve essere impostata su true.
package { import flash.display.Sprite; import flash.display.Stage; import flash.events.*; import flash.net.NetConnection; import flash.net.NetStream; import flash.media.Video; public class FullScreenExample extends Sprite { private var videoURL:String = "testVideo.flv"; private var connection:NetConnection; private var stream:NetStream; private var video:Video; public function FullScreenExample() { connection = new NetConnection(); connection.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler); connection.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler); connection.connect(null); loaderInfo.addEventListener(Event.INIT, createMouseListener); } private function createMouseListener(event:Event):void { stage.addEventListener(MouseEvent.CLICK,toggleFullScreen); } private function toggleFullScreen(event:MouseEvent):void { switch(stage.displayState) { case "normal": stage.displayState = "fullScreen"; break; case "fullScreen": default: stage.displayState = "normal"; break; } } // Video related: private function netStatusHandler(event:NetStatusEvent):void { switch (event.info.code) { case "NetConnection.Connect.Success": connectStream(); break; case "NetStream.Play.StreamNotFound": trace("Unable to locate video: " + videoURL); break; } } private function connectStream():void { var stream:NetStream = new NetStream(connection); stream.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler); stream.addEventListener(AsyncErrorEvent.ASYNC_ERROR, asyncErrorHandler); video = new Video(stage.stageWidth,stage.stageHeight); video.attachNetStream(stream); stream.play(videoURL); addChild(video); } private function securityErrorHandler(event:SecurityErrorEvent):void { trace("securityErrorHandler: " + event); } private function asyncErrorHandler(event:AsyncErrorEvent):void { // ignore AsyncErrorEvent events. } } }
focus | proprietà |
focus:InteractiveObject
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
L'oggetto interattivo attivato mediante la tastiera, oppure null
se l'attivazione non è impostata oppure l'oggetto attivo appartiene a una sicurezza sandbox alla quale l'oggetto chiamante non ha accesso.
Implementazione
public function get focus():InteractiveObject
public function set focus(value:InteractiveObject):void
Genera
Error — Genera un errore se non è possibile impostare l'attivazione sulla destinazione.
|
Esempio ( Come utilizzare questo esempio )
myTF
, in modo che l'utente possa iniziare a digitare senza dover fare clic su un qualsiasi elemento. In iOS, nei dispositivi mobili Android e nei dispositivi tvOS, l'utente deve fare clic sul campo di testo per attivare la tastiera software. Se provate questo codice nell'interfaccia dello strumento di creazione, potete avere accesso solo ad alcuni tasti perché l'host (browser o strumento) interpreta per prima cosa la maggior parte delle pressioni di tasti. Per visualizzare il funzionamento corretto di questo esempio, compilatelo ed eseguitelo nel file SWF.
var myTF:TextField = new TextField(); myTF.border =true; myTF.type = TextFieldType.INPUT; addChild(myTF); stage.focus= myTF;
frameRate | proprietà |
frameRate:Number
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Ottiene e imposta la frequenza di fotogrammi dello stage. La frequenza è espressa in fotogrammi al secondo. Per impostazione predefinita, la frequenza impostata è quella del primo file SWF caricato. I valori validi sono compresi tra 0.01 e 1000 fotogrammi al secondo.
Nota: un'applicazione potrebbe non essere in grado di applicare valori di frequenza di fotogrammi particolarmente elevati, ad esempio perché la piattaforma di destinazione non è abbastanza veloce oppure il lettore è sincronizzato con la temporizzazione verticale vuota del dispositivo di visualizzazione (solitamente 60 Hz sui dispositivi LCD). In alcuni casi, una piattaforma di destinazione potrebbe anche scegliere di ridurre la frequenza di fotogrammi massima se è previsto un uso intensivo della CPU.
Per il contenuto in esecuzione in Adobe AIR, se impostate la proprietà frameRate
di un oggetto Stage viene modificata la frequenza di fotogrammi di tutti gli oggetti Stage (utilizzati da oggetti NativeWindow diversi).
Implementazione
public function get frameRate():Number
public function set frameRate(value:Number):void
Genera
SecurityError — Una chiamata alla proprietà frameRate di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
|
fullScreenHeight | proprietà |
fullScreenHeight:uint
[sola lettura] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9.0.115.0, Flash Lite 4 |
Restituisce l'altezza del monitor che verrà utilizzata per la modalità a schermo intero, se tale stato viene attivato immediatamente. Se l'utente utilizza vari monitor, il monitor utilizzato è quello su cui si trova la maggior parte dello stage in un preciso momento.
Nota: se l'utente ha la possibilità di spostare il browser da un monitor a un altro tra il recupero del valore e il passaggio alla modalità a schermo intero, il valore potrebbe non essere corretto. Se richiamate il valore in un gestore eventi che imposta Stage.displayState
su StageDisplayState.FULL_SCREEN
, il valore sarà corretto.
Questa è l'altezza in pixel del monitor, che corrisponde a quella dello stage se Stage.align
è impostato su StageAlign.TOP_LEFT
e Stage.scaleMode
è impostato su StageScaleMode.NO_SCALE
.
Implementazione
public function get fullScreenHeight():uint
Elementi API correlati
fullScreenSourceRect
fullScreenWidth
scaleMode
StageDisplayState
flash.events.Event.RESIZE
flash.events.FullScreenEvent
Esempio ( Come utilizzare questo esempio )
enterFullScreen()
, che imposta la proprietà fullScreenSourceRect
e avvia la modalità a schermo intero. Per impostare la proprietà fullScreenSourceRect
, il gestore di eventi parte dalla posizione e dalle dimensioni del quadrato rosso. Quindi confronta il rapporto proporzionale (larghezza diviso per altezza) del quadrato rosso con il rapporto proporzionale dello stage con larghezza e altezza a schermo intero, in modo da poter ampliare il rettangolo (fullScreenSourceRect
) finché non raggiunge il rapporto proporzionale dello schermo. Il risultato è che il quadrato rosso occupa tutta l'altezza del monitor con lo sfondo verde visibile ai lati. Se il rapporto proporzionale non viene raggiunto, il colore di sfondo dello stage (bianco per impostazione predefinita) viene visualizzato ai lati al posto dello sfondo verde.
Nota: provate a riprodurre questo esempio nel browser. Nella scheda HTML della finestra Impostazioni pubblicazione di Flash, selezionate il modello Solo Flash - Consenti schermo intero Specificate la versione di Flash Player 9.0.115.0 e controllate che i formati Flash e HTML siano selezionati nella scheda Formati. Pubblicate e aprite il file HTML ottenuto nel browser.
import flash.display.Sprite; import flash.display.Stage; import flash.display.StageDisplayState; import flash.events.MouseEvent; import flash.geom.Rectangle; // cover the stage with a green rectangle var greenRect:Sprite = new Sprite(); greenRect.graphics.beginFill(0x00FF00); greenRect.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight); addChild(greenRect); // create red square on stage, turn it into a button for going to full screen var redSquare:Sprite = new Sprite(); redSquare.graphics.beginFill(0xFF0000); redSquare.graphics.drawRect(0, 0, 300, 300); redSquare.x = 50; redSquare.y = 50; redSquare.addEventListener(MouseEvent.CLICK, enterFullScreen); redSquare.buttonMode = true; addChild(redSquare); function enterFullScreen(e:MouseEvent):void { // we will go to full screen zoomed in on the red square var redSquare:Sprite = e.target as Sprite; var fullScreenRect:Rectangle = new Rectangle(redSquare.x, redSquare.y, redSquare.width, redSquare.height); // calculate aspect ratio of the red square var rectAspectRatio:Number = fullScreenRect.width / fullScreenRect.height; // calculate aspect ratio of the screen var screenAspectRatio:Number = stage.fullScreenWidth / stage.fullScreenHeight; // change the fullScreenRect so that it covers the entire screen, keeping it centered on the redSquare // try commenting out this section to see what happens if you do not fix the aspect ratio. if (rectAspectRatio > screenAspectRatio) { var newHeight:Number = fullScreenRect.width / screenAspectRatio; fullScreenRect.y -= ((newHeight - fullScreenRect.height) / 2); fullScreenRect.height = newHeight; } else if (rectAspectRatio < screenAspectRatio) { var newWidth:Number = fullScreenRect.height * screenAspectRatio; fullScreenRect.x -= ((newWidth - fullScreenRect.width) / 2); fullScreenRect.width = newWidth; } // go to full screen stage.fullScreenSourceRect = fullScreenRect; stage.displayState = StageDisplayState.FULL_SCREEN; }
fullScreenSourceRect | proprietà |
fullScreenSourceRect:Rectangle
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9.0.115.0, Flash Lite 4 |
Imposta il runtime Flash affinché modifichi in scala un'area specifica dello stage alla modalità a schermo intero. Se possibile, il runtime Flash esegue la modifica in scala utilizzando l'hardware, ovvero utilizzando la scheda grafica e video disponibile sul computer dell'utente e visualizza in genere il contenuto più velocemente rispetto a quando viene modificato in scala dal software.
Quando questa proprietà è impostata su un rettangolo valido e la proprietà displayState
è impostata sulla modalità a schermo intero, il runtime Flash modifica in scala l'area specificata. La dimensione effettiva dello stage. espressa in pixel, in ActionScript non varia. Il runtime Flash applica un limite minimo per la dimensione del rettangolo che contiene il messaggio standard "Premere Esc per uscire dalla modalità a schermo intero". Questo limite si aggira in genere intorno a 260 per 30 pixel, ma può variare in base al tipo di piattaforma e alla versione del runtime Flash.
Questa proprietà può essere impostata solo se il runtime Flash non è in modalità a schermo intero. Per utilizzare correttamente questa proprietà, impostatela per prima, quindi impostate la proprietà displayState
sulla modalità a schermo intero, come mostrato negli esempi di codice. Nota: in Flash Player 15 e versioni successive, questa proprietà può essere impostata anche quando il runtime di Flash è in modalità a schermo intero.
Per consentire il ridimensionamento in scala, impostate la proprietà fullScreenSourceRect
su un oggetto rettangolo:
// valid, will enable hardware scaling stage.fullScreenSourceRect = new Rectangle(0,0,320,240);
Per disattivare il ridimensionamento in scala, impostate fullScreenSourceRect=null
in ActionScript 3.0 e undefined
in ActionScript 2.0.
stage.fullScreenSourceRect = null;
L'utente finale può anche selezionare la disattivazione della possibilità di scalare dalle impostazioni di visualizzazione di Flash Player (impostazione predefinita). Per ulteriori informazioni, vedete www.adobe.com/go/display_settings_it.
Implementazione
public function get fullScreenSourceRect():Rectangle
public function set fullScreenSourceRect(value:Rectangle):void
Elementi API correlati
Stage.displayState
Stage.scaleMode
flash.events.FullScreenEvent
flash.events.Event.RESIZE
Esempio ( Come utilizzare questo esempio )
import flash.geom.*; { stage.fullScreenSourceRect = new Rectangle(0,0,320,240); stage.displayState = StageDisplayState.FULL_SCREEN; }
Per fare in modo che venga utilizzata la modalità a schermo intero con ridimensionamento hardware, devono essere rispettate le condizioni seguenti:
- Sono richiesti Flash Player versione 9.0.115.0 o successiva e uno strumento di creazione che lo supporti.
- Per il supporto della modalità schermo intero è necessario modificare i modelli HTML. L'attributo
allowFullScreen
deve essere impostato sutrue
perobject
e il tagembed
. (Anche gli script che generano l'incorporamento SWF devono essere impostati per supportare la modalità schermo intero.) Per un campione di file utilizzabili per Flex Builder, vedete l'articolo Exploring full-screen mode in Flash Player 9 (Modalità a schermo intero). - L'applicazione deve disporre dell'autorizzazione e dell'accesso necessario a un file video FLV. In questo esempio si presume che il file Flash Video (FLV) si trovi nella stessa directory del file SWF.
- L'utente deve consentire l'accesso alla modalità schermo intero.
- Per maggiori informazioni sulla modifica in scala hardware, vedete l'articolo Exploring Flash Player support for high-definition H.264 video and AAC audio (Supporto di Flash Player per il video H.264 ad alta definizione e l'audio AAC) per Flash Player.
Un file FLV viene caricato utilizzando gli oggetti NetConnection e NetStream. Poiché il file FLV si trova nella stessa directory del file SWF ed effettua la connessione mediante HTTP, il parametro del metodo NetConnection.connect()
viene impostato su null
. L'oggetto connect
di NetConnection riferisce il suo stato trasmettendo un evento netStatus
che richiama il metodo netStatusHandler()
. Il metodo netStatusHandler()
verifica l'esito corretto della connessione e richiama il metodo connectStream()
, che crea un oggetto NetStream che utilizza l'oggetto NetConnection come parametro. Crea inoltre un oggetto video e allega l'oggetto NetStream all'oggetto video. L'oggetto video viene quindi aggiunto all'elenco di visualizzazione e il flusso viene impostato per la riproduzione. Poiché il file video FLV non contiene metadati o informazioni sul cue point, viene trasmesso un evento AsyncError
. Deve essere impostato un listener per la gestione dell'evento. In questo caso il listener viene impostato ed ignora l'evento. Per l'oggetto NetStream viene impostato anche un altro listener per l'evento netStatus
. Se il flusso non viene individuato, il listener visualizza un messaggio di errore. Notate che sarebbe possibile utilizzare netStatusHandler()
per gestire un qualsiasi numero di diverse informazioni di stato riferite per il flusso o per la connessione.
Quando le proprietà e i metodi di un file SWF sono accessibili, viene richiamato il metodo createMouseListener()
. Esso imposta un listener di eventi per i clic del mouse sullo stage. Il metodo toggleFullScreen()
verifica se lo stato della visualizzazione è nella modalità schermo intero o schermo normale. Se è normale, le dimensioni dell'oggetto video vengono impostate su quelle del flusso video. La proprietà fullScreenSourceRect
viene impostata su un rettangolo le cui dimensioni corrispondono a quelle dell'oggetto video. La proprietà Stage.displayMode
viene quindi impostata su schermo intero, con la conseguente espansione del video del rettangolo di origine fino al riempimento dell'intera area dello schermo. Se i requisiti di sistema vengono rispettati, viene utilizzato l'hardware grafico del PC per migliorare le prestazioni del rendering video a pieno schermo e lo stato della visualizzazione viene impostato sulla modalità a schermo intero. Per intercettare eventuali errori di protezione che eventualmente si verificano durante il passaggio alla modalità a schermo intero, viene utilizzato un blocco di codice try...catch
. Tenete presente che lo stato della visualizzazione deve essere impostato sulla modalità a schermo intero dopo l'impostazione della proprietà fullScreenSourceRect
. Prima del passaggio alla modalità a schermo normale, la larghezza e l'altezza dell'oggetto video vengono salvate nuovamente in base alla larghezza e all'altezza dell'oggetto video originale salvato. In caso contrario, la larghezza e l'altezza saranno determinate dalle modifiche apportate all'oggetto video per la modalità a schermo intero.
package { import flash.display.Sprite; import flash.display.StageDisplayState; import flash.media.Video; import flash.net.NetConnection; import flash.net.NetStream; import flash.events.NetStatusEvent; import flash.events.AsyncErrorEvent; import flash.events.SecurityErrorEvent; import flash.events.MouseEvent; import flash.events.Event; import flash.geom.Rectangle; public class Stage_fullScreenSourceRectExample2 extends Sprite { private var videoURL:String = "testVideo1.flv"; private var connection:NetConnection; private var stream:NetStream; private var myVideo:Video; private var savedWidth:uint; private var savedHeight:uint; public function Stage_fullScreenSourceRectExample2() { connection = new NetConnection(); connection.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler); connection.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler); connection.connect(null); loaderInfo.addEventListener(Event.INIT, createMouseListener); } private function createMouseListener(event:Event):void { stage.addEventListener(MouseEvent.CLICK, toggleFullScreen); } private function toggleFullScreen(event:MouseEvent):void { if(stage.displayState == StageDisplayState.NORMAL) { myVideo.width = myVideo.videoWidth; myVideo.height = myVideo.videoHeight; try { stage.fullScreenSourceRect = new Rectangle(myVideo.x, myVideo.y, myVideo.width, myVideo.height); stage.displayState = StageDisplayState.FULL_SCREEN; } catch (e:SecurityError) { trace ("A security error occurred while switching to full screen: " + event); myVideo.width = savedWidth; myVideo.height = savedHeight; } }else { myVideo.width = savedWidth; myVideo.height = savedHeight; stage.displayState = StageDisplayState.NORMAL; } } private function netStatusHandler(event:NetStatusEvent):void { switch (event.info.code) { case "NetConnection.Connect.Success": connectStream(); break; case "NetStream.Play.StreamNotFound": trace ("Unable to locate video: " + videoURL); break; } } private function connectStream():void { var stream:NetStream = new NetStream(connection); stream.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler); stream.addEventListener(AsyncErrorEvent.ASYNC_ERROR, asyncErrorHandler); myVideo = new Video(); myVideo.attachNetStream(stream); stream.play(videoURL); savedWidth = myVideo.width; savedHeight = myVideo.height; addChild(myVideo); } private function securityErrorHandler(event:SecurityErrorEvent):void { trace("securityErrorHandler: " + event); } private function asyncErrorHandler(event:AsyncErrorEvent):void { } } }
fullScreenWidth | proprietà |
fullScreenWidth:uint
[sola lettura] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9.0.115.0, Flash Lite 4 |
Restituisce la larghezza del monitor che verrà utilizzata per la modalità a schermo intero, se tale stato viene attivato immediatamente. Se l'utente utilizza vari monitor, il monitor utilizzato è quello su cui si trova la maggior parte dello stage in un preciso momento.
Nota: se l'utente ha la possibilità di spostare il browser da un monitor a un altro tra il recupero del valore e il passaggio alla modalità a schermo intero, il valore potrebbe non essere corretto. Se richiamate il valore in un gestore eventi che imposta Stage.displayState
su StageDisplayState.FULL_SCREEN
, il valore sarà corretto.
Questa è la larghezza in pixel del monitor, che corrisponde a quella dello stage se Stage.align
è impostato su StageAlign.TOP_LEFT
e Stage.scaleMode
è impostato su StageScaleMode.NO_SCALE
.
Implementazione
public function get fullScreenWidth():uint
Elementi API correlati
fullScreenHeight
fullScreenSourceRect
scaleMode
StageDisplayState
flash.events.Event.RESIZE
flash.events.FullScreenEvent
Esempio ( Come utilizzare questo esempio )
enterFullScreen()
, che imposta la proprietà fullScreenSourceRect
e avvia la modalità a schermo intero. Per impostare la proprietà fullScreenSourceRect
, il gestore di eventi parte dalla posizione e dalle dimensioni del quadrato rosso. Quindi confronta il rapporto proporzionale (larghezza diviso per altezza) del quadrato rosso con il rapporto proporzionale dello stage con larghezza e altezza a schermo intero, in modo da poter ampliare il rettangolo (fullScreenSourceRect
) finché non raggiunge il rapporto proporzionale dello schermo. Il risultato è che il quadrato rosso occupa tutta l'altezza del monitor con lo sfondo verde visibile ai lati. Se il rapporto proporzionale non viene raggiunto, il colore di sfondo dello stage (bianco per impostazione predefinita) viene visualizzato ai lati al posto dello sfondo verde.
Nota: provate a riprodurre questo esempio nel browser. Nella scheda HTML della finestra Impostazioni pubblicazione di Flash, selezionate il modello Solo Flash - Consenti schermo intero Specificate la versione di Flash Player 9.0.115.0 e controllate che i formati Flash e HTML siano selezionati nella scheda Formati. Pubblicate e aprite il file HTML ottenuto nel browser.
import flash.display.Sprite; import flash.display.Stage; import flash.display.StageDisplayState; import flash.events.MouseEvent; import flash.geom.Rectangle; // cover the stage with a green rectangle var greenRect:Sprite = new Sprite(); greenRect.graphics.beginFill(0x00FF00); greenRect.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight); addChild(greenRect); // create red square on stage, turn it into a button for going to full screen var redSquare:Sprite = new Sprite(); redSquare.graphics.beginFill(0xFF0000); redSquare.graphics.drawRect(0, 0, 300, 300); redSquare.x = 50; redSquare.y = 50; redSquare.addEventListener(MouseEvent.CLICK, enterFullScreen); redSquare.buttonMode = true; addChild(redSquare); function enterFullScreen(e:MouseEvent):void { // we will go to full screen zoomed in on the red square var redSquare:Sprite = e.target as Sprite; var fullScreenRect:Rectangle = new Rectangle(redSquare.x, redSquare.y, redSquare.width, redSquare.height); // calculate aspect ratio of the red square var rectAspectRatio:Number = fullScreenRect.width / fullScreenRect.height; // calculate aspect ratio of the screen var screenAspectRatio:Number = stage.fullScreenWidth / stage.fullScreenHeight; // change the fullScreenRect so that it covers the entire screen, keeping it centered on the redSquare // try commenting out this section to see what happens if you do not fix the aspect ratio. if (rectAspectRatio > screenAspectRatio) { var newHeight:Number = fullScreenRect.width / screenAspectRatio; fullScreenRect.y -= ((newHeight - fullScreenRect.height) / 2); fullScreenRect.height = newHeight; } else if (rectAspectRatio < screenAspectRatio) { var newWidth:Number = fullScreenRect.height * screenAspectRatio; fullScreenRect.x -= ((newWidth - fullScreenRect.width) / 2); fullScreenRect.width = newWidth; } // go to full screen stage.fullScreenSourceRect = fullScreenRect; stage.displayState = StageDisplayState.FULL_SCREEN; }
height | proprietà |
height:Number
[override] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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.
Implementazione
override public function get height():Number
override public function set height(value:Number):void
Genera
SecurityError — Una chiamata alla proprietà height di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa funzione di sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
| |
IllegalOperationError — Non è mai consentito impostare la proprietà height di un oggetto Stage, nemmeno se l'oggetto chiamante è il titolare dello stage (il file SWF principale).
|
mouseChildren | proprietà |
mouseChildren:Boolean
[override] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Determina se gli elementi secondari dell'oggetto sono abilitati o meno per il mouse o per il dispositivo di input dell'utente. Se un oggetto è abilitato, l'utente può interagire con esso mediante il mouse o il dispositivo di input dell'utente. Il valore predefinito è true
.
Questa proprietà è utile quando create un pulsante con un'istanza della classe Sprite (anziché utilizzare la classe SimpleButton). Quando usate un'istanza Sprite per creare un pulsante, potete scegliere di decorare il pulsante utilizzando il metodo addChild()
per aggiungere ulteriori istanze Sprite. Questo processo può produrre un comportamento imprevisto degli eventi del mouse perché le istanze Sprite che aggiungete come elementi secondari possono diventare l'oggetto target di un evento mouse invece dell'istanza principale. Per fare sì che solo l'istanza principale possa essere l'oggetto target degli eventi del mouse, potete impostare la proprietà mouseChildren
dell'istanza principale su false
.
Nessun evento viene inviato impostando questa proprietà. Dovete utilizzare il metodo addEventListener()
per creare la funzionalità interattiva.
Implementazione
override public function get mouseChildren():Boolean
override public function set mouseChildren(value:Boolean):void
Genera
SecurityError — Una chiamata alla proprietà mouseChildren di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa funzione di sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
|
mouseLock | proprietà |
mouseLock:Boolean
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | Flash Player 11.2, AIR 3.2 |
Impostate su true
per abilitare il blocco del mouse. Il blocco del mouse comporta la disattivazione del cursore e consente il movimento svincolato del mouse. Potete abilitare il blocco del mouse in modalità a schermo intero solo per le applicazioni desktop. Se lo impostate in applicazioni che non operano a schermo intero, ad esempio nelle applicazioni per dispositivi mobili, viene generata un'eccezione.
Il blocco del mouse viene disattivato e il cursore viene reso nuovamente visibile quando:
- L'utente esce dalla modalità a schermo intero premendo il tasto Esc (tutte le piattaforme), Control-W (Windows), Comando-W (Mac) o Alt-F4 (Windows).
- L'applicazione cessa di essere l'elemento attivo.
- È visibile una qualsiasi interfaccia di impostazioni, comprese tutte le finestre di dialogo relative alla privacy.
- È visualizzata una finestra di dialogo nativa, ad esempio una finestra per il caricamento di file.
Quando si esce dalla modalità a schermo intero, questa proprietà viene automaticamente impostata su false
.
Gli eventi associati al movimento del mouse, ad esempio mouseMove
, utilizzano la classe MouseEvent per rappresentare l'oggetto evento. Quando il blocco del mouse è disattivato, usate le proprietà MouseEvent.localX
e MouseEvent.localY
per determinare la posizione del mouse. Quando il blocco è attivo, usate invece le proprietà MouseEvent.movementX
e MouseEvent.movementY
. Le proprietà movementX
e movementY
contengono i cambiamenti di posizione del mouse dall'ultimo evento, anziché le coordinate assolute della posizione del mouse.
Nota: quando l'applicazione è in modalità a schermo intero, i listener degli eventi del mouse associati agli oggetti di visualizzazione diversi da Stage non vengono inviati. Di conseguenza, per ricevere i delta del mouse e qualsiasi altro evento del mouse quando mouseLock
è true
, associate i listener degli eventi del mouse all'oggetto Stage.
Implementazione
public function get mouseLock():Boolean
public function set mouseLock(value:Boolean):void
Elementi API correlati
nativeWindow | proprietà |
nativeWindow:NativeWindow
[sola lettura] Versioni runtime: | AIR 1.0, Flash Lite 4 |
Un riferimento all'oggetto NativeWindow che contiene questo stage.
La finestra rappresenta la finestra nativa del sistema operativo; lo stage rappresenta il contenuto presente nella finestra. Questa proprietà è valida solo per contenuti eseguiti in AIR su piattaforme che supportano la classe NativeWindow. Su altre piattaforme, la proprietà è null
. Anche in Flash Player (contenuto eseguito in un browser) questa proprietà è null
.
Implementazione
public function get nativeWindow():NativeWindow
numChildren | proprietà |
numChildren:int
[sola lettura] [override] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Restituisce il numero di elementi secondari di questo oggetto.
Implementazione
override public function get numChildren():int
Genera
SecurityError — Una chiamata alla proprietà numChildren di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa funzione di sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
|
orientation | proprietà |
orientation:String
[sola lettura] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 2 |
L'orientamento attuale dello stage. Questa proprietà è impostata su uno dei seguenti quattro valori definiti come costanti nella classe StageOrientation:
Costante StageOrientation | Orientamento dello stage |
---|---|
StageOrientation.DEFAULT | Lo schermo è nell'orientamento predefinito (lato destro in alto). |
StageOrientation.ROTATED_RIGHT | Lo schermo è ruotato a destra. |
StageOrientation.ROTATED_LEFT | Lo schermo è ruotato a sinistra. |
StageOrientation.UPSIDE_DOWN | Lo schermo è capovolto. |
StageOrientation.UNKNOWN | L'applicazione non ha ancora determinato l'orientamento iniziale dello schermo. Potete aggiungere un listener di eventi per l'evento orientationChange . |
Per impostare l'orientamento dello stage, utilizzate il metodo setOrientation()
.
Importante: la proprietà orientation è supportata sui dispositivi Android a partire dallo spazio dei nomi della versione 2.6
Implementazione
public function get orientation():String
Altre informazioni
Elementi API correlati
quality | proprietà |
quality:String
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Un valore della classe StageQuality che specifica la qualità di rendering utilizzata da Flash Player. I valori validi sono i seguenti:
StageQuality.LOW
- Qualità di rendering bassa. Le immagini non vengono sottoposte ad antialiasing e le bitmap non vengono smussate, ma i runtime continuano a utilizzare il midmapping.StageQuality.MEDIUM
- Qualità di rendering media. Le immagini vengono sottoposte ad aliasing utilizzando una griglia di 2 x 2 pixel, ma la smussatura delle bitmap dipende dall'impostazioneBitmap.smoothing
. I runtime utilizzano il midmapping. Si tratta di un'impostazione adatta per i filmati che non contengono testo.StageQuality.HIGH
- Qualità di rendering alta. Le immagini vengono sottoposte ad aliasing utilizzando una griglia di 4 x 4 pixel e la smussatura delle bitmap dipende dall'impostazioneBitmap.smoothing
. I runtime utilizzano il midmapping. È l'impostazione predefinita utilizzata da Flash per la qualità di rendering.StageQuality.BEST
- Qualità di rendering molto alta. Le immagini vengono sottoposte ad aliasing utilizzando una griglia di 4 x 4 pixel SeBitmap.smoothing
ètrue
, il runtime utilizza un algoritmo di downscaling di alta qualità che produce un numero inferiore di artefatti (tuttavia, l'utilizzo diStageQuality.BEST
conBitmap.smoothing
impostata sutrue
rallenta significativamente le prestazioni, pertanto ne è sconsigliato l'utilizzo).
Se impostate una qualità superiore, viene prodotto un rendering migliore delle immagini bitmap modificate in scala. Tuttavia, impostazioni di qualità superiori richiedono più risorse di elaborazione. In particolare, quando si effettua il rendering di un video modificato in scala, l'utilizzo di una qualità migliore può ridurre la frequenza dei fotogrammi.
Il metodo BitmapData.draw()
usa il valore della proprietà Stage.quality
. In alternativa, potete usare il metodo BitmapData.drawWithQuality()
, che permette di specificare il parametro quality
del metodo ignorando il valore corrente di Stage.quality
.
Nel profilo desktop di Adobe AIR, potete impostare quality
su StageQuality.BEST
o StageQuality.HIGH
(che è il valore predefinito). L'impostazione su un altro valore non produce alcun effetto (e la proprietà rimane invariata). Nel profilo mobile di AIR, tutte e quattro le impostazioni di qualità sono disponibili. Il valore predefinito nei dispositivi mobili è
StageQuality.MEDIUM
.
Per il contenuto in esecuzione in Adobe AIR, se impostate la proprietà quality
di un oggetto Stage viene modificata la qualità di rendering di tutti gli oggetti Stage (utilizzati da oggetti NativeWindow diversi).
quality
non ha effetto.
Implementazione
public function get quality():String
public function set quality(value:String):void
Genera
SecurityError — Una chiamata alla proprietà quality di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa funzione di sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
|
Elementi API correlati
scaleMode | proprietà |
scaleMode:String
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Un valore della classe StageScaleMode che specifica la modalità scala da utilizzare. I valori validi sono i seguenti:
StageScaleMode.EXACT_FIT
: rende visibile l'intera applicazione nell'area specificata senza cercare di mantenere le proporzioni originali. Può verificarsi una distorsione e l'applicazione può apparire allungata o compressa.StageScaleMode.SHOW_ALL
: rende visibile l'intera applicazione nell'area specificata senza distorsione, mantenendone le proporzioni originali. Ai due lati dell'applicazione possono apparire dei bordi.StageScaleMode.NO_BORDER
: l'intera applicazione riempie l'area specificata, senza distorsione ma con un eventuale ritaglio, mantenendo le proporzioni originali dell'applicazione.StageScaleMode.NO_SCALE
: rende fissa l'intera applicazione, in modo che rimanga invariata anche se cambiano le dimensioni della finestra del lettore. Possono verificarsi dei ritagli se la finestra del lettore è più piccola del contenuto.
Implementazione
public function get scaleMode():String
public function set scaleMode(value:String):void
Genera
SecurityError — Una chiamata alla proprietà scaleMode di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
|
Altri esempi
Elementi API correlati
showDefaultContextMenu | proprietà |
showDefaultContextMenu:Boolean
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9 |
Specifica se visualizzare o nascondere le voci predefinite del menu di scelta rapida del runtime Flash.
Se la proprietà showDefaultContextMenu
è impostata su true
(valore predefinito), vengono visualizzate tutte le voci del menu di scelta rapida. Se invece showDefaultContextMenu
è impostata su false
, vengono visualizzate solo le voci Impostazioni e Informazioni su.
Implementazione
public function get showDefaultContextMenu():Boolean
public function set showDefaultContextMenu(value:Boolean):void
Genera
SecurityError — Una chiamata alla proprietà showDefaultContextMenu di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa funzione di sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
|
softKeyboardRect | proprietà |
softKeyboardRect:Rectangle
[sola lettura] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 2.6, Flash Player 10.2 |
Un rettangolo che specifica l'area dello stage attualmente coperta da una tastiera software. I componenti di Rect sono (0,0,0,0) quando la tastiera software non è attiva.
Implementazione
public function get softKeyboardRect():Rectangle
Elementi API correlati
stage3Ds | proprietà |
stage3Ds:Vector.<Stage3D>
[sola lettura] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | Flash Player 11, AIR 3 |
Un elenco di oggetti Stage3D disponibili per la visualizzazione del contenuto tridimensionale.
Potete utilizzare solo un numero limitato di oggetti Stage3D alla volta. Il numero di oggetti Stage3D disponibili dipende dalla piattaforma e dall'hardware disponibile.
Un oggetto Stage3D viene disegnato davanti a un oggetto StageVideo e dietro l'elenco di visualizzazione di Flash.
Implementazione
public function get stage3Ds():Vector.<Stage3D>
Elementi API correlati
stageFocusRect | proprietà |
stageFocusRect:Boolean
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Specifica se viene visualizzato o meno un bordo luminoso intorno agli oggetti che vengono attivati.
Implementazione
public function get stageFocusRect():Boolean
public function set stageFocusRect(value:Boolean):void
Genera
SecurityError — Una chiamata alla proprietà stageFocusRect di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa funzione di sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
|
stageHeight | proprietà |
stageHeight:int
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
L'altezza corrente dello stage, in pixel.
Se il valore della proprietà Stage.scaleMode
è impostato su StageScaleMode.NO_SCALE
quando l'utente ridimensiona la finestra, il contenuto dello stage mantiene la propria dimensione mentre la proprietà stageHeight
cambia per rispecchiare la nuova altezza dell'area dello schermo occupata dal file SWF. Nelle altre modalità di modifica in scala la proprietà stageHeight
rispecchia sempre l'altezza originale del file SWF. Potete aggiungere un listener di eventi per l'evento resize
e successivamente utilizzare la proprietà stageHeight
della classe Stage per determinare la dimensione in pixel effettiva della finestra del runtime Flash ridimensionata. Il listener di eventi consente di controllare il modo in cui viene regolato il contenuto dello schermo quando l'utente ridimensiona la finestra.
I dispositivi AIR per TV presentano un comportamento leggermente diverso rispetto ai dispositivi desktop quando si imposta la proprietà stageHeight
. Se la proprietà Stage.scaleMode
viene impostata su StageScaleMode.NO_SCALE
e si imposta la proprietà stageHeight
, l'altezza dello stage non cambia fino al fotogramma successivo del file SWF.
Nota: in una pagina HTML che contiene il file SWF, sia per il tag object
che per il tag embed
gli attributi height
devono essere impostati su un valore in percentuale (ad esempio, 100%
), e non in pixel. Se le impostazioni vengono generate da un codice JavaScript, anche il parametro height
del metodo AC_FL_RunContent()
deve essere impostato su un valore percentuale. Questa percentuale viene applicata al valore stageHeight
.
Implementazione
public function get stageHeight():int
public function set stageHeight(value:int):void
Genera
SecurityError — Una chiamata alla proprietà stageHeight di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa funzione di sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
|
Elementi API correlati
stageVideos | proprietà |
stageVideos:Vector.<StageVideo>
[sola lettura] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 2.5, Flash Player 10.2 |
Un elenco di oggetti StageVideo disponibili per la riproduzione di video esterni.
È possibile utilizzare solo un numero limitato di oggetti StageVideo alla volta. Quando inizia la riproduzione di un SWF, il numero di oggetti StageVideo disponibili dipende dalla piattaforma e dall'hardware disponibile.
Per utilizzare un oggetto StageVideo, assegnate un membro dell'oggetto Vector stageVideos
a una variabile StageVideo.
Tutti gli oggetti StageVideo vengono visualizzati sullo stage dietro gli oggetti di visualizzazione. Gli oggetti StageVideo vengono visualizzati sullo stage nell'ordine in cui appaiono nell'oggetto Vector stageVideos
. Ad esempio, se l'oggetto Vector stageVideos
contiene tre voci:
- L'oggetto StageVideo nell'indice 0 dell'oggetto Vector
stageVideos
viene visualizzato dietro a tutti gli oggetti StageVideo. - L'oggetto StageVideo nella posizione di indice 1 viene visualizzato davanti all'oggetto StageVideo nella posizione di indice 0.
- L'oggetto StageVideo nella posizione di indice 2 viene visualizzato davanti all'oggetto StageVideo nella posizione di indice 1.
Utilizzate la proprietà StageVideo.depth
per cambiare questa modalità di ordinamento.
Nota: i dispositivi AIR per TV supportano un solo oggetto StageVideo.
Implementazione
public function get stageVideos():Vector.<StageVideo>
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
var stageVideo:StageVideo; if ( stage.stageVideos.length >= 1 ) { stageVideo = stage.stageVideos[0]; }
stageWidth | proprietà |
stageWidth:int
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Specifica la larghezza corrente dello stage, in pixel.
Se il valore della proprietà Stage.scaleMode
è impostato su StageScaleMode.NO_SCALE
quando l'utente ridimensiona la finestra, il contenuto dello stage mantiene la dimensione definita mentre la proprietà stageWidth
cambia per rispecchiare la nuova larghezza dell'area dello schermo occupata dal file SWF. Nelle altre modalità di modifica in scala la proprietà stageWidth
rispecchia sempre la larghezza originale del file SWF. Potete aggiungere un listener di eventi per l'evento resize
e successivamente utilizzare la proprietà stageWidth
della classe Stage per determinare la dimensione in pixel effettiva della finestra del runtime Flash ridimensionata. Il listener di eventi consente di controllare il modo in cui viene regolato il contenuto dello schermo quando l'utente ridimensiona la finestra.
I dispositivi AIR per TV presentano un comportamento leggermente diverso rispetto ai dispositivi desktop quando si imposta la proprietà stageWidth
. Se la proprietà Stage.scaleMode
viene impostata su StageScaleMode.NO_SCALE
e si imposta la proprietà stageWidth
, la larghezza dello stage non cambia fino al fotogramma successivo del file SWF.
Nota: in una pagina HTML che contiene il file SWF, sia per il tag object
che per il tag embed
gli attributi width
devono essere impostati su un valore in percentuale (ad esempio, 100%
), e non in pixel. Se le impostazioni vengono generate da un codice JavaScript, anche il parametro width
del metodo AC_FL_RunContent()
deve essere impostato su un valore percentuale. Questa percentuale viene applicata al valore stageWidth
.
Implementazione
public function get stageWidth():int
public function set stageWidth(value:int):void
Genera
SecurityError — Una chiamata alla proprietà stageWidth di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa funzione di sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
|
Elementi API correlati
supportedOrientations | proprietà |
supportedOrientations:Vector.<String>
[sola lettura] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 2.6 |
Gli orientamenti supportati dal dispositivo corrente.
Potete usare le stringhe di orientamento incluse in questo elenco come parametri del metodo setOrientation()
. L'impostazione di un orientamento non supportato ha esito negativo senza generare un errore.
Gli orientamenti possibili comprendono:
Costante StageOrientation | Orientamento dello stage |
---|---|
StageOrientation.DEFAULT | Imposta l'orientamento predefinito dello stage (lato destro in alto). |
StageOrientation.ROTATED_RIGHT | Imposta l'orientamento dello stage ruotato a destra. |
StageOrientation.ROTATED_LEFT | Imposta l'orientamento dello stage ruotato a sinistra. |
StageOrientation.UPSIDE_DOWN | Imposta l'orientamento dello stage capovolto. |
Implementazione
public function get supportedOrientations():Vector.<String>
Elementi API correlati
supportsOrientationChange | proprietà |
supportsOrientationChange:Boolean
[sola lettura] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 2 |
Indica se l'applicazione supporta le modifiche apportate all'orientamento dello stage (e alla rotazione del dispositivo). Attualmente, questa proprietà è true
solo nelle applicazioni AIR eseguite sui dispositivi mobili.
Implementazione
public static function get supportsOrientationChange():Boolean
Elementi API correlati
tabChildren | proprietà |
tabChildren:Boolean
[override] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9 |
Determina se gli elementi secondari dell'oggetto sono abilitati per la tabulazione. Abilita o disabilita la tabulazione per gli elementi secondari dell'oggetto. Il valore predefinito è true
.
Nota: non utilizzate la proprietà tabChildren
con Flex. Usate invece la proprietà mx.core.UIComponent.hasFocusableChildren
.
Implementazione
override public function get tabChildren():Boolean
override public function set tabChildren(value:Boolean):void
Genera
SecurityError — Una chiamata alla proprietà tabChildren di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa funzione di sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
|
textSnapshot | proprietà |
textSnapshot:flash.text:TextSnapshot
[sola lettura] [override] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9 |
Restituisce un oggetto TextSnapshot per questa istanza DisplayObjectContainer.
Implementazione
override public function get textSnapshot():flash.text:TextSnapshot
Genera
IllegalOperationError — Un riferimento alla proprietà textSnapshot di un oggetto Stage genera un'eccezione perché la classe Stage non implementa questa proprietà. Per evitare questo problema, chiamate la proprietà textSnapshot di un contenitore di oggetto di visualizzazione diverso dall'oggetto Stage.
|
vsyncEnabled | proprietà |
vsyncEnabled:Boolean
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 29.0 |
Rappresenta lo stato corrente di vsync della soluzione delle immagini sottostanti. È possibile attivare/disattivare vsync, quindi possiamo eseguire immediatamente il rendering senza attendere lo stato successivo VSYNC. La lettura della proprietà è valida in qualsiasi momento. Tuttavia, l'impostazione della proprietà è valida solo dopo l'attivazione di VsyncStateChangeAvailabilityEvent.
Implementazione
public function get vsyncEnabled():Boolean
public function set vsyncEnabled(value:Boolean):void
width | proprietà |
width:Number
[override] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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.
Implementazione
override public function get width():Number
override public function set width(value:Number):void
Genera
SecurityError — Una chiamata alla proprietà width di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
| |
IllegalOperationError — Non è mai consentito impostare la proprietà width di un oggetto Stage, nemmeno per il titolare dello stage.
|
wmodeGPU | proprietà |
wmodeGPU:Boolean
[sola lettura] Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | Flash Player 10.0.32, AIR 1.5.2, Flash Lite 4 |
Indica se la creazione di effetti compositi basata su GPU è disponibile e in uso. Il valore wmodeGPU
è true
solo in presenza di tutte le tre condizioni elencate di seguito:
- la creazione di effetti compositi basata su GPU è stata richiesta;
- la creazione di effetti compositi basata su GPU è disponibile;
- la creazione di effetti compositi basata su GPU è in uso.
In particolare, la proprietà wmodeGPU
indica una delle seguenti condizioni:
- La creazione di effetti compositi basata su GPU non è stata richiesta o non è disponibile. In questo caso, il valore della proprietà
wmodeGPU
èfalse
. - La creazione di effetti compositi basata su GPU è stata richiesta (se applicabile e disponibile), ma l'ambiente funziona in "modalità fallback" (rendering non ottimale) a causa di limitazioni del contenuto. In questo caso, il valore della proprietà
wmodeGPU
ètrue
. - La creazione di effetti compositi basata su GPU è stata richiesta (se applicabile e disponibile) e l'ambiente funziona in modalità ottimale. Anche in questo caso, il valore della proprietà
wmodeGPU
ètrue
.
In altre parole, la proprietà wmodeGPU
identifica la funzionalità e lo stato dell'ambiente di rendering. Per i runtime che non supportano la creazione di effetti compositi basata su GPU, ad esempio AIR 1.5.2, il valore è sempre false
, in quanto (come specificato sopra) il valore è true
solo quando la creazione di effetti compositi basata su GPU è stata richiesta, è disponibile e in uso.
La proprietà wmodeGPU
è utile per determinare, in fase di runtime, se tale funzionalità è o meno in uso. Il valore di wmodeGPU
indica che il contenuto viene o meno modificato in scala dall'hardware, in modo da presentare le immagini con le dimensioni corrette. Potete inoltre determinare se il rendering viene eseguito in un percorso rapido o meno, al fine di regolare di conseguenza la complessità del contenuto.
Per Flash Player in un browser, la creazione di effetti compositi basata su GPU può essere richiesta tramite il valore di gpu
per il parametro HTML wmode
nella pagina che contiene il file SWF. Per altre configurazioni, la creazione di effetti compositi basata su GPU può essere richiesta nell'intestazione di un file SWF (impostata tramite strumenti di creazione SWF).
La proprietà wmodeGPU
non consente tuttavia di identificare le prestazioni di rendering correnti. Anche se la creazione di effetti compositi basata su GPU è "in uso", è possibile che il processo di rendering non funzioni in modalità ottimale. Per regolare il contenuto affinché il rendering sia eseguito in modalità ottimale, utilizzate una versione di debug del runtime Flash e impostate DisplayGPUBlendsetting
nel file mm.cfg.
Nota: questa proprietà è sempre false
quando vi si fa riferimento da codice ActionScript eseguito prima che il runtime esegua la prima fase di rendering. Se, ad esempio, esaminate wmodeGPU
da uno script nel fotogramma 1 di Adobe Flash Professional e il file SWF che utilizzate è il primo file SWF caricato in una nuova istanza del runtime, il valore di wmodeGPU
sarà false
. Per ottenere un valore preciso, attendete finché non sarà stata eseguita almeno una fase di rendering. Se scrivete un listener di eventi per l'evento exitFrame
di qualsiasi DisplayObject
, il valore di wmodeGPU
è quello corretto.
Implementazione
public function get wmodeGPU():Boolean
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
wmodeGPU
dopo il rendering dell'oggetto di visualizzazione mySprite, in modo che possiate ottenere un valore preciso.
mySprite.addEventListener(EXIT_FRAME, exithandler): function exithandler(exiteventobject:Event):void { trace(stage.wmodeGPU); }
addChild | () | metodo |
override public function addChild(child:DisplayObject):DisplayObject
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Aggiunge un'istanza secondaria DisplayObject a questa istanza DisplayObjectContainer. L'istanza secondaria viene aggiunta al livello principale (primo) di tutti gli altri elementi secondari di questa istanza DisplayObjectContainer. Per aggiungere un elemento secondario in una posizione specifica, utilizzate il metodo, addChildAt()
.
Se aggiungete un oggetto secondario che ha già un contenitore di oggetto di visualizzazione diverso come elemento principale, l'oggetto viene rimosso dall'elenco degli elementi secondari dell'altro contenitore.
Nota: il comando stage.addChild()
può causare problemi con un file SWF pubblicato, tra cui problemi di sicurezza e conflitti con altri file SWF caricati. In un'istanza del runtime Flash è presente un solo stage, indipendentemente dal numero di file SWF caricati nel runtime. In generale, quindi, gli oggetti non devono assolutamente essere aggiunti direttamente allo stage. Il solo oggetto che lo stage deve contenere è l'oggetto radice. Create un DisplayObjectContainer che conterrà tutti gli elementi dell'elenco di visualizzazione. Quindi, se necessario, aggiungete allo stage tale istanza DisplayObjectContainer.
Parametri
child:DisplayObject — L'istanza DisplayObject da aggiungere come elemento secondario a questa istanza DisplayObjectContainer.
|
DisplayObject — L'istanza DisplayObject passata nel parametro child .
|
Genera
SecurityError — Una chiamata al metodo addChild() di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
|
Altri esempi
Altre informazioni
addChildAt | () | metodo |
override public function addChildAt(child:DisplayObject, index:int):DisplayObject
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Aggiunge un'istanza secondaria DisplayObject a questa istanza DisplayObjectContainer. L'istanza viene aggiunta nella posizione di indice specificata. L'indice 0 corrisponde all'ultimo livello di profondità dell'elenco di visualizzazione di questo oggetto DisplayObjectContainer.
L'esempio seguente mostra tre oggetti di visualizzazione (a, b e c) rispettivamente nelle posizioni di indice 0, 2 e 1:
Se aggiungete un oggetto secondario che ha già un contenitore di oggetto di visualizzazione diverso come elemento principale, l'oggetto viene rimosso dall'elenco degli elementi secondari dell'altro contenitore.
Parametri
child:DisplayObject — L'istanza DisplayObject da aggiungere come elemento secondario a questa istanza DisplayObjectContainer.
| |
index:int — La posizione di indice in cui viene aggiunto l'elemento secondario. Se specificate una posizione di indice già occupata, l'oggetto secondario che si trova in quella posizione e quelli delle posizioni superiori vengono spostati in alto di una posizione nell'elenco degli elementi secondari.
|
DisplayObject — L'istanza DisplayObject passata nel parametro child .
|
Genera
SecurityError — Una chiamata al metodo addChildAt() di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa funzione di sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
|
Altri esempi
Altre informazioni
addEventListener | () | metodo |
override public function addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Registra un oggetto listener di eventi con un oggetto EventDispatcher, in modo che il listener riceva la notifica di un evento. Potete registrare listener di eventi in tutti i nodi dell'elenco di visualizzazione per un tipo di evento, una fase e una priorità specifiche.
Una volta registrato un listener di eventi, non potete modificarne la priorità mediante chiamate aggiuntive a addEventListener()
. Per modificare la priorità di un listener dovete chiamare innanzitutto removeListener()
. In seguito potete registrare nuovamente il listener con il nuovo livello di priorità.
Tenete presente che, dopo la registrazione del listener, le successive chiamate a addEventListener()
con un valore type
o useCapture
diverso determinano la creazione di un'altra registrazione per il listener. Ad esempio, se registrate un listener inizialmente con useCapture
impostato su true
, l'intercettazione avviene solo durante la fase di cattura. Se chiamate di nuovo addEventListener()
utilizzando lo stesso oggetto listener ma impostando useCapture
su false
, ottenete due listener separati: uno rileva gli eventi durante la fase di cattura e l'altro durante la fasi target e di bubbling.
Non potete registrare un listener di eventi solo per la fase target o per la fase di bubbling. Queste fasi vengono accoppiate durante la registrazione perché la propagazione è valida solo per gli antenati del nodo target.
Se il listener di eventi non è più necessario, rimovetelo con una chiamata a removeEventListener()
per evitare problemi di memoria. I listener di eventi non vengono eliminati automaticamente dalla memoria perché il garbage collector non rimuove il listener fintantoché esiste l'oggetto che effettua l'invio (a meno che il parametro useWeakReference
non sia impostato su true
).
Se copiate un'istanza EventDispatcher, i listener di eventi associati all'istanza non vengono copiati (se un nodo appena creato necessita di un listener di eventi, dovete associarlo dopo avere creato il nodo). Se invece spostate un'istanza EventDispatcher, insieme a questa vengono spostati anche i listener di eventi associati.
Se il listener di eventi viene registrato su un nodo mentre questo sta elaborando un evento, il listener di eventi non viene attivato durante la fase corrente ma può esserlo durante una fase successiva del flusso di eventi, ad esempio la fase di bubbling.
Se un listener di eventi viene rimosso da un nodo mentre questo sta elaborando un evento, il listener continua a essere attivato dalle azioni in corso. Dopo che è stato rimosso, il listener di eventi non viene più richiamato (a meno che non venga registrato nuovamente per elaborazioni future).
Parametri
type:String — Il tipo di evento.
| |
listener:Function — La funzione listener che elabora l'evento. Questa funzione deve accettare un oggetto Event come unico parametro e non restituire alcun valore, come mostra l'esempio che segue:
function(evt:Event):void La funzione può avere qualunque nome. | |
useCapture:Boolean (default = false ) —
Determina se il listener funziona nella fase di cattura o nelle fasi target e di bubbling. Se useCapture è impostato su true , il listener elabora l'evento solo durante la fase di cattura e non nella fase target o di bubbling. Se useCapture è impostato su false , il listener elabora l'evento solo durante la fase target o di bubbling. Per consentire l'intercettazione dell'evento in tutte e tre le fasi, chiamate due volte addEventListener , una volta con useCapture impostato su true e un'altra volta con useCapture impostato su false .
| |
priority:int (default = 0 ) — Il livello di priorità del listener di eventi. La priorità è indicata da un numero intero a 32 bit con segno. Più alto è il numero, più alta è la priorità. Tutti i listener con priorità n vengono elaborati prima dei listener con priorità n-1. Se due o più listener hanno la stessa priorità, l'elaborazione avviene secondo l'ordine in cui sono stati aggiunti. La priorità predefinita è 0.
| |
useWeakReference:Boolean (default = false ) — Determina se il riferimento al listener è forte o debole. Un riferimento forte (predefinito) evita che il listener venga sottoposto al processo di garbage collection, un riferimento debole no. Le funzioni dei membri a livello di classe non sono soggette a garbage collection, pertanto è possibile impostare |
Genera
SecurityError — Una chiamata al metodo addEventListener di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa funzione di sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
|
Altre informazioni
assignFocus | () | metodo |
public function assignFocus(objectToFocus:InteractiveObject, direction:String):void
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0 |
Rende attivabile mediante tastiera l'oggetto interattivo specificato da objectToFocus
, con la direzione dell'attivazione specificata dal parametro direction
.
Il concetto di direzione dell'attivazione deve essere definito dall'applicazione (o dalla struttura dell'applicazione). Non è presente alcun ordinamento intrinseco per l'attivazione degli oggetti interattivi, benché possiate utilizzare altre proprietà disponibili per stabilire un principio di ordinamento. Ad esempio, potete ordinare gli oggetti interattivi in base alle relative posizioni sullo stage o nell'elenco di visualizzazione. La chiamata ad assignFocus()
equivale a impostare la proprietà Stage.focus
, con la possibilità aggiuntiva di indicare la direzione da cui viene impostata l'attivazione.
objectToFocus
invia un evento focusIn
quando diventa attivo. La proprietà direction
dell'oggetto FocusEvent segnala l'impostazione del parametro direction
.
Se assegnate un oggetto HTMLLoader al parametro objectToFocus
, l'oggetto HTMLLoader seleziona l'oggetto attivabile appropriato nel DOM HTML, in base al valore del parametro direction
. Se è FocusDirection.BOTTOM
, viene attivato l'oggetto attivabile nel DOM HTML alla fine dell'ordine di lettura. Se è FocusDirection.TOP
, viene attivato l'oggetto attivabile nel DOM HTML all'inizio dell'ordine di lettura. Se è NONE
, l'oggetto HTMLLoader viene attivato senza modificare il relativo elemento attivato corrente.
Parametri
objectToFocus:InteractiveObject — L'oggetto da rendere attivo, oppure null per eliminare lo stato attivo per qualunque elemento sullo stage.
| |
direction:String — La direzione da cui si sta rendendo attivo objectToFocus . I valori validi vengono enumerati sotto forma di costanti nella classe FocusDirection.
|
Genera
Error — Se l'elemento di destinazione non può essere impostato come attivo o se direction non è di tipo valido.
|
Elementi API correlati
dispatchEvent | () | metodo |
override public function dispatchEvent(event:Event):Boolean
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Invia un evento nel flusso di eventi. Il target dell'evento è l'oggetto EventDispatcher su cui viene chiamato il metodo dispatchEvent()
.
Parametri
event:Event — L'oggetto evento inviato al flusso di eventi. Se l'evento viene inviato nuovamente, viene creato automaticamente un clone dell'evento. Dopo l'invio, la proprietà target dell'evento non può essere modificata e pertanto per poter inviare nuovamente l'evento è necessario crearne una nuova copia.
|
Boolean — Un valore true se l'evento è stato inviato correttamente. Un valore false indica un esito negativo o il fatto che sull'evento è stato chiamato preventDefault() .
|
Genera
SecurityError — Una chiamata al metodo dispatchEvent() di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa funzione di sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
|
hasEventListener | () | metodo |
override public function hasEventListener(type:String):Boolean
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Verifica se per l'oggetto EventDispatcher sono presenti listener registrati per un tipo specifico di evento. Questo consente di determinare in quale punto un oggetto EventDispatcher ha alterato la gestione di un tipo di evento nella gerarchia del flusso di eventi. Per determinare se un tipo di evento specifico attiva effettivamente un listener di eventi, utilizzate willTrigger()
.
La differenza tra hasEventListener()
e willTrigger()
consiste nel fatto che hasEventListener()
esamina solo l'oggetto a cui appartiene, mentre willTrigger()
esamina tutto il flusso di eventi relativo all'evento specificato dal parametro type
.
Quando hasEventListener()
viene chiamato da un oggetto LoaderInfo vengono considerati solo i listener a cui il chiamante può accedere.
Parametri
type:String — Il tipo di evento.
|
Boolean — Un valore true se è stato registrato un listener del tipo specificato; false in caso contrario.
|
Genera
SecurityError — Una chiamata al metodo hasEventListener() di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa funzione di sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
|
invalidate | () | metodo |
public function invalidate():void
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Una chiamata al metodo invalidate()
segnala ai runtime Flash di inserire un avviso per gli oggetti di visualizzazione alla prima opportunità di eseguire il rendering dell'elenco di visualizzazione (ad esempio, quando l'indicatore di riproduzione si sposta su un nuovo fotogramma). Dopo la chiamata al metodo invalidate()
, quando viene eseguito il nuovo rendering dell'elenco di visualizzazione, il runtime Flash invia un evento render
a ciascun oggetto di visualizzazione registrato per il rilevamento dell'evento render
. Dovete chiamare il metodo invalidate()
ogni volta che desiderate inviare un evento render
mediante il runtime Flash.
L'evento render
offre l'opportunità di modificare l'elenco di visualizzazione immediatamente prima che ne venga eseguito il rendering. In questo modo potete ritardare l'aggiornamento dell'elenco di visualizzazione fino all'ultima opportunità disponibile, ottenendo così un incremento delle prestazioni grazie all'eliminazione degli aggiornamenti dello schermo non necessari.
L'evento render
viene inviato solo agli oggetti di visualizzazione che si trovano nello stesso dominio di sicurezza del codice che chiama il metodo stage.invalidate()
oppure a quelli appartenenti a un dominio di sicurezza che è stato autorizzato tramite il metodo Security.allowDomain()
.
Elementi API correlati
isFocusInaccessible | () | metodo |
public function isFocusInaccessible():Boolean
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Determina se la proprietà Stage.focus
restituisce null
per motivi di sicurezza. In altre parole, isFocusInaccessible
restituisce true
se l'oggetto di visualizzazione appartiene a una funzione di sicurezza sandbox a cui il file SWF non ha accesso.
Boolean — true se l'oggetto di visualizzazione appartiene a una funzione di sicurezza sandbox a cui il file SWF non ha accesso.
|
removeChildAt | () | metodo |
override public function removeChildAt(index:int):DisplayObject
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Rimuove un'istanza DisplayObject secondaria dalla posizione index
specificata nell'elenco degli elementi secondari di DisplayObjectContainer. La proprietà parent
dell'istanza secondaria rimossa viene impostata su null
e l'oggetto viene rimosso dal garbage collector se non esistono altri riferimenti all'istanza secondaria. Le posizioni di indice di tutti gli oggetti di visualizzazione che si trovano sopra l'istanza secondaria in DisplayObjectContainer vengono diminuite di 1.
Il garbage collector riassegna lo spazio in memoria inutilizzato. Quando una variabile o un oggetto non sono più associati a un riferimento attivo o memorizzati da qualche parte, il garbage collector li rimuove e libera lo spazio di memoria che occupavano, se non risultano altri riferimenti ad essi.
Parametri
index:int — L'indice di elemento secondario dell'istanza DisplayObject da rimuovere.
|
DisplayObject — L'istanza DisplayObject che è stata rimossa.
|
Genera
SecurityError — Una chiamata al metodo removeChildAt() di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa sicurezza sandbox dell'oggetto da rimuovere. Per evitare questa situazione, il titolare dell'oggetto può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
|
setAspectRatio | () | metodo |
public function setAspectRatio(newAspectRatio:String):void
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 2 |
Imposta lo stage su un orientamento con il rapporto proporzionale specificato.
Se l'orientamento dello stage cambia dopo la chiamata del metodo, l'oggetto Stage invia un evento orientationChange.
Per verificare se l'orientamento del dispositivo è supportato, verificate il valore della proprietà Stage.supportsOrientantionChange
.
Supporto profili AIR: questa funzionalità è supportata nei dispositivi mobili ma non nei sistemi operativi desktop o nei dispositivi AIR per TV. È possibile verificare se la funzionalità è supportata in fase runtime utilizzando la proprietà Stage.supportsOrientantionChange
. Per ulteriori informazioni sul supporto delle API tra più profili, vedete Supporto dei profili AIR.
Parametri
newAspectRatio:String — Il codice del rapporto proporzionale desiderato (StageAspectRatio.PORTRAIT , StageAspectRatio.LANDSCAPE o StageAspectRatio.ANY ).
|
Genera
ArgumentError — Il valore passato come parametro newAspectRatio non è valido. Il valore deve corrispondere a una delle costanti definite nella classe StageAspectRatio.
|
Elementi API correlati
setChildIndex | () | metodo |
override public function setChildIndex(child:DisplayObject, index:int):void
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Cambia la posizione di un elemento secondario nel contenitore di oggetto di visualizzazione. Questa operazione influisce sulla stratificazione degli oggetti secondari. L'esempio seguente mostra tre oggetti di visualizzazione (a, b e c) rispettivamente nelle posizioni di indice 0, 1 e 2:
Quando utilizzate il metodo setChildIndex()
e specificate una posizione di indice già occupata, le uniche posizioni che cambiano sono quelle comprese tra la posizione precedente e la nuova posizione dell'oggetto di visualizzazione. Tutte le altre rimangono uguali. Se un elemento secondario viene spostato in un indice INFERIORE al relativo indice corrente, tutti gli elementi secondari intermedi AUMENTANO di 1 per quanto riguarda il riferimento di indice. Se un elemento secondario viene spostato in un indice SUPERIORE al relativo indice corrente, tutti gli elementi secondari intermedi DIMINUISCONO di 1 per quanto riguarda il riferimento di indice. Ad esempio, se il contenitore di oggetto di visualizzazione dell'esempio precedente si chiama container
, potete scambiare la posizione degli oggetti di visualizzazione con etichetta a e b chiamando il codice seguente:
container.setChildIndex(container.getChildAt(1), 0);
Questo codice determina la seguente disposizione degli oggetti:
Parametri
child:DisplayObject — L'istanza DisplayObject secondaria per la quale si vuole cambiare il numero di indice.
| |
index:int — Il numero di indice risultante per l'oggetto di visualizzazione child .
|
Genera
SecurityError — Una chiamata al metodo setChildIndex() di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa funzione di sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
|
setOrientation | () | metodo |
public function setOrientation(newOrientation:String):void
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 2 |
Imposta lo stage sull'orientamento specificato.
Imposta il parametro newOrientation
su uno dei seguenti quattro valori definiti come costanti nella classe StageOrientation:
Costante StageOrientation | Orientamento dello stage |
---|---|
StageOrientation.DEFAULT | Imposta l'orientamento predefinito dello stage (lato destro in alto). |
StageOrientation.ROTATED_RIGHT | Imposta l'orientamento dello stage ruotato a destra. |
StageOrientation.ROTATED_LEFT | Imposta l'orientamento dello stage ruotato a sinistra. |
StageOrientation.UPSIDE_DOWN | Imposta l'orientamento dello stage capovolto. |
Non impostate il parametro su StageOrientation.UNKNOWN
o qualsiasi altro valore di stringa diverso da quelli elencati nella tabella.
Per verificare se la modifica dell'orientamento del dispositivo è supportata, controllate il valore della proprietà Stage.supportsOrientantionChange
. Verificate l'elenco fornito dalla proprietà supportedOrientations
per determinare gli orientamenti supportati dal dispositivo corrente.
L'impostazione dell'orientamento è un'operazione asincrona. Non c'è garanzia che venga completata subito dopo la chiamata al metodo setOrientation()
. Aggiungete un listener di eventi per l'evento orientationChange
per determinare il completamento della modifica dell'orientamento.
Importante: il metodo setOrientation()
non era supportato sui dispositivi Android prima di AIR 2.6.
setOrientation()
non provoca l'invio di un evento orientationChanging
.
Parametri
newOrientation:String — Il nuovo orientamento dello stage.
|
Eventi
orientationChange: — Lo stage è stato ridimensionato a seguito della chiamata al metodo setOrientation() .
|
Genera
ArgumentError — Il valore passato come parametro newOrientation non è valido. Il valore deve corrispondere a una delle costanti definite nella classe StageOriention, ad eccezione della costante StageOrientation.UNKNOWN .
|
Elementi API correlati
swapChildrenAt | () | metodo |
override public function swapChildrenAt(index1:int, index2:int):void
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Scambia lo z-order (ordine di profondità) degli oggetti secondari nelle due posizioni di indice specificate nell'elenco degli elementi secondari. Tutti gli altri oggetti secondari del contenitore di oggetto di visualizzazione rimangono nelle stesse posizioni di indice.
Parametri
index1:int — La posizione di indice del primo oggetto secondario.
| |
index2:int — La posizione di indice del secondo oggetto secondario.
|
Genera
SecurityError — Una chiamata al metodo swapChildrenAt() di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa funzione di sicurezza sandbox del titolare di uno degli oggetti da scambiare. Per evitare questa situazione, il titolare dell'oggetto può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
|
willTrigger | () | metodo |
override public function willTrigger(type:String):Boolean
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9 |
Verifica se un listener di eventi è registrato con questo oggetto EventDispatcher o qualsiasi suo antenato per il tipo di evento specificato. Questo metodo restituisce true
se durante qualsiasi fase del flusso di eventi viene attivato un listener di eventi quando un evento del tipo specificato viene inviato all'oggetto EventDispatcher o a uno qualsiasi dei suoi discendenti.
La differenza tra il metodo hasEventListener()
e il metodo willTrigger()
consiste nel fatto che hasEventListener()
esamina solo l'oggetto a cui appartiene, mentre willTrigger()
esamina tutto il flusso di eventi relativo all'evento specificato dal parametro type.
Quando willTrigger()
viene chiamato da un oggetto LoaderInfo vengono considerati solo i listener a cui il chiamante può accedere.
Parametri
type:String — Il tipo di evento.
|
Boolean — Un valore true se viene attivato un listener del tipo specificato; false in caso contrario.
|
Genera
SecurityError — Una chiamata al metodo willTrigger() di un oggetto Stage genera un'eccezione per qualunque chiamante che non si trova nella stessa funzione di sicurezza sandbox del titolare dello stage (il file SWF principale). Per evitare questa situazione, il titolare dello stage può autorizzare il dominio del chiamante chiamando il metodo Security.allowDomain() o Security.allowInsecureDomain() . Per ulteriori informazioni, consultate il capitolo "Sicurezza" nella Guida per gli sviluppatori di ActionScript 3.0.
|
browserZoomChange | Evento |
flash.events.Event
proprietà Event.type =
flash.events.Event.BROWSER_ZOOM_CHANGE
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 15 |
Inviato quando la proprietà browserZoomFactor
dell’oggetto Stage viene modificata.
Event.BROWSER_ZOOM_CHANGE
definisce il valore della proprietà type
di un oggetto evento browserZoomChange
.
Questo evento ha le seguenti proprietà:
Proprietà | Valore |
---|---|
bubbles | false |
cancelable | false ; non è presente alcun comportamento predefinito da annullare. |
currentTarget | L'oggetto che elabora attivamente l'oggetto Event con un listener di eventi. |
target | L’istanza di Stage. |
fullScreen | Evento |
flash.events.FullScreenEvent
proprietà FullScreenEvent.type =
flash.events.FullScreenEvent.FULL_SCREEN
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9.0.28.0, Flash Lite 4 |
Inviato quando l'oggetto Stage entra o esce dalla modalità a schermo intero. La modalità a schermo intero può essere modificata mediante ActionScript, tramite una scelta rapida selezionata dall'utente oppure se la finestra a schermo intero perde lo stato di attivazione.
La costanteFullScreenEvent.FULL_SCREEN
definisce il valore della proprietà type
di un oggetto evento fullScreen
.
Questo evento ha le seguenti proprietà:
Proprietà | Valore |
---|---|
fullScreen | true se lo stato di visualizzazione è a schermo intero oppure false se è normale. |
bubbles | false |
cancelable | false ; non è presente alcun comportamento predefinito da annullare. |
currentTarget | L'oggetto che elabora attivamente l'oggetto Event con un listener di eventi. |
target | L'oggetto Stage. |
mouseLeave | Evento |
flash.events.Event
proprietà Event.type =
flash.events.Event.MOUSE_LEAVE
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Inviato dall'oggetto Stage quando il puntatore esce dall'area dello stage. Se viene premuto il pulsante del mouse, l'evento non viene inviato.
La costanteEvent.MOUSE_LEAVE
definisce il valore della proprietà type
di un oggetto evento mouseLeave
.
Questo evento ha le seguenti proprietà:
Proprietà | Valore |
---|---|
bubbles | false |
cancelable | false ; non è presente alcun comportamento predefinito da annullare. |
currentTarget | L'oggetto che elabora attivamente l'oggetto Event con un listener di eventi. |
target | L'oggetto Stage. Il target non è sempre l'oggetto nell'elenco di visualizzazione che ha registrato il listener di eventi. Utilizzate la proprietà currentTarget per accedere all'oggetto dell'elenco di visualizzazione che sta elaborando l'evento. |
orientationChange | Evento |
flash.events.StageOrientationEvent
proprietà StageOrientationEvent.type =
flash.events.StageOrientationEvent.ORIENTATION_CHANGE
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 2.0 |
Inviato dall'oggetto Stage quando l'orientamento dello stage cambia.
I cambi di orientamento si possono verificare quando l'utente ruota il dispositivo, apre una tastiera scorrevole o quando viene chiamato setAspectRatio()
.
Nota: se la proprietà autoOrients
è false
, l'orientamento dello stage non cambia quando un dispositivo viene ruotato. Di conseguenza, gli eventi StageOrientationEvent vengono inviati per la rotazione del dispositivo solo quando autoOrients
è true
.
ORIENTATION_CHANGE
definisce il valore della proprietà type
di un oggetto evento orientationChange
. Questo evento ha le seguenti proprietà:
Proprietà | Valori |
---|---|
afterOrientation | Il nuovo orientamento dello stage. |
beforeOrientation | Il precedente orientamento dello stage. |
target | L'oggetto Stage che ha inviato il cambiamento di orientamento. |
bubbles | true |
currentTarget | Indica l'oggetto che sta elaborando attivamente l'oggetto Event con un listener di eventi. |
cancelable | false ; non è più possibile annullare il cambiamento. |
Altre informazioni
orientationChanging | Evento |
flash.events.StageOrientationEvent
proprietà StageOrientationEvent.type =
flash.events.StageOrientationEvent.ORIENTATION_CHANGING
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 2.0 |
Inviato dall'oggetto Stage all'inizio della modifica dell'orientamento dello stage.
Importante: gli eventi orientationChanging non vengono inviati sui dispositivi Android.
Note:
-
Se la proprietà
autoOrients
èfalse
, l'orientamento dello stage non cambia quando un dispositivo viene ruotato. Di conseguenza, gli eventi StageOrientationEvent vengono inviati per la rotazione del dispositivo solo quandoautoOrients
ètrue
. -
Se impostate l'orientamento a livello di codice mediante il metodo
setOrientation()
, l'eventoorientationChanging
non viene inviato.
ORIENTATION_CHANGING
definisce il valore della proprietà type
di un oggetto evento orientationChanging
. Questo evento ha le seguenti proprietà:
Proprietà | Valori |
---|---|
afterOrientation | Il nuovo orientamento dello stage. |
beforeOrientation | Il precedente orientamento dello stage. |
target | L'oggetto Stage che ha inviato il cambiamento di orientamento. |
bubbles | true |
currentTarget | Indica l'oggetto che sta elaborando attivamente l'oggetto Event con un listener di eventi. |
cancelable | true . |
Altre informazioni
resize | Evento |
flash.events.Event
proprietà Event.type =
flash.events.Event.RESIZE
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Inviato quando la proprietà scaleMode
dell’oggetto Stage viene impostata su StageScaleMode.NO_SCALE
e il file SWF viene ridimensionato. Inviato anche quando l’orientamento della schermata cambia durante la modalità a schermo intero in Flash Player 15 e versioni successive.
Event.RESIZE
definisce il valore della proprietà type
di un oggetto evento resize
.
Questo evento ha le seguenti proprietà:
Proprietà | Valore |
---|---|
bubbles | false |
cancelable | false ; non è presente alcun comportamento predefinito da annullare. |
currentTarget | L'oggetto che elabora attivamente l'oggetto Event con un listener di eventi. |
target | L'oggetto Stage. |
stageVideoAvailability | Evento |
flash.events.StageVideoAvailabilityEvent
proprietà StageVideoAvailabilityEvent.type =
flash.events.StageVideoAvailabilityEvent.STAGE_VIDEO_AVAILABILITY
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 1.0, Flash Player 10.2 |
Inviato dall'oggetto Stage quando lo stato della proprietà stageVideos cambia.
Definisce il valore della proprietàtype
di un oggetto evento stageVideoAvailability
.
Questo evento ha le seguenti proprietà:
Proprietà | Valore |
---|---|
availability | Lo stato segnalato dall'evento. |
bubbles | false |
cancelable | false ; non è presente alcun comportamento predefinito da annullare. |
currentTarget | L'oggetto che sta elaborando attivamente l'evento. |
target | L'oggetto Stage che segnala la disponibilità del video sullo stage. |
Esempio ( Come utilizzare questo esempio )
StageExample
per inviare degli eventi ogni qual volta lo stage viene attivato o ridimensionato. Questa operazione viene eseguita mediante la procedura seguente:
- La funzione di costruzione della classe dapprima imposta l'applicazione Flash da regolare, a prescindere dalle dimensioni della finestra di Flash Player, quindi aggiunge due listener di eventi con i metodi
activateHandler()
eresizeHandler()
. - Il metodo
activateHandler()
viene eseguito ogni volta che viene premuto il pulsante sinistro del mouse. - Il metodo
resizeHandler()
viene eseguito quando lo stage viene ridimensionato.
package { import flash.display.Sprite; import flash.display.StageAlign; import flash.display.StageScaleMode; import flash.events.Event; public class StageExample extends Sprite { public function StageExample() { stage.scaleMode = StageScaleMode.NO_SCALE; stage.align = StageAlign.TOP_LEFT; stage.addEventListener(Event.ACTIVATE, activateHandler); stage.addEventListener(Event.RESIZE, resizeHandler); } private function activateHandler(event:Event):void { trace("activateHandler: " + event); } private function resizeHandler(event:Event):void { trace("resizeHandler: " + event); trace("stageWidth: " + stage.stageWidth + " stageHeight: " + stage.stageHeight); } } }
VsyncStateChangeAvailability | Evento |
flash.events.VsyncStateChangeAvailabilityEvent
proprietà VsyncStateChangeAvailabilityEvent.type =
flash.events.VsyncStateChangeAvailabilityEvent
Versione linguaggio: | ActionScript 3.0 |
Versioni runtime: | AIR 29.0 |
Inviato dall’oggetto Stage quando lo stato della proprietà vsync cambia.
Definisce il valore della proprietà type di un oggetto evento VsyncStateChangeAvailabilityEvent
.
Esempio ( Come utilizzare questo esempio )
VsyncExample
per inviare degli eventi ogni qual volta lo stato vsync dello stage può essere abilitato o disabilitato. Questa operazione viene eseguita mediante la procedura seguente:
- La funzione di costruzione innanzitutto attiva l'evento
VsyncStateChangeAvailabilityEvent
dello stage - Quindi viene chiamato il metodo
onVsyncStateChangeAvailability
in cui viene verificato se ilVsyncStateChangeAvailabilityEvent
è disponibile o meno. - Se disponibile, è possibile attivare/disattivare lo stato vsync dello stage oppure il valore della proprietà
vsyncEnable
resta di sola lettura. - Il valore di vsync enable può essere attivato se e solo se l'evento viene attivato.
package { import flash.display.Sprite; import flash.events.VsyncStateChangeAvailabilityEvent public class VsyncExample extends Sprite { public function VsyncExample() { stage.addEventListener(VsyncStateChangeAvailabilityEvent.VSYNC_STATE_CHANGE_AVAILABILITY, onVsyncStateChangeAvailability); } public function onVsyncStateChangeAvailability(event:VsyncStateChangeAvailabilityEvent):void { if (event.available) { // vsyncEnabled is now changeable and can be turned off. stage.vsyncEnabled = false; // Now, AS can change VSYNC state because event.available is true trace("vsyncEnabled of Stage object is changeable"); } else { // vsyncEnabled is not changeable now. This could be due to fallback to software rendering, for example. stage.vsyncEnabled = false; // This will be ignored because event.available is now false trace("vsyncEnabled of Stage object is read-only"); trace("Current value of vsyncEnabled of Stage object is "+ stage.vsyncEnabled); } } } }
Tue Jun 12 2018, 02:44 PM Z