NativeWindow  - AS3

Geeft aan of dit venster het actieve toepassingsvenster is.

Gebruik de methode activate() om een venster actief te maken.

Verwante API-elementen

Geeft aan of dit venster altijd vóór andere vensters wordt weergegeven (inclusief die van andere toepassingen).

Er zijn twee groepen vensters in de dieptevolgorde van het systeem. Vensters in de groep alwaysInFront worden altijd vóór alle andere vensters weergegeven. Dieptevolgorde tussen vensters binnen dezelfde groep wordt normaal bepaald. Met andere woorden: als een venster wordt geactiveerd, wordt het vóór andere vensters in dezelfde groep geplaatst.

Als alwaysInFront wordt gewijzigd van false in true, komt dit venster boven alle andere vensters. Als de eigenschap wordt gewijzigd van true in false, wordt het venster achter "alwaysInFront"-vensters geplaatst, maar vóór andere vensters. Als u de eigenschap op de huidige waarde instelt, wordt de dieptevolgorde van het venster niet gewijzigd. Als u de eigenschap alwaysInFront van een venster met een eigenaar instelt, heeft dat geen effect.

De eigenschap alwaysInFront hoeft slechts zelden te worden ingesteld op true omdat vensters met deze instelling voor de vensters van andere toepassingen worden weergegeven, ook als die andere toepassing actief is.

Gedragingsopmerkingen voor OS:

• Sommige Linux window managers geven geen vensters weer, waarvan de alwaysInFront-eigenschap op is ingesteld voor vensters op volledig scherm.
• Onder Mac^® OS X heeft het instellen van alwaysInFront op true geen effect wanneer de eigenschap displayState van het werkgebied van het venster fullScreen of fullScreenInteractive is.

windowObj.alwaysInFront = true;

displayObject.stage.nativeWindow.alwaysInFront=true;

window.nativeWindow.alwaysInFront = true;

Het formaat en de locatie van dit venster.

De afmetingen van een venster zijn inclusief een eventuele systeemchroom. De afmetingen van het werkgebied van een venster zijn gelijk aan de afmetingen van het venster min de afmetingen van een eventuele systeemchroom. Als u de breedte en hoogte van het venster wijzigt, worden de stageWidth en stageHeight van het werkgebied eveneens gewijzigd. Het omgekeerde is ook van toepassing: als de afmetingen van het werkgebied worden gewijzigd, verandert ook het formaat van het venster.

In een HTML-hoofdvenster zijn de eigenschappen outerWidth en outerHeigth equivalent aan de eigenschappen height en width van het venster. De eigenschappen innerWidth en innerHeight zijn gelijk aan de eigenschappen stage.stageWidth en stage.stageHeight min de dikte van eventuele automatische schuifbalken die in het venster worden weergegeven.

Een resize-gebeurtenis wordt verzonden zodra de breedte of hoogte van het venster wordt gewijzigd. Evenzo wordt ook een move-gebeurtenis verzonden wanneer de oorsprong (x,y) van dit venster wordt gewijzigd. Als u direct op Mac OS en Windows de bounds-eigenschap instelt, wordt er geen moving of resizing-gebeurtenis verstuurd. Op Linux verstuurt NativeWindow echter geen moving en resizing-gebeurtenissen wanneer u de bounds-eigenschap instelt.

Als u de eigenschap bounds van een venster instelt, is dit gelijkwaardig met het instellen van de eigenschappen x, y, width en height. Evenzo is het instellen van de afzonderlijke afmetingen equivalent met het instellen van de eigenschap bounds. Wanneer u alle afmetingen tegelijkertijd instelt met de eigenschap bounds, worden minder gebeurtenissen verzonden.

De volgorde waarin de afzonderlijke afmetingen worden ingesteld, is niet gegarandeerd. Bij Linux-functies voor vensterbeheer die niet toestaan dat vensters groter worden dan het bureaubladgebied, kan het wijzigen van een afzonderlijke eigenschap worden geblokkeerd, zelfs als het netto/effect bij het toepassen van alle gewijzigde eigenschappen tot een toegestaan venster leidt.

Als de opgegeven breedte of hoogte kleiner dan de minimale of groter dan de maximale toegestane breedte of hoogte is, wordt de breedte of hoogte van het venster aangepast aan de dichtste bladgrootte. De factoren die de minimum- en maximumbreedte en -hoogte bepalen zijn de volgende:

• De eigenschappen minSize en maxSize van het NativeWindow-object.
• De minimum- en maximumbeperkingen van het besturingssysteem zijn de waarden van NativeWindow.systemMinSize en NativeWindow.systemMaxSize.
• De maximale breedte en hoogte van een venster in Adobe AIR, die elk 4095 pixels zijn. (In AIR 1.5 en eerdere versies is de maximumbreedte en -hoogte van een venster 2880 pixels.)
• De minimale breedte en hoogte die vereist zijn voor elke weergegeven systeemchroom.

Als de positie of de afmetingen van een venster worden gewijzigd, worden de pixelwaarden afgerond op het dichtstbijzijnde gehele getal.

Verwante API-elementen

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

Geeft aan of het venster is gesloten.

Als de volgende eigenschappen in een gesloten venster worden aangeroepen, treedt een fout met betrekking tot een ongeldige bewerking op:

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

Ook als de volgende methoden worden aangeroepen in een gesloten venster, treedt een fout met betrekking tot een ongeldige bewerking op:

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

var isWindowClosed:Boolean = windowObj.closed;

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

var isWindowClosed = window.nativeWindow.closed;

De weergavestatus van dit venster.

Constanten voor de mogelijke waarden zijn gedefinieerd in de klasse NativeWindowDisplayState:

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

Verwante API-elementen

var state:String = windowObj.displayState;

De hoogte van dit venster, in pixels.

De afmetingen van een venster zijn inclusief een eventueel weergegeven systeemchroom. De hoogte van het bruikbare weergavegebied binnen een venster is beschikbaar uit de eigenschap Stage.stageHeight.

Wijzigen van de venstereigenschap height is gelijk aan het wijzigen van de hoogte via de eigenschap bounds.

Als de opgegeven hoogte kleiner dan de minimale of groter dan de maximale toegestane hoogte is, wordt de hoogte van het venster aangepast aan de dichtste bladgrootte. De factoren die de minimum- en maximumhoogte bepalen zijn de volgende:

• De eigenschappen minSize.x en maxSize.x van het NativeWindow-object.
• De minimum- en maximumbeperkingen van het besturingssysteem zijn de waarden van NativeWindow.systemMinSize.x en NativeWindow.systemMaxSize.x.
• De maximumhoogte van een venster in Adobe AIR, te weten 4095 pixels (2880 pixels in AIR 1.5 en eerder).

Op Linux is het instellen van de eigenschap height een asynchrone bewerking.

Om de voltooiing van de hoogtewijziging te controleren, luistert u naar de resize-gebeurtenis die op alle platforms wordt verzonden.

Als de hoogte van een venster wordt gewijzigd, worden de pixelwaarden afgerond op het dichtstbijzijnde gehele getal.

Verwante API-elementen

Geeft aan of native vensters worden ondersteund op het clientsysteem.

Meldt de instelling voor maximaliseren die bij het maken van dit venster is gebruikt.

De instelling voor maximizable kan na het maken van een venster niet meer worden gewijzigd.

Opmerking: met sommige Linux window managers kunnen vensters door de gebruiker worden gemaximaliseerd, zelfs als de maximizable-eigenschap op false is ingesteld.

Verwante API-elementen

Het maximumformaat voor dit venster.

De formaatlimieten zijn opgegeven als de coördinaten van een Point-object. De eigenschap punt x komt overeen met de vensterbreedte, en de eigenschap y komt overeen met de vensterhoogte.

maxSize wordt opgelegd aan bewerkingen voor vensterformaatwijziging die zowel via ActionScript-code als via het besturingssysteem worden aangeroepen.

Als maxSize wordt ingesteld, worden de grenzen van het venster gewijzigd als de huidige grenzen groter zijn dan het nieuwe maximumformaat.

Als de opgegeven breedte of hoogte groter dan de maximale toegestane breedte of hoogte is, wordt de breedte van het venster aangepast aan de dichtste bladgrootte. De factoren die de minimum- en maximumbreedte en -hoogte bepalen zijn de volgende:

• De maximumbegrenzing van het besturingssysteem is de waarde NativeWindow.systemMaxSize.
• De maximale breedte en hoogte van een venster in Adobe AIR, die elk 4095 pixels zijn. (In AIR 1.5 en eerdere versies is de maximumbreedte en -hoogte van een venster 2880 pixels.)

Opmerking: In sommige besturingssystemen, zoals Mac OS X, wordt bij het maximaliseren van een venster het venster slechts vergroot tot de waarde maxSize, zelfs als het gemaximaliseerde venster kleiner is dan het scherm van het besturingssysteem. Het venster heeft dan nog steeds de weergavestatus gemaximaliseerd.

Verwante API-elementen

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

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

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

Het native menu voor dit venster.

Wanneer een object NativeMenu is toegewezen aan de venstereigenschap menu, wordt een native menu weergegeven voor een venster als NativeWindow.supportsMenu is true, tenzij de venstereigenschap systemChrome NativeWindowSystemChrome.NONE is.

Opmerking: Een menu toewijzen aan een venster als NativeWindow.supportsMenu false is of als de venstereigenschap systemChrome NativeWindowSystemChrome.NONEis, is toegestaan, maar doet niets. Gebruik de eigenschap NativeWindow.supportsMenu om te bepalen of het besturingssysteem venstermenu's ondersteunt. Bepaal met behulp van andere middelen (zoals Capabilities.os) of ondersteuning kan leiden tot programmeringsfouten (als er geen rekening wordt gehouden met bepaalde doelbesturingssystemen).

Verwante API-elementen

Meldt de instelling voor minimaliseren die bij het maken van dit venster is gebruikt.

De instelling voor minimizable kan na het maken van een venster niet meer worden gewijzigd.

Opmerking: met sommige Linux window managers kunnen vensters door de gebruiker worden geminimaliseerd, zelfs als de minimizable-eigenschap op false is ingesteld.

Verwante API-elementen

Het minimumformaat voor dit venster.

De formaatlimieten zijn opgegeven als de coördinaten van een Point-object. De eigenschap punt x komt overeen met de vensterbreedte, en de eigenschap y komt overeen met de vensterhoogte.

Als minSize wordt ingesteld, worden de grenzen van het venster gewijzigd als de huidige grenzen kleiner zijn dan het nieuwe minimumformaat.

minSize wordt opgelegd aan bewerkingen voor vensterformaatwijziging die zowel via ActionScript-code als via het besturingssysteem worden aangeroepen.

Opmerking: De breedte en hoogte van elke weergegeven systeemchroom kan de instelling van het minimumformaat voor een venster onmogelijk maken.

Verwante API-elementen

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

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

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

Het NativeWindow-object dat de eigenaar is van dit venster.

Het eigendom van een venster wordt bepaald wanneer een venster wordt gemaakt en kan niet worden gewijzigd. Als u een venster wilt maken dat een eigenaar heeft, stelt u het NativeWindow-object dat de eigenaar is, in als de eigenschap owner van het NativeWindowInitOptions-object waarmee u het venster wilt maken dat in eigendom is.

Opmerking: Op Linux-systemen worden vensters niet vóór de eigenaar weergegeven wanneer het venster dat de eigenaar is in de volledige-schermmodus wordt weergegeven.

Verwante API-elementen

Meldt de instelling voor renderMode die bij het maken van dit venster is gebruikt.

De waarde die door NativeWindow.renderMode wordt geretourneerd, is een van de constanten die zijn gedefinieerd in de klasse NativeRenderMode.

De instelling voor renderMode kan na het maken van een venster niet meer worden gewijzigd.

Verwante API-elementen

Meldt de instelling voor formaatwijziging die bij het maken van dit venster is gebruikt.

De instelling voor resizable kan na het maken van een venster niet meer worden gewijzigd.

Verwante API-elementen

Het Stage-object voor dit venster. Het object Stage is het hoofdobject in de weergavelijstarchitectuur die wordt gebruikt in SWF-inhoud die op ActionScript 3.0 is gemaakt.

Het werkgebied is de basis van de weergavelijst voor het venster. U kunt visuele weergaveobjecten aan een venster toevoegen door deze aan het werkgebied toe te voegen of aan een ander object dat zich al in de weergavelijst voor dit werkgebied bevindt. De afmetingen van het werkgebied zijn die van het clientgebied van het venster wanneer het venster systeemchroom gebruikt. Als systeemchroom niet wordt gebruikt, zijn de afmetingen van het werkgebied gelijk aan de afmetingen van het venster.

Verwante API-elementen

import flash.display.StageAlign;

windowObj.stage.align = StageAlign.TOP_LEFT;

Geeft aan of AIR native venstermenu's op het huidige computersysteem ondersteunt.

Wanneer NativeWindow.supportsMenu trueis, wordt een native menu voor een venster weergegeven wanneer een NativeMenu-object is toegewezen aan de eigenschap menu van het venster (tenzij de venstereigenschap systemChrome NativeWindowSystemChrome.NONE is ). Gebruik de eigenschap NativeWindow.supportsMenu om te bepalen of het besturingssysteem native venstermenu's ondersteunt. Bepaal met behulp van andere middelen (zoals Capabilities.os) of ondersteuning kan leiden tot programmeringsfouten (als er geen rekening wordt gehouden met bepaalde doelbesturingssystemen).

Opmerking: Een menu toewijzen aan een venster als NativeWindow.supportsMenu false is of als de venstereigenschap systemChrome NativeWindowSystemChrome.NONEis, is toegestaan, maar doet niets.

Verwante API-elementen

Geeft aan of AIR acties voor meldingsvensters op het huidige computersysteem ondersteunt.

Wanneer NativeWindow.supportsNotification true is, resultaat een aanroep van de methode notifyUser() van het venster in een visuele hint voor de gebruiker dat een belangrijke gebeurtenis heeft plaatsgevonden. Deze visuele actie voldoet aan de standaardconventie van het native systeem. In Windows ^® gaat bijvoorbeeld het taakbalkpictogram knipperen.

Opmerking:notifyUser() aanroepen wanneer NativeWindow.supportsNotification is false is toegestaan, maar dan gebeurt er niets.

Verwante API-elementen

Geeft aan of AIR eigen vensters met transparante pixels ondersteunt.

Als NativeWindow.supportsTransparency is ingesteld op true, wordt transparantie in pixels van een eigen venster toegestaan, als de eigenschap transparent van het venster is ingesteld op true. De dekking van alle pixels wordt ingesteld op 1 als NativeWindow.supportsTransparency is ingesteld op false, ongeacht de waarde van de eigenschap transparent van het venster. Volledig transparante pixels worden weergegeven als zwart wanneer NativeWindow.supportsTransparency is ingesteld op false. Gebruik de eigenschap NativeWindow.supportsTransparency om te bepalen of het besturingssysteem transparantie ondersteunt. Bepaal met behulp van andere middelen (zoals Capabilities.os) of ondersteuning kan leiden tot programmeringsfouten (als er geen rekening wordt gehouden met bepaalde doelbesturingssystemen).

Opmerking: de waarde van deze eigenschap kan veranderen als een toepassing wordt uitgevoerd, op basis van gebruikersvoorkeuren die voor het besturingssysteem zijn ingesteld.

Verwante API-elementen

Meldt de instelling voor de systeemchroom die bij het maken van dit venster is gebruikt.

De waarden die door NativeWindow.systemChrome worden geretourneerd, zijn enkele constanten die zijn gedefinieerd in de klasse NativeWindowSystemChrome.

De instelling voor de systeemchroom kan na het maken van een venster niet meer worden gewijzigd.

Verwante API-elementen

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

Het grootste vensterformaat dat het besturingssysteem toestaat.

De formaatlimieten zijn opgegeven als de coördinaten van een Point-object. De eigenschap punt x komt overeen met de vensterbreedte, en de eigenschap y komt overeen met de vensterhoogte.

Naast de formaatlimiet van het besturingssysteem, geldt in AIR een maximumvensterformaat van 4095 bij 4095 pixels (2880 bij 2880 pixels in AIR 1.5 en eerder). En een toepassing kan een begrenzing instellen met behulp van de maxSize-eigenschap van het NativeWindow-object.

Het kleinste vensterformaat dat het besturingssysteem toestaat.

De formaatlimieten zijn opgegeven als de coördinaten van een Point-object. De eigenschap punt x komt overeen met de vensterbreedte, en de eigenschap y komt overeen met de vensterhoogte.

De venstertitel.

De titel verschijnt in de systeemchroom voor het venster, indien weergegeven, én in andere systeemafhankelijke locaties (zoals de taakbalk).

windowObj.title = "Window Title";

Meldt de instelling voor de transparantie die bij het maken van dit venster is gebruikt.

De eigenschap transparent kan na het maken van een venster niet meer worden gewijzigd. Transparantie beïnvloedt zowel de visuele verschijning als het muisgedrag van het venster. In Windows en Mac OS X zal het venster geen muisgebeurtenissen vastleggen wanneer de alfawaarde van de pixel onder een bepaalde drempelwaarde ligt; deze ligt, afhankelijk van het besturingssysteem, tussen .06 en .01. In Linux zal het venster muisgebeurtenissen boven volledig transparante gebieden vastleggen zodat gebruikers geen toegang hebben tot andere vensters en items op het bureaublad.

Opmerking: Transparantie van vensters wordt niet altijd ondersteund. Als het besturingssysteem van de gebruiker zodanig is geconfigureerd dat transparantie niet beschikbaar is, wordt het venster zonder transparantie gemaakt. Gebieden die transparant zouden moeten zijn, worden gecombineerd met zwart. Gebruik de eigenschap NativeWindow.supportsTransparency om te bepalen of transparantie van vensters wordt ondersteund.

Verwante API-elementen

Meldt de instelling voor type die bij het maken van dit venster is gebruikt.

De waarden die door NativeWindow.type worden geretourneerd, zijn enkele constanten die zijn gedefinieerd in de klasse NativeWindowType.

De instelling voor type kan na het maken van een venster niet meer worden gewijzigd.

Verwante API-elementen

Geeft aan of het venster zichtbaar is.

Een onzichtbaar venster wordt niet op het bureaublad weergegeven, maar alle venstereigenschappen en -methoden zijn nog wel geldig.

Standaard is visible ingesteld op false. Als u een venster wilt weergeven, stelt u visible in op true of roept u NativeWindow.activate() aan.

Als dit venster een eigenaar heeft, bepaalt de zichtbare status van het venster dat de eigenaar is, of dit venster al dan niet wordt weergegeven. Als het venster dat de eigenaar is niet wordt weergegeven, worden de vensters die in eigendom zijn ook niet weergegeven, ook al is de waarde van de eigenschappen visible ingesteld op true.

Opmerking: Onder Mac OS X verwijdert u met visible=false in een geminimaliseerd venster het vensterpictogram niet uit de dock. Als een gebruiker vervolgens op het dockpictogram klikt, verandert de status weer in visible en wordt het venster op het bureaublad weergegeven.

Verwante API-elementen

windowObj.visible = true;

displayObj.stage.nativeWindow.visible = true;

window.nativeWindow.visible = true;

De breedte van dit venster, in pixels.

De afmetingen die voor een native venster worden gemeld, zijn inclusief een eventueel weergegeven systeemchroom. De breedte van het bruikbare weergavegebied binnen een venster is beschikbaar uit de eigenschap Stage.stageWidth.

Het wijzigen van de venstereigenschap width is gelijk aan het wijzigen van de breedte via de eigenschap bounds.

Als de opgegeven breedte kleiner dan de minimale of groter dan de maximale toegestane breedte is, wordt de breedte van het venster aangepast aan de dichtste bladgrootte. De factoren die de minimum- en maximumbreedte bepalen zijn de volgende:

• De eigenschappen minSize.y en maxSize.y van het NativeWindow-object.
• De minimum- en maximumbeperkingen van het besturingssysteem zijn de waarden van NativeWindow.systemMinSize.y en NativeWindow.systemMaxSize.y.
• De maximumbreedte van een venster in Adobe AIR, te weten 4095 pixels (2880 pixels in AIR 1.5 en eerder).

Op Linux is het instellen van de eigenschap width een asynchrone bewerking.

Om de voltooiing van de breedtewijziging te controleren, luistert u naar de resize-gebeurtenis die op alle platforms wordt verzonden.

Als de breedte van een venster wordt gewijzigd, worden de pixelwaarden afgerond op het dichtstbijzijnde gehele getal.

Verwante API-elementen

De coördinaat op de horizontale as van de linkerbovenhoek van dit venster ten opzichte van de oorsprong van het bureaublad van het besturingssysteem.

Op systemen met meerdere monitoren kan x negatief zijn. Als u de waarde opslaat, bijvoorbeeld om een venster op een vorige locatie terug te zetten, moet u altijd controleren of het venster op een bruikbare locatie wordt neergezet wanneer de positie wordt hersteld. Wijzigingen in de schermresolutie of de indeling van de monitor kunnen tot gevolg hebben dat een venster buiten het scherm komt te staan. Gebruik de klasse Screen om informatie over de indeling van het bureaublad te verkrijgen.

Het wijzigen van de venstereigenschap x is gelijk aan het wijzigen van de locatie via de eigenschap bounds.

Op Linux is het instellen van de eigenschap x een asynchrone bewerking.

Om de voltooiing van de positiewijziging te controleren, luistert u naar de move-gebeurtenis die op alle platforms wordt verzonden.

Als de x-coördinaat van een venster wordt gewijzigd, worden de pixelwaarden afgerond op het dichtstbijzijnde gehele getal.

Verwante API-elementen

De coördinaat op de verticale as van de linkerbovenhoek van dit venster ten opzichte van de linkerbovenhoek van het bureaublad van het besturingssysteem.

Op systemen met meerdere monitoren kan y negatief zijn. Als u de waarde opslaat, bijvoorbeeld om een venster op een vorige locatie terug te zetten, moet u altijd controleren of het venster op een bruikbare locatie wordt neergezet wanneer de positie wordt hersteld. Wijzigingen in de schermresolutie of de indeling van de monitor kunnen tot gevolg hebben dat een venster buiten het scherm komt te staan. Gebruik de klasse Screen om informatie over de indeling van het bureaublad te verkrijgen.

Het wijzigen van de venstereigenschap y is gelijk aan het wijzigen van de locatie via de eigenschap bounds.

Op Linux is het instellen van de eigenschap y een asynchrone bewerking.

Om de voltooiing van de positiewijziging te controleren, luistert u naar de move-gebeurtenis die op alle platforms wordt verzonden.

Als de y-coördinaat van een venster wordt gewijzigd, worden de pixelwaarden afgerond op het dichtstbijzijnde gehele getal.

Verwante API-elementen

Maakt een nieuwe instantie NativeWindow en een overeenkomstig besturingssysteemvenster.

De instellingen die zijn gedefinieerd in de parameter initOptions kunnen niet meer worden gewijzigd nadat het venster is gemaakt.. Ongeldige initOptions-instellingen hebben tot gevolg dat de fout 'Ongeldige bewerking' wordt gegenereerd. Instellingen die geldig maar niet beschikbaar zijn in het huidige systeem, veroorzaken geen fout. De venstermogelijkheden van het huidige besturingssysteem kunnen desgewenst worden gedetecteerd met de statische leden van NativeWindow, zoals systemMaxSize.

Het standaardvensterformaat wordt bepaald door het besturingssysteem en vensters worden in onzichtbare toestand gemaakt. U kunt voorkomen dat wijzigingen in het venster zichtbaar zijn door de venstereigenschapvisible niet op true in te stellen of activate() aan te roepen totdat de vensterwijzigingen zijn voltooid.

Verwante API-elementen

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

Activeert dit venster.

Activeren van een venster heeft het volgende tot gevolg:

• Maakt het venster zichtbaar
• Brengt het venster naar voren
• Geeft het venster toetsenbord- en muisfocus

Op Linux is activate() een asynchrone bewerking.

Het NativeWindow-object verstuurt een activate-gebeurtenis naar alle platforms.

Verwante API-elementen

displayObject.stage.nativeWindow.activate();

windowObj.activate();

window.nativeWindow.activate();

Sluit dit venster.

Een close-gebeurtenis wordt verzonden zodra het sluiten voltooid is. Er wordt geen closing-gebeurtenis verzonden. Als annulering van het sluiten moet worden toegestaan, verzendt u een closing-gebeurtenis en controleert u of geregistreerde listeners het standaardgedrag annuleren voordat u de methode close() aanroept.

Wanneer een venster wordt gesloten, worden alle onderliggende vensters ook gesloten. Er worden geen closing-gebeurtenissen verzonden door vensters die het eigendom zijn van een ander venster.

Instanties van weergaveobjecten die zich op dat moment in het venster bevinden en waarnaar niet elders wordt verwezen, worden vernietigd, behalve de instanties in het eerste toepassingsvenster dat door AIR is gemaakt. Als u wilt dat ook de weergaveobjecten in het eerste venster worden vernietigd, verwijdert u ze uit het vensterwerkgebied.

Het NativeWindow-object is na het sluiten nog steeds een geldige verwijzing, maar als geprobeerd wordt een eigenschap of methode te gebruiken, zullen de meeste een fout met betrekking tot een ongeldige bewerking veroorzaken.

Eenmaal gesloten vensters kunnen niet meer worden geopend. Als het venster al gesloten is, wordt geen actie uitgevoerd en worden geen gebeurtenissen verzonden.

Opmerking: Als u een venster wilt verbergen zonder het te sluiten, stelt u de eigenschap visible van het venster in op false.

Verwante API-elementen

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>

Zet een punt in pixelcoördinaten ten opzichte van de oorsprong van het werkgebied van het venster (een algemeen punt op de weergavelijst), om in een punt op het virtuele werkblad.

Virtuele bureaubladcoördinaten ten opzichte van de linkerbovenhoek van de primaire monitor.

Parameters

Verwante API-elementen

Retourneert een overzicht met de NativeWindow-objecten die eigendom zijn van dit venster.

U kunt het eigendom van NativeWindows niet wijzigen door objecten toe te voegen of te verwijderen van de geretourneerde vector. Het eigendom van een venster kan niet worden gewijzigd nadat het venster is gemaakt.

Verwante API-elementen

Maximaliseert dit venster.

Als de methode maximize() wordt aangeroepen, wordt een displayStateChange-gebeurtenis verzonden en, indien van toepassing, een move- en resize-gebeurtenis. Terwijl systeemchroom een displayStateChanging-gebeurtenis verzendt die kan worden geannuleerd wanneer een gebruiker een maximize-opdracht uitvoert, moet dit gedrag desgewenst door de logica voor maximaliseren worden geïmplementeerd.

De methode maximize() wordt asynchroon uitgevoerd. Als u de voltooiing van de statuswijziging wilt detecteren, luistert u naar de displayStateChange-gebeurtenis. Als het venster al gemaximaliseerd is, wordt geen actie uitgevoerd en worden geen gebeurtenissen verzonden.

Gedragingsopmerkingen voor OS:

• Bij besturingssystemen als Mac OS X, waarbij het maximaliseren van een venster formaatwijziging niet voorkomt, wordt het venster schermvullend weergegeven als maximize() wordt aangeroepen, maar wordt de daarop volgende formaatwijziging van het venster niet voorkomen. Als het formaat van een schermvullend weergegeven venster wordt gewijzigd, wordt ook de weergavestatus hersteld.
• In sommige besturingssystemen, zoals Mac OS X, en in sommige Linux-functies voor vensterbeheer, wordt een gemaximaliseerd venster niet groter gemaakt dan de breedte en hoogte die zijn opgegeven in de eigenschap maxSize. In andere besturingssystemen wordt het venster vergroot tot het volledige scherm, zelfs als het scherm groter is dan maxSize.
• Sommige Linux-functies voor vensterbeheer staan niet toe dat hulpprogrammavensters worden gemaximaliseerd.

Verwante API-elementen

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

Minimaliseert dit venster.

Als minimize() wordt aangeroepen, wordt een displayStateChange-gebeurtenis verzonden en, indien van toepassing, een move- en resize-gebeurtenis. Terwijl systeemchroom een displayStateChanging-gebeurtenis verzendt die kan worden geannuleerd wanneer een minimize-opdracht door een gebruiker wordt gegeven, gebeurt dit niet als minimize() rechtstreeks wordt aangeroepen. Dit gedrag kan desgewenst worden geïmplementeerd door de logica voor minimaliseren.

De methode minimize() wordt asynchroon uitgevoerd. Om de voltooiing van de statuswijziging te controleren, luistert u naar de displayStateChange-gebeurtenis die op alle platforms wordt verzonden. Als het venster al geminimaliseerd is, wordt geen actie uitgevoerd en worden geen gebeurtenissen verzonden.

Vensters die eigendom zijn van dit venster worden verborgen wanneer dit venster wordt geminimaliseerd. Er worden geen displayStateChanging- of displayStateChange-gebeurtenissen verzonden door de vensters die eigendom zijn van een ander venster.

Opmerkingen:

• Als u in Windows een onzichtbaar venster minimaliseert (visible == false), wordt het venster zichtbaar.
• Het minimaliseren van hulpprogrammavensters is niet door alle Linux-functies voor vensterbeheer toegestaan.

Verwante API-elementen

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

Activeert een visueel actiepunt via het besturingssysteem dat een belangwekkende gebeurtenis heeft plaatsgevonden.

Wanneer NativeWindow.supportsNotification is true, conformeert het visuele actiepunt zich aan de systeemstandaard van het native systeem. In Windows gaat bijvoorbeeld het taakbalkpictogram knipperen.

De parameter type bepaalt de intensiteit van de actie. Constanten voor de toegestane waarden worden gedefinieerd in de klasse NotificationType en kunnen het volgende zijn:

• NotificationType.INFORMATIONAL
• NotificationType.CRITICAL

De acties die ter informatie worden gegeven zijn van korte duur; de acties voor zeer dringende meldingen blijven aanhouden totdat de gebruiker het venster activeert. Niet alle Linux-functies voor vensterbeheer ondersteunen twee meldingsniveaus. Voor dergelijke functies voor vensterbeheer zal notifyUser() hetzelfde effect hebben, onafhankelijk van de opgegeven optie.

Opmerking:notifyUser() aanroepen wanneer NativeWindow.supportsNotification is false is toegestaan, maar dan gebeurt er niets.

Parameters

Stuurt dit venster direct achter het opgegeven venster.

Activeert het venster of de toepassing niet. Geminimaliseerde of verborgen (visible is false) vensters kunnen niet in een andere volgorde worden geplaatst.

Een venster kan nooit achter zijn eigenaar worden geplaatst. Als dit venster een eigenaar heeft, wordt de eigenaar van dit venster, samen met de andere vensters waarvan het eigenaar is, achter het doelvenster geplaatst. Als het doelvenster een eigenaar heeft, wordt dit venster achter de eigenaar van het doelvenster geplaatst.

Sommige Linux-functies voor vensterbeheer staan niet toe dat hulpprogrammavensters achter normale vensters worden geplaatst.

Parameters

windowBehind.orderInBackOf(windowFront);

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

jsWindowObjBehind.nativeWindow.orderInBackOf(jsWindowObjFront.nativeWindow);

Brengt dit venster direct vóór het opgegeven venster.

Activeert het venster of de toepassing niet. Geminimaliseerde of verborgen (visible is false) vensters kunnen niet in een andere volgorde worden geplaatst.

Een venster kan nooit vóór een venster worden geplaatst waarvan het eigenaar is. Als dit venster een eigenaar heeft, wordt de eigenaar van dit venster, samen met de andere vensters waarvan het eigenaar is, ook vóór het doelvenster geplaatst. Als het doelvenster een eigenaar heeft, wordt dit venster ook vóór alle andere vensters geplaatst die dezelfde eigenaar hebben als het doelvenster.

Sommige Linux-functies voor vensterbeheer staan niet toe dat normale venster vóór hulpprogrammavensters worden geplaatst.

Parameters

windowFront.orderInFrontOf(windowBehind);

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

jsWindowObjFront.nativeWindow.orderInFrontOf(jsWindowObjBehind.nativeWindow);

Stuurt dit venster achter andere zichtbare vensters.

Activeert het venster of de toepassing niet. Geminimaliseerde of verborgen (visible is false) vensters kunnen niet in een andere volgorde worden geplaatst.

Als alwaysInFront true is, wordt dit venster door het aanroepen van deze methode niet geplaatst achter vensters waarvoor alwaysInFront is ingesteld op false.

Een venster kan nooit achter zijn eigenaar worden geplaatst. Als dit venster een eigenaar heeft, wordt de eigenaar van dit venster, samen met de andere vensters waarvan het eigenaar is, ook onder aan het weergaveoverzicht met vensters geplaatst. Dit venster wordt achter de andere vensters geplaatst die eigendom zijn van hetzelfde venster. Als dit venster eigenaar is van andere vensters, worden die vensters ook naar achteren geplaatst, met behoud van hun onderlinge rangschikking.

Sommige Linux-functies voor vensterbeheer staan niet toe dat hulpprogrammavensters achter normale vensters worden geplaatst.

windowObj.orderToBack();

displayObj.stage.nativeWindow.orderToBack();

window.nativeWindow.orderToBack();

Brengt dit venster vóór alle andere zichtbare vensters.

Activeert het venster of de toepassing niet. Geminimaliseerde of verborgen (visible is false) vensters kunnen niet in een andere volgorde worden geplaatst.

Als alwaysInFront false is, wordt dit venster door het aanroepen van deze methode niet geplaatst vóór vensters waarvoor alwaysInFront is ingesteld op true.

Een venster kan nooit vóór een venster worden geplaatst waarvan het eigenaar is. Als dit venster eigenaar is van andere vensters, worden die vensters ook naar voren geplaatst, met behoud van hun onderlinge rangschikking. Als dit venster een eigenaar heeft, wordt de eigenaar van dit venster, samen met de andere vensters waarvan het eigenaar is, ook boven aan het weergaveoverzicht met vensters geplaatst. Dit venster wordt vóór de andere vensters met dezelfde eigenaar geplaatst.

Sommige Linux-functies voor vensterbeheer staan niet toe dat normale venster vóór hulpprogrammavensters worden geplaatst.

windowObj.orderToFront();

displayObj.stage.nativeWindow.orderToFront();

window.nativeWindow.orderToFront();

Herstelt dit venster na minimalisering of maximalisering in de oorspronkelijke staat.

Als restore() wordt aangeroepen, wordt een displayStateChange-gebeurtenis verzonden en, indien van toepassing, een move- en resize-gebeurtenis. Terwijl systeemchroom een displayStateChanging-gebeurtenis verzendt die kan worden geannuleerd wanneer een gebruiker een restore-opdracht uitvoert, moet dit gedrag desgewenst door de logica voor statusherstel worden geïmplementeerd.

Als het venster al de status NativeWindowDisplayState.NORMAL heeft, wordt geen actie uitgevoerd en worden geen gebeurtenissen verzonden.

Om de voltooiing van de statuswijziging te controleren, luistert u naar de displayStateChange-gebeurtenis die op alle platforms wordt verzonden.

Verwante API-elementen

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

Start een door het systeem bepaalde verplaatsing van dit venster.

Als deze methode wordt aangeroepen vanuit een gebeurtenis mouseDown, wordt een muisgestuurde verplaatsingsreeks gestart die doorgaat totdat een gebeurtenis mouseUp optreedt.

Als deze methode vanuit andere code wordt aangeroepen, wordt een toetsenbord- of muisgestuurde verplaatsingsreeks gestart die overeenkomt met de standaardreeks van het besturingssysteem.

Tijdens een verplaatsingsreeks wordt een serie gebeurtenissen verzonden bij elke verplaatsing van de oorsprong van het venster. Voor elke volgende verplaatsing wordt eerst een moving-gebeurtenis verzonden en als de moving-gebeurtenis niet wordt geannuleerd, wordt de vensterlocatie bijgewerkt en wordt een move-gebeurtenis verzonden. Als een moving-gebeurtenis wordt geannuleerd, wordt de verplaatsingsreeks onmiddellijk beëindigd.

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

Start een systeemgestuurde formaatwijziging van dit venster.

Als deze methode wordt aangeroepen vanuit een gebeurtenishandler mouseDown, wordt een muisgestuurde formaatwijzigingsreeks gestart die doorgaat totdat een gebeurtenis mouseUp optreedt.

Als deze methode vanuit andere code wordt aangeroepen, wordt een toetsenbord- of muisgestuurde formaatwijzigingsreeks gestart die overeenkomt met de standaardreeks van het besturingssysteem.

Tijdens een formaatwijzigingsreeks wordt een serie gebeurtenissen verzonden bij elke wijziging van de afmetingen van het venster. Voor elke volgende wijziging wordt eerst een resizing-gebeurtenis verzonden en als de resizing-gebeurtenis niet wordt geannuleerd, worden de vensterafmetingen bijgewerkt en een resize-gebeurtenis verzonden. Als een resizing-gebeurtenis wordt geannuleerd, wordt de reeks onmiddellijk beëindigd.

Parameters

Verwante API-elementen

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

Wordt verzonden door dit NativeWindow-object nadat het venster is geactiveerd.

Opmerking: Deze gebeurtenis heeft geen 'vastlegfase' en geen 'bubbelfase', wat betekent dat gebeurtenislisteners rechtstreeks aan mogelijke doelen moeten worden toegevoegd, ongeacht of het doel voorkomt in de weergavelijst.

Deze gebeurtenis wordt nooit automatisch verzonden door AIR for TV. U kunt de gebeurtenis wel handmatig verzenden.

Deze gebeurtenis heeft de volgende eigenschappen:

Wordt verzonden door dit NativeWindow-object nadat het venster is gesloten.

Deze gebeurtenis heeft de volgende eigenschappen:

Wordt verzonden door dit NativeWindow-object vlak voordat het venster wordt gesloten. Deze gebeurtenis kan worden geannuleerd om te voorkomen dat het venster wordt gesloten.

Deze gebeurtenis heeft de volgende eigenschappen:

Wordt verzonden door dit NativeWindow-object nadat het venster is gedeactiveerd.

Opmerking: Deze gebeurtenis heeft geen 'vastlegfase' en geen 'bubbelfase', wat betekent dat gebeurtenislisteners rechtstreeks aan mogelijke doelen moeten worden toegevoegd, ongeacht of het doel voorkomt in de weergavelijst.

Deze gebeurtenis wordt nooit automatisch verzonden door AIR for TV. U kunt de gebeurtenis wel handmatig verzenden.

Deze gebeurtenis heeft de volgende eigenschappen:

Wordt door dit NativeWindow-object verzonden nadat de eigenschap displayState van het venster is gewijzigd.

Pas de grootte van het venster niet aan of wijzig de weergavestatus in de gebeurtenishandler displayStateChange.

Deze gebeurtenis heeft de volgende eigenschappen:

Wordt door dit NativeWindow-object verzonden vlak voordat de weergavestatus van het venster wordt gewijzigd. Deze gebeurtenis kan worden geannuleerd om de wijziging te voorkomen.

Deze gebeurtenis heeft de volgende eigenschappen:

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

Wordt verzonden door dit NativeWindow-object nadat het venster op het bureaublad is verplaatst.

Een move-gebeurtenis wordt verzonden zodra de oorsprong (eigenschap x of y) van het venster wordt gewijzigd. Dit kan zich voordoen als gevolg van een door het systeem veroorzaakte verplaatsing, door minimaliseren, maximaliseren of in het oorspronkelijke formaat herstellen van het venster, of door de locatie van het venster te wijzigen door het instellen van de eigenschappen x, y of bounds.

Opmerking:Voorkom acties die gelijktijdig dialoogvensters van het besturingssysteem openen in de handlerfuncties voor de gebeurtenissen moving en move van een NativeWindow-object. Dit kan bijvoorbeeld gebeuren als in beide handlerfuncties een fout optreedt. Als dat gebeurt, worden in het dialoogvenster dat als tweede wordt geopend, geen muisklikken geregistreerd en moet dit venster via het toetsenbord worden gesloten.

Deze gebeurtenis heeft de volgende eigenschappen:

Wordt verzonden door dit NativeWindow-object vlak voordat het venster op het bureaublad wordt verplaatst. Deze gebeurtenis kan worden geannuleerd om de verplaatsing te voorkomen of te wijzigen.

Opmerking:Voorkom acties die gelijktijdig dialoogvensters van het besturingssysteem openen in de handlerfuncties voor de gebeurtenissen moving en move van een NativeWindow-object. Dit kan bijvoorbeeld gebeuren als in beide handlerfuncties een fout optreedt. Als dat gebeurt, worden in het dialoogvenster dat als tweede wordt geopend, geen muisklikken geregistreerd en moet dit venster via het toetsenbord worden gesloten.

Deze gebeurtenis heeft de volgende eigenschappen:

Opmerking: op Linux wordt de ) Methode Gebeurtenis.

Wordt verzonden door dit NativeWindow-object nadat het formaat van het venster is gewijzigd. Een resize-gebeurtenis wordt verzonden zodra de grootte (eigenschap width of height) van het venster verandert. Dit kan zich voordoen als gevolg van een door het systeem veroorzaakte formaatwijziging, door minimaliseren, maximaliseren of in het oorspronkelijke formaat herstellen, of door wijzigen van de venstergrootte door het instellen van de eigenschappen width, height of bounds. resize-gebeurtenissen van NativeWindow worden verzonden tijdens formaatwijzigingslussen van het systeem. resize-gebeurtenissen van het Stage-object worden daarentegen verzonden wanneer het werkgebied gereed is voor tekenen.

Deze gebeurtenis heeft de volgende eigenschappen:

Verwante API-elementen

Wordt verzonden door dit NativeWindow-object vlak voordat het formaat van het venster op het bureaublad wordt gewijzigd. Deze gebeurtenis kan worden geannuleerd om wijziging van het formaat te voorkomen of te wijzigen.

Deze gebeurtenis heeft de volgende eigenschappen:

Opmerking: op Linux wordt de ) Methode Gebeurtenis.

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