Hantera fönster

Om du ska kunna ändra ett fönster måste du först hämta fönsterinstansen. Du kan hämta en fönsterinstans från någon av följande platser:

• Den konstruktor för inbyggda fönster som användes för att skapa fönstret:

  var win:NativeWindow = new NativeWindow(initOptions);

• nativeWindow -egenskapen för fönsterscenen:

  var win:NativeWindow = stage.nativeWindow;

• stage -egenskapen för ett visningsobjekt i fönstret:

  var win:NativeWindow = displayObject.stage.nativeWindow;

• target -egenskapen för en händelse för inbyggda fönster som skickas av fönstret:

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

• nativeWindow -egenskapen för en HTML-sida som visas i fönstret:

  var win:NativeWindow = htmlLoader.window.nativeWindow;

• activeWindow - och openedWindows -egenskaperna för NativeApplication-objektet:

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

  NativeApplication.nativeApplication.activeWindow refererar till det aktiva fönstret för ett program (men returnerar null om det aktiva fönstret inte är ett fönster för det här AIR-programmet). NativeApplication.nativeApplication.openedWindows -arrayen innehåller alla fönster i ett AIR-program som inte har stängts.

Eftersom Flex-objekten mx:WindowedApplication och mx:Window är visningsobjekt kan du enkelt referera till programfönstret i en MXML-fil med hjälp av egenskapen stage , enligt följande:

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

Du aktiverar ett fönster genom att anropa NativeWindow-metoden activate() . När ett fönster aktiveras placeras det överst, kommer i fokus för tangentbordet och musen och, om det behövs, görs synligt genom att det återställs eller genom att egenskapen visible anges till true . Ordningen för övriga fönster i programmet ändras inte när ett fönster aktiveras. När metoden activate() anropas skickar fönstret en activate -händelse.

Om du vill visa ett dolt fönster utan att aktivera det anger du egenskapen visible till true . Detta placerar fönstret överst, men tilldelar inte fönstret fokus.

Om du vill dölja ett fönster anger du egenskapen visible för fönstret till false . När ett fönster döljs inaktiveras visningen av såväl fönstret som eventuella ikoner i Aktivitetsfältet och, i Mac OS X, menyalternativet på Fönster-menyn.

När du ändrar synligheten för ett fönster ändras även synligheten för fönster som ägs av det fönstret. Om du till exempel döljer ett fönster, döljs även alla fönster som ägs av det fönstret.

AIR innehåller flera metoder för att ändra visningsordningen för fönster direkt. Du kan placera ett fönster överst eller underst i visningsordningen och du kan placera ett fönster framför eller bakom ett annat fönster. Samtidigt kan användaren ändra ordningen för fönstren genom att aktivera dem.

Du kan behålla ett fönster framför andra fönster genom att ange egenskapen alwaysInFront för det till true . Om fler än ett fönster har den här inställningen sorteras de fönstren efter den inbördes visningsordningen, men de hamnar alltid framför fönster som har egenskapen alwaysInFront angiven till false.

Fönster i den översta gruppen visas också framför fönster i andra program, även om AIR-programmet inte är aktivt. Eftersom detta kan vara störande för användaren bör alwaysInFront endast anges till true när detta är nödvändigt och lämpligt. Det kan till exempel vara befogat i följande fall:

• För tillfälliga popup-fönster för kontroller som knappbeskrivningar, popup-listor, anpassade menyer eller kombinationsrutor. Eftersom de här fönstren stängs när de förlorar fokus undviks irritationsmomentet att en användare inte kan visa ett annat fönster.

• För extremt angelägna felmeddelanden och varningar. När en oåterkallelig ändring kan utföras om användaren inte agerar i tid kan det vara befogat att placera ett varningsfönster längst fram. De flesta fel och varningar kan emellertid hanteras i den normala fönstervisningsordningen.

• Enkla meddelandefönster med kort varaktighet.

Om ett fönster äger andra fönster ordnas de ägda fönstren alltid framför det. Om du anropar orderToFront() eller anger alwaysInFront som true för ett fönster som äger andra fönster, så ordnas de ägda fönstren om tillsammans med det ägande fönstret framför andra fönster, men de ägda fönstren visas fortfarande framför det ägande huvudfönstret.

Att anropa fönsterordningsmetoder för ägda fönster fungerar normalt bland fönster som ägs av samma huvudfönster, men det kan även ändra ordningen för hela gruppen med ägda fönster i förhållande till fönster utanför gruppen. Om du till exempel anropar orderToFront() för ett ägt fönster flyttas både det fönstret, dess ägare och alla andra fönster som ägs av samma ägare längst fram i fönstervisningsordningen.

Klassen NativeWindow innehåller följande egenskaper och metoder för att ange visningsordningen för ett fönster i förhållande till andra fönster:

I Linux-operativsystemet tillämpar olika fönsterhanterare olika regler för fönstrens visningsordning:

• I vissa fönsterhanterare visas verktygsfönster alltid framför vanliga fönster.

• I vissa fönsterhanterare visas helskärmsfönster som har en alwaysInFront -egenskap med värdet true alltid framför andra fönster som också har alwaysInFront angivet till true .

Om du vill stänga ett fönster använder du metoden NativeWindow.close() .

När ett fönster stängs tas innehållet bort från fönstret, men om andra objekt har referenser till innehållet förstörs inte innehållsobjekten. Metoden NativeWindow.close() körs asynkront och det program fönstret innehåller fortsätter att köras under stängningsprocessen. Metoden close() skickar en close-händelse när åtgärden har slutförts. NativeWindow-objektet är i princip fortfarande giltigt, men för de flesta egenskaper och metoder för ett stängt fönster genereras felet IllegalOperationError vid försök till åtkomst. Du kan inte öppna ett stängt fönster på nytt. Kontrollera egenskapen closed för ett fönster om du vill testa huruvida fönstret har stängts. Om du bara vill dölja ett fönster anger du egenskapen NativeWindow.visible till false .

Om egenskapen Nativeapplication.autoExit har värdet true , vilket är standardinställningen, avslutas programmet när dess sista fönster stängs.

Alla fönster som har en ägare stängs när ägarfönstret stängs. De ägda fönstren skickar inga closing-händelser och kan därför inte förhindra stängningen. En close-händelse skickas.

När ett fönster använder systemfönsterstandard kan användaråtgärder i fönstret avbrytas genom att lämpliga händelser avlyssnas och deras standardfunktioner förhindras. När en användare exempelvis klickar på stängningsknappen för systemfönsterstandarden, skickas händelsen closing . Om en registrerad lyssnare anropar metoden preventDefault() för händelsen stängs inte fönstret.

När ett fönster inte använder systemfönsterstandard skickas inte automatiskt meddelandehändelser gällande förestående ändringar innan ändringarna utförs. Om du anropar metoderna för att stänga ett fönster, ändrar fönsterstatus eller anger någon av egenskaperna för fönstergränserna går det därför inte att avbryta ändringen. Om du vill skicka meddelanden till komponenter i programmet innan en fönsterändring utförs, kan programlogiken skicka den relevanta meddelandehändelsen med hjälp av metoden dispatchEvent() för fönstret.

Exempelvis implementerar följande logik en händelsehanterare som kan avbrytas för en stängningsknapp i ett fönster:

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

Metoden dispatchEvent() returnerar false om metoden preventDefault() för händelsen anropas av en lyssnare. Den kan emellertid också returnera false av andra orsaker, så det är bättre att uttryckligen använda metoden isDefaultPrevented() för att testa huruvida ändringen ska avbrytas.

Om du vill maximera fönstret använder du NativeWindow-metoden maximize() .

myWindow.maximize(); 

Om du vill minimera fönstret använder du NativeWindow-metoden minimize() .

myWindow.minimize(); 

Om du vill återställa fönstret (det vill säga ändra tillbaka till den storlek fönstret hade innan det minimerades eller maximerades) använder du NativeWindow-metoden restore() .

myWindow.restore(); 

Ett fönster som har en ägare minimeras och återställs när det ägande fönstret minimeras och återställs. Inga händelser skickas av det ägda fönstret när det minimeras på grund av att ägaren minimeras.

I Linux-operativsystemet tillämpar olika fönsterhanterare olika regler för fönstrens visningsläge:

• I vissa fönsterhanterare går det inte att maximera verktygsfönster.

• Om en största storlek har angetts för fönstret går det inte att maximera vissa fönster. I andra fönsterhanterare är fönstren maximerade, och det går inte att ändra storlek på dem. Ingen händelse för ändrat visningsläge skickas i något av dessa fall.

• En del fönsterhanterare respekterar inte fönsterinställningarna maximizable och minimizable .

Med följande korta MXML-program demonstreras Window-metoderna maximize() , minimize() , restore() och close() :

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

I följande ActionScript-exempel för Flash skapas fyra klickbara textfält som utlöser NativeWindow-metoderna minimize() , maximize() , restore() och close() :

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

När ett fönster använder systemfönsterstandard tillhandahåller systemfönsterstandarden kontroller för att ändra storlek på fönstret och flytta runt det på skrivbordet. Om ett fönster inte använder systemfönsterstandard måste du lägga till egna kontroller för att användaren ska kunna ändra storlek på och flytta fönstret.

Följande exempel visar hur du initierar storleksändrings- och flyttåtgärder i ett fönster:

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