Vensters beheren

Als u een venster wilt bewerken, moet u eerst een instantie van het venster opvragen. U kunt een vensterinstantie opvragen uit een van de volgende locaties:

• De native vensterconstructor die wordt gebruikt om het venster te maken:

  var win:NativeWindow = new NativeWindow(initOptions);

• De eigenschap nativeWindow van het werkgebied van het venster:

  var win:NativeWindow = stage.nativeWindow;

• De eigenschap stage van een weergaveobject in het venster:

  var win:NativeWindow = displayObject.stage.nativeWindow;

• De eigenschap target van een native venstergebeurtenis die wordt verzonden door het venster:

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

• De eigenschap nativeWindow van een HTML-pagina die wordt weergegeven in het venster:

  var win:NativeWindow = htmlLoader.window.nativeWindow;

• De eigenschappen activeWindow en openedWindows van het NativeApplication-object:

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

  NativeApplication.nativeApplication.activeWindow verwijst naar het actieve venster van een toepassing (maar retourneert de waarde null als het actieve venster geen venster van deze AIR-toepassing is). De array NativeApplication.nativeApplication.openedWindows bevat alle vensters in een AIR-toepassing die niet zijn gesloten.

Omdat de Flex-objecten mx:WindowedApplication en mx:Window weergaveobjecten zijn, kunt u gemakkelijk naar het toepassingsvenster in een MXML-bestand verwijzen met de eigenschap stage . U doet dit als volgt:

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

Als u een venster wilt activeren, roept u de NativeWindow-methode activate() op. Als het venster wordt geactiveerd, wordt het venster op de voorgrond weergegeven, krijgt het de focus voor toetsenbord- en muisbewerkingen en wordt het, indien nodig, zichtbaar gemaakt. U maakt het venster zichtbaar door het vorige formaat van het venster te herstellen of de eigenschap visible op true in te stellen. Als een venster wordt geactiveerd, wordt de volgorde van andere vensters in de toepassing niet gewijzigd. Het aanroepen van de methode activate() leidt ertoe dat het venster de gebeurtenis activate verzendt.

Als u een verborgen venster wilt weergeven zonder het te activeren, stelt u de eigenschap visible in op true . Hiermee wordt het venster op de voorgrond geplaatst, maar wordt de focus niet aan het venster toegewezen.

Als u een venster wilt verbergen, stelt u de eigenschap visible van dat venster in op false . Door een venster te verbergen, wordt de weergave onderdrukt van zowel het venster als de betreffende taakbalkpictogrammen, en - in Mac OS X - ook de toegang tot het Windows-menu.

Wanneer u de zichtbaarheid van een venster wijzigt, wordt de zichtbaarheid van alle vensters waarvan het venster de eigenaar is ook gewijzigd. Als u bijvoorbeeld een venster verbergt, worden alle vensters waarvan het de eigenaar is ook verborgen.

AIR biedt verschillende methoden voor het rechtstreeks wijzigen van de weergavevolgorde van vensters. U kunt een venster vooraan of achteraan in de weergavevolgorde plaatsen en u kunt een venster boven of onder een ander venster plaatsen. Tegelijkertijd kan de gebruiker de volgorde van vensters wijzigen door deze te activeren.

U kunt zorgen dat een venster steeds vóór de andere vensters wordt weergegeven door de eigenschap alwaysInFront in te stellen op true . Als deze instelling is geconfigureerd voor meer dan één venster, bepalen de vensters onderling de weergavevolgorde, maar deze vensters worden wel altijd weergegeven vóór de vensters waarvoor de eigenschap alwaysInFront is ingesteld op false.

Vensters in de bovenste groep worden ook weergegeven boven op vensters in andere toepassingen, zelfs wanneer de AIR-toepassing niet actief is. Omdat dit gedrag storend kan zijn voor een gebruiker, moet u de eigenschap alwaysInFront alleen op true instellen als dat echt nodig en terecht is. Hier volgen enkele voorbeelden van gerechtvaardigd gebruik van deze instelling:

• Tijdelijke pop-upvensters voor besturingen zoals scherminfo, pop-uplijsten, aangepaste menu's of keuzelijsten. Omdat deze vensters gewoonlijk worden gesloten als ze de focus verliezen, wordt voorkomen dat ze de gebruiker het zicht op een ander venster benemen.

• Uiterst urgente foutberichten en waarschuwingen mogen deze instelling hebben. Wanneer er een onomkeerbare wijziging wordt aangebracht als de gebruiker niet tijdig reageert, kan het gerechtvaardigd zijn om een waarschuwingsvenster boven op alle andere vensters weer te geven. De meeste foutberichten en waarschuwingen kunnen echter worden verwerkt in de normale weergavevolgorde van vensters.

• Kortstondig weergegeven, eenvoudige en rechthoekige (toast-stijl) informatievensters mogen deze instelling hebben.

Als een venster eigenaar is van andere vensters, worden die vensters altijd vóór het eigenaarvenster geplaatst. Als u orderToFront() aanroept of alwaysInFront instelt op true voor een venster dat eigenaar is van andere vensters, worden deze vensters samen met het eigenaarvenster vóór andere vensters gerangschikt, maar worden de eigendomvensters nog steeds vóór de eigenaar weergegeven.

Het aanroepen van methodes voor het rangschikken van vensters voor eigendomvensters werkt op de gebruikelijke wijze voor vensters die eigendom zijn van hetzelfde venster, maar kan ook de volgorde van de volledige groep met eigendomvensters wijzigen in vergelijking met vensters buiten die groep. Als u bijvoorbeeld orderToFront() aanroept voor een eigendomvenster, worden dat venster, de eigenaar en alle andere vensters van dezelfde eigenaar vooraan in de vensterrangschikking geplaatst.

De klasse NativeWindow biedt de volgende eigenschappen en methoden voor het instellen van de plaats van een venster ten opzichte van andere vensters in de weergavevolgorde:

Bij het Linux-besturingssysteem dwingen verschillende vensterbeheerprogramma's verschillende regels af met betrekking tot de weergavevolgorde van vensters:

• Bij bepaalde vensterbeheerprogramma's worden hulpprogrammavensters altijd weergegeven vóór normale vensters.

• Bij bepaalde vensterbeheerprogramma's wordt een venster dat op het volledige scherm wordt weergegeven en waarvan alwaysInFront is ingesteld op true , altijd weergegeven vóór andere vensters waarvoor alwaysInFront ook is ingesteld op true .

Als u een venster wilt sluiten, gebruikt u de methode NativeWindow.close() .

Als u een venster sluit, wordt de inhoud uit het venster verwijderd, maar als andere objecten verwijzingen naar deze inhoud bevatten, worden de inhoudsobjecten niet vernietigd. De methode NativeWindow.close() wordt asynchroon uitgevoerd. Dit betekent dat de toepassing die zich in het venster bevindt, actief blijft tijdens het sluiten van het venster. De methode close verzendt de gebeurtenis close wanneer het sluiten van het venster is voltooid. Het NativeWindow-object functioneert technisch gezien nog steeds, maar als u toegang probeert te krijgen tot eigenschappen en methoden van een gesloten venster, wordt er in de meeste gevallen een IllegalOperationError gegenereerd. U kunt een gesloten venster niet opnieuw openen. Controleer de eigenschap closed van een venster om na te gaan of een venster is gesloten. Als u een venster gewoon wilt verbergen, stelt u de eigenschap NativeWindow.visible in op false .

Als de eigenschap Nativeapplication.autoExit op true is ingesteld (dit is de standaardinstelling), wordt de toepassing afgesloten op het moment dat het laatste venster wordt gesloten.

Alle vensters met een eigenaar worden gesloten wanneer de eigenaar wordt gesloten. De eigendomvensters verzenden geen sluitgebeurtenis en kunnen het sluiten dus niet voorkomen. Er wordt een sluitgebeurtenis verzonden.

Wanneer voor een venster het systeemchroom wordt gebruikt, kunt u de interactie van de gebruiker met het venster annuleren door te luisteren naar de juiste gebeurtenissen en hiervan het standaardgedrag te annuleren. Wanneer een gebruiker bijvoorbeeld op het sluitvak van het systeemchroom klikt, wordt de gebeurtenis closing verzonden. Als een geregistreerde listener de methode preventDefault() van de gebeurtenis aanroept, wordt het venster niet gesloten.

Wanneer voor een venster niet het systeemchroom wordt gebruikt, worden er ook niet automatisch meldingsgebeurtenissen voor aanstaande wijzigingen verzonden voordat de wijziging wordt aangebracht. Als u daarom de methoden voor het sluiten van een venster aanroept, waarbij de status van het venster wordt gewijzigd, of als u een van de eigenschappen van venstergrenzen instelt, kan de wijziging niet worden geannuleerd. Als u componenten in uw toepassing wilt waarschuwen voordat er een wijziging in een venster wordt aangebracht, kan de logica van uw toepassing de relevante meldingsgebeurtenis verzenden met de methode dispatchEvent() van het venster.

Met de volgende logica implementeert u bijvoorbeeld een annuleerbare gebeurtenishandler voor het sluitvak van een venster:

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

De methode dispatchEvent() retourneert de waarde false als de methode preventDefault() van de gebeurtenis door een listener wordt aangeroepen. Aangezien de methode echter ook om andere redenen de waarde false kan retourneren, is het beter om expliciet de methode isDefaultPrevented() te gebruiken om te controleren of de wijziging moet worden geannuleerd.

Als u het venster wilt maximaliseren, gebruikt u de methode maximize() van NativeWindow.

myWindow.maximize(); 

Als u het venster wilt minimaliseren, gebruikt u de methode minimize() van NativeWindow.

myWindow.minimize(); 

Als u het vorige formaat van het venster wilt herstellen (dat wil zeggen het formaat van het venster voordat het werd geminimaliseerd of gemaximaliseerd), gebruikt u de methode restore() van NativeWindow.

myWindow.restore(); 

Een venster met een eigenaar wordt verkleind tot pictogram en hersteld wanneer het eigenaarvenster wordt verkleind tot pictogram of hersteld. Er worden geen gebeurtenissen verzonden door het eigendomvenster als dit tot pictogram wordt verkleind, aangezien de eigenaar ook tot pictogram is verkleind.

Bij het Linux-besturingssysteem dwingen verschillende vensterbeheerprogramma's verschillende regels af met betrekking tot de weergavestatus van vensters:

• Bij bepaalde vensterbeheerprogramma's kunnen vensters van hulpprogramma's niet worden gemaximaliseerd.

• Als een maximumgrootte is ingesteld voor het venster, kunnen in sommige gevallen vensters niet worden gemaximaliseerd. Bepaalde andere vensterbeheerprogramma's stellen de weergavestatus in op gemaximaliseerd, maar wijzigen het formaat van het venster niet. In beide gevallen wordt er geen gebeurtenis betreffende de verandering van de weergavestatus verzonden.

• Bepaalde vensterbeheerprogramma's negeren de vensterinstellingen maximizable of minimizable .

De volgende kleine MXML-toepassing laat zien hoe de methoden maximize() , minimize() , restore() en close() van Window werken:

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

Met het volgende ActionScript-voorbeeld voor Flash worden vier tekstvelden gemaakt waarop kan worden geklikt en waarmee de methoden minimize() , maximize() , restore() en close() van NativeWindow kunnen worden geactiveerd:

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

Wanneer voor een venster het systeemchroom wordt gebruikt, biedt de interface sleepbesturingselementen waarmee u het vensterformaat kunt wijzigen en het venster op het bureaublad kunt verplaatsen. Als voor een venster niet het systeemchroom wordt gebruikt, moet u uw eigen besturingselementen toevoegen om het vensterformaat te wijzigen en het venster te verplaatsen.

In het volgende voorbeeld ziet u hoe u bewerkingen zoals het wijzigen van het formaat of het verplaatsen, kunt starten voor een venster:

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