NativeWindow  - AS3

Anger om detta fönster är det aktiva programfönstret.

Använd activate()-metoden för att göra ett fönster aktivt.

Relaterade API-element

Anger om fönstret alltid kommer att ligga framför andra fönster (inklusive dem från andra program).

De finns två fönstergrupper i systemets djupordning. Fönster i alwaysInFront-gruppen visas alltid framför andra fönster. Djupordningen mellan fönster inom samma grupp avgörs på normalt sätt. Att aktivera ett fönster innebär alltså att lägga det framför andra fönster i dess grupp.

Att ändra alwaysInFront från false till true lägger fönstret framför alla andra fönster. Att ändra egenskapen från true till false lägger fönstret bakom alwaysInFront-fönster men fortfarande framför andra fönster. Att ställa in egenskapen till dess aktuella värde ändrar inte fönstrens djupordning. Att ställa in egenskapen alwaysInFront för ett fönster som har en ägare gör ingen skillnad.

alwaysInFront ska sällan anges till true eftersom fönster med denna inställning kommer att visas framför fönster i andra program även när det andra programmet är aktivt.

Information för olika operativsystem:

• Vissa Linux-fönsterhanterare visar inte fönster som har egenskapen alwaysInFront inställd på framför helskärmsfönster.
• Att ställa in alwaysInFront till true i Mac^® OS X får ingen effekt när egenskapen displayState i fönsterscenen är fullScreen eller fullScreenInteractive.

windowObj.alwaysInFront = true;

displayObject.stage.nativeWindow.alwaysInFront=true;

window.nativeWindow.alwaysInFront = true;

Fönstrets storlek och plats.

Fönsterdimensionerna innehåller systemfärgen. Dimensionerna på fönsterscenen är lika med fönsterdimensionerna, minus storlek på eventuell systemfärg. Om du ändrar bredd och höjd på fönstret ändrar du scenens stageWidth och stageHeight. Det motsatta gäller också. Om du ändrar scendimensionerna ändras fönsterstorleken.

I ett rot-HTML-fönster är egenskaperna outerWidth och outerHeigth lika med fönstrets height- och width-egenskaper. Egenskaperna innerWidth och innerHeight är lika med egenskaperna stage.stageWidth och stage.stageHeight minus tjockleken på eventuella automatiska rullningslister som visas i fönstret.

En resize resize-händelse skickas när bredd eller höjd på fönstret ändras. På samma sätt skickas en move-händelse när ursprunget (x,y) på fönstret ändras. Om egenskapen bounds ställs in direkt i Mac OS eller Windows skickas inte en moving- eller resizing-händelse. I Linux skickar NativeWindow moving- och resizing-händelser när du anger egenskapen bounds.

Inställningen av ett fönsters bounds-egenskap motsvarar inställningen av dess x, y, width och height-egenskaper. På samma sätt är en inställning av de enskilda dimensionerna likvärdigt med att ställa in bounds-egenskapen. När du ställer in alla dimensionerna på samma gång med bounds-egenskapen skickas färre händelser.

Den ordning som de enskilda dimensionerna ställs in i garanteras inte. I Linux-fönsterhanterare där det inte tillåts att fönster utvidgas utanför skrivbordsområdet, kan en ändring av en enskild egenskap förhindras även om nettoeffekten av att använda alla egenskapsändringar skulle leda till ett giltigt fönster.

Om den angivna bredden eller höjden är mindre än den minsta eller större än den högsta tillåtna bredden eller höjden, ställs fönstrets bredd eller höjd in på närmaste tillåtna storlek. Följande faktorer avgör minsta och största bredd och höjd:

• Egenskaperna minSize och maxSize för NativeWindow-objektet
• Operativsystemets minsta och högsta gränser som är värden i NativeWindow.systemMinSize och NativeWindow.systemMaxSize.
• Den maximala bredden och höjden på ett fönster i Adobe AIR, som båda är 4 095 pixlar. (I AIR 1.5 och tidigare versioner var den maximala bredden och höjden på ett fönster 2 880 pixlar.)
• Den minsta bredden och höjden som krävs av en systemfärg som visas.

Pixelvärden avrundas till närmaste heltal när positionen eller storleken på ett fönster ändras.

Relaterade API-element

windowObj.bounds = new Rectangle(200, 200, 1000, 800);

displayObject.stage.nativeWindow.bounds = new Rectangle(20, 20, 800, 600);

window.nativeWindow.bounds = new air.Rectangle(20, 20, 800, 600);

Indikerar om fönstret har stängts.

Eventuella försök att komma åt följande egenskaper för ett stängt fönster kommer att returnera ett ogiltighetsfel:

• title
• bounds
• x, y, width och height
• displayState
• visible

Eventuella försök att anropa följande metoder i ett stängt fönster kommer på samma sätt också att returnera ett ogiltighetsfel:

• minimize()
• maximize()
• restore()
• startResize()
• startMove()

var isWindowClosed:Boolean = windowObj.closed;

var isWindowClosed:Boolean = displayObject.stage.nativeWindow.closed;

var isWindowClosed = window.nativeWindow.closed;

Fönstrets visningsläge.

Konstanter för möjliga värden definieras i klassen NativeWindowDisplayState.

• NativeWindowDisplayState.NORMAL
• NativeWindowDisplayState.MINIMIZED
• NativeWindowDisplayState.MAXIMIZED

Relaterade API-element

var state:String = windowObj.displayState;

Fönstrets höjd i pixlar.

Fönsterdimensionerna inkluderar eventuell systemfärg som visas. Höjden på den användbara visningsytan inuti ett fönster finns tillgänglig i egenskapen Stage.stageHeight.

Att ändra height-egenskapen hos ett fönster motsvarar att ändra höjden med bounds-egenskapen.

Om den angivna höjden är mindre än den minsta eller större än den högsta tillåtna höjden, ställs fönstrets höjd in på närmaste tillåtna storlek. Följande faktorer avgör minsta och största höjd:

• Egenskaperna minSize.x och maxSize.x för NativeWindow-objektet
• Operativsystemets minsta och högsta gränser som är värden i NativeWindow.systemMinSize.x och NativeWindow.systemMaxSize.x.
• Den maximala höjden på ett fönster i Adobe AIR, som är 4 095 pixlar (2 880 pixlar i AIR 1.5 och tidigare versioner).

I Linux är inställning av egenskapen height en asynkron åtgärd.

Avlyssna resize-händelsen, som skickas på alla plattformar, om du vill känna av när höjdändringen har slutförts.

Pixelvärden avrundas till närmaste heltal när höjden på ett fönster ändras.

Relaterade API-element

Anger om inbyggda fönster stöds på klientsystemet.

Rapporterar den maximizable-inställning som används för att skapa det här fönstret.

maximizable-inställningen kan inte ändras efter att fönstret har skapats.

Obs! Vissa Linux-fönsterhanterare tillåter att fönster maximeras av användaren trots att egenskapen maximizable är inställd på false.

Relaterade API-element

Maximistorleken för det här fönstret.

Storleksbegränsningen anges som koordinaterna i ett Point-objekt. Punkt x-egenskapen motsvarar fönstrets bredd och y-egenskapen fönstrets höjd.

maxSize-begränsningen påtvingas för storleksändringsåtgärder för fönster som anropas både via ActionScript-kod och via operativsystemet.

Att ställa in maxSize ändrar fönstrets begränsningar om de nuvarande begränsningarna är större än den nya maximistorleken.

Om den angivna bredden eller höjden är större än den högsta tillåtna bredden eller höjden, ställs fönstrets bredd in på närmaste tillåtna storlek. Följande faktorer avgör minsta och största bredd och höjd:

• Operativsystemets maximala gräns som är värdet NativeWindow.systemMaxSize.
• Den maximala bredden och höjden på ett fönster i Adobe AIR, som båda är 4 095 pixlar. (I AIR 1.5 och tidigare versioner var den maximala bredden och höjden på ett fönster 2 880 pixlar.)

Obs! När du maximerar ett fönster i vissa operativsystem, till exempel Mac OS X, förstoras fönstret bara till värdet maxSize även om det maximerade fönstret blir mindre än operativsystemskärmen. Fönstret kommer ändå att vara i visningsläget maximized.

Relaterade API-element

windowObj.maxSize = new Point(1040,920);

displayObject.stage.nativeWindow.maxSize = new Point(800,600);

window.nativeWindow.maxSize = new air.Point(960,960);

Den inbyggda menyn för det här fönstret.

Om ett NativeWindow-objekt tilldelas fönstrets menu-egenskap kommer en inbyggd meny att visas för ett fönster om NativeWindow.supportsMenu är true, om inte fönstrets systemChrome-egenskap är NativeWindowSystemChrome.NONE.

Obs! Att tilldela en meny till ett fönster när NativeWindow.supportsMenu är false eller när fönstrets systemChrome-egenskap är NativeWindowSystemChrome.NONE är tillåtet men utför ingenting. Kom ihåg att använda egenskapen NativeWindow.supportsMenu för att avgöra om operativsystemet har stöd för fönstermenyer. Om du använder andra metoder (till exempel Capabilities.os) för att fastställa om stöd finns kan det ge upphov till programmeringsfel (om inte alla möjliga operativsystem beaktas).

Relaterade API-element

Rapporterar den minimizable-inställning som används för att skapa det här fönstret.

minimizable-inställningen kan inte ändras efter att fönstret har skapats.

Obs! Vissa Linux-fönsterhanterare tillåter att fönster minimeras av användaren trots att egenskapen minimizable är inställd på false.

Relaterade API-element

Minimistorleken för det här fönstret.

Storleksbegränsningen anges som koordinaterna i ett Point-objekt. Punkt x-egenskapen motsvarar fönstrets bredd och y-egenskapen fönstrets höjd.

Att ställa in minSize ändrar fönstrets begränsningar om de nuvarande begränsningarna är mindre än den nya minimistorleken.

minSize-begränsningen påtvingas för storleksändringsåtgärder för fönster som anropas både via ActionScript-kod och via operativsystemet.

Obs!Bredden och höjden på eventuell visad systemfärg kan också göra det omöjligt att göra ett fönster så litet som den angivna minimistorleken.

Relaterade API-element

windowObj.minSize = new Point(200,80);

displayObject.stage.nativeWindow.minSize = new Point(120,60);

window.nativeWindow.minSize = new air.Point(80,60);

Det NativeWindow-objekt som äger det här fönstret.

Fönsterägarskap fastställs när ett fönster skapas och kan inte ändras. Om du vill skapa ett fönster som har en ägare anger du det ägande NativeWindow-objektet som owner-egenskap för det NativeWindowInitOptions-objekt som används för att skapa det ägda fönstret.

Obs! På Linux visar vissa fönsterhanterare inte ägda fönster framför det ägande fönstret när ägaren visas i helskärmsläge.

Relaterade API-element

Rapporterar fönstrets renderMode-inställning som används för att skapa detta fönster.

Det värde som returneras av NativeWindow.renderMode kommer att vara en av de konstanter som definieras i klassen NativeWindowRenderMode.

renderMode-inställningen kan inte ändras sedan ett fönster har skapats.

Relaterade API-element

Rapporterar den resizable-inställning som används för att skapa det här fönstret.

resizable-inställningen kan inte ändras efter att fönstret har skapats.

Relaterade API-element

Stage-objektet för det här fönstret. Stage-objektet är rotobjektet i den visningslistearkitektur som används i ActionScript 3.0-baserat SWF-innehåll.

Scenen är roten till fönstrets visningslista. Lägg till visuella visningsobjekt till ett fönster genom att lägga till dem till en scen eller till ett annat objekt som redan finns i denna scens visningslista. Scendimensionerna är fönstrets klientområde när fönstret använder systemfärgen. Scendimensionerna är lika med fönstrets dimensioner om systemfärgen inte används.

Relaterade API-element

import flash.display.StageAlign;

windowObj.stage.align = StageAlign.TOP_LEFT;

Indikerar huruvida AIR stöder inbyggda fönster på det aktuella datorsystemet.

När NativeWindow.supportsMenu är true kommer en inbyggd meny att visas för ett fönster när ett NativeMenu-objekt tilldelas fönstrets menu-egenskap, om inte fönstrets systemChrome-egenskap är NativeWindowSystemChrome.NONE. Kom ihåg att använda egenskapen NativeWindow.supportsMenu för att avgöra om operativsystemet har stöd för inbyggda fönstermenyer. Om du använder andra metoder (till exempel Capabilities.os) för att fastställa om stöd finns kan det ge upphov till programmeringsfel (om inte alla möjliga operativsystem beaktas).

Obs! Att tilldela en meny till ett fönster när NativeWindow.supportsMenu är false eller när fönstrets systemChrome-egenskap är NativeWindowSystemChrome.NONE är tillåtet men utför ingenting.

Relaterade API-element

Indikerar huruvida AIR stöder meddelandereferenser till fönster på det aktuella datorsystemet.

Om NativeWindow.supportsNotification är true kommer ett anrop till fönstrets notifyUser()-metod att resultera i en visuell referens till användaren om att något av intresse har inträffat. Den visuella referensen kommer att stämma överens med operativsystemkonventionen i det underliggande systemet. I Windows^® kommer till exempel ikonen i aktivitetsfältet att blinka.

Obs! Att anropa notifyUser() när NativeWindow.supportsNotification är false är tillåtet men utför ingenting.

Relaterade API-element

Anger om AIR stöder inbyggda fönster med genomskinliga pixlar.

Om NativeWindow.supportsTransparency är true, kommer genomskinliga pixlar i inbyggda fönster att respekteras om fönstrets transparent-egenskap är inställd på true. Om NativeWindow.supportsTransparency är false sätts ogenomskinlighet för alla pixlar till 1, oavsett värdet på fönstrets transparent-egenskap. Om NativeWindow.supportsTransparency är false återges genomskinliga pixlar som svarta. Kom ihåg att använda egenskapen NativeWindow.supportsTransparency för att avgöra om operativsystemet har stöd för genomskinlighet. Om du använder andra metoder (till exempel Capabilities.os) för att fastställa om stöd finns kan det ge upphov till programmeringsfel (om inte alla möjliga operativsystem beaktas).

Obs! Värdet på den här egenskapen kan ändras när ett program körs, beroende på användarens inställningar i operativsystemet.

Relaterade API-element

Rapporterar systemfärgsinställningarna som används för att skapa detta fönster.

De värden som returneras av NativeWindow.systemChrome kommer att vara en av de konstanter som definieras i klassen NativeWindowSystemChrome.

Systemfärgsinställningen kan inte ändras efter att fönstret har skapats.

Relaterade API-element

var sysChromeType:String = windowObj.systemChrome;

var sysChromeType:String = displayObject.stage.nativeWindow.systemChrome;

var sysChromeType = window.nativeWindow.systemChrome;

import flash.display.NativeWindow;
import flash.display.NativeWindowSystemChrome;
import flash.display.NativeWindowInitOptions;

public function deChromeWindow(oldWindow:NativeWindow):NativeWindow{
    if(oldWindow.systemChrome != NativeWindowSystemChrome.NONE){
        var newOptions:NativeWindowInitOptions = new NativeWindowInitOptions();
        newOptions.systemChrome = NativeWindowSystemChrome.NONE;
        newOptions.transparent = true;
        
        var newWindow:NativeWindow = new NativeWindow(newOptions);
        newWindow.stage.stageWidth = oldWindow.stage.stageWidth;
        newWindow.stage.stageHeight = oldWindow.stage.stageHeight;
        newWindow.stage.align = oldWindow.stage.align;
        newWindow.stage.scaleMode = oldWindow.stage.scaleMode;
        
        for(var i:int = 0; i < oldWindow.stage.numChildren; i++){
            newWindow.stage.addChild(oldWindow.stage.getChildAt(i));
        }
        newWindow.activate();
        oldWindow.close();
        
        return newWindow;
    }
    return oldWindow;
}

Den största fönsterstorlek som operativsystemet tillåter.

Storleksbegränsningen anges som koordinaterna i ett Point-objekt. Punkt x-egenskapen motsvarar fönstrets bredd och y-egenskapen fönstrets höjd.

Utöver operativsystemets storleksgräns har AIR en maximal fönsterstorlek på 4 095 gånger 4 095 pixlar (2 880 ggr 2 880 pixlar i AIR 1.5 och tidigare versioner). Och ett program kan ställa in en gräns med NativeWindow-objektets egenskap maxSize.

Den minsta fönsterstorlek som operativsystemet tillåter.

Storleksbegränsningen anges som koordinaterna i ett Point-objekt. Punkt x-egenskapen motsvarar fönstrets bredd och y-egenskapen fönstrets höjd.

Fönstertitel.

Titeln visas i fönstrets systemfärg, om den visas, såväl som i andra systemberoende platser (till exempel aktivitetsfältet).

windowObj.title = "Window Title";

Rapporterar genomskinlighetsinställningarna som används för att skapa detta fönster.

Egenskapen transparent kan inte ändras efter att fönstret har skapats. Genomskinlighet påverkar både fönstrets visuella utseende och musbeteendet. I Windows och Mac OS X fångar inte fönstret mushändelserna när alfavärdet för pixeln ligger under ett visst tröskelvärde, som varierar mellan 0,06 och 0,01 beroende på operativsystem. I Linux fångar fönstret mushändelser över fullständigt genomskinliga områden och därför kan användarna inte få tillgång till andra fönster och objekt på skrivbordet.

Obs! Fönstergenomskinlighet stöds inte alltid. Om användarens operativsystemkonfiguration är sådan att genomskinlighet inte är tillgänglig, skapas fönstret utan genomskinlighet. Områden som skulle ha varit genomskinliga är sammansatta mot svart. Använd egenskapen NativeWindow.supportsTransparency om du vill ta reda på om fönstergenomskinlighet stöds.

Relaterade API-element

Rapporterar fönstrets type-inställningar som används för att skapa detta fönster.

De värden som returneras av NativeWindow.type kommer att vara en av de konstanter som definieras i klassen NativeWindowType.

type-inställningen kan inte ändras efter att fönstret har skapats.

Relaterade API-element

Anger om fönstret är synligt.

Ett osynligt fönster visas inte på skrivbordet, men alla fönsteregenskaper och -metoder är giltiga.

visible är som standard false. Om du vill visa ett fönster anger du visible till true eller anropar NativeWindow.activate().

Om fönstret har en ägare, kommer det synliga läget på det ägande fönstret att bestämma om fönstret kommer att visas. Om det ägande fönstret inte visas, kommer inte något ägt fönster att visas, även om egenskapen visible är true.

Obs! Att ställa in visible=false i Mac OS X på ett minimerat fönster gör inte att fönsterikonen tas bort från Dock. Om en användare sedan klickar på ikonen i Dock kommer fönstret att återgå till synligt läge och visas på skrivbordet.

Relaterade API-element

windowObj.visible = true;

displayObj.stage.nativeWindow.visible = true;

window.nativeWindow.visible = true;

Fönstrets bredd i pixlar.

Dimensionerna som har rapporterats för ett inbyggt fönster inkluderar eventuell systemfärg som visas. Bredden på den användbara visningsytan inuti ett fönster finns tillgänglig i egenskapen Stage.stageWidth.

Att ändra width-egenskapen hos ett fönster motsvarar att ändra bredden med bounds-egenskapen.

Om den angivna bredden är mindre än den minsta eller större än den högsta tillåtna bredden, ställs fönstrets bredd in på närmaste tillåtna storlek. Följande faktorer avgör minsta och största bredd:

• Egenskaperna minSize.y och maxSize.y för NativeWindow-objektet
• Operativsystemets minsta och högsta gränser som är värden i NativeWindow.systemMinSize.y och NativeWindow.systemMaxSize.y.
• Den maximala bredden på ett fönster i Adobe AIR, som är 4 095 pixlar (2 880 pixlar i AIR 1.5 och tidigare versioner).

I Linux är inställning av egenskapen width en asynkron åtgärd.

Avlyssna resize-händelsen, som skickas på alla plattformar, om du vill känna av när breddändringen har slutförts.

Pixelvärden avrundas till närmaste heltal när bredden på ett fönster ändras.

Relaterade API-element

Den vågräta axelns koordinat för det här fönstrets övre vänstra hörn i förhållande till ursprungspunkten på operativsystemets skrivbord.

På system med mer än en skärm kan x vara negativ. Om du sparar värdet för att eventuellt återplacera ett fönster på dess tidigare plats bör du alltid kontrollera att fönstrets placering är användbar innan placeringen återställs. Ändringar av skärmupplösning eller bildskärmsinställningar kan leda till att ett fönster placeras utanför skärmen. Använd klassen Screen för att få information om skrivbordets geometri.

Att ändra x-egenskapen hos ett fönster motsvarar att ändra placeringen med bounds-egenskapen.

I Linux är inställning av egenskapen x en asynkron åtgärd.

Avlyssna move-händelsen, som skickas på alla plattformar, om du vill känna av när positionsändringen har slutförts.

Pixelvärden avrundas till närmaste heltal när x-koordinaten för ett fönster ändras.

Relaterade API-element

Den lodräta axelns koordinat för detta fönsters övre vänstra hörn i förhållande till det övre vänstra hörnet på operativsystemets skrivbord.

På system med mer än en skärm kan y vara negativ. Om du sparar värdet för att eventuellt återplacera ett fönster på dess tidigare plats bör du alltid kontrollera att fönstrets placering är användbar innan placeringen återställs. Ändringar av skärmupplösning eller bildskärmsinställningar kan leda till att ett fönster placeras utanför skärmen. Använd klassen Screen för att få information om skrivbordets geometri.

Att ändra y-egenskapen hos ett fönster motsvarar att ändra placeringen med bounds-egenskapen.

I Linux är inställning av egenskapen y en asynkron åtgärd.

Avlyssna move-händelsen, som skickas på alla plattformar, om du vill känna av när positionsändringen har slutförts.

Pixelvärden avrundas till närmaste heltal när y-koordinaten för ett fönster ändras.

Relaterade API-element

Skapar en ny NativeWindow-instans och ett korresponderande operativsystemsfönster.

De inställningar som definieras med parametern initOptions kan inte ändras efter att fönstret skapas. Vid en ogiltig initOptions-inställning returneras ett ogiltig åtgärd-fel. Inställningar som är giltiga men inte tillgängliga i det aktuella systemet returnerar inte. Fönsterfunktioner som är specifika för det aktuella operativsystemet kan kännas av, om så önskas, med hjälp av statiska NativeWindow-medlemmar som systemMaxSize.

Standardstorleken på fönster avgörs av operativsystemet, och fönster skapas i ett osynligt läge. Om du vill förhindra att fönsterändringar syns ska du inte ändra egenskapen visible för fönstret till true eller anropa activate() förrän fönsterändringarna är klara.

Relaterade API-element

import flash.display.NativeWindowInitOptions;
import flash.display.NativeWindowSystemChrome;
import flash.display.NativeWindowType;
import flash.display.NativeWindow;
import flash.display.StageAlign;
import flash.display.StageScaleMode;
import flash.geom.Rectangle;

var windowOptions:NativeWindowInitOptions = new NativeWindowInitOptions();
windowOptions.systemChrome = NativeWindowSystemChrome.STANDARD;
windowOptions.type = NativeWindowType.NORMAL;

var newWindow:NativeWindow = new NativeWindow(windowOptions);
newWindow.stage.scaleMode = StageScaleMode.NO_SCALE;
newWindow.stage.align = StageAlign.TOP_LEFT;
newWindow.bounds = new Rectangle(100, 100, 800, 800);

newWindow.activate();

Aktiverar fönstret.

Att aktivera fönstret kommer att:

• Göra fönstret osynligt
• Lägga fönstret längst fram
• Ge fokus till tangentbord och mus

I Linux är activate() en asynkron åtgärd.

NativeWindow-objektet skickar en activate-händelse på alla plattformar.

Relaterade API-element

displayObject.stage.nativeWindow.activate();

windowObj.activate();

window.nativeWindow.activate();

Stänger fönstret.

En close-händelse skickas så snart close-åtgärden har slutförts. Ingen closing-händelse kommer att skickas. Om avbrott av close-åtgärden ska tillåtas, ska en closing-händelse skickas. Kontrollera om några registrerade avlyssnare avbryter standardbeteendet innan close()-metoden anropas.

När ett fönster stängs, stängs även alla eventuella tillhörande fönster. De tillhörande fönstren skickar inga closing-händelser.

Om visningsobjektsinstanser som för närvarande finns i fönstret inte refereras av något annat kommer de att skräpsamlas och tas bort. Detta gäller inte det ursprungliga programfönstret som skapades av AIR. Om du vill tillåta att visningsobjekt på det ursprungliga fönstret skräpsamlas, tar du bort dem från fönsterscenen.

Efter stängning är NativeWindow-objektet fortfarande en giltig referens, men ett försök att komma åt någon av egenskaperna och metoderna kommer att returnera felet ”Ogiltig åtgärd”.

Det går inte att öppna stängda fönster på nytt. Om fönstret redan är stängt vidtas ingen åtgärd och inga händelser skickas.

Obs! Om du vill dölja ett fönster utan att stänga det anger du fönstrets visible-egenskap till false.

Relaterade API-element

windowObj.close();

displayObj.stage.nativeWindow.close();

window.close(); //overriddable in HTMLHost

window.nativeWindow.close(); //not overriddable

public function closeCommand():Boolean{
    var closeEvent:Event = new Event(Event.CLOSING,true,true);
    windowObj.dispatchEvent(closeEvent);
    if(!closeEvent.isDefaultPrevented()){
        windowObj.close();
        return true;
    } else {
      return false;
    }
}

<script src="AIRAliases.js" type="text/javascript"></script>
<script type="text/javascript">
    var dirtyData = false;
    function closeWindow(){
            var closingEvent = new air.Event(air.Event.CLOSING,true,true);
            window.nativeWindow.dispatchEvent(closingEvent);
               if(!closingEvent.isDefaultPrevented()){
                   window.nativeWindow.close();
                //or use: window.close(); 
               return true;
           } else {
               return false;
        }
    }
        
    function onClosing(event){
        if(dirtyData){
            event.preventDefault();
            //Save data...
        }
    }    

    window.nativeWindow.addEventListener(air.Event.CLOSING,onClosing);        
</script>

Konverterar en punkt i pixelkoordinater i förhållande till fönsterscenens ursprung (en global punkt i visningslistan), till en punkt på det virtuella skrivbordet.

Koordinater för virtuella skrivbord anges i förhållande till det övre vänstra hörnet på den primära skärmen.

Parametrar

Relaterade API-element

Returnerar en lista över de NativeWindow-objekt som ägs av det här fönstret.

Du kan inte ändra ägarskap för NativeWindows genom att lägga till eller ta bort objekt från den returnerade vektorn. Fönsterägarskap kan inte ändras sedan ett fönster har skapats.

Relaterade API-element

Maximerar det här fönstret.

Anrop till minimize()-metoden skickar en displayStateChange-händelse och, om tillämpligt, en move- och en resize-händelse. Systemets fönsterstandard skickar en displayStateChanging-händelse som kan avbrytas om användaren initierar ett maximize-kommando. Därmed måste maximize-logiken utföra detta beteende om så önskas.

Metoden maximize() körs asynkront. Avlyssna displayStateChange-händelsen om du vill känna av när tillståndsändringen har slutförts. Om fönstret redan är maximerat vidtas ingen åtgärd och inga händelser skickas.

Information för olika operativsystem:

• På operativsystem som Mac OS X, där maximering av ett fönster inte förhindrar även en storleksändring, kommer ett maximize()-anrop att zooma fönstret till full storlek. Detta kommer dock inte att förhindra efterföljande storleksändring av fönstret. Att storleksändra ett zoomat fönster kommer också att återställa visningsläget.
• I vissa operativsystem, till exempel Mac OS X, samt i vissa Linux-fönsterhanterare, utvidgas inte fönstret när det maximeras till att bli större än den bredd och höjd som anges i egenskapen maxSize. I andra operativsystem utvidgas fönstret till att fylla skärmen även om skärmen är större än maxSize.
• I vissa Linux-fönsterhanterare går det inte att maximera verktygsfönster.

Relaterade API-element

public function maximizeWindow(nativeWin:NativeWindow):Boolean{
  if(nativeWin.displayState != NativeWindowDisplayState.MAXIMIZED){
    var beforeState:String = nativeWin.displayState;
    var afterState:String = NativeWindowDisplayState.MAXIMIZED;
    var displayStateEvent:NativeWindowDisplayStateEvent = 
        new NativeWindowDisplayStateEvent(NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                              true,true,beforeState,afterState);
    nativeWin.dispatchEvent(displayStateEvent);
    if(!displayStateEvent.isDefaultPrevented()){
        nativeWin.maximize();
        return true;
    } else {
      return false;
    }
  }
  return false;
}

function maximizeWindow(nativeWin){
    if(nativeWin.displayState != air.NativeWindowDisplayState.MAXIMIZED){
        var beforeState = nativeWin.displayState;
        var afterState = air.NativeWindowDisplayState.MAXIMIZED;
        var displayStateEvent = 
            new air.NativeWindowDisplayStateEvent(air.NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                              true,true,beforeState,afterState);
        nativeWin.dispatchEvent(displayStateEvent);
        if(!displayStateEvent.isDefaultPrevented()){
            nativeWin.maximize();
            return true;
        } else {
          return false;
        }
     }
     return false;
}

Minimerar det här fönstret.

Att anropa minimize() skickar en displayStateChange-händelse och, om tillämpligt, en move- eller resize-händelse. Systemfärgen skickar en displayStateChanging-händelse som kan avbrytas när ett minimize-kommando initieras av användaren. Om däremot minimize() anropas direkt sker inte detta. Din minimeringslogik kan implementera detta beteende om så önskas.

Metoden minimize() körs asynkront. Avlyssna displayStateChange-händelsen, som skickas på alla plattformar, om du vill känna av när tillståndsändringen har slutförts. Om fönstret redan är minimerat vidtas ingen åtgärd och inga händelser skickas.

Alla eventuella fönster som tillhör det här fönstret döljs när det minimeras. Det tillhörande fönstret skickar ingen displayStateChanging- eller displayStateChange-händelse.

Obs!

• Om du minimerar ett osynligt fönster (visible == false) i Windows blir fönstret synligt.
• I vissa Linux-fönsterhanterare går det inte att minimera verktygsfönster.

Relaterade API-element

public function minimizeWindow(nativeWin:NativeWindow):Boolean{
    if(nativeWin.displayState != NativeWindowDisplayState.MINIMIZED){
        var beforeState:String = nativeWin.displayState;
        var afterState:String = NativeWindowDisplayState.MINIMIZED;
        var displayStateEvent:NativeWindowDisplayStateEvent = 
            new NativeWindowDisplayStateEvent(NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                              true,true,beforeState,afterState);
        nativeWin.dispatchEvent(displayStateEvent);
        if(!displayStateEvent.isDefaultPrevented()){
            nativeWin.minimize();
            return true;
        } else {
          return false;
        }
     }
     return false;
}

 
function minimizeWindow(){
    if(window.nativeWindow.displayState != air.NativeWindowDisplayState.MINIMIZED){
        var beforeState = window.nativeWindow.displayState;
        var afterState = air.NativeWindowDisplayState.MINIMIZED;
        var displayStateEvent = 
            new air.NativeWindowDisplayStateEvent(air.NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                              true,true,beforeState,afterState);
        window.nativeWindow.dispatchEvent(displayStateEvent);
        if(!displayStateEvent.isDefaultPrevented()){
            window.nativeWindow.minimize();
            return true;
        } else {
          return false;
        }
     }
     return false;
}

Utlöser en visuell referens via operativsystemet om att en händelse av intresse har inträffat.

När NativeWindow.supportsNotification är true kommer den visuella referensen att stämma överens med operativsystemkonventionen i det underliggande systemet. I Windows kommer till exempel ikonen i aktivitetsfältet att blinka.

Parametern type avgör referensens intensitet. Konstanter för tillåtna värden definieras i NotificationType-klassen och kan vara:

• NotificationType.INFORMATIONAL
• NotificationType.CRITICAL

Referenserna som finns för informationsmeddelanden har kort varaktighet. Referenser för viktiga meddelanden visas tills användaren aktiverar detta fönster. Alla Linux-fönsterhanterare stöder inte två nivåer av meddelanden. För sådana fönster har notifyUser() samma effekt oavsett vilket alternativ som anges.

Obs! Att anropa notifyUser() när NativeWindow.supportsNotification är false är tillåtet men utför ingenting.

Parametrar

Lägger detta fönster direkt bakom det angivna fönstret.

Aktiverar eller hämtar inte fokus för detta fönster eller program. Minimerade eller dolda (visible är false) fönster kan inte ordnas om.

Ett tillhörande fönster kan aldrig flyttas bakom det ägande fönstret. Om fönstret har en ägare ordnas ägaren och andra tillhörande fönster också bakom målet. Om målfönstret har en ägare ordnas det här fönstret bakom ägaren till målet i stället.

I vissa Linux-fönsterhanterare går det inte att placera verktygsfönster bakom normala fönster.

Parametrar

windowBehind.orderInBackOf(windowFront);

displayObjBehind.stage.nativeWindow.orderInBackOf(displayObjectFront.stage.nativeWindow);

jsWindowObjBehind.nativeWindow.orderInBackOf(jsWindowObjFront.nativeWindow);

Lägger det här fönstret direkt framför det angivna fönstret.

Aktiverar eller hämtar inte fokus för detta fönster eller program. Minimerade eller dolda (visible är false) fönster kan inte ordnas om.

Ett fönster kan aldrig flyttas framför ett fönster som det äger. Om fönstret har en ägare ordnas ägaren och andra tillhörande fönster också framför målet. Om målfönstret har en ägare ordnas även det här fönstret framför eventuella andra fönster som har samma ägare som målet.

I vissa Linux-fönsterhanterare går det inte att placera normala fönster framför verktygsfönster.

Parametrar

windowFront.orderInFrontOf(windowBehind);

displayObjFront.stage.nativeWindow.orderInFrontOf(displayObjectBehind.stage.nativeWindow);

jsWindowObjFront.nativeWindow.orderInFrontOf(jsWindowObjBehind.nativeWindow);

Lägger detta fönster bakom alla andra synliga fönster.

Aktiverar eller hämtar inte fokus för detta fönster eller program. Minimerade eller dolda (visible är false) fönster kan inte ordnas om.

Om alwaysInFront är true kommer ett anrop till denna metod inte att lägga det här fönstret bakom andra fönster som har alwaysInFront inställt på false.

Ett tillhörande fönster kan aldrig flyttas bakom det ägande fönstret. Om fönstret har en ägare ordnas ägaren och andra tillhörande fönster också nederst i fönstervisningslistan. Det här fönstret flyttas bakom eventuella andra fönster som ägs av samma fönster. Om det här fönstret äger andra fönster flyttas även de bakåt, och deras inbördes ordning till varandra bevaras.

I vissa Linux-fönsterhanterare går det inte att placera verktygsfönster bakom normala fönster.

windowObj.orderToBack();

displayObj.stage.nativeWindow.orderToBack();

window.nativeWindow.orderToBack();

Lägger det här fönstret framför alla andra synliga fönster.

Aktiverar eller hämtar inte fokus för detta fönster eller program. Minimerade eller dolda (visible är false) fönster kan inte ordnas om.

Om alwaysInFront är false kommer ett anrop till denna metod inte att lägga det här fönstret framför andra fönster som har alwaysInFront inställt på true.

Ett fönster kan aldrig flyttas framför ett fönster som det äger. Om det här fönstret äger andra fönster flyttas även de framåt, och deras inbördes ordning till varandra bevaras. Om fönstret har en ägare ordnas ägaren och andra tillhörande fönster också längst fram i fönstervisningslistan. Det här fönstret flyttas framför andra fönster som har samma ägare.

I vissa Linux-fönsterhanterare går det inte att placera normala fönster framför verktygsfönster.

windowObj.orderToFront();

displayObj.stage.nativeWindow.orderToFront();

window.nativeWindow.orderToFront();

Återställer detta fönster från antingen ett minimerat eller maximerat läge.

Att anropa restore() skickar en displayStateChange-händelse och, om tillämpligt, en move- eller resize-händelse. Systemets fönsterstandard skickar en displayStateChanging-händelse som kan avbrytas när ett restore-kommando initieras av användaren. Din restore-logik måste därför implementera detta beteende, om så önskas.

Om fönstret redan är i läget NativeWindowDisplayState.NORMAL vidtas ingen åtgärd och inga händelser skickas.

Avlyssna displayStateChange-händelsen, som skickas på alla plattformar, om du vill känna av när tillståndsändringen har slutförts.

Relaterade API-element

public function restoreWindow(nativeWin:NativeWindow):Boolean{
    if(nativeWin.displayState != NativeWindowDisplayState.NORMAL){
        var beforeState:String = nativeWin.displayState;
        var afterState:String = NativeWindowDisplayState.NORMAL;
        var displayStateChangingEvent:NativeWindowDisplayStateEvent = 
            new NativeWindowDisplayStateEvent(NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                              true,true,beforeState,afterState);
        nativeWin.dispatchEvent(displayStateChangingEvent);
        if(!displayStateChangingEvent.isDefaultPrevented()){
            nativeWin.restore();
            return true;
        } else {
          return false;
        }
     }
     return false;
}

function restoreWindow(nativeWin){
    if(window.nativeWindow.displayState != air.NativeWindowDisplayState.NORMAL){
        var beforeState = window.nativeWindow.displayState;
        var afterState = air.NativeWindowDisplayState.NORMAL;
        var displayStateEvent = 
            new air.NativeWindowDisplayStateEvent(air.NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                              true,true,beforeState,afterState);
        window.nativeWindow.dispatchEvent(displayStateEvent);
        if(!displayStateEvent.isDefaultPrevented()){
            window.nativeWindow.restore();
            return true;
        } else {
          return false;
        }
     }
     return false;
}

Startar en systemstyrd flyttning av detta fönster.

Vid anrop från en mouseDown-händelse påbörjar den här metoden en musdriven flyttsekvens som fortsätter tills en mouseUp-händelse inträffar.

Vid anrop från annan kod påbörjar denna metod en tangentbords- eller musdriven flyttsekvens som är konsekvent med operativsystemets standardsekvens.

Under en flyttsekvens skickas en serie händelser då fönsterplaceringen flyttas. För varje inkrementell rörelse skickas först en moving-händelse. Sedan, om moving-händelsen inte avbryts, uppdateras fönsterplaceringen och en move-händelse skickas. Om en moving--händelse avbryts, avslutas flyttsekvensen omedelbart.

var initOpts:NativeWindowInitOptions = new NativeWindowInitOptions();
var win:NativeWindow = new NativeWindow(initOpts);
win.activate();
win.stage.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);

function mouseDownHandler(event:MouseEvent):void
{
    win.startMove();
}

Startar en systemstyrd resize-åtgärd av detta fönster.

Vid anrop från en mouseDown-händelsehanterare påbörjar den här metoden en musdriven resizing-sekvens som fortsätter tills en mouseUp-händelse inträffar.

Vid anrop från annan kod påbörjar denna metod en tangentbords- eller musdriven resizing-sekvens som är konsekvent med operativsystemets standardsekvens.

Under en rezize-sekvens skickas en serie händelser då fönstrets mått ändras. För varje inkrementell förändring skickas först en resizing-händelse och sedan, om resizing-händelsen inte avbryts, uppdateras fönstrets mått och en resize-händelse skickas. Om en resizing-händelse avbryts avslutas sekvensen omedelbart.

Parametrar

Relaterade API-element

stage.addEventListener(MouseEvent.MOUSE_DOWN, onResizeCommand);

function onResizeCommand(event:MouseEvent):void
{
    var win:NativeWindow = event.target.nativeWindow;
    var resizeFrom:String = "";
    if (event.stageY < win.height * .33)
    {
        resizeFrom = NativeWindowResize.TOP;
    }
    else if (event.stageY > win.height * .66)
    {
        resizeFrom = NativeWindowResize.BOTTOM;
    }
    if (event.stageX < win.width * .33)
    {
        resizeFrom += NativeWindowResize.LEFT;
    }
    else if (event.stageX > win.width * .66)
    {
        resizeFrom += NativeWindowResize.RIGHT;
    }
    win.startResize(resizeFrom);    
}

Skickas av detta NativeWindow-objekt efter att fönstret har aktiverats.

Obs! Den här händelsen har varken en ”capture phase” eller en ”bubble phase” vilket innebär att händelseavlyssnaren måste läggas till direkt i potentiella mål, oavsett om målet visas i listan eller inte.

Enheter med AIR for TV skickar aldrig den här händelsen automatiskt. Du kan skicka den manuellt om du vill.

Den här händelsen har följande egenskaper:

Skickas av detta NativeWindow-objekt efter att fönstret har stängts.

Den här händelsen har följande egenskaper:

Skickas av detta NativeWindow-objekt omedelbart innan fönstret ska stängas. Denna händelse kan avbrytas för att förhindra att fönstret stängs.

Den här händelsen har följande egenskaper:

Skickas av detta NativeWindow-objekt efter att fönstret har inaktiverats.

Obs! Den här händelsen har varken en ”capture phase” eller en ”bubble phase” vilket innebär att händelseavlyssnaren måste läggas till direkt i potentiella mål, oavsett om målet visas i listan eller inte.

Enheter med AIR for TV skickar aldrig den här händelsen automatiskt. Du kan skicka den manuellt om du vill.

Den här händelsen har följande egenskaper:

Skickas av detta NativeWindow-objekt efter att fönstrets displayState-egenskap har ändrats.

Ändra inte storlek på fönstret och ändra inte dess visningsläge i displayStateChange-händelsehanteraren.

Den här händelsen har följande egenskaper:

Skickas av detta NativeWindow-objekt omedelbart innan fönstret ändrar visningsläge. Denna händelse kan avbrytas för att förhindra ändringen.

Den här händelsen har följande egenskaper:

function displayStateChanging_handler(displayStateEvent:NativeWindowDisplayStateEvent):void
{
  //shouldStopStateChange is an application-defined Boolean indicating 
  //that display state changes should be canceled
  if (displayStateEvent.type == NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING 
                                  &&    shouldStopStateChange)
  {
    displayStateEvent.preventDefault();
  }
}

Skickas av detta NativeWindow-objekt efter att fönstret har flyttats på skrivbordet.

En move-händelse skickas när fönstrets storlek (x- eller y-egenskaperna) ändras, vilket kan ske genom en systemstyrd flyttning av fönstret; minimering, maximering eller återställning av fönstret eller genom ändring av fönsterplacering med egenskaperna x, y eller bounds.

Obs! Undvik åtgärder som kan öppna samtidiga dialogrutor i operativsystemet i hanterarfunktionerna för både händelserna moving och move i ett NativeWindow-objekt. Detta kan inträffa om t.ex. båda handler-funktionerna returnerar ett fel. Om det inträffar kommer den andra dialogrutan som öppnas inte att registrera musklick och måste stängas med tangentbordet.

Den här händelsen har följande egenskaper:

Skickas av NativeWindow-objektet omedelbart innan fönstret ska flyttas på skrivbordet. Denna händelse kan avbrytas för att förhindra flyttningen eller för att ändra den.

Obs! Undvik åtgärder som kan öppna samtidiga dialogrutor i operativsystemet i hanterarfunktionerna för både händelserna moving och move i ett NativeWindow-objekt. Detta kan inträffa om t.ex. båda handler-funktionerna returnerar ett fel. Om det inträffar kommer den andra dialogrutan som öppnas inte att registrera musklick och måste stängas med tangentbordet.

Den här händelsen har följande egenskaper:

Obs! På Linux stöds inte metoden preventDefault() för den här händelsen.

Skickas av detta NativeWindow-objekt efter att fönstret har ändrat storlek. En resize-händelse skickas när fönstrets storlek (width- eller height-egenskaperna) ändras, vilket kan ske genom en systemstyrd storleksändring av fönstret; minimering, maximering eller återställning av fönstret eller genom ändring av fönsterstorlek med egenskaperna width, height eller bounds. NativeWindow-objekts resize-händelser skickas vid systemstyrda storleksändringsslingor. Däremot skickas Stage-objekts resize-händelser när scenen är redo att ritas.

Den här händelsen har följande egenskaper:

Relaterade API-element

Skickas av detta NativeWindow-objekt omedelbart innan fönstret ska storleksändras på skrivbordet. Denna händelse kan avbrytas för att förhindra storleksändringen eller för att justera den.

Den här händelsen har följande egenskaper:

Obs! På Linux stöds inte metoden preventDefault() för den här händelsen.

function boundsChanging_handler(boundsEvent:NativeWindowBoundsEvent):void
{
  //shouldStopResize is an application-defined Boolean indicating 
  //that resize operations should be canceled
  if (boundsEvent.type == NativeWindowBoundsEvent.RESIZING && shouldStopResize)
  {
    boundsEvent.preventDefault();
  }
}