Um ein Fenster bearbeiten zu können, müssen Sie zuerst die Window-Instanz abrufen. Eine Window-Instanz können Sie von einem der folgenden Orte abrufen:

• Der native Fensterkonstruktor, der zum Erstellen des Fensters verwendet wird:

  var win:NativeWindow = new NativeWindow(initOptions);

• Die nativeWindow-Eigenschaft der Fensterbühne:

  var win:NativeWindow = stage.nativeWindow;

• Die stage-Eigenschaft eines Anzeigeobjekts im Fenster:

  var win:NativeWindow = displayObject.stage.nativeWindow;

• Die target-Eigenschaft eines nativen Fensterereignisses, das vom Fenster ausgelöst wird:

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

• Die nativeWindow-Eigenschaft einer HTML-Seite, die im Fenster angezeigt wird:

  var win:NativeWindow = htmlLoader.window.nativeWindow;

• Die activeWindow- und openedWindows-Eigenschaften des NativeApplication-Objekt:

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

  NativeApplication.nativeApplication.activeWindow verweist auf das aktive Fenster einer Anwendung (gibt jedoch null zurück, wenn es sich bei dem aktiven Fenster nicht um ein Fenster dieser AIR-Anwendung handelt). Das NativeApplication.nativeApplication.openedWindows-Array enthält alle Fenster in einer AIR-Anwendung, die nicht geschlossen wurden.

Sie aktivieren ein Fenster, indem Sie die activate()-Methode von NativeWindow aufrufen. Durch das Aktivieren wird das Fenster in den Vordergrund gestellt, es erhält den Tastatur- und Mausfokus und wird, bei Bedarf, sichtbar gemacht, indem das Fenster wiederhergestellt oder die visible-Eigenschaft auf true eingestellt wird. Durch das Aktivieren eines Fensters wird die Reihenfolge der anderen Fenster in der Anwendung nicht verändert. Durch das Aufrufen der activate()-Methode wird das Fenster veranlasst, ein activate-Ereignis auszulösen.

Um ein Fenster einzublenden. ohne es zu aktivieren, stellen Sie seine visible-Eigenschaft auf true ein. Dadurch wird das Fenster in den Vordergrund gestellt, erhält aber nicht den Fokus.

Um ein Fenster auszublenden, stellen Sie seine visible-Eigenschaft auf false ein. Durch das Ausblenden des Fensters wird die Anzeige des Fensters und dazugehöriger Taskleisten-Symbole, sowie, unter Mac OS X, der Eintrag im Windows-Menü unterdrückt.

AIR bietet mehrere Methoden, mit denen die Anzeigereihenfolge der Fernster direkt geändert werden kann. Sie können ein Fenster an den Anfang oder das Ende der Anzeigereihenfolge verschieben, und Sie können ein Fenster vor oder hinter ein anderes Fenster verschieben. Außerdem können Sie die Anzeigereihenfolge von Fenstern ändern, indem Sie sie aktivieren.

Sie können dafür sorgen, dass ein Fenster immer vor anderen Fenstern angezeigt wird, indem Sie seine alwaysInFront-Eigenschaft auf true einstellen. Wenn mehrere Fenster diese Einstellung aufweisen, wird eine Anzeigereihenfolge unter diesen Fenstern erstellt, sie werden aber immer vor Fenstern angezeigt, deren alwaysInFront-Eigenschaft auf „false“ eingestellt ist. Fenster in der obersten Gruppe werden außerdem vor Fenstern in anderen Anwendungen angezeigt, selbst wenn die AIR-Anwendung nicht aktiv ist. Da sich dieses Verhalten störend auf den Benutzer auswirken kann, sollte alwaysInFront nur auf true eingestellt werden, wenn es erforderlich und angemessen ist. Beispiele:

• Temporäre Popupfenster für Steuereinheiten, wie etwa QuickInfos, Popuplisten, benutzerdefinierte Menüs oder Kombinationsfelder. Da diese Fenster geschlossen werden, wenn sie den Fokus verlieren, wird Benutzern nicht die Sicht auf andere Fenster genommen und sie fühlen sich nicht gestört.

• Sehr dringende Fehlermeldungen und Warnungen. Wenn eine unwiderrufliche Änderung auftreten kann, falls der Benutzer nicht rechtzeitig reagiert, kann es gerechtfertigt sein, eine Warnmeldung im Vordergrund einzublenden. Die meisten Fehlermeldungen und Warnungen können jedoch in der normalen Anzeigereihenfolge der Fenster verarbeitet werden.

• Kurzfristige überlappende Fenster

Die NativeWindow-Klasse bietet die folgenden Eigenschaften und Methoden, mit denen die Anzeigereihenfolge eines Fensters relativ zu anderen Fenstern festgelegt werden kann:

Unter dem Linux-Betriebssystem erzwingen verschiedene Fenstermanager unterschiedliche Regeln bezüglich der Anzeigereihenfolge der Fenster:

• Bei einigen Fenstermanagern werden Dienstprogrammfenster vor normalen Fenstern angezeigt.

• Bei bestimmten Fenstermanagern wird ein Vollbildfenster, dessen alwaysInFront-Eigenschaft auf true eingestellt ist, immer vor anderen Fenstern angezeigt, bei denen alwaysInFront ebenfalls auf true eingestellt ist.

Sie können ein Fenster mithilfe der NativeWindow.close()-Methode schließen.

Beim Schließen eines Fensters werden die Inhalte des Fenster entfernt, wenn jedoch andere Objekte auf diesen Inhalt verweisen, werden die Inhaltsobjekte nicht gelöscht. Die NativeWindow.close()-Methode wird asynchron ausgeführt, und die im Fenster enthaltene Anwendung wird während des Schließvorgangs ausgeführt. Die close-Methode löst ein close-Ereignis aus, wenn der Schließvorgang abgeschlossen ist. Das NativeWindow-Objekt ist im Prinzip noch gültig, aber der Zugriff auf die meisten Eigenschaften und Methoden eines geschlossenen Fensters erzeugt einen IllegalOperationError. Ein geschlossenes Fenster kann nicht erneut geöffnet werden. Überprüfen Sie die closed-Eigenschaft eines Fensters, um zu prüfen, ob das Fenster geschlossen wurde. Um ein Fenster einfach nur auszublenden, stellen Sie seine NativeWindow.visible-Eigenschaft auf false ein.

Ist die Nativeapplication.autoExit-Eigenschaft auf true eingestellt (die Standardeinstellung ), wird die Anwendung mit dem Schließen ihres letzten Fensters beendet.

Wurde einem Fenster das System-Fensterdesign zugewiesen, können Benutzerinteraktionen mit dem Fenster abgebrochen werden, indem auf Standardverhalten der entsprechenden Ereignisse gewartet wird, um sie anschließend abzubrechen. Wenn beispielsweise ein Benutzer auf die Schaltfläche „Schließen“ des System-Fensterdesigns klickt, wird das closing-Ereignis ausgelöst. Wird die preventDefault()-Methode des Ereignisses durch einen registrierten Listener aufgerufen, wird das Fenster nicht geschlossen.

Wenn einem Fenster nicht das System-Fensterdesign zugewiesen wurde, werden Benachrichtigungsereignisse für beabsichtigte Änderungen nicht automatisch vor der Änderung ausgelöst. Das bedeutet, wenn die Methoden zum Schließen eines Fensters oder Ändern des Fensterzustands aufgerufen werden, oder eine der bound-Eigenschaften des Fensters einstellt wird, kann die Änderung nicht abgebrochen werden. Die Anwendungslogik kann das relevante Benachrichtigungsereignis mithilfe der dispatchEvent()-Methode des Fensters auslösen, um Komponenten in Ihrer Anwendung auf bevorstehende Fensteränderungen hinzuweisen.

Im folgenden Beispiel wird eine abbrechbare Ereignisprozedur für die Schaltfläche „Schließen“ eines Fensters implementiert:

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

Die dispatchEvent()-Methode gibt false zurück, wenn die preventDefault()-Ereignismethode durch einen Listener aufgerufen wird. Da sie jedoch auch aus anderen Gründen false zurückgeben kann, empfiehlt es sich, mithilfe der isDefaultPrevented()-Methode ausdrücklich zu prüfen, ob die Änderungen abgebrochen werden sollen.

Sie können ein Fenster mithilfe der maximize()-Methode der NativeWindow-Klasse maximieren.

myWindow.maximize(); 

Sie können ein Fenster mithilfe der minimize()-Methode der NativeWindow-Klasse minimieren.

myWindow.minimize(); 

Mithilfe der restore()-Methode der NativeWindow-Klasse können Sie ein Fenster wiederherstellen, d. h. die Größe auf den Wert vor dem Minimieren oder Maximieren zurücksetzen.

myWindow.restore(); 

Unter dem Linux-Betriebssystem erzwingen verschiedene Fenstermanager unterschiedliche Regeln bezüglich der Einstellung des Anzeigestatus der Fenster:

• Unter einigen Fenstermanagern können Dienstprogrammfenster nicht maximiert werden.

• Wenn für ein Fenster eine maximale Größe festgelegt wurde, lassen einige Fenstermanager die Maximierung des Fensters nicht zu. Andere Fenstermanager maximieren den Anzeigestatus, ändern aber nicht die Größe des Fensters. In beiden Fällen wird kein Ereignis für die Anzeigestatusänderung ausgelöst.

• Einige Fenstermanager berücksichtigen die maximizable- oder minimizable-Einstellungen des Fensters nicht.

Im folgenden ActionScript-Beispiel für Flash werden vier klickbare Textfelder erstellt, mit denen die minimize()-, maximize()-, restore()- und close()-Methoden der NativeWindow-Klasse ausgelöst werden:

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

Wurde einem Fenster das System-Fensterdesign zugewiesen, stehen dadurch Haltegriffe zur Verfügung, um durch Ziehen die Größe des Fensters zu skalieren und um es auf dem Desktop zu verschieben. Wenn einem Fenster nicht das System-Fensterdesign zugewiesen wurde, müssen Sie selbst dem Fenster Steuerelemente hinzufügen, um dem Benutzer das Skalieren und Verschieben des Fensters zu ermöglichen.

Im folgenden Beispiel wird gezeigt, wie Skalierungs- und Verschiebungsvorgänge an einem Fenster eingeleitet werden:

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