Indicates whether this window is the active application window.

Use the activate() method to make a window active.

See also

Specifies whether this window will always be in front of other windows (including those of other applications).

There are two groups of windows in the system depth order. Windows in the alwaysInFront=true group are always displayed in front of all other windows. Depth ordering between windows within the same group is determined normally. In other words, activating a window will bring it in front of other windows in its group.

Changing alwaysInFront from false to true will bring the window to the top of all other windows. Changing the property from true to false will send the window to the back of "alwaysInFront" windows, but still in front of other windows. Setting the property to its current value will not change the window depth order.

alwaysInFront=true should be used sparingly since windows with this setting will appear in front of the windows of other applications even when the other application is active.

Note: On Mac OS X, setting alwaysInFront=true will have no effect when the displayState property of the window stage is fullScreen or fullScreenInteractive.

windowObj.alwaysInFront = true;

displayObject.stage.nativeWindow.alwaysToFront=true;

window.nativeWindow.alwaysInFront = true;

The size and location of this window.

The dimensions of a window include any system chrome. The dimensions of a window's stage are equal to the dimensions of the window, minus the size of any system chrome. Changing the width and height of the window will change the stage's stageWidth and stageHeight. The reverse also applies; changing the stage dimensions will change the window size.

In a root HTML window, the outerWidth and outerHeigth properties are equivalent to the window height and width. The innerWidth and innerHeight properties equal the stage.stageWidth and stage.stageHeight properties minus the thickness of any automatic scrollbars displayed by the window.

A NativeWindowBoundsChangeEvent "resize" event is dispatched whenever the width or height of this window changes. Likewise, a "move" event is dispatched whenever the origin (x,y) of this window changes. Setting the bounds property directly will not dispatch a "moving" or "resizing" event. To allow other components to prepare for or cancel an impending move or resize operation, your bounds changing logic can dispatch "moving" and "resizing" events with the NativeWindow.dispatchEvent method and then check whether the event was cancelled by a registered listener.

Setting the bounds property of a window is equivalent to setting its x, y, width, and height properties (and vice-versa).

If the width and the height specified are less than the minimum or greater than the maximum allowed size, either because of the minSize and maxSize properties of the window, or the minimum and maximum operating system limits, then the window dimensions are set to the closest legal size. The minimum width and height of any displayed system chrome may also result in a window that is larger than the specified size.

See also

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

Indicates whether this window has been closed.

Accessing the following properties on a closed window will throw an IllegalOperationError:

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

Likewise, calling the following methods on a closed window will also throw an IllegalOperationError:

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

var isWindowClosed:Boolean = windowObj.closed;

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

var isWindowClosed = window.nativeWindow.closed;

A string reporting this window's current display state.

Constants for the possible values are defined in the NativeWindowDisplayState class:

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

See also

var state:String = windowObj.displayState;

The height of this window in pixels.

The dimensions of a window include any system window chrome that is displayed. The height of the usable display area inside a window is available from the Stage.stageHeight property.

Changing the height property of a window is equivalent to changing the height through the bounds property.

If the height specified is less than the minimum or greater than the maximum allowed height, either because of the minSize and maxSize properties of the window, or the minimum and maximum operating system limits, then the window height is set to the closest legal size.

See also

Reports the maximizable setting used to create the window.

The maximizable setting cannot be changed after a window is created.

See also

The maximum size for this window.

The size limit is specified as the coordinates of a Point object. Point.x corresponds to the window width; Point.y to the window height.

maxSize is enforced for window resizing operations invoked both through ActionScript JavaScript code and through the operating system.

Setting maxSize, will change the window bounds if the current bounds are larger than the new maximum size.

Note: Maximizing a window will only enlarge the window to the maxSize value even if the maximized window will be smaller than the operating system screen. The window will still be in the maximized display state.

See also

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

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

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

The native menu for the window.

When a NativeMenu object is assigned to the window menu property, a native menu will be displayed for a window if NativeWindow.supportsMenu is true, unless the window systemChrome property is NativeWindowSystemChrome.NONE.

Note: Assigning a menu to a window when NativeWindow.supportsMenu is false or when the window systemChrome property is NativeWindowSystemChrome.NONE is allowed, but does nothing.

See also

Reports the minimizable setting used to create the window.

The minimizable setting cannot be changed after a window is created.

See also

The minimum size for this window.

The size limit is specified as the coordinates of a Point object. Point.x corresponds to the window width; Point.y to the window height.

Setting minSize, will change the window bounds if the current bounds are smaller than the new minimum size.

minSize is enforced for window resizing operations invoked both through ActionScript JavaScript code and through the operating system.

Note: The width and height of any displayed system chrome may make it impossible to set a window as small as the specified minimum size.

See also

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

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

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

Reports the resizable setting used to create the window.

The resizable setting cannot be changed after a window is created.

See also

The Stage object for this window. The Stage object is the root object in the display list architecture used in ActionScript 3.0-based SWF content.

The stage is the root of the display list for the window. Add visual display objects to a window by adding them to the stage or to another object already in the display list of this stage. The stage dimensions are that of the window client area when the window uses system chrome. The stage dimensions are equal to the dimensions of the window if system chrome is not used.

The HTMLLoader, which renders HTML content, is a single leaf in the display list tree. ActionScript-defined display objects can be both above and below the HTMLLoader in the drawing order, but not in between the visual elements rendered by the HTMLLoader.

See also

import flash.display.StageAlign;

windowObj.stage.align = StageAlign.TOP_LEFT;

Indicates whether AIR supports native window menus on the current computer system.

When NativeWindow.supportsMenu is true, then a native menu will be displayed for a window when a NativeMenu object is assigned to the window menu property, unless the window systemChrome property is NativeWindowSystemChrome.NONE.

Note: Assigning a menu to a window when NativeWindow.supportsMenu is false or when the window systemChrome property is NativeWindowSystemChrome.NONE is allowed, but does nothing.

See also

Indicates whether AIR supports window notification cueing on the current computer system.

When NativeWindow.supportsNotification is true, then calling the window's notify() method will result in a visual cue to the user that an event of interest has occured. This visual cue will conform to the operating system convention of the native system. For example, on Windows, the task bar icon will flash.

Note: Calling notify() when NativeWindow.supportsNotification is false is allowed, but does nothing.

See also

Reports the system chrome setting used to create the window.

The values returned by NativeWindow.systemChrome will be one of the constants defined in the NativeWindowSystemChrome class.

The system chrome setting cannot be changed after a window is created.

See also

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

The largest window size allowed by the operating system.

systemMaxSize.x is the maximum window width; systemMaxSize.y is the maximum window height.

The smallest window size allowed by the operating system.

systemMinSize.x is the minimum window width; systemMinSize.y is the minimum window height.

The window title.

The title will appear in the system chrome for the window, if displayed, as well as in other system-dependent locations (such as the task bar).

windowObj.title = "Window Title";

Reports the transparency setting used to create the window.

The transparent property cannot be changed after a window is created. Transparency affects both the visual appearance and the mouse behavior of the window. If the alpha value of a pixel is below a certain threshold, which varies between about .06 and .01 depending on the operating system, then the window will not capture mouse events above that pixel.

See also

Reports the window type setting used to create the window.

The values returned by NativeWindow.type will be one of the constants defined in the NativeWindowType class.

The type setting cannot be changed after a window is created.

See also

Specifies whether this window is visible.

An invisible window is not displayed on the desktop, but all window properties and methods are valid.

By default, visible is set to false. To display a window, set visible to true or call NativeWindow.activate().

Note: On Mac OS X, setting visible=false on a minimized window will not remove the window icon from the dock. If a user subsequently clicks the dock icon, the window will return to the visible state and be displayed on the desktop.

See also

windowObj.visible = true;

displayObj.stage.nativeWindow.visible = true;

window.nativeWindow.visible = true;

The width of this window in pixels.

The dimensions of a NativeWindow include any system window chrome that is displayed. The width of the usable display area inside a window is available from the Stage.stageWidth property.

Changing the width property of a window is equivalent to changing the width through the bounds property.

If the width specified is less than the minimum or greater than the maximum allowed width, either because of the minSize and maxSize properties of the window, or the minimum and maximum operating system limits, then the window width is set to the closest legal size.

See also

The horizontal axis coordinate of this window's top left corner relative to the upper left corner of the operating system's desktop.

Changing the x property of a window is equivalent to changing the location through the bounds property.

See also

The vertical axis coordinate of this window's top left corner relative to the upper left corner of the operating system's desktop.

Changing the y property of a window is equivalent to changing the location through the bounds property.

See also

Creates a new NativeWindow instance and a corresponding operating system window.

The settings defined in the initOptions parameter cannot be changed after the window is created. Invalid initOptions will cause an IllegalOperationError to be thrown. Settings that are valid but not available on the current system will not throw an exception. The window capabilities specific to the current operating system can be detected, if desired, using the static NativeWindow members such as systemMaxSize.

The default window size is determined by the operating system, but can be changed by setting the window bounds. The change will not be visible if the window visible property is false.

See also

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

newWindow.activate();

Activates this window.

Activating a window will:

• Make the window visible
• Bring the window to the front
• Give the window keyboard and mouse focus

See also

displayObject.stage.nativeWindow.activate();

windowObj.activate();

window.nativeWindow.activate();

Closes this window.

A "close" event is dispatched as soon as the close operation is complete. A "closing" event will not be dispatched. If cancellation of the close operation should be allowed, dispatch a closing event and check whether any registered listeners cancel the default behavior before calling the close method.

If DisplayObject instances that are currently in the window are not referenced elsewhere they will be garbage collected and destroyed.

After being closed, the NativeWindow object is still a valid reference, but accessing most properties and methods will throw an ''IllegalOperationError''.

Closed windows cannot be reopened. If the window is already closed, no action is taken and no events are dispatched.

Note: to hide a window, set the window's visible property to false.

See also

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()){
                //The following calls are equivalent (by default)
                   window.nativeWindow.close();
                //window.close(); 
               return true;
           } else {
               return false;
        }
    }
        
    function onClosing(event){
        if(dirtyData){
            event.preventDefault();
            //Save data...
        }
    }    

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

Converts a point in pixel coordinates relative to the origin of the window stage (a global point in terms of the display list), to a point on the virtual desktop.

Virtual desktop coordinates are relative to the upper, lefthand corner of the primary monitor.

Parameters

See also

Maximizes this native window according to system rules and behavior.

Calling maximize() dispatches a displayStateChange event, and, if applicable, a move and a resize event. Wheras system chrome will dispatch a displayStateChanging event that can be canceled when a maximize command is initiated by a user, your maximize logic must implement this behavior, if desired.

maximize() executes asynchronously. To detect the completion of the state change, listen for the "displayStateChange" event.

If the window is already maximized, no action is taken and no events are dispatched.

Note: On operating systems, such as Mac OS X, in which maximizing a window does not also prevent resizing, calling maximize() will zoom the window to fill the screen, but will not prevent subsequent resizing of the window. Resizing a zoomed window will also restore the display state.

See also

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

Minimizes this native window according to system rules and behavior.

Calling minimize() dispatches a displayStateChange event, and, if applicable, a move and a resize event. Wheras system chrome will dispatch a displayStateChanging event that can be canceled when a minimize command is initiated by a user, calling minimize() directly does not. Your minimize logic may implement this behavior, if desired.

minimize() executes asynchronously. To detect the completion of the state change, listen for the "displayStateChange" event.

If the window is already minimized, no action is taken and no events are dispatched.

See also

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(nativeWin){
    if(nativeWin.displayState != air.NativeWindowDisplayState.MINIMIZED){
        var beforeState = nativeWin.displayState;
        var afterState = air.NativeWindowDisplayState.MINIMIZED;
        var displayStateEvent = 
            new air.NativeWindowDisplayStateEvent(air.NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                              true,true,beforeState,afterState);
        nativeWin.dispatchEvent(displayStateEvent);
        if(!displayStateEvent.isDefaultPrevented()){
            nativeWin.minimize();
            return true;
        } else {
          return false;
        }
     }
     return false;
}

Triggers a visual cue through the operating system that an event of interest has occured.

When NativeWindow.supportsNotification is true, the visual cue will conform to the operating system convention of the native system. For example, on Windows, the task bar icon will flash.

The type parameter determines the intensity of the cue. Constants for the permitted values are defined in the NotificationType class, and may be:

• NotificationType.INFORMATIONAL
• NotificationType.CRITICAL

The cues provided for informational notifications are of short duration; those provided for critical notifications will last until the user activates the window.

Note: Calling notifyUser() when NativeWindow.supportsNotification is false is allowed, but does nothing.

Parameters

Sends this window directly behind the specified window.

Does not activate or acquire the focus for the window or the application. Minimized or hidden (visible==false) windows cannot be reordered.

If alwaysInFront = true, then sending this window behind a window with alwaysInFront = false will change this window's alwaysInFront property to match.

Parameters

windowBehind.orderInBackOf(windowFront);

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

jsWindowObjBehind.nativeWindow.orderInBackOf(jsWindowObjFront.nativeWindow);

Brings this window directly in front of the specified window.

Does not activate or acquire the focus for the window or the application. Minimized or hidden (visible==false) windows cannot be reordered.

If alwaysInFront = false, then bringing this window in front of a window with alwaysInFront = true will change this window's alwaysInFront property to match.

Parameters

windowFront.orderInFrontOf(windowBehind);

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

jsWindowObjFront.nativeWindow.orderInFrontOf(jsWindowObjBehind.nativeWindow);

Sends this window behind any other visible windows.

Does not activate or acquire the focus for this window or the application. Minimized or hidden (visible==false) windows cannot be reordered.

If alwaysInFront = true, then calling this method will not send this window behind any windows which have alwaysInFront == false.

windowObj.orderToBack();

displayObj.stage.nativeWindow.orderToBack();

window.nativeWindow.orderToBack();

Brings this window in front of any other visible windows.

Does not activate or acquire the focus for this window or the application. Minimized or hidden (visible==false) windows cannot be reordered.

If alwaysInFront = false, then calling this method will not send this window in front of any windows which have alwaysInFront == true.

windowObj.orderToFront();

displayObj.stage.nativeWindow.orderToFront();

window.nativeWindow.orderToFront();

Restores this window from either a minimized or a maximized state.

Calling restore() dispatches a displayStateChange event, and, if applicable, a move and a resize event. Wheras system chrome will dispatch a displayStateChanging event that can be canceled when a restore command is initiated by a user, your restore logic must implement this behavior, if desired.

restore() executes asynchronously. To detect the completion of the state change, listen for the "displayStateChange" event.

If the window is already in the NativeWindowDisplayState.NORMAL state, no action is taken and no events are dispatched.

See also

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

Starts a system-controlled move of this window.

When called from a mouseDown event, this method begins a mouse-driven move sequence that continues until a mouseUp event occurs.

When called from other code this method begins a keyboard- or mouse-driven move sequence consistent with the operating system's default sequence.

During a move sequence, a series of events will be dispatched as the window origin moves. For each incremental move, first a moving event is dispatched and then, if the moving event is not canceled, the window location is updated and a move event is dispatched. If a moving event is canceled, the move sequence is immediately terminated.

import flash.display.NativeWindow;
import flash.events.MouseEvent;

public class MovableWindow extends NativeWindow{
    private function MovableWindow():void{
        super(new NativeWindowInitOptions());
        this.visible = true;
        this.stage.addEventListener(MouseEvent.MOUSE_DOWN, onMoveCommand);
    }
    
    private function onMoveCommand(event:MouseEvent):void{
        this.startMove();
    }
}

Starts a system-controlled resize operation of this window.

When called from a mouseDown event handler this method begins a mouse-driven resizing sequence that continues until a mouseUp event occurs.

When called from other code this method begins a keyboard- or mouse-driven resizing sequence consistent with the operating system's default sequence.

During the resize sequence, a series of events will be dispatched as the window dimensions change. For each incremental change, first a resizing event is dispatched and then, if the resizing event is not canceled, the window dimensions are updated and a resize event is dispatched. If a resizing event is canceled, the the sequence is immediately terminated.

Parameters

public class ResizableWindow extends NativeWindow
{
    public function ResizableWindow()
    {
        var options:NativeWindowInitOptions = new NativeWindowInitOptions();
        super(options);
        this.stage.align = StageAlign.TOP_LEFT;
        this.stage.scaleMode = StageScaleMode.NO_SCALE;
        this.visible = true;
        this.stage.addEventListener(MouseEvent.MOUSE_DOWN, onResizeCommand);
    }

    private function onResizeCommand(event:MouseEvent):void{
        var resizeFrom:String = "";
        if(event.localY < this.height * .33){resizeFrom = "T";}
        else if(event.localY > this.height * .66){resizeFrom = "B";}
        if(event.localX < this.width * .33){resizeFrom += "L";}
        else if(event.localX > this.width * .66){resizeFrom += "R";}
        
        this.startResize(resizeFrom);
    }    
}

Dispatched by this NativeWindow object after the window has been activated.

Note: This event does not go through a "capture phase" and is dispatched directly to the target, whether the target is on the display list or not.

This event has the following properties:

Dispatched by this NativeWindow object after the window has been closed.

This event has the following properties:

Dispatched by this NativeWindow object immediately before the window is to be closed. This event can be cancelled to prevent the window from being closed.

This event has the following properties:

Dispatched by this NativeWindow object after the window has been deactivated.

Note: This event does not go through a "capture phase" and is dispatched directly to the target, whether the target is on the display list or not.

This event has the following properties:

Dispatched by this NativeWindow object after the window's displayState has changed.

Dispatched by this NativeWindow object immediately before the window changes displayState. This event can be cancelled to prevent the change.

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

Dispatched by this NativeWindow object after the window has been moved on the desktop.

A move event is dispatched whenever the origin (x or y properties) of the window changes, which can occur because of a system-controlled window move; minimizing, maximizing, or restoring the window; or changing the window location by setting the x, y, or bounds properties.

Note: Avoid actions that may open simultaneous operating system dialogs in the handler functions for both the moving and move events of a NativeWindow. This may occur, for example, if both handler functions throw an error. If it does occur, the second dialog opened will not register mouse clicks and must be dismissed using the keyboard.

Dispatched by the NativeWindow object immediately before the window is to be moved on the desktop. This event can be cancelled to prevent or modify the move.

Note: Avoid actions that may open simultaneous operating system dialogs in the handler functions for both the moving and move events of a NativeWindow. This may occur, for example, if both handler functions throw an error. If it does occur, the second dialog opened will not register mouse clicks and must be dismissed using the keyboard.

Dispatched by this NativeWindow object after the window has been resized. A resize event is dispatched whenever the size (width or height properties) of the window changes, which can occur because of a system-controlled window resize; minimizing, maximizing, or restoring the window; or changing the window size by setting the width, height, or bounds properties. NativeWindow "resize" events are dispatched during system-controled resize loops. In contrast, Stage object "resize" events are dispatched when the Stage is ready for drawing.

See also

Dispatched by this NativeWindow object immediately before the window is to be resized on the desktop. This event can be canceled to prevent or modify the resize.

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