NativeWindow  - AS3

Indica se questa finestra è la finestra dell'applicazione attiva.

Utilizzate il metodo activate() per rendere attiva una finestra.

Elementi API correlati

Specifica se questa finestra sarà sempre in primo piano rispetto alle altre finestre (incluse le finestre di altre applicazioni).

Sono presenti due gruppi di finestre nell'ordine di profondità del sistema. Le finestre nel gruppo alwaysInFront sono sempre visualizzate in primo piano rispetto a tutte le altre. L'ordine di profondità tra le finestre di uno stesso gruppo viene determinato normalmente. In altre parole, l'attivazione di una finestra la porta in primo piano rispetto alle altre finestre del relativo gruppo.

Se modificate il valore di alwaysInFront da false a true, la finestra viene portata in primo piano rispetto a tutte le altre finestre. Se modificate il valore della proprietà da true a false, la finestra viene riportata in secondo piano rispetto alle finestre specificate con "alwaysInFront", ma sempre in primo piano rispetto alle altre finestre. L'impostazione della proprietà sul valore corrente non modifica l'ordine di profondità delle finestre. L'impostazione della proprietà alwaysInFront di una finestra che ha un titolare non produce alcun effetto.

La proprietà alwaysInFront deve essere impostata su true con parsimonia, poiché le finestre con questa impostazione vengono visualizzate in primo piano rispetto alle finestre di un'altra applicazione anche se quest'ultima è attiva.

Note sul comportamento del sistema operativo:

• Alcuni gestori di finestre Linux non visualizzano le finestre la cui proprietà alwaysInFront è impostata su e che si trovano in primo piano rispetto a finestre a schermo intero.
• In Mac^® OS X, l'impostazione di alwaysInFront su true non ha effetto quando la proprietà displayState dello stage della finestra è fullScreen o fullScreenInteractive.

windowObj.alwaysInFront = true;

displayObject.stage.nativeWindow.alwaysInFront=true;

window.nativeWindow.alwaysInFront = true;

Le dimensioni e la posizione della finestra.

Le dimensioni di una finestra comprendono qualunque chrome di sistema. Le dimensioni di uno stage di una finestra sono uguali alle dimensioni della finestra, meno la dimensione degli eventuali chrome di sistema. Se cambiate la larghezza e l'altezza della finestra, vengono modificati anche i valori di stageWidth e stageHeight dello stage. Vale anche il contrario; se cambiate le dimensioni dello stage, cambiano le dimensioni della finestra.

In una finestra HTML principale, le proprietà outerWidth e outerHeight sono equivalenti ai valori di height e width della finestra. Le proprietà innerWidth e innerHeight sono uguali alle proprietà stage.stageWidth e stage.stageHeight meno lo spessore di qualunque eventuale barra di scorrimento automatico visualizzata dalla finestra.

Un evento resize viene inviato ogni volta che cambia la larghezza o l'altezza di questa finestra. In modo analogo, un evento move viene inviato ogni volta che cambia l'origine (x,y) di questa finestra. In Mac OS e Windows, l'impostazione diretta della proprietà bounds non determina l'invio di un evento moving o resizing. Al contrario, in Linux NativeWindow invia un evento moving e un evento resizing quando impostate la proprietà bounds.

L'impostazione della proprietà bounds di una finestra equivale a impostarne le proprietà x, y, width e height. In modo analogo, l'impostazione di qualsiasi dimensione individuale equivale a impostarne la proprietà bounds. Quando si impostano tutte le dimensioni contemporaneamente utilizzando la proprietà bounds, viene inviato un minor numero di eventi.

L'ordine in cui sono impostate le singole dimensioni non è garantito. Nei gestori di finestre Linux che non consentono alle finestre di espandersi oltre l'area del desktop, è possibile che venga bloccata una modifica apportata a una singola proprietà, anche se il risultato dell'applicazione di tutte le modifiche alle proprietà sarebbe una finestra valida.

Se la larghezza o l'altezza specificata è minore del valore minimo o maggiore del valore massimo consentito per la larghezza o l'altezza, questi valori della finestra vengono impostati sulla dimensione valida più vicina. Di seguito sono riportati i fattori che determinano la larghezza e l'altezza minime e massime:

• Le proprietà minSize e maxSize dell'oggetto NativeWindow.
• I limiti minimi e massimi del sistema operativo, che corrispondono ai valori di NativeWindow.systemMinSize e NativeWindow.systemMaxSize.
• La larghezza e l'altezza massime di una finestra in Adobe AIR, ognuna costituita da 4095 pixel. (In AIR 1.5, la larghezza e l'altezza massime di una finestra sono entrambe pari a 2880 pixel.)
• La larghezza e l'altezza minime richieste da qualsiasi chrome di sistema visualizzato.

I valori in pixel vengono arrotondati al più vicino numero intero quando la posizione o le dimensioni di una finestra cambiano.

Elementi API correlati

windowObj.bounds = new Rectangle(200, 200, 1000, 800);

displayObject.stage.nativeWindow.bounds = new Rectangle(20, 20, 800, 600);

window.nativeWindow.bounds = new air.Rectangle(20, 20, 800, 600);

Indica se la finestra è stata chiusa.

L'accesso alle proprietà seguenti in una finestra chiusa genera un errore di operazione non valida:

• title
• bounds
• x, y, width, height
• displayState
• visible

In modo analogo, anche la chiamata ai seguenti metodi in una finestra chiusa genera un errore di operazione non valida:

• minimize()
• maximize()
• restore()
• startResize()
• startMove()

var isWindowClosed:Boolean = windowObj.closed;

var isWindowClosed:Boolean = displayObject.stage.nativeWindow.closed;

var isWindowClosed = window.nativeWindow.closed;

Lo stato di visualizzazione della finestra.

Le costanti per i possibili valori sono definite nella classe NativeWindowDisplayState:

• NativeWindowDisplayState.NORMAL
• NativeWindowDisplayState.MINIMIZED
• NativeWindowDisplayState.MAXIMIZED

Elementi API correlati

var state:String = windowObj.displayState;

L'altezza di questa finestra in pixel.

Le dimensioni di una finestra comprendono gli eventuali chrome delle finestra di sistema visualizzati. L'altezza dell'area di visualizzazione utilizzabile all'interno di una finestra è disponibile nella proprietà Stage.stageHeight.

Modificare la proprietà height di una finestra equivale a modificare l'altezza mediante la proprietà bounds.

Se l'altezza specificata è minore del valore minimo o maggiore del valore massimo consentito per l'altezza, questo valore della finestra viene impostato sulla dimensione valida più vicina. Di seguito sono riportati i fattori che determinano l'altezza minima e massima:

• Le proprietà minSize.x e maxSize.x dell'oggetto NativeWindow.
• I limiti minimi e massimi del sistema operativo, che corrispondono ai valori di NativeWindow.systemMinSize.x e NativeWindow.systemMaxSize.x.
• L'altezza massima di una finestra in Adobe AIR, che è di 4095 pixel (2880 pixel in AIR 1.5 e versioni precedenti).

In Linux, l'impostazione della proprietà height è un'operazione asincrona.

Per rilevare l'avvenuto completamento della modifica dell'altezza, intercettate l'evento resize, che viene inviato su tutte le piattaforme.

I valori in pixel vengono arrotondati al più vicino numero intero quando l'altezza di una finestra viene modificata.

Elementi API correlati

Indica se le finestre native sono supportate nel sistema client.

Segnala l'impostazione di ingrandimento utilizzata per creare la finestra.

L'impostazione maximizable non può essere modificata dopo che è stata creata una finestra.

Nota: alcuni gestori di finestre Linux consentono all'utente di ingrandire le finestre a tutto schermo anche se la proprietà maximizable è impostata su false.

Elementi API correlati

La dimensione massima per questa finestra.

Il limite alla dimensione è specificato sotto forma di coordinate di un oggetto Point. La proprietà point x corrisponde alla larghezza della finestra, la proprietà y all'altezza.

La restrizione maxSize viene applicata per le operazioni di ridimensionamento delle finestre richiamate sia mediante il codice ActionScript, sia attraverso il sistema operativo.

Se impostate maxSize, i limiti della finestra vengono modificati se la dimensione dei limiti correnti è superiore alla nuova dimensione massima.

Se la larghezza o l'altezza specificata è maggiore del valore massimo consentito per la larghezza o l'altezza, questi valori della finestra vengono impostati sulla dimensione valida più vicina. Di seguito sono riportati i fattori che determinano la larghezza e l'altezza minime e massime:

• il limite massimo del sistema operativo, che corrisponde al valore NativeWindow.systemMaxSize;
• la larghezza e l'altezza massime di una finestra in Adobe AIR, ognuna costituita da 4095 pixel. (In AIR 1.5, la larghezza e l'altezza massime di una finestra sono entrambe pari a 2880 pixel.)

Nota: in alcuni sistemi operativi, ad esempio Mac OS X, l'ingrandimento di una finestra espande la finestra solo in base al valore maxSize, anche se la finestra ingrandita ha dimensioni inferiori alla schermata del sistema operativo. La finestra rimane comunque nello stato di visualizzazione ingrandito.

Elementi API correlati

windowObj.maxSize = new Point(1040,920);

displayObject.stage.nativeWindow.maxSize = new Point(800,600);

window.nativeWindow.maxSize = new air.Point(960,960);

Il menu nativo della finestra.

Quando un oggetto NativeMenu viene assegnato alla proprietà menu della finestra, viene visualizzato un menu nativo per una finestra se NativeWindow.supportsMenu è true, a meno che la proprietà systemChrome della finestra non sia NativeWindowSystemChrome.NONE.

Nota: è consentito assegnare un menu a una finestra quando NativeWindow.supportsMenu è false o quando la proprietà systemChrome della finestra è NativeWindowSystemChrome.NONE, ma l'operazione non ha alcun effetto. Utilizzate la proprietà NativeWindow.supportsMenu per determinare se il sistema operativo supporta i menu della finestra. Altri modi (ad esempio Capabilities.os) per determinare il supporto possono causare errori di programmazione (se non vengono considerati alcuni possibili sistemi di destinazione).

Elementi API correlati

Segnala l'impostazione di riduzione a icona utilizzata per creare la finestra.

L'impostazione minimizable non può essere modificata dopo che è stata creata una finestra.

Nota: alcuni gestori di finestre Linux consentono all'utente di ridurre a icona le finestre anche se la proprietà minimizable è impostata su false.

Elementi API correlati

La dimensione minima per questa finestra.

Il limite alla dimensione è specificato sotto forma di coordinate di un oggetto Point. La proprietà point x corrisponde alla larghezza della finestra, la proprietà y all'altezza.

Se impostate minSize, i limiti della finestra vengono modificati se la dimensione dei limiti correnti è inferiore alla nuova dimensione minima.

La restrizione minSize viene applicata per le operazioni di ridimensionamento delle finestre richiamate sia mediante il codice ActionScript, sia attraverso il sistema operativo.

Nota: la larghezza e l'altezza di eventuali chrome di sistema visualizzati possono rendere impossibile l'impostazione della dimensione di una finestra in base alla dimensione minima specificata.

Elementi API correlati

windowObj.minSize = new Point(200,80);

displayObject.stage.nativeWindow.minSize = new Point(120,60);

window.nativeWindow.minSize = new air.Point(80,60);

Oggetto NativeWindow titolare di questa finestra.

La proprietà di una finestra viene stabilita al momento della sua creazione e non può essere modificata. Per creare una finestra con un titolare, impostare l'oggetto titolare NativeWindow come proprietà owner dell'oggetto NativeWindowInitOptions utilizzato per creare la finestra di proprietà del titolare.

Nota: in Linux, alcuni gestori di finestre non visualizzano le finestre appartenenti ad altre finestre in primo piano rispetto alla finestra titolare quando questa è in modalità a schermo intero.

Elementi API correlati

Segnala l'impostazione renderMode della finestra utilizzata per creare questa finestra.

I valori restituiti da NativeWindow.renderMode saranno costituti da una delle costanti definite nella classe NativeWindowRenderMode.

L'impostazione renderMode non può essere modificata dopo che è stata creata una finestra.

Elementi API correlati

Segnala l'impostazione di ridimensionamento utilizzata per creare la finestra.

L'impostazione resizable non può essere modificata dopo che è stata creata una finestra.

Elementi API correlati

L'oggetto Stage per questa finestra. L'oggetto Stage è l'oggetto principale nell'architettura dell'elenco di visualizzazione utilizzata nei contenuti SWF basati su ActionScript 3.0.

Lo stage è l'elemento principale dell'elenco di visualizzazione per la finestra. Aggiungete oggetti di visualizzazione visivi a una finestra aggiungendoli allo stage o a un altro oggetto già presente nell'elenco di visualizzazione di questo stage. Le dimensioni dello stage sono quelle dall'area client della finestra quando la finestra utilizza il chrome di sistema. Le dimensioni dello stage sono uguali alle dimensioni della finestra se non viene utilizzato il chrome di sistema.

Elementi API correlati

import flash.display.StageAlign;

windowObj.stage.align = StageAlign.TOP_LEFT;

Indica se AIR supporta i menu delle finestre native sul computer corrente.

Quando NativeWindow.supportsMenu è true, un menu nativo viene visualizzato per una finestra quando viene assegnato un oggetto NativeMenu alla proprietà menu della finestra, a meno che la proprietà systemChrome della finestra non sia NativeWindowSystemChrome.NONE. Utilizzate la proprietà NativeWindow.supportsMenu per determinare se il sistema operativo supporta i menu della finestra nativa. Altri modi (ad esempio Capabilities.os) per determinare il supporto possono causare errori di programmazione (se non vengono considerati alcuni possibili sistemi di destinazione).

Nota: è consentito assegnare un menu a una finestra quando NativeWindow.supportsMenu è false o quando la proprietà systemChrome della finestra è NativeWindowSystemChrome.NONE, ma l'operazione non ha alcun effetto.

Elementi API correlati

Indica se AIR supporta l'invio di notifiche relative alle finestre sul computer corrente.

Quando NativeWindow.supportsNotification è true, la chiamata al metodo notifyUser() della finestra genera un segnale visivo che avvisa l'utente che si è verificato un evento di interesse. Il segnale visivo si conforma alla convenzione del sistema operativo del sistema nativo. Ad esempio, in Windows^® lampeggia l'icona sulla barra delle applicazioni.

Nota: è consentito chiamare notifyUser() quando NativeWindow.supportsNotification è false, ma non viene prodotto alcun effetto.

Elementi API correlati

Indica se AIR supporta le finestre native con pixel trasparenti.

Quando NativeWindow.supportsTransparency è true, la trasparenza dei pixel di una finestra nativa viene rispettata se la proprietà transparent della finestra è impostata su true. L'opacità di tutti i pixel viene impostata su 1 seNativeWindow.supportsTransparency è false, indipendentemente dal valore della proprietà transparent della finestra. Se NativeWindow.supportsTransparency è false, i pixel completamente trasparenti vengono viene considerati come nero. Utilizzate la proprietà NativeWindow.supportsTransparency per determinare se il sistema operativo supporta la trasparenza. Altri modi (ad esempio Capabilities.os) per determinare il supporto possono causare errori di programmazione (se non vengono considerati alcuni possibili sistemi di destinazione).

Nota: il valore di questa proprietà potrebbe essere modificato durante l'esecuzione di un'applicazione, a seconda delle preferenze dell'utente impostate per il sistema operativo.

Elementi API correlati

Segnala l'impostazione del chrome di sistema utilizzata per creare la finestra.

I valori restituiti da NativeWindow.systemChrome saranno costituti da una delle costanti definite nella classe NativeWindowSystemChrome.

L'impostazione del chrome di sistema non può essere modificata dopo che è stata creata una finestra.

Elementi API correlati

var sysChromeType:String = windowObj.systemChrome;

var sysChromeType:String = displayObject.stage.nativeWindow.systemChrome;

var sysChromeType = window.nativeWindow.systemChrome;

import flash.display.NativeWindow;
import flash.display.NativeWindowSystemChrome;
import flash.display.NativeWindowInitOptions;

public function deChromeWindow(oldWindow:NativeWindow):NativeWindow{
    if(oldWindow.systemChrome != NativeWindowSystemChrome.NONE){
        var newOptions:NativeWindowInitOptions = new NativeWindowInitOptions();
        newOptions.systemChrome = NativeWindowSystemChrome.NONE;
        newOptions.transparent = true;
        
        var newWindow:NativeWindow = new NativeWindow(newOptions);
        newWindow.stage.stageWidth = oldWindow.stage.stageWidth;
        newWindow.stage.stageHeight = oldWindow.stage.stageHeight;
        newWindow.stage.align = oldWindow.stage.align;
        newWindow.stage.scaleMode = oldWindow.stage.scaleMode;
        
        for(var i:int = 0; i < oldWindow.stage.numChildren; i++){
            newWindow.stage.addChild(oldWindow.stage.getChildAt(i));
        }
        newWindow.activate();
        oldWindow.close();
        
        return newWindow;
    }
    return oldWindow;
}

La dimensione massima consentita dal sistema operativo.

Il limite alla dimensione è specificato sotto forma di coordinate di un oggetto Point. La proprietà point x corrisponde alla larghezza della finestra, la proprietà y all'altezza.

Oltre al limite di dimensioni del sistema operativo, in AIR il limite massimo di una finestra è di 4095 x 4095 pixel (2880 x 2880 pixel in AIR 1.5 e versioni precedenti). Per impostare un limite in un'applicazione, potete utilizzare la proprietà maxSize dell'oggetto NativeWindow.

La dimensione minima consentita dal sistema operativo.

Il limite alla dimensione è specificato sotto forma di coordinate di un oggetto Point. La proprietà point x corrisponde alla larghezza della finestra, la proprietà y all'altezza.

Il titolo della finestra.

Il titolo compare nel chrome di sistema per la finestra, se visualizzata, oltre che in altre posizioni dipendenti dal sistema (ad esempio, la barra delle applicazioni).

windowObj.title = "Window Title";

Segnala l'impostazione di trasparenza utilizzata per creare la finestra.

La proprietà transparent non può essere modificata dopo che è stata creata una finestra. La trasparenza influisce sia sull'aspetto visivo della finestra sia sul suo comportamento rispetto al mouse. In Windows e Mac OS X la finestra non rileva gli eventi del mouse quando il valore alfa del pixel è inferiore a una determinata soglia che varia tra 0,06 e 0,01, in base al sistema operativo. In Linux la finestra rileva gli eventi del mouse su aree completamente trasparenti e pertanto impedisce agli utenti di accedere ad altre finestre ed elementi sul desktop.

Nota: la trasparenza delle finestre non è sempre supportata. Se la configurazione del sistema operativo dell'utente è tale per cui la trasparenza non è disponibile, la finestra viene creata senza trasparenza. Le aree originariamente trasparenti vengono create su uno sfondo nero. Utilizzate la proprietà NativeWindow.supportsTransparency per determinare se la trasparenza delle finestre è supportata.

Elementi API correlati

Segnala l'impostazione type della finestra utilizzato per creare la finestra.

I valori restituiti da NativeWindow.type saranno costituti da una delle costanti definite nella classe NativeWindowType.

L'impostazione type non può essere modificata dopo che è stata creata una finestra.

Elementi API correlati

Specifica se la finestra è visibile.

Una finestra invisibile non viene visualizzata sul desktop, ma tutte le proprietà e i metodi della finestra sono validi.

Per impostazione predefinita, visible è false. Per visualizzare una finestra, impostate visible su true o chiamate NativeWindow.activate().

Se questa finestra ha un titolare, sarà lo stato di visualizzazione impostato per la finestra titolare che determinerà se la finestra è visualizzata o meno. Se la finestra titolare non è visualizzata, non lo saranno neanche le altre finestre appartenenti a essa, anche nel caso in cui la proprietà visible sia impostata su true.

Nota: su Mac OS X, l'impostazione visible=false per una finestra ridotta a icona non rimuove l'icona della finestra dal dock. Se successivamente un utente fa clic sull'icona nel dock, la finestra ritorna allo stato visibile e viene visualizzata sul desktop.

Elementi API correlati

windowObj.visible = true;

displayObj.stage.nativeWindow.visible = true;

window.nativeWindow.visible = true;

La larghezza di questa finestra in pixel.

Le dimensioni segnalate per una finestra nativa comprendono gli eventuali chrome delle finestre di sistema visualizzati. La larghezza dell'area di visualizzazione utilizzabile all'interno di una finestra è disponibile nella proprietà Stage.stageWidth.

Modificare la proprietà width di una finestra equivale a modificare la larghezza mediante la proprietà bounds.

Se la larghezza specificata è minore del valore minimo o maggiore del valore massimo consentito per la larghezza, questo valore della finestra viene impostato sulla dimensione valida più vicina. Di seguito sono riportati i fattori che determinano la larghezza minima e massima:

• le proprietà minSize.y e maxSize.y dell'oggetto NativeWindow;
• i limiti minimi e massimi del sistema operativo, che corrispondono ai valori di NativeWindow.systemMinSize.y e NativeWindow.systemMaxSize.y;
• La larghezza massima di una finestra in Adobe AIR, che è di 4095 pixel (2880 pixel in AIR 1.5 e versioni precedenti).

In Linux, l'impostazione della proprietà width è un'operazione asincrona.

Per rilevare l'avvenuto completamento della modifica della larghezza, intercettate l'evento resize, che viene inviato su tutte le piattaforme.

I valori in pixel vengono arrotondati al più vicino numero intero quando la larghezza di una finestra viene modificata.

Elementi API correlati

La coordinata dell'asse orizzontale dell'angolo superiore sinistro della finestra in relazione all'origine del desktop del sistema operativo.

Sui sistemi con più di un monitor, x può essere negativo. Se salvate il valore, ad esempio per riposizionare una finestra nel punto precedente, verificate sempre che la finestra sia collocata in un punto utilizzabile, dopo il ripristino della posizione originale. Eventuali modifiche della risoluzione dello schermo o della disposizione dei monitor possono causare il posizionamento di una finestra fuori dallo schermo. Per ottenere informazioni sulla geometria del desktop, utilizzate la classe Screen.

Modificare la proprietà x di una finestra equivale a modificare la posizione mediante la proprietà bounds.

In Linux, l'impostazione della proprietà x è un'operazione asincrona.

Per rilevare l'avvenuto completamento della modifica della posizione, intercettate l'evento move, che viene inviato su tutte le piattaforme.

I valori in pixel vengono arrotondati al più vicino numero intero quando la coordinata x di una finestra viene modificata.

Elementi API correlati

La coordinata dell'asse verticale dell'angolo superiore sinistro della finestra in relazione all'angolo superiore sinistro del desktop del sistema operativo.

Sui sistemi con più di un monitor, y può essere negativo. Se salvate il valore, ad esempio per riposizionare una finestra nel punto precedente, verificate sempre che la finestra sia collocata in un punto utilizzabile, dopo il ripristino della posizione originale. Eventuali modifiche della risoluzione dello schermo o della disposizione dei monitor possono causare il posizionamento di una finestra fuori dallo schermo. Per ottenere informazioni sulla geometria del desktop, utilizzate la classe Screen.

Modificare la proprietà y di una finestra equivale a modificare la posizione mediante la proprietà bounds.

In Linux, l'impostazione della proprietà y è un'operazione asincrona.

Per rilevare l'avvenuto completamento della modifica della posizione, intercettate l'evento move, che viene inviato su tutte le piattaforme.

I valori in pixel vengono arrotondati al più vicino numero intero quando la coordinata y di una finestra viene modificata.

Elementi API correlati

Crea una nuova istanza NativeWindow e una finestra del sistema operativo corrispondente.

Le impostazioni definite nel parametro initOptions non possono essere modificate dopo che è stata creata la finestra. Impostazioni non valide per initOptions provocano la generazione di un errore di operazione non valida. Le impostazioni che sono valide ma non disponibili sul sistema corrente non generano un'eccezione. Le funzioni della finestra specifiche del sistema operativo corrente possono essere rilevate mediante i membri statici di NativeWindow, quale systemMaxSize.

La dimensione predefinita della finestra è determinata dal sistema operativo e le finestre vengono create con stato invisibile. Per evitare che le modifiche apportate alla finestra siano visibili, non modificate la proprietà visible della finestra in true e non chiamate activate() finché le modifiche non sono state completate.

Elementi API correlati

import flash.display.NativeWindowInitOptions;
import flash.display.NativeWindowSystemChrome;
import flash.display.NativeWindowType;
import flash.display.NativeWindow;
import flash.display.StageAlign;
import flash.display.StageScaleMode;
import flash.geom.Rectangle;

var windowOptions:NativeWindowInitOptions = new NativeWindowInitOptions();
windowOptions.systemChrome = NativeWindowSystemChrome.STANDARD;
windowOptions.type = NativeWindowType.NORMAL;

var newWindow:NativeWindow = new NativeWindow(windowOptions);
newWindow.stage.scaleMode = StageScaleMode.NO_SCALE;
newWindow.stage.align = StageAlign.TOP_LEFT;
newWindow.bounds = new Rectangle(100, 100, 800, 800);

newWindow.activate();

Attiva la finestra.

L'attivazione di una finestra:

• Rende visibile la finestra.
• Porta la finestra in primo piano.
• Rende la finestra l'elemento attivo per la tastiera e il mouse.

In Linux, activate() è un'operazione asincrona.

L'oggetto NativeWindow invia un evento activate in tutte le piattaforme.

Elementi API correlati

displayObject.stage.nativeWindow.activate();

windowObj.activate();

window.nativeWindow.activate();

Chiude la finestra.

Un evento close viene inviato non appena l'operazione di chiusura è stata completata. Un evento closing non viene inviato. Se l'annullamento di un'operazione di chiusura deve essere consentito, inviate un evento closing e verificate se i listener registrati annullano il comportamento predefinito prima di chiamare il metodo close.

Quando una finestra viene chiusa. vengono chiuse anche tutte le finestre di cui è titolare. Le finestre appartenenti alla finestra titolare non inviano eventi closing.

Se per le istanze dell'oggetto di visualizzazione che si trovano al momento nella finestra non esistono riferimenti altrove, vengono sottoposte a garbage collection e distrutte, ad eccezione della finestra dell'applicazione iniziate creata da AIR. Per consentire l'esecuzione del processo di garbage collection degli oggetti di visualizzazione nella finestra iniziale, rimoveteli dallo stage della finestra.

Una volta chiuso, l'oggetto NativeWindow è ancora un riferimento valido, ma l'accesso alla maggior parte delle proprietà e dei metodi genera un errore di operazione non valida.

Le finestre chiuse non possono essere riaperte. Se la finestra è già chiusa, non viene eseguita alcuna operazione e non viene inviato alcun evento.

Nota: per nascondere una finestra senza chiuderla, impostate la proprietà visible della finestra su false.

Elementi API correlati

windowObj.close();

displayObj.stage.nativeWindow.close();

window.close(); //overriddable in HTMLHost

window.nativeWindow.close(); //not overriddable

public function closeCommand():Boolean{
    var closeEvent:Event = new Event(Event.CLOSING,true,true);
    windowObj.dispatchEvent(closeEvent);
    if(!closeEvent.isDefaultPrevented()){
        windowObj.close();
        return true;
    } else {
      return false;
    }
}

<script src="AIRAliases.js" type="text/javascript"></script>
<script type="text/javascript">
    var dirtyData = false;
    function closeWindow(){
            var closingEvent = new air.Event(air.Event.CLOSING,true,true);
            window.nativeWindow.dispatchEvent(closingEvent);
               if(!closingEvent.isDefaultPrevented()){
                   window.nativeWindow.close();
                //or use: window.close(); 
               return true;
           } else {
               return false;
        }
    }
        
    function onClosing(event){
        if(dirtyData){
            event.preventDefault();
            //Save data...
        }
    }    

    window.nativeWindow.addEventListener(air.Event.CLOSING,onClosing);        
</script>

Converte un punto in coordinate pixel relativo all'origine dello stage della finestra (un punto globale in termini di elenco di visualizzazione) in un punto del desktop virtuale.

Le coordinate del desktop virtuale sono relative all'angolo superiore sinistro del monitor principale.

Parametri

Elementi API correlati

Restituisce un elenco degli oggetti NativeWindow appartenenti a questa finestra.

Non potete modificare la proprietà degli oggetti NativeWindow aggiungendo o rimuovendo oggetti dal Vector restituito. La proprietà di una finestra non può essere modificata dopo che tale finestra è stata creata.

Elementi API correlati

Ingrandisce questa finestra.

La chiamata al metodo maximize() invia un evento displayStateChange e, se applicabile, un evento move e un evento resize. Mentre il chrome di sistema invia un evento displayStateChanging che è possibile annullare quando un utente inizializza un comando di ingrandimento, la logica di ingrandimento in uso deve implementare questo comportamento, se lo desiderate.

Il metodo maximize() viene eseguito in modalità asincrona. Per rilevare l'avvenuto completamento della modifica dello stato, intercettate l'evento displayStateChange. Se la finestra è già ingrandita, non viene eseguita alcuna operazione e non viene inviato alcun evento.

Note sul comportamento del sistema operativo:

• Nei sistemi operativi quali Mac OS X, in cui l'ingrandimento di una finestra non impedisce il ridimensionamento, la chiamata a maximize() ingrandisce la finestra fino a riempire la schermata, ma non impedisce il successivo ridimensionamento della finestra. Il ridimensionamento di una finestra ingrandita ripristina anche lo stato di visualizzazione.
• In alcuni sistemi operativi, ad esempio Mac OS X, e in alcuni gestori di finestre Linux, l'ingrandimento di una finestra non la espande oltre la larghezza e l'altezza specificate nella finestra maxSize. In altri, la finestra si espande per riempire lo schermo anche se la schermata ha dimensioni superiori a maxSize.
• Alcuni gestori di finestre Linux non consentono l'ingrandimento delle finestre delle utilità.

Elementi API correlati

public function maximizeWindow(nativeWin:NativeWindow):Boolean{
  if(nativeWin.displayState != NativeWindowDisplayState.MAXIMIZED){
    var beforeState:String = nativeWin.displayState;
    var afterState:String = NativeWindowDisplayState.MAXIMIZED;
    var displayStateEvent:NativeWindowDisplayStateEvent = 
        new NativeWindowDisplayStateEvent(NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                              true,true,beforeState,afterState);
    nativeWin.dispatchEvent(displayStateEvent);
    if(!displayStateEvent.isDefaultPrevented()){
        nativeWin.maximize();
        return true;
    } else {
      return false;
    }
  }
  return false;
}

function maximizeWindow(nativeWin){
    if(nativeWin.displayState != air.NativeWindowDisplayState.MAXIMIZED){
        var beforeState = nativeWin.displayState;
        var afterState = air.NativeWindowDisplayState.MAXIMIZED;
        var displayStateEvent = 
            new air.NativeWindowDisplayStateEvent(air.NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                              true,true,beforeState,afterState);
        nativeWin.dispatchEvent(displayStateEvent);
        if(!displayStateEvent.isDefaultPrevented()){
            nativeWin.maximize();
            return true;
        } else {
          return false;
        }
     }
     return false;
}

Riduce a icona questa finestra.

La chiamata a minimize() invia un evento displayStateChange e, se applicabile, un evento move e un evento resize. Mentre il chrome di sistema invia un evento displayStateChanging che è possibile annullare quando un utente inizializza un comando di riduzione a icona, la chiamata diretta a minimize() non ha lo stesso effetto. La logica in uso per la riduzione a icona può implementare questo comportamento, se lo desiderate.

Il metodo minimize() viene eseguito in modalità asincrona. Per rilevare l'avvenuto completamento della modifica dello stato, intercettate l'evento displayStateChange, che viene inviato su tutte le piattaforme. Se la finestra è già ridotta a icona, non viene eseguita alcuna operazione e non viene inviato alcun evento.

Tutte le finestre appartenenti a questa finestra vengono nascoste quando la finestra nativa è ridotta a icona. Le finestre appartenenti alla finestra titolare non inviano eventi displayStateChanging o displayStateChange.

Note:

• In Windows, la riduzione a icona di una finestra invisibile (visible == false) rende la finestra invisibile.
• Alcuni gestori di finestre Linux non consentono la riduzione a icona delle finestre delle utilità.

Elementi API correlati

public function minimizeWindow(nativeWin:NativeWindow):Boolean{
    if(nativeWin.displayState != NativeWindowDisplayState.MINIMIZED){
        var beforeState:String = nativeWin.displayState;
        var afterState:String = NativeWindowDisplayState.MINIMIZED;
        var displayStateEvent:NativeWindowDisplayStateEvent = 
            new NativeWindowDisplayStateEvent(NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                              true,true,beforeState,afterState);
        nativeWin.dispatchEvent(displayStateEvent);
        if(!displayStateEvent.isDefaultPrevented()){
            nativeWin.minimize();
            return true;
        } else {
          return false;
        }
     }
     return false;
}

 
function minimizeWindow(){
    if(window.nativeWindow.displayState != air.NativeWindowDisplayState.MINIMIZED){
        var beforeState = window.nativeWindow.displayState;
        var afterState = air.NativeWindowDisplayState.MINIMIZED;
        var displayStateEvent = 
            new air.NativeWindowDisplayStateEvent(air.NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                              true,true,beforeState,afterState);
        window.nativeWindow.dispatchEvent(displayStateEvent);
        if(!displayStateEvent.isDefaultPrevented()){
            window.nativeWindow.minimize();
            return true;
        } else {
          return false;
        }
     }
     return false;
}

Attiva un segnale visivo nel sistema operativo per indicare il verificarsi di un evento di interesse.

Quando NativeWindow.supportsNotification è true, il segnale visivo si conforma alla convenzione del sistema operativo del sistema nativo. Ad esempio, in Windows lampeggia l'icona sulla barra delle applicazioni.

Il parametro type determina l'intensità del segnale. Le costanti per i valori consentiti sono definite nella classe NotificationType e possono essere le seguenti:

• NotificationType.INFORMATIONAL
• NotificationType.CRITICAL

I segnali forniti per le notifiche informative sono di breve durata; quelle fornite per le notifiche di importanza critica rimangono visualizzate fino a quando l'utente non attiva questa finestra. Non tutti i gestori di finestre Linux supportano due livelli di notifica. Per questi gestori, notifyUser() ha lo stesso effetto a prescindere da quale opzione è specificata.

Nota: è consentito chiamare notifyUser() quando NativeWindow.supportsNotification è false, ma non viene prodotto alcun effetto.

Parametri

Mette questa finestra in secondo piano rispetto alla finestra specificata.

Non attiva o acquisisce l'attivazione per la finestra o l'applicazione. Le finestre ridotte a icona o nascoste (visible è false) non possono essere riordinate.

Una finestra appartenente a un'altra finestra non può mai essere spostata in secondo piano rispetto al titolare. Se questa finestra ha un titolare, quest'ultimo e le altre finestre di cui è titolare vengono ordinati in secondo piano rispetto alla finestra target. Se la finestra target ha un titolare, viene ordinata in secondo piano rispetto al suo titolare.

Alcuni gestori di finestre Linux non consentono l'ordinamento delle finestre delle utilità in secondo piano rispetto alle finestre normali.

Parametri

windowBehind.orderInBackOf(windowFront);

displayObjBehind.stage.nativeWindow.orderInBackOf(displayObjectFront.stage.nativeWindow);

jsWindowObjBehind.nativeWindow.orderInBackOf(jsWindowObjFront.nativeWindow);

Porta questa finestra in primo piano rispetto alla finestra specificata.

Non attiva o acquisisce l'attivazione per la finestra o l'applicazione. Le finestre ridotte a icona o nascoste (visible è false) non possono essere riordinate.

Una finestra non può mai essere spostata in primo piano rispetto a una finestra di cui è titolare. Se questa finestra ha un titolare, quest'ultimo e le altre finestre di cui è titolare vengono ordinati in primo piano rispetto alla finestra target. Se la finestra target ha un titolare, viene ordinata in primo piano rispetto a tutte le altre finestre che hanno lo stesso titolare.

Alcuni gestori di finestre Linux non consentono l'ordinamento delle finestre normali in primo piano rispetto alle finestre delle utilità.

Parametri

windowFront.orderInFrontOf(windowBehind);

displayObjFront.stage.nativeWindow.orderInFrontOf(displayObjectBehind.stage.nativeWindow);

jsWindowObjFront.nativeWindow.orderInFrontOf(jsWindowObjBehind.nativeWindow);

Mette questa finestra in secondo piano rispetto a tutte le altre finestre visibili.

Non attiva o acquisisce l'elemento attivo per la finestra o l'applicazione. Le finestre ridotte a icona o nascoste (visible è false) non possono essere riordinate.

Se alwaysInFront è true, la chiamata a questo metodo non invia la finestra in secondo piano rispetto a tutte le finestre per cui alwaysInFront è impostato su false.

Una finestra appartenente a un'altra finestra non può mai essere spostata in secondo piano rispetto al titolare. Se questa finestra ha un titolare, quest'ultimo e le altre finestre di cui è titolare vengono ordinati alla fine dell'elenco di visualizzazione delle finestre. Questa finestra verrà spostata in secondo piano rispetto a tutte le finestre di proprietà della stessa finestra. Se questa finestra è titolare di altre finestre, anche queste verranno spostate in secondo piano, mantenendo l'attuale ordinamento tra di esse.

Alcuni gestori di finestre Linux non consentono l'ordinamento delle finestre delle utilità in secondo piano rispetto alle finestre normali.

windowObj.orderToBack();

displayObj.stage.nativeWindow.orderToBack();

window.nativeWindow.orderToBack();

Porta questa finestra in primo piano rispetto a tutte le altre finestre visibili.

Non attiva o acquisisce l'elemento attivo per la finestra o l'applicazione. Le finestre ridotte a icona o nascoste (visible è false) non possono essere riordinate.

Se alwaysInFront è false, la chiamata a questo metodo non invia la finestra in primo piano rispetto a tutte le finestre per cui alwaysInFront è impostato su true.

Una finestra non può mai essere spostata in primo piano rispetto a una finestra di cui è titolare. Se questa finestra è titolare di altre finestre, anche queste verranno spostate in primo piano, mantenendo l'attuale ordinamento tra di esse. Se questa finestra ha un titolare, quest'ultimo e le altre finestre di cui è titolare vengono ordinati all'inizio dell'ordine di visualizzazione delle finestre. Questa finestra viene spostata in primo piano rispetto alle altre finestre con lo stesso titolare.

Alcuni gestori di finestre Linux non consentono l'ordinamento delle finestre normali in primo piano rispetto alle finestre delle utilità.

windowObj.orderToFront();

displayObj.stage.nativeWindow.orderToFront();

window.nativeWindow.orderToFront();

Ripristina la finestra dallo stato ingrandito o ridotto a icona.

La chiamata a restore() invia un evento displayStateChange e, se applicabile, un evento move e un eventoresize. Mentre il chrome di sistema invia un evento displayStateChanging che è possibile annullare quando un utente inizializza un comando di ripristino, la logica di ingrandimento in uso deve implementare questo comportamento, se lo desiderate.

Se lo stato della finestra è già NativeWindowDisplayState.NORMAL, non viene eseguita alcuna operazione e non viene inviato alcun evento.

Per rilevare l'avvenuto completamento della modifica dello stato, intercettate l'evento displayStateChange, che viene inviato su tutte le piattaforme.

Elementi API correlati

public function restoreWindow(nativeWin:NativeWindow):Boolean{
    if(nativeWin.displayState != NativeWindowDisplayState.NORMAL){
        var beforeState:String = nativeWin.displayState;
        var afterState:String = NativeWindowDisplayState.NORMAL;
        var displayStateChangingEvent:NativeWindowDisplayStateEvent = 
            new NativeWindowDisplayStateEvent(NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                              true,true,beforeState,afterState);
        nativeWin.dispatchEvent(displayStateChangingEvent);
        if(!displayStateChangingEvent.isDefaultPrevented()){
            nativeWin.restore();
            return true;
        } else {
          return false;
        }
     }
     return false;
}

function restoreWindow(nativeWin){
    if(window.nativeWindow.displayState != air.NativeWindowDisplayState.NORMAL){
        var beforeState = window.nativeWindow.displayState;
        var afterState = air.NativeWindowDisplayState.NORMAL;
        var displayStateEvent = 
            new air.NativeWindowDisplayStateEvent(air.NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                              true,true,beforeState,afterState);
        window.nativeWindow.dispatchEvent(displayStateEvent);
        if(!displayStateEvent.isDefaultPrevented()){
            window.nativeWindow.restore();
            return true;
        } else {
          return false;
        }
     }
     return false;
}

Avvia un movimento della finestra controllato dal sistema.

Quando viene chiamato da un evento mouseDown, questo metodo inizia una sequenza di spostamento guidata dal mouse che continua fino a quando non si verifica un evento mouseUp.

Quando viene chiamato da altro codice, questo metodo inizia una sequenza di spostamento guidata dalla tastiera o dal mouse in modo coerente con la sequenza predefinita del sistema operativo.

Durante una sequenza di spostamento, una serie di eventi viene inviata mentre l'origine della finestra si sposta. Per ogni spostamento incrementale, dapprima viene inviato un evento moving e successivamente, se l'evento moving non viene annullato, la posizione della finestra viene aggiornata e viene inviato un evento move. Se un evento moving viene annullato, la sequenza di spostamento viene immediatamente terminata.

var initOpts:NativeWindowInitOptions = new NativeWindowInitOptions();
var win:NativeWindow = new NativeWindow(initOpts);
win.activate();
win.stage.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);

function mouseDownHandler(event:MouseEvent):void
{
    win.startMove();
}

Avvia un'operazione di ridimensionamento della finestra controllata dal sistema.

Quando viene chiamato da un gestore di eventi mouseDown, questo metodo inizia una sequenza di ridimensionamento guidata dal mouse che continua fino a quando non si verifica un evento mouseUp.

Quando viene chiamato da altro codice, questo metodo inizia una sequenza di ridimensionamento guidata dalla tastiera o dal mouse in modo coerente con la sequenza predefinita del sistema operativo.

Durante la sequenza di ridimensionamento, una serie di eventi viene inviata mentre le dimensioni della finestra cambiano. Per ogni modifica incrementale, dapprima viene inviato un evento resizing e successivamente, se l'evento resizing non viene annullato, le dimensioni della finestra vengono aggiornate e viene inviato un evento resize. Se un evento resizing viene annullato, la sequenza viene immediatamente terminata.

Parametri

Elementi API correlati

stage.addEventListener(MouseEvent.MOUSE_DOWN, onResizeCommand);

function onResizeCommand(event:MouseEvent):void
{
    var win:NativeWindow = event.target.nativeWindow;
    var resizeFrom:String = "";
    if (event.stageY < win.height * .33)
    {
        resizeFrom = NativeWindowResize.TOP;
    }
    else if (event.stageY > win.height * .66)
    {
        resizeFrom = NativeWindowResize.BOTTOM;
    }
    if (event.stageX < win.width * .33)
    {
        resizeFrom += NativeWindowResize.LEFT;
    }
    else if (event.stageX > win.width * .66)
    {
        resizeFrom += NativeWindowResize.RIGHT;
    }
    win.startResize(resizeFrom);    
}

Inviato dall'oggetto NativeWindow in seguito all'attivazione della finestra.

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

I dispositivi AIR per TV non inviano mai automaticamente questo evento. È possibile, tuttavia, inviarlo manualmente.

Questo evento ha le seguenti proprietà:

Inviato dall'oggetto NativeWindow in seguito alla chiusura della finestra.

Questo evento ha le seguenti proprietà:

Inviato dall'oggetto NativeWindow immediatamente prima della chiusura della finestra. Questo evento può essere annullato per impedire che la finestra venga chiusa.

Questo evento ha le seguenti proprietà:

Inviato dall'oggetto NativeWindow in seguito alla disattivazione della finestra.

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

I dispositivi AIR per TV non inviano mai automaticamente questo evento. È possibile, tuttavia, inviarlo manualmente.

Questo evento ha le seguenti proprietà:

Inviato dall'oggetto NativeWindow in seguito alla modifica della proprietà displayState per la finestra.

Evitate di ridimensionare la finestra o di modificarne lo stato di visualizzazione nel gestore dell'evento displayStateChange.

Questo evento ha le seguenti proprietà:

Inviato dall'oggetto NativeWindow immediatamente prima della modifica dello stato di visualizzazione della finestra. Questo evento può essere annullato per impedire la modifica.

Questo evento ha le seguenti proprietà:

function displayStateChanging_handler(displayStateEvent:NativeWindowDisplayStateEvent):void
{
  //shouldStopStateChange is an application-defined Boolean indicating 
  //that display state changes should be canceled
  if (displayStateEvent.type == NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING 
                                  &&    shouldStopStateChange)
  {
    displayStateEvent.preventDefault();
  }
}

Inviato dall'oggetto NativeWindow in seguito allo spostamento della finestra sul desktop.

Un evento move viene inviato ogni qual volta cambia l'origine (proprietà x or y) della finestra, una circostanza che può verificarsi a causa dello spostamento di una finestra controllata dal sistema: la riduzione a icona, l'ingrandimento o il ripristino della finestra oppure la modifica delle dimensioni della finestra mediante le proprietà x, y o bounds.

Nota: evitate operazioni che possono aprire più finestre di dialogo del sistema operativo contemporaneamente nelle funzioni del gestore per entrambi gli eventi moving e move dell'oggetto NativeWindow. Questa situazione può verificarsi ad esempio se entrambe le funzioni del gestore generano un errore. Se ciò accade, la seconda finestra di dialogo aperta non registra i clic del mouse e deve essere chiusa mediante tastiera.

Questo evento ha le seguenti proprietà:

Inviato dall'oggetto NativeWindow immediatamente prima che la finestra venga spostata sul desktop. Questo evento può essere annullato per impedire o modificare lo spostamento.

Nota: evitate operazioni che possono aprire più finestre di dialogo del sistema operativo contemporaneamente nelle funzioni del gestore per entrambi gli eventi moving e move dell'oggetto NativeWindow. Questa situazione può verificarsi ad esempio se entrambe le funzioni del gestore generano un errore. Se ciò accade, la seconda finestra di dialogo aperta non registra i clic del mouse e deve essere chiusa mediante tastiera.

Questo evento ha le seguenti proprietà:

Nota: in Linux, il metodo preventDefault() non è supportato per questo evento.

Inviato dall'oggetto NativeWindow in seguito al ridimensionamento della finestra. Un evento resizeviene inviato ogni qual volta cambiano le dimensioni (proprietà width o height) della finestra, una circostanza che può verificarsi a causa del ridimensionamento di una finestra controllata dal sistema: la riduzione a icona, l'ingrandimento o il ripristino della finestra oppure la modifica delle dimensioni della finestra mediante le proprietà width, height o bounds. Gli eventi resize NativeWindow vengono inviati durante i cicli di ridimensionamento controllati dal sistema. Al contrario, gli eventi resize dell'oggetto Stage vengono inviati quando lo stage è pronto per il disegno.

Questo evento ha le seguenti proprietà:

Elementi API correlati

Inviato dall'oggetto NativeWindow immediatamente prima che la finestra venga ridimensionata sul desktop. Questo evento può essere annullato per impedire o modificare il ridimensionamento.

Questo evento ha le seguenti proprietà:

Nota: in Linux, il metodo preventDefault() non è supportato per questo evento.

function boundsChanging_handler(boundsEvent:NativeWindowBoundsEvent):void
{
  //shouldStopResize is an application-defined Boolean indicating 
  //that resize operations should be canceled
  if (boundsEvent.type == NativeWindowBoundsEvent.RESIZING && shouldStopResize)
  {
    boundsEvent.preventDefault();
  }
}