Gestione delle finestre

Per modificare una finestra, occorre innanzitutto ottenere l'istanza della finestra. Potete ottenere un'istanza della finestra da una delle posizioni seguenti:

• Il metodo di costruzione della finestra nativa usato per creare la finestra:

  var win:NativeWindow = new NativeWindow(initOptions);

• La proprietà nativeWindow dello stage della finestra:

  var win:NativeWindow = stage.nativeWindow;

• La proprietà stage di un oggetto di visualizzazione nella finestra:

  var win:NativeWindow = displayObject.stage.nativeWindow;

• La proprietà target dell'evento window nativo inviato dalla finestra:

  private function onNativeWindowEvent(event:NativeWindowBoundsEvent):void 
  { 
      var win:NativeWindow = event.target as NativeWindow; 
  }

• La proprietà nativeWindow di una pagina HTML visualizzata nella finestra:

  var win:NativeWindow = htmlLoader.window.nativeWindow;

• Le proprietà activeWindow e openedWindows dell'oggetto NativeApplication:

  var nativeWin:NativeWindow = NativeApplication.nativeApplication.activeWindow; 
  var firstWindow:NativeWindow = NativeApplication.nativeApplication.openedWindows[0];

  NativeApplication.nativeApplication.activeWindow fa riferimento alla finestra attiva di un'applicazione (ma restituisce null se la finestra attiva non è una finestra dell'applicazione AIR). L'array NativeApplication.nativeApplication.openedWindows contiene tutte le finestre di un'applicazione AIR che non è stata chiusa.

Poiché gli oggetti Flex mx:WindowedApplication e mx:Window sono oggetti di visualizzazione, potete fare facilmente riferimento alla finestra dell'applicazione in un file MXML usando la proprietà stage , come segue:

<?xml version="1.0" encoding="utf-8"?> 
<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml" applicationComplete="init();"> 
    <mx:Script> 
        <![CDATA[ 
            import flash.display.NativeWindow; 
 
            public function init():void{ 
                var appWindow:NativeWindow = this.stage.nativeWindow; 
                //set window properties 
                appWindow.visible = true; 
            } 
        ]]> 
    </mx:Script> 
</WindowedApplication

Per attivare una finestra, potete chiamare il metodo activate() della classe NativeWindow. L'operazione di attivazione porta una finestra in primo piano, attiva la tastiera e il mouse, e, se necessario, rende la finestra visibile ripristinandola o impostando la proprietà visible su true . L'attivazione di una finestra non cambia l'ordine delle altre finestre nell'applicazione. La chiamata al metodo activate() causa l'invio di un evento activate .

Per mostrare o nascondere una finestra senza attivarla, potete impostare la proprietà visible su true . Questa operazione porta la finestra in primo piano senza però attivarla.

Per nascondere una finestra, potete impostare la sua proprietà visible su false . Nascondere una finestra significa non visualizzare la finestra, le eventuali icone della barra delle applicazioni correlate e, in Mac OS X, le voci del menu Finestre.

Se cambiate la visibilità di una finestra, viene cambiata anche la visibilità di tutte le finestre di cui la finestra è proprietaria. Ad esempio, se nascondete una finestra, vengono nascoste anche tutte le finestre di proprietà.

AIR fornisce diversi metodi per modificare direttamente l'ordine di visualizzazione delle finestre. Potete spostare una finestra in primo piano o sullo sfondo nell'ordine di visualizzazione; potete spostare una finestra sopra o dietro un'altra finestra. Allo stesso tempo, l'utente può riordinare le finestre attivandole.

Potete tenere una finestra in primo piano rispetto alle altre finestre impostando la sua proprietà alwaysInFront su true . Se più finestre hanno questa impostazione, l'ordine di visualizzazione di queste finestre è definito tra loro stesse, ma comunque sempre sopra le finestre la cui proprietà alwaysInFront è impostata su false.

Le finestre nel gruppo in primo piano sono sempre visualizzate sopra le finestre di altre applicazioni, anche quando l'applicazione AIR non è attiva. Poiché questo comportamento può disturbare il lavoro dell'utente, è opportuno impostare alwaysInFront su true solo quando è necessario e appropriato. Esempi di uso giustificato includono:

• Finestre popup temporanee per controlli quali descrizioni comandi, elenchi popup, menu personalizzati o caselle combinate. Poiché queste finestre si devono chiudere quando non sono più attive, è possibile evitare di bloccare la visualizzazione di altre finestre.

• Messaggi di errore e avvisi estremamente urgenti. Se la mancata risposta dell'utente in un tempo utile causa una modifica irrevocabile, potrebbe essere giustificato visualizzare una finestra di avviso in primo piano. Tuttavia, la maggior parte degli errori e avvisi può essere gestito nel normale ordine di visualizzazione delle finestre.

• Finestre stile toast momentanee.

Se una finestra è proprietaria di altre finestre, tali finestre sono sempre ordinate davanti ad essa. Se chiamate orderToFront() o impostate alwaysInFront su true su una finestra proprietaria di altre finestre, le finestre di proprietà vengono riordinate insieme con la finestra proprietaria, ma vengono ancora visualizzate davanti al proprietario.

La chiamata ai metodi di ordinamento finestre su finestre di proprietà funziona normalmente tra finestre di proprietà della stessa finestra, ma può anche modificare l'ordine dell'intero gruppo di finestre di proprietà rispetto alle finestre esterne al gruppo. Ad esempio, se chiamate orderToFront() su una finestra di proprietà, tale finestra, il suo proprietario e qualsiasi altra finestra di proprietà dallo stesso proprietario vengono spostate davanti all'ordine di visualizzazione finestre.

La classe NativeWindow fornisce le proprietà e i metodi seguenti per l'impostazione dell'ordine di visualizzazione di una finestra in relazione alle altre finestre:

Nel sistema operativo Linux, diversi gestori di finestre applicano regole diverse per quanto riguarda l'ordine di visualizzazione delle finestre:

• In alcuni gestori di finestre, le finestre di utilità vengono visualizzate in primo piano rispetto alle finestre normali.

• In alcuni gestori di finestre, una finestra a schermo intero con la proprietà alwaysInFront impostata su true viene sempre visualizzata in primo piano rispetto ad altre finestre la cui proprietà alwaysInFront è impostata su true .

Per chiudere una finestra, potete utilizzare il metodo NativeWindow.close() .

La chiusura di una finestra consente di scaricane il contenuto, ma se altri oggetti contengono riferimenti a questo contenuto, gli oggetti contenuto non vengono distrutti. Il metodo NativeWindow.close() viene eseguito in maniera asincrona, l'applicazione contenuta nella finestra continua a essere eseguita durante il processo di chiusura. Il metodo close invia un evento close quando l'operazione di chiusura è terminata. L'oggetto NativeWindow è ancora tecnicamente valido, ma l'accesso alla maggior parte delle proprietà e dei metodi di una finestra chiusa genera un IllegalOperationError. Non potete riaprire una finestra chiusa. Potete verificare se una finestra è stata chiusa controllando la proprietà closed . Per nascondere una finestra, potete impostare la proprietà NativeWindow.visible su false .

Se la proprietà Nativeapplication.autoExit è true (impostazione predefinita), l'applicazione esce quando viene chiusa l'ultima finestra.

Eventuali finestre di proprietà vengono chiuse quando si chiude il proprietario. Le finestre di proprietà non inviano un evento di chiusura e pertanto non possono impedire la chiusura. Un evento close viene inviato.

Quando una finestra utilizza il chrome di sistema, l'interazione con l'utente può essere annullata intercettando e annullando il comportamento predefinito degli eventi appropriati. Ad esempio, se un utente fa clic sul pulsante di chiusura del chrome di sistema, viene inviato l'evento closing . Se qualsiasi listener registrato chiama il metodo preventDefault() dell'evento, la finestra non si chiude.

Se una finestra non utilizza il chrome di sistema, gli eventi di notifica per le modifiche designate non vengono inviati automaticamente prima che venga apportata la modifica. Pertanto, se si chiamano i metodi per chiudere una finestra, modificare lo stato della finestra o impostare le proprietà dei limiti della finestra, la modifica non può essere annullata. Per inviare notifiche ai componenti dell'applicazione prima di apportare una modifica alla finestra, la logica dell'applicazione può inviare l'evento di notifica relativo utilizzando il metodo dispatchEvent() della finestra.

Ad esempio, la logica seguente implementa un gestore eventi annullabile per un pulsante di chiusura della finestra:

public function onCloseCommand(event:MouseEvent):void{ 
    var closingEvent:Event = new Event(Event.CLOSING,true,true); 
    dispatchEvent(closing); 
    if(!closingEvent.isDefaultPrevented()){ 
        win.close(); 
    } 
} 

Il metodo dispatchEvent() restituisce false se il metodo preventDefault() dell'evento viene chiamato da un listener. Tuttavia, può anche restituire false per altri motivi, pertanto è preferibile utilizzare in modo esplicito il metodo isDefaultPrevented() per verificare se la modifica deve essere annullata.

Per ingrandire la finestra, potete utilizzare il metodo maximize() della classe NativeWindow.

myWindow.maximize(); 

Per ridurre a icona la finestra, potete utilizzare il metodo minimize() della classe NativeWindow.

myWindow.minimize(); 

Per ripristinare la finestra (ovvero, riportarla alle dimensioni che aveva prima di essere ridotta a icona o ingrandita), potete utilizzare il metodo restore() della classe NativeWindow.

myWindow.restore(); 

Una finestra di proprietà viene ridotta a icona e ripristinata quando la finestra a cui è associata viene ridotta a icona o ripristinata. Nessun evento viene inviato dalla finestra di proprietà quando viene ridotta a icona perché il suo proprietario viene ridotto a icona.

Nel sistema operativo Linux, diversi gestori di finestre applicano regole diverse per quanto riguarda l'impostazione dello stato di visualizzazione delle finestre:

• In alcuni gestori di finestre, le finestre di utilità non possono essere ingrandite.

• Se vengono impostate le dimensioni massime per la finestra, alcune finestre non consentono l'ingrandimento. Altri gestori di finestre impostano lo stato di visualizzazione su ingrandita, ma non ridimensionano la finestra. In entrambi i casi, non viene inviato alcun evento di modifica dello stato.

• Alcuni gestori di finestre non rispettano l'impostazione maximizable o minimizable relativa alle finestre.

Nella breve applicazione MXML seguente vengono dimostrati i metodi maximize() , minimize() , restore() e close() della finestra:

<?xml version="1.0" encoding="utf-8"?> 
 
<mx:WindowedApplication  
    xmlns:mx="http://www.adobe.com/2006/mxml"  
    layout="vertical"> 
     
     
    <mx:Script> 
    <![CDATA[ 
    public function minimizeWindow():void 
    { 
        this.stage.nativeWindow.minimize(); 
    } 
 
    public function maximizeWindow():void 
    { 
        this.stage.nativeWindow.maximize(); 
    }           
     
    public function restoreWindow():void 
    { 
        this.stage.nativeWindow.restore(); 
    }           
 
    public function closeWindow():void 
    { 
        this.stage.nativeWindow.close(); 
    } 
    ]]> 
    </mx:Script> 
 
    <mx:VBox> 
        <mx:Button label="Minimize" click="minimizeWindow()"/> 
        <mx:Button label="Restore" click="restoreWindow()"/> 
        <mx:Button label="Maximize" click="maximizeWindow()"/> 
        <mx:Button label="Close" click="closeWindow()"/> 
    </mx:VBox> 
 
</mx:WindowedApplication>

L'esempio ActionScript seguente per Flash crea quattro campi di testo selezionabili che attivano i metodi minimize() , maximize() , restore() e close() della classe NativeWindow:

package 
{ 
    import flash.display.Sprite; 
    import flash.events.MouseEvent; 
    import flash.text.TextField; 
     
    public class MinimizeExample extends Sprite 
    { 
        public function MinimizeExample():void  
        { 
            var minTextBtn:TextField = new TextField(); 
            minTextBtn.x = 10; 
            minTextBtn.y = 10; 
            minTextBtn.text = "Minimize"; 
            minTextBtn.background = true; 
            minTextBtn.border = true; 
            minTextBtn.selectable = false; 
            addChild(minTextBtn); 
            minTextBtn.addEventListener(MouseEvent.CLICK, onMinimize); 
         
            var maxTextBtn:TextField = new TextField(); 
            maxTextBtn.x = 120; 
            maxTextBtn.y = 10; 
            maxTextBtn.text = "Maximize"; 
            maxTextBtn.background = true; 
            maxTextBtn.border = true; 
            maxTextBtn.selectable = false; 
            addChild(maxTextBtn); 
            maxTextBtn.addEventListener(MouseEvent.CLICK, onMaximize); 
         
            var restoreTextBtn:TextField = new TextField(); 
            restoreTextBtn.x = 230; 
            restoreTextBtn.y = 10; 
            restoreTextBtn.text = "Restore"; 
            restoreTextBtn.background = true; 
            restoreTextBtn.border = true; 
            restoreTextBtn.selectable = false; 
            addChild(restoreTextBtn); 
            restoreTextBtn.addEventListener(MouseEvent.CLICK, onRestore); 
             
            var closeTextBtn:TextField = new TextField(); 
            closeTextBtn.x = 340; 
            closeTextBtn.y = 10; 
            closeTextBtn.text = "Close Window"; 
            closeTextBtn.background = true; 
            closeTextBtn.border = true; 
            closeTextBtn.selectable = false; 
            addChild(closeTextBtn); 
            closeTextBtn.addEventListener(MouseEvent.CLICK, onCloseWindow); 
        } 
        function onMinimize(event:MouseEvent):void 
        { 
            this.stage.nativeWindow.minimize(); 
        } 
        function onMaximize(event:MouseEvent):void 
        { 
            this.stage.nativeWindow.maximize(); 
        } 
        function onRestore(event:MouseEvent):void 
        { 
            this.stage.nativeWindow.restore(); 
        } 
        function onCloseWindow(event:MouseEvent):void 
        { 
            this.stage.nativeWindow.close(); 
        } 
    } 
}

Il chrome di sistema di una finestra fornisce i controlli di trascinamento per il ridimensionamento e lo spostamento della finestra sul desktop. Se una finestra non utilizza il chrome di sistema, occorre aggiungere controlli personalizzati per consentire all'utente di ridimensionare e spostare la finestra.

L'esempio seguente mostra come avviare le operazioni di ridimensionamento e spostamento in una finestra:

package 
{ 
    import flash.display.Sprite; 
    import flash.events.MouseEvent; 
    import flash.display.NativeWindowResize; 
 
    public class NativeWindowResizeExample extends Sprite 
    { 
        public function NativeWindowResizeExample():void 
        { 
            // Fills a background area. 
            this.graphics.beginFill(0xFFFFFF); 
            this.graphics.drawRect(0, 0, 400, 300); 
            this.graphics.endFill(); 
     
            // Creates a square area where a mouse down will start the resize. 
            var resizeHandle:Sprite =  
                createSprite(0xCCCCCC, 20, this.width - 20, this.height - 20); 
            resizeHandle.addEventListener(MouseEvent.MOUSE_DOWN, onStartResize); 
     
            // Creates a square area where a mouse down will start the move. 
            var moveHandle:Sprite = createSprite(0xCCCCCC, 20, this.width - 20, 0); 
            moveHandle.addEventListener(MouseEvent.MOUSE_DOWN, onStartMove); 
        } 
     
        public function createSprite(color:int, size:int, x:int, y:int):Sprite 
        { 
            var s:Sprite = new Sprite(); 
            s.graphics.beginFill(color); 
            s.graphics.drawRect(0, 0, size, size); 
            s.graphics.endFill(); 
            s.x = x; 
            s.y = y; 
            this.addChild(s);     
            return s;         
        } 
     
        public function onStartResize(event:MouseEvent):void 
        { 
            this.stage.nativeWindow.startResize(NativeWindowResize.BOTTOM_RIGHT); 
        } 
 
        public function onStartMove(event:MouseEvent):void 
        { 
            this.stage.nativeWindow.startMove(); 
        } 
    } 
}