Zarządzanie oknami

Aby manipulować oknem, należy najpierw pobrać instancję okna. Instancję okna można pobrać z jednego z następujących miejsc:

• Konstruktor rodzimego okna używany do utworzenia okna:

  var win:NativeWindow = new NativeWindow(initOptions);

• Właściwość nativeWindow stołu montażowego okna:

  var win:NativeWindow = stage.nativeWindow;

• Właściwość stage obiektu wyświetlanego w oknie:

  var win:NativeWindow = displayObject.stage.nativeWindow;

• Właściwość target zdarzenia rodzimego okna wywoływanego przez okno:

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

• Właściwość nativeWindow strony HTML wyświetlanej w oknie:

  var win:NativeWindow = htmlLoader.window.nativeWindow;

• Właściwości activeWindow i openedWindows obiektu NativeApplication:

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

  NativeApplication.nativeApplication.activeWindow odwołuje się do aktywnego okna aplikacji (ale zwraca wartość null, jeśli aktywne okno nie jest oknem tej aplikacji AIR). Tablica NativeApplication.nativeApplication.openedWindows zawiera wszystkie okna w aplikacji AIR, które nie zostały zamknięte.

Ponieważ obiekty Application, mx:WindowedApplication i mx:Window środowiska Flex są obiektami wyświetlanymi, programista może w łatwy sposób odwołać się do okna aplikacji w pliku MXML za pomocą właściwości stage, co ilustruje poniższy przykład:

<?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

Aby aktywować okno, należy wywołać metodę activate() NativeWindow. Aktywowanie okna przenosi okno na wierzch i przypisuje mu obszar aktywności dla klawiatury i myszy oraz, jeśli zachodzi taka konieczność, spowoduje, że okno stanie się widoczne, przywracając okno lub ustawiając właściwość visible na wartość true. Aktywowanie okna nie zmienia kolejności pozostałych okien w aplikacji. Wywołanie metody activate() powoduje, że okno wywołuje zdarzenie activate.

Aby wyświetlić ukryte okno, nie aktywując go, należy ustawić właściwość visible na wartość true. Spowoduje to przeniesienie okna na wierzch, ale nie przypisze do niego obszaru aktywności.

Aby ukryć okno, należy ustawić jego właściwość visible na wartość false. Ukrycie okna blokuje wyświetlanie obu elementów: okna oraz powiązanych ikon paska zadań oraz (w systemie Mac OS X) wpisu w menu Okno.

Podczas zmieniania widoczności okna zmienia się również widoczność wszystkich okien, których dane okno jest właścicielem. Na przykład w przypadku ukrycia okna są również ukrywane wszystkie okna, których okno jest właścicielem.

Środowisko AIR dostarcza kilka metod do bezpośredniej zmiany kolejności wyświetlania okien. Programista może przesuwać okno na wierzch lub pod spód kolejności wyświetlania; możliwe jest również przesunięcie przed lub za inne okno. W tym samym czasie użytkownik może ponownie ustawić kolejność okien, aktywując je.

Okno można zachować na wierzchu w stosunku do pozostałych okien, ustawiając jego właściwość alwaysInFront na wartość true. Jeśli więcej niż jedno okno ma to ustawienie, wówczas kolejność wyświetlania dla tych okien jest określana między nimi, ale sortowanie wykonywane jest zawsze nad oknami, dla których we właściwości alwaysInFront ustawiona została wartość false.

Okna w grupie na samym wierzchu wyświetlane są również nad oknami w innych aplikacjach, nawet jeśli aplikacja AIR nie jest aktywna. Ponieważ to zachowanie może zakłócać pracę użytkownika, ustawienie właściwości alwaysInFront na wartość true powinno być używane tylko, jeśli jest konieczne i odpowiednie. Przykłady uzasadnionych zastosowań obejmują:

• Tymczasowe okna podręczne dla elementów sterowania np. podpowiedzi, podręczne listy, niestandardowe menu lub pola kombinowane. Ponieważ okna te powinny zostać zamknięte po utracie aktywności; w ten sposób unikniona zostanie irytacja z powodu blokowania użytkownikowi możliwości wyświetlenia innego okna.

• Niezwykle pilne komunikaty o błędach i alerty. Wypchnięcie okna z alertem na wierzch może być uzasadnione w momencie wystąpienia nieodwołalnej zmiany i konieczności odpowiedzi na nią w odpowiednim czasie. Jednak większość błędów i alertów można obsłużyć w normalnej kolejności wyświetlania.

• Tymczasowe okna o wyglądzie „kanapkowym”.

Jeśli okno posiada inne okna, te okna są zawsze umieszczane przed nim. Wywołanie funkcji orderToFront() lub ustawienie dla właściwości alwaysInFront wartości true dla okna posiadającego inne okna spowoduje umieszczenie posiadanych okien wraz z oknem głównym przed innymi oknami, ale posiadane okna będą nadal wyświetlane przed oknem głównym.

Wywoływanie metod zmiany kolejności okien względem posiadanych okien działa normalnie między oknami posiadanymi przez to samo okno, ale może również doprowadzić do zmiany kolejności całej grupy posiadanych okien względem okien spoza tej grupy. Na przykład po wywołaniu klasy orderToFront() dla posiadanego okna spowoduje, że to okno, jego właściciel oraz wszystkie okna posiadane przez tego samego właściciela zostaną przesunięte do przodu w kolejności wyświetlania.

Klasa NativeWindow dostarcza następujących właściwości i metod do ustawiania kolejności wyświetlania okna względem innych okien:

W systemie operacyjnym Linux różne menedżery okien wymuszają różne zasady w zależności od kolejności wyświetlania okien:

• W niektórych menedżerach okien okna utility są zawsze wyświetlane przed zwykłymi oknami.

• W niektórych menedżerach okien okno w trybie pełnoekranowym z właściwością alwaysInFront ustawioną na wartość true jest zawsze wyświetlane przed innymi oknami, dla których właściwość alwaysInFront jest również ustawiona na wartość true.

Aby zamknąć okno, należy użyć metody NativeWindow.close().

Zamknięcie okna powoduje wyładowanie treści okna, ale jeśli inne obiekty mają odwołania do tej treści, obiekty treści nie zostaną zniszczone. Metoda NativeWindow.close() wykonywana jest asynchronicznie; aplikacja zawarta w oknie kontynuuje działanie podczas procesu zamykania. Metoda close wywołuje zdarzenie close, gdy operacja zamykania zostanie zakończona. Obiekt NativeWindow pozostaje technicznie prawidłowy, ale dostęp do większości właściwości i metod zamkniętego okna generuje błąd IllegalOperationError. Nie można ponownie otworzyć zamkniętego okna. Aby przeprowadzić test, czy okno zostało zamknięte, należy sprawdzić właściwość closed okna. Aby ukryć okno, należy ustawić właściwość NativeWindow.visible na wartość false.

Jeśli właściwość Nativeapplication.autoExit ma wartość true (sytuacja domyślna), wówczas aplikacja zakończy działanie, gdy zamknięte zostanie jej ostatnie okno.

Wszystkie okna posiadane przez inne okna zostają zamknięte w momencie zamknięcia okna głównego. Posiadane okna nie wywołują zdarzenia closing, dlatego nie można zapobiec ich zamknięciu. Zostaje wywołane zdarzenie close.

Jeśli okno korzysta z karnacji systemowej, interakcja użytkownika z oknem może zostać anulowana przez wykrywanie i anulowanie domyślnego zachowania odpowiednich zdarzeń. Na przykład: jeśli użytkownik kliknie przycisk zamykania karnacji systemowej, wywołane zostanie zdarzenie closing. Jeśli dowolny zarejestrowany detektor wywoła metodę preventDefault() zdarzenia, wówczas okno nie zostanie zamknięte.

Jeśli okno nie korzysta z karnacji systemowej, zdarzenia powiadomień dla zamierzonych zmian nie są automatycznie wywoływane przed dokonaniem zmiany. W skutek tego, jeśli wywołane zostaną metody w celu zamknięcia okna, zmiany jego stanu lub ustawienia dowolnej właściwości obwiedni, zmiany nie można anulować. Aby powiadomić składniki w aplikacji przed zmianą okna, logika aplikacji może wywołać stosowane zdarzenie powiadomienia za pomocą metody dispatchEvent() okna.

Na przykład: poniższa logika implementuje moduł obsługi zdarzenia cancelable dla przycisku zamykania okna:

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

Metoda dispatchEvent() zwraca wartość false, jeśli metoda preventDefault() zdarzenia wywoływana jest przez detektor. Możne jednak zwrócić również wartość false z innych powodów, dlatego lepszym rozwiązaniem jest jawne użycie metody isDefaultPrevented() w celu przetestowania, czy zmianę należy anulować.

Aby zmaksymalizować okno, należy użyć metody maximize() klasy NativeWindow.

myWindow.maximize(); 

Aby zminimalizować okno, należy użyć metody minimize() klasy NativeWindow.

myWindow.minimize(); 

Aby przywrócić okno (tj. powrócić do rozmiaru przed minimalizacją lub maksymalizacją), należy użyć metody restore() klasy NativeWindow.

myWindow.restore(); 

Okno, które ma właściciela, jest minimalizowane i przywracane, gdy jest minimalizowane i przywracane okno główne. Podczas minimalizowania posiadane okno nie wywołuje żadnych zdarzeń, ponieważ to okno główne jest minimalizowane.

W systemie operacyjnym Linux różne menedżery okien wymuszają różne zasady w zależności od ustawienia stanu wyświetlania okien:

• W niektórych menedżerach okien okna utility nie mogą być maksymalizowane.

• Jeśli dla okna zostanie ustawiony maksymalny rozmiar, wówczas niektóre okna nie zezwalają na maksymalizację. Niektóre inne menedżery okien ustawiają stan wyświetlania na zmaksymalizowany, ale nie zmieniają rozmiaru okna. W żadnym z tych przypadków nie jest wywoływane zdarzenie zmiany stanu wyświetlania.

• Niektóre menedżery okien nie uznają ustawień maximizable ani minimizable okna.

Poniższa krótka aplikacja MXML przedstawia metody maximize(), minimize(), restore() i close() klasy Window:

<?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>

Poniższy przykład kodu ActionScript dla treści Flash tworzy cztery pola tekstowe, które można kliknąć i które wywołują metody minimize(), maximize(), restore() i close() klasy 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(); 
        } 
    } 
}

Jeśli okno korzysta z karnacji systemowej, karnacja dostarcza elementów sterowania przeciąganiem do zmiany rozmiaru okna i przesuwania po pulpicie. Jeśli okno nie korzysta z karnacji systemowej, należy dodać własne elementy sterowania, aby zezwolić użytkownikowi na zmianę rozmiaru i przesuwanie okna.

Poniższy przykład przedstawia sposób, w jaki inicjowane są operacje zmiany rozmiaru i przesuwania dla okna:

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