指示此窗口是否为活动应用程序窗口。

使用 activate() 方法可使窗口处于活动状态。

另请参见

指定此窗口是否始终显示在其他窗口前面（包括其他应用程序的窗口）。

沿系统深度顺序有两组窗口。位于 alwaysInFront 组中的窗口始终显示在所有其他窗口的前面。同一组内的窗口之间的深度顺序按常规确定。换句话说，激活一个窗口会将该窗口置于其组内的其他窗口前面。

将 alwaysInFront 从 false 更改为 true 会将该窗口置于所有其他窗口的前面。将该属性从 true 更改为 false 会将该窗口置于“alwaysInFront”窗口的后面，但仍位于其他窗口前面。将该属性设置为其当前值不会更改该窗口的深度顺序。

应该尽量少将 alwaysInFront 设置为 true，因为使用此设置的窗口将出现在其他应用程序的窗口之前，即使其他应用程序处于活动状态时也是如此。

某些 Linux 窗口管理器始终将实用程序窗口显示在常规窗口之前。

注意：在 Mac^® OS X 中，如果窗口舞台的 displayState 属性为 fullScreen 或 fullScreenInteractive，将 alwaysInFront 设置为 true 将不起作用。在 Linux 中，alwaysInFront 设置为 true 的全屏窗口始终显示在 alwaysInFront 设置为 true 的其它窗口之前。

windowObj.alwaysInFront = true;

displayObject.stage.nativeWindow.alwaysInFront=true;

window.nativeWindow.alwaysInFront = true;

此窗口的大小和位置。

窗口尺寸包括任何系统镶边。窗口舞台的尺寸等于窗口尺寸减去任何系统镶边的大小。更改窗口的宽度和高度将更改舞台的 stageWidth 和 stageHeight。反之亦然：更改舞台尺寸也将更改窗口大小。

在根 HTML 窗口中，outerWidth 和 outerHeigth 属性等效于窗口的 height 和 width 属性。innerWidth 和 innerHeight 属性等于 stage.stageWidth 和 stage.stageHeight 属性减去该窗口显示的任何滚动条的粗细。

每当此窗口的宽度或高度更改时即调度 resize 事件。同样，每当此窗口的原点 (x,y) 更改时即调度 move 事件。直接设置 bounds 属性不会调度 moving 或 resizing 事件。若要使其他组件可以准备或取消即将进行的移动或调整大小操作，您的范围更改逻辑可以使用 NativeWindow dispatchEvent() 方法调度 moving 和 resizing 事件，然后检查注册侦听器是否取消了该事件。

设置窗口的 bounds 属性等效于设置其 x、y、width 和 height 属性。同样，设置任何单个尺寸等效于设置 bounds 属性。使用 bounds 属性同时设置所有尺寸时，调度的事件会较少。

无法保证设置各个尺寸的顺序。在不允许窗口扩大到桌面区域之外的 Linux 窗口管理器中，即使应用所有属性更改的最终效果会产生合法的窗口，也可能会阻止对单个属性的更改。

如果由于窗口的 minSize 和 maxSize 属性，或由于操作系统的最小值和最大值限制，指定的宽度和高度小于允许的最小值或大于允许的最大值，则会将窗口尺寸设置为最接近的合法大小。显示的任何系统镶边的最小宽度和高度也可能导致窗口大于指定的大小。

另请参见

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

指示此窗口是否已关闭。

对已关闭的窗口访问以下属性将引发非法操作错误：

• 标题
• 范围
• x、y、width、height
• displayState
• visible

同样，对已关闭的窗口调用以下方法也将引发非法操作错误：

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

var isWindowClosed:Boolean = windowObj.closed;

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

var isWindowClosed = window.nativeWindow.closed;

此窗口的显示状态。

用作可能值的常数在 NativeWindowDisplayState 类中定义：

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

另请参见

var state:String = windowObj.displayState;

此窗口的高度（以像素为单位）。

窗口的尺寸包括显示的任何系统窗口镶边。可以从 Stage.stageHeight 属性获取窗口内部可用的显示区域高度。

更改窗口的 height 属性等效于通过 bounds 属性更改高度。

如果由于窗口的 minSize 和 maxSize 属性，或由于操作系统的最小值和最大值限制，指定的高度小于允许的最小高度或大于允许的最大高度，则会将窗口高度设置为最接近的合法大小。

另请参见

报告用于创建此窗口的 maximizable 设置。

创建窗口后，不能更改 maximizable 设置。

并非所有 Linux 窗口管理器都保留 maximizable 设置。

另请参见

此窗口的最大大小。

大小限制指定为 Point 对象的坐标。点的 x 属性对应于窗口宽度，y 属性对应于窗口高度。

对于通过 ActionScript JavaScript 代码和通过操作系统调用的窗口大小调整操作实施 maxSize 限制。

如果窗口的当前范围大于新的最大大小，则设置 maxSize 将更改窗口的范围。

注意：在某些操作系统（如 Mac OS X）中，即使最大化后的窗口将小于操作系统屏幕，将窗口最大化也只能使窗口扩大至 maxSize 值。该窗口将仍然处于最大化显示状态。

另请参见

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

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

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

此窗口的本机菜单。

在将 NativeMenu 对象分配给窗口的 menu 属性时，如果 NativeWindow.supportsMenu 为 true，将为窗口显示一个本机菜单，除非该窗口的 systemChrome 属性为 NativeWindowSystemChrome.NONE。

注意：允许在 NativeWindow.supportsMenu 为 false 或窗口的 systemChrome 属性为 NativeWindowSystemChrome.NONE 时为窗口分配菜单，但不执行任何操作。

另请参见

报告用于创建此窗口的 minimizable 设置。

创建窗口后，不能更改 minimizable 设置。

并非所有 Linux 窗口管理器都保留 minimizable 设置。

另请参见

此窗口的最小大小。

大小限制指定为 Point 对象的坐标。点的 x 属性对应于窗口宽度，y 属性对应于窗口高度。

如果窗口的当前范围小于新的最小大小，则设置 minSize 将更改窗口的范围。

对于通过 ActionScript JavaScript 代码和通过操作系统调用的窗口大小调整操作实施 minSize 限制。

注意：显示的任何系统镶边的宽度和高度可能使得无法将窗口设置得与指定的最小大小一样小。

另请参见

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

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

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

报告用于创建此窗口的 resizable 设置。

创建窗口后，不能更改 resizable 设置。

另请参见

此窗口的 Stage 对象。Stage 对象是基于 ActionScript 3.0 的 SWF 内容中使用的显示列表体系结构中的根对象。

舞台是窗口显示列表的根。通过将可视显示对象添加到舞台或添加到此舞台的显示列表中已有的另一个对象来将可视显示对象添加到窗口。舞台尺寸是在窗口使用系统镶边时窗口客户端区域的尺寸。如果不使用系统镶边，舞台尺寸等于窗口尺寸。

呈现 HTML 内容的 HTMLLoader 是显示列表树上的一个叶。由 ActionScript 定义的显示对象可以按绘制顺序位于 HTMLLoader 之上，也可以位于其下，但不能位于由 HTMLLoader 呈现的可视元素之间。

另请参见

import flash.display.StageAlign;

windowObj.stage.align = StageAlign.TOP_LEFT;

指示 AIR 是否在当前计算机系统上支持本机窗口菜单。

如果 NativeWindow.supportsMenu 为 true，则在将 NativeMenu 对象分配给窗口的 menu 属性时，将为该窗口显示本机菜单（除非该窗口的 systemChrome 属性为 NativeWindowSystemChrome.NONE）。

注意：允许在 NativeWindow.supportsMenu 为 false 或窗口的 systemChrome 属性为 NativeWindowSystemChrome.NONE 时为窗口分配菜单，但不执行任何操作。

另请参见

指示 AIR 是否在当前计算机系统上支持窗口通知提示。

如果 NativeWindow.supportsNotification 为 true，则调用该窗口的 notifyUser() 方法将向用户显示一个可视提示，提示用户发生了需要关注的事件。此可视提示将遵循本机系统的操作系统约定。例如在 Windows^®中，任务栏图标将闪烁。

注意：允许在 NativeWindow.supportsNotification 为 false 时调用 notifyUser()，但不执行任何操作。

另请参见

指示 AIR 是否支持具有透明像素的本机窗口。

当 NativeWindow.supportsTransparency 为 true，若窗口 transparent 属性设为 true，将保留本机窗口的像素的透明度。若 NativeWindow.supportsTransparency 为 false，则无论窗口 transparent 属性为何值，所有像素的不透明度都将设为 1。NativeWindow.supportsTransparency 为 false 时，完全透明的像素将呈现黑色。

注意：根据为操作系统设置的用户首选项的不同，在应用程序运行过程中，此属性的值可能会发生变化。

另请参见

报告用于创建此窗口的系统镶边设置。

由 NativeWindow.systemChrome 返回的值将是在 NativeWindowSystemChrome 类中定义的常数之一。

创建窗口后，不能更改系统镶边设置。

另请参见

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

操作系统允许的最大窗口大小。

大小限制指定为 Point 对象的坐标。点的 x 属性对应于窗口宽度，y 属性对应于窗口高度。

操作系统允许的最小窗口大小。

大小限制指定为 Point 对象的坐标。点的 x 属性对应于窗口宽度，y 属性对应于窗口高度。

窗口标题。

该标题将出现在该窗口的系统镶边中（如果显示系统镶边），也会出现在与系统相关的其他位置（如任务栏）。

windowObj.title = "Window Title";

报告用于创建此窗口的透明度设置。

创建窗口后，不能更改 transparent 属性。透明度影响窗口的视觉外观和鼠标行为。如果某一像素的 Alpha 值低于特定的阈值（大约在 .06 和 .01 之间变化，具体取决于操作系统），则该窗口将无法捕获该像素上方的鼠标事件。

注意：并不总是支持窗口透明度。如果用户的操作系统配置不提供透明度，则创建窗口时将不含透明度。原本要透明的区域将混合为黑色。请使用 NativeWindow.supportsTransparency 属性确定是否支持窗口透明度。

另请参见

报告用于创建此窗口的窗口 type 设置。

由 NativeWindow.type 返回的值将是在 NativeWindowType 类中定义的常数之一。

创建窗口后，不能更改 type 设置。

另请参见

指定此窗口是否可见。

不可见窗口不显示在桌面上，但所有窗口属性和方法都是有效的。

在默认情况下，visible 设置为 false。若要显示窗口，请将 visible 设置为 true 或调用 NativeWindow.activate()。

注意：在 Mac OS X 中，对一个最小化的窗口设置 visible=false 不会从停靠处删除该窗口图标。如果用户随后单击该停靠图标，该窗口将返回可见状态并显示在桌面上。

另请参见

windowObj.visible = true;

displayObj.stage.nativeWindow.visible = true;

window.nativeWindow.visible = true;

此窗口的宽度（以像素为单位）。

为本机窗口报告的尺寸包括显示的任何系统窗口镶边。可以从 Stage.stageWidth 属性获取窗口内部可用的显示区域宽度。

更改窗口的 width 属性等效于通过 bounds 属性更改宽度。

如果由于窗口的 minSize 和 maxSize 属性，或由于操作系统的最小值和最大值限制，指定的宽度小于允许的最小宽度或大于允许的最大宽度，则会将窗口宽度设置为最接近的合法大小。

另请参见

此窗口的左上角相对于操作系统桌面原点的水平轴坐标。

在安装了多个显示器的系统中，x 可能为负。如果保存该值可能是为了将窗口重新定位在上次的位置，则应始终验证在还原位置时是否将窗口放置到可用的位置。更改屏幕分辨率或显示器布置可能会导致窗口被置于屏幕以外。使用 Screen 类可获取有关桌面几何形状的信息。

更改窗口的 x 属性等效于通过 bounds 属性更改位置。

另请参见

此窗口的左上角相对于操作系统桌面左上角的垂直轴坐标。

在安装了多个显示器的系统中，y 可能为负。如果保存该值可能是为了将窗口重新定位在上次的位置，则应始终验证在还原位置时是否将窗口放置到可用的位置。更改屏幕分辨率或显示器布置可能会导致窗口被置于屏幕以外。使用 Screen 类可获取有关桌面几何形状的信息。

更改窗口的 y 属性等效于通过 bounds 属性更改位置。

另请参见

创建新的 NativeWindow 实例和相应的操作系统窗口。

创建窗口后，不能更改 initOptions 参数中定义的设置。无效的 initOptions 设置将导致引发非法操作错误。在当前系统中有效但不可用的设置不会引发异常。如果需要，可以使用静态 NativeWindow 成员（比如 systemMaxSize）来检测特定于当前操作系统的窗口功能。

默认的窗口大小由操作系统确定，但是可以通过设置窗口范围来更改。如果窗口的 visible 属性为 false，则更改将是不可见的。

另请参见

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

激活此窗口。

激活一个窗口将会：

• 使该窗口可见
• 将该窗口置于前面
• 为该窗口提供键盘和鼠标焦点

另请参见

displayObject.stage.nativeWindow.activate();

windowObj.activate();

window.nativeWindow.activate();

关闭此窗口。

关闭操作一旦完成即调度 close 事件。将不调度 closing 事件。如果应该允许取消关闭操作，请调度一个 closing 事件并检查在调用 close() 方法之前是否有任何注册的侦听器取消了默认行为。

如果未在其他位置引用当前处于此窗口中的显示对象实例，则会将这些实例作为垃圾回收，除非它们位于由 AIR 创建的初始应用程序窗口中。若要允许将初始窗口中的显示对象作为垃圾进行回收，请将它们从窗口舞台上删除。

关闭后的 NativeWindow 对象仍然是有效的引用，但访问大多数属性和方法都将引发非法操作错误。

关闭的窗口无法重新打开。如果窗口已经关闭，则不执行任何动作，也不调度任何事件。

注意：若要在不关闭窗口的情况下隐藏一个窗口，请将该窗口的 visible 属性设置为 false。

另请参见

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>

将像素坐标中相对于窗口舞台原点（就显示列表而言为全局点）转换为虚拟桌面上的点。

虚拟桌面坐标相对于主监视器的左上角。

参数

另请参见

使此窗口最大化。

调用 maximize() 将调度 displayStateChange 事件，如果适用，还将调度 move 和 resize 事件。系统镶边将调度 displayStateChanging 事件，当用户启动最大化命令时可取消该事件，如果需要，您的最大化逻辑必须实现此行为。

maximize() 方法异步执行。若要检测状态更改是否完成，请侦听 displayStateChange 事件。

如果窗口已经最大化，则不执行任何动作，也不调度任何事件。

注意：

• 在某些操作系统（如 Mac OS X）中，将窗口最大化并不会同时阻止调整大小，调用 maximize() 将缩放窗口以填充屏幕，但并不阻止随后的调整窗口大小。调整经过缩放的窗口的大小也会还原显示状态。
• 在某些操作系统（如 Mac OS X）中以及在某些 Linux 窗口管理器中，将窗口最大化并不会将窗口扩大至超出 maxSize 属性中指定的宽度和高度。在其它操作系统中，即使屏幕大于 maxSize，也将扩大窗口以填充屏幕。

某些 Linux 窗口管理器不允许将实用程序窗口最大化。

另请参见

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

使此窗口最小化。

调用 minimize() 将调度 displayStateChange 事件，如果适用，还将调度 move 和 resize 事件。系统镶边将调度 displayStateChanging 事件，当用户启动最小化命令时可取消该事件，而直接调用 minimize() 不能调度该事件。如果需要，您的最小化逻辑可以实现此行为。

minimize() 方法异步执行。若要检测状态更改是否完成，请侦听 displayStateChange 事件。

如果窗口已经最小化，则不执行任何动作，也不调度任何事件。

某些 Linux 窗口管理器不允许将实用程序窗口最小化。

另请参见

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

通过操作系统触发可视提示：发生了需要关注的事件。

当 NativeWindow.supportsNotification 为 true 时，可视提示将遵循本机系统的操作系统约定。例如在 Windows 中，任务栏图标将闪烁。

type 参数确定提示的强度。用作允许值的常数在 NotificationType 类中定义，这些常数可以是：

• NotificationType.INFORMATIONAL
• NotificationType.CRITICAL

为信息性通知提供的提示持续时间很短，而为关键通知提供的提示将持续到用户激活此窗口为止。并非所有 Linux 窗口管理器都支持两种通知级别。对于此类窗口管理器，无论指定哪个选项，notifyUser() 的效果都将相同。

注意：允许在 NativeWindow.supportsNotification 为 false 时调用 notifyUser()，但不执行任何操作。

参数

将此窗口放在紧靠指定窗口后面。

不要激活此窗口或应用程序或获取其焦点。最小化或隐藏的 (visible 为 false) 窗口无法重新排序。

某些 Linux 窗口管理器不允许将实用程序窗口排在常规窗口之后。

参数

windowBehind.orderInBackOf(windowFront);

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

jsWindowObjBehind.nativeWindow.orderInBackOf(jsWindowObjFront.nativeWindow);

将此窗口放在紧靠指定窗口前面。

不要激活此窗口或应用程序或获取其焦点。最小化或隐藏的 (visible 为 false) 窗口无法重新排序。

某些 Linux 窗口管理器不允许将常规窗口排在实用程序窗口之前。

参数

windowFront.orderInFrontOf(windowBehind);

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

jsWindowObjFront.nativeWindow.orderInFrontOf(jsWindowObjBehind.nativeWindow);

将此窗口放在任何其他可见窗口后面。

不要激活此窗口或应用程序或获取其焦点。最小化或隐藏的 (visible 为 false) 窗口无法重新排序。

如果 alwaysInFront 为 true，则调用此方法不会将此窗口置于任何 alwaysInFront 设置为 false 的窗口的后面。

某些 Linux 窗口管理器不允许将实用程序窗口排在常规窗口之后。

windowObj.orderToBack();

displayObj.stage.nativeWindow.orderToBack();

window.nativeWindow.orderToBack();

将此窗口放在任何其他可见窗口前面。

不要激活此窗口或应用程序或获取其焦点。最小化或隐藏的 (visible 为 false) 窗口无法重新排序。

如果 alwaysInFront 为 false，则调用此方法不会将此窗口置于任何已将 alwaysInFront 设置为 true 的窗口的前面。

某些 Linux 窗口管理器不允许将常规窗口排在实用程序窗口之前。

windowObj.orderToFront();

displayObj.stage.nativeWindow.orderToFront();

window.nativeWindow.orderToFront();

从最小化或最大化状态恢复此窗口。

调用 restore() 将调度 displayStateChange 事件，如果适用，还将调度 move 和 resize 事件。系统镶边将调度 displayStateChanging 事件，当用户启动还原命令时可取消该事件，如果需要，您的还原逻辑必须实现此行为。

restore() 方法异步执行。若要检测状态更改是否完成，请侦听 displayStateChange 事件。

如果窗口已经处于 NativeWindowDisplayState.NORMAL 状态，则不执行任何动作，也不调度任何事件。

另请参见

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

启动此窗口的系统控制移动。

在从 mouseDown 事件调用时，此方法开始一个由鼠标驱动的移动序列，该序列将持续到发生 mouseUp 事件为止。

在从其他代码调用时，此方法开始一个由键盘或鼠标驱动的移动序列，该序列与操作系统的默认序列一致。

在移动序列执行期间，随着窗口原点的移动，将调度一系列事件。对于每次增量移动，首先调度一个 moving 事件，然后，如果未取消该 moving 事件，则将更新窗口位置并调度一个 move 事件。如果取消了 moving 事件，则移动序列将立即终止。

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

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

启动此窗口的系统控制调整大小操作。

在从 mouseDown 事件处理函数调用时，此方法开始一个由鼠标驱动的调整大小序列，该序列将持续到发生 mouseUp 事件为止。

在从其他代码调用时，此方法开始一个由键盘或鼠标驱动的调整大小序列，该序列与操作系统的默认序列一致。

在调整大小序列执行期间，随着窗口尺寸的更改，将调度一系列事件。对于每次增量更改，首先调度一个 resizing 事件，然后，如果未取消该 resizing 事件，则将更新窗口尺寸并调度一个 resize 事件。如果取消了 resizing 事件，则该序列将立即终止。

参数

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.stage.addEventListener(MouseEvent.MOUSE_DOWN, onResizeCommand);
        this.activate();
    }

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

在激活窗口后由此 NativeWindow 对象调度。

注意：此事件既不具有“捕获阶段”也不具有“冒泡阶段”，这意味着必须直接将事件侦听器添加到任何潜在的目标，而无论目标是否位于显示列表中。

此事件具有以下属性：

在关闭窗口后由此 NativeWindow 对象调度。

此事件具有以下属性：

在关闭窗口的前一刻由此 NativeWindow 对象调度。可以取消此事件以避免关闭窗口。

此事件具有以下属性：

在取消激活窗口后由此 NativeWindow 对象调度。

注意：此事件既不具有“捕获阶段”也不具有“冒泡阶段”，这意味着必须直接将事件侦听器添加到任何潜在的目标，而无论目标是否位于显示列表中。

此事件具有以下属性：

在窗口的 displayState 属性更改后由此 NativeWindow 对象调度。

在窗口更改其显示状态的前一刻由此 NativeWindow 对象调度。可以取消此事件以避免更改。

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

在桌面上移动窗口后由此 NativeWindow 对象调度。

每当窗口原点（x 或 y 属性）更改时调度 move 事件，窗口原点的更改可能是系统控制的窗口移动操作的结果：最小化、最大化或还原窗口、或通过设置 x、y 或 bounds 属性更改窗口位置。

注意：在 NativeWindow 对象的 moving 和 move 事件的处理函数中，避免可能会同时打开操作系统对话框的动作。例如，如果两个处理函数都引发错误，则可能发生这种情况。如果真的发生这种情况，则打开的第二个对话框将不会注册鼠标单击，必须使用键盘才能取消。

在桌面上移动窗口的前一刻由此 NativeWindow 对象调度。可以取消此事件以避免或修改移动。

注意：在 NativeWindow 对象的 moving 和 move 事件的处理函数中，避免可能会同时打开操作系统对话框的动作。例如，如果两个处理函数都引发错误，则可能发生这种情况。如果真的发生这种情况，则打开的第二个对话框将不会注册鼠标单击，必须使用键盘才能取消。

在调整窗口大小后由此 NativeWindow 对象调度。每当窗口大小（width 或 height 属性）更改时调度 resize 事件，窗口大小的更改可能是系统控制的窗口大小调整操作的结果：最小化、最大化或还原窗口、或通过设置 width、height 或 bounds 属性更改窗口大小。NativeWindow 的 resize 事件是在系统控制的调整大小循环中调度的。相反，Stage 对象的 resize 事件是在舞台准备好绘图时调度的。

另请参见

在桌面上调整窗口大小的前一刻由此 NativeWindow 对象调度。可以取消此事件以避免或修改调整大小。

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