NativeWindow  - AS3

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

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

相关 API 元素

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

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

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

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

操作系统行为注意事项：

• 某些 Linux 窗口管理器不会在全屏窗口的前面显示 alwaysInFront 属性设置为 的窗口。
• 在 Mac^® OS X 中，如果窗口舞台的 displayState 属性为 fullScreen 或 fullScreenInteractive，将 alwaysInFront 设置为 true 将不起作用。

windowObj.alwaysInFront = true;

displayObject.stage.nativeWindow.alwaysInFront=true;

window.nativeWindow.alwaysInFront = true;

此窗口的大小和位置。

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

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

每当此窗口的宽度或高度更改时即调度 resize 事件。同样，每当此窗口的原点 (x,y) 更改时即调度 move 事件。在 Mac OS 和 Windows 上，直接设置 bounds 属性不会调度 moving 或 resizing 事件。但在 Linux 上，设置 bounds 属性时，NativeWindow 会调度 moving 和 resizing 事件。

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

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

如果指定的宽度或高度小于允许的最小值或大于允许的最大值，则会将窗口宽度或高度设置为最接近的合法大小。决定宽度和高度的最小值和最大值的因素包括以下这些：

• NativeWindow 对象的 minSize 属性和 maxSize 属性
• 操作系统的最小限值和最大限值，即 NativeWindow.systemMinSize 和 NativeWindow.systemMaxSize 的值。
• 在 Adobe AIR 中，窗口的最大宽度和高度均为 4095 像素。（在 AIR 1.5 及早期版本中，窗口宽度和高度的最大值都是 2880 像素。）
• 任何显示的系统镶边需要的最小宽度和高度。

当窗口的位置或尺寸更改时，像素值将舍入为最近的整数。

相关 API 元素

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

表示此窗口是否已关闭。

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

• title
• bounds
• 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

相关 API 元素

var state:String = windowObj.displayState;

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

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

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

如果指定高度小于允许的最小值或大于允许的最大值，则会将窗口高度设置为最接近的合法大小。决定高度的最小值和最大值的因素包括以下这些：

• NativeWindow 对象的 minSize.x 和属性 maxSize.x 属性
• 操作系统的最小限值和最大限值，即 NativeWindow.systemMinSize.x 和 NativeWindow.systemMaxSize.x 的值。
• 在 Adobe AIR 中，窗口高度的最大值是 4095 像素（在 AIR 1.5 及早期版本中是 2880 像素）。

在 Linux 上，设置 height 属性是一种异步操作。

要检测高度更改是否完成，请侦听 resize 事件，所有平台上都会调度该事件。

当窗口的高度更改时，像素值将舍入为最近的整数。

相关 API 元素

表示客户端系统上是否支持本机窗口。

报告用于创建此窗口的可最大化设置。

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

注意：即使在 maximizable 属性设置为 false 时，某些 Linux 窗口管理器也允许用户最大化窗口。

相关 API 元素

此窗口的最大大小。

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

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

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

如果指定的宽度或高度大于允许的最大值，则会将窗口的宽度或高度设置为最接近的合法大小。决定宽度和高度的最小值和最大值的因素包括以下这些：

• 操作系统的最大限值，即 NativeWindow.systemMaxSize 的值。
• 在 Adobe AIR 中，窗口的最大宽度和高度均为 4095 像素。（在 AIR 1.5 及早期版本中，窗口宽度和高度的最大值都是 2880 像素。）

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

相关 API 元素

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 时为窗口分配菜单，但不执行任何操作。务必使用 NativeWindow.supportsMenu 属性来确定操作系统是否支持窗口菜单。使用其他方法（如 Capabilities.os）确定支持情况可能导致编程错误（如果没有考虑到某些可行的目标操作系统）。

相关 API 元素

报告用于创建此窗口的可最小化设置。

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

注意：即使在 minimizable 属性设置为 false 时，某些 Linux 窗口管理器也允许用户最小化窗口。

相关 API 元素

此窗口的最小大小。

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

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

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

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

相关 API 元素

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

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

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

拥有此窗口的 NativeWindow 对象。

窗口所有权是在创建窗口时建立的，不能更改。要创建具有所有者的窗口，请将拥有的 NativeWindow 对象设置为用于创建所拥有窗口的 NativeWindowInitOptions 对象的 owner 属性。

注意：在 Linux 上，当所有者处于全屏模式时，有些窗口管理器不在拥有窗口前面显示所拥有的窗口。

相关 API 元素

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

NativeWindow.renderMode 返回的值将是在 NativeWindowRenderMode 类中定义的常量之一。

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

相关 API 元素

报告用于创建此窗口的可调整大小设置。

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

相关 API 元素

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

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

相关 API 元素

import flash.display.StageAlign;

windowObj.stage.align = StageAlign.TOP_LEFT;

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

如果 NativeWindow.supportsMenu 为 true，则在将 NativeMenu 对象分配给窗口的 menu 属性时，将为该窗口显示本机菜单（除非该窗口的 systemChrome 属性为 NativeWindowSystemChrome.NONE）。务必使用 NativeWindow.supportsMenu 属性来确定操作系统是否支持本机窗口菜单。使用其他方法（如 Capabilities.os）确定支持情况可能导致编程错误（如果没有考虑到某些可行的目标操作系统）。

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

相关 API 元素

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

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

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

相关 API 元素

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

当 NativeWindow.supportsTransparency 为 true，若窗口 transparent 属性设为 true，将保留本机窗口的像素的透明度。若 NativeWindow.supportsTransparency 为 false，则无论窗口 transparent 属性为何值，所有像素的不透明度都将设为 1。当 NativeWindow.supportsTransparency 为 false 时，完全透明的像素将呈现为黑色。务必使用 NativeWindow.supportsTransparency 属性来确定操作系统是否支持透明度。使用其他方法（如 Capabilities.os）确定支持情况可能导致编程错误（如果没有考虑到某些可行的目标操作系统）。

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

相关 API 元素

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

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

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

相关 API 元素

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

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

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

除了操作系统大小限制，AIR 将窗口大小的最大值限制为 4095 x 4095 像素（在 AIR 1.5 及早期版本中限制为 2880 x 2880 像素）。此外，应用程序可以使用 NativeWindow 对象的 maxSize 属性来设置限值。

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

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

窗口标题。

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

windowObj.title = "Window Title";

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

创建窗口后，不能更改 transparent 属性。透明度影响窗口的视觉外观和鼠标行为。在 Windows 和 Mac OS X 中，当像素的 Alpha 值低于特定的阈值（大约在 .06 和 .01 之间变化，具体取决于操作系统）时，窗口将无法捕获鼠标事件。在 Linux 中，窗口将捕获完全透明区域上方的鼠标事件，从而阻止用户访问桌面上的其他窗口和项目。

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

相关 API 元素

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

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

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

相关 API 元素

指定此窗口是否可见。

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

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

如果此窗口有所有者，该所有者窗口的可见状态确定是否显示此窗口。如果不显示所有者窗口，则不显示任何拥有的窗口，即使其 visible 属性为 true。

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

相关 API 元素

windowObj.visible = true;

displayObj.stage.nativeWindow.visible = true;

window.nativeWindow.visible = true;

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

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

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

如果指定宽度小于允许的最小值或大于允许的最大值，则会将窗口宽度设置为最接近的合法大小。决定宽度的最小值和最大值的因素包括以下这些：

• NativeWindow 对象的 minSize.y 属性和 maxSize.y 属性
• 操作系统的最小限值和最大限值，即 NativeWindow.systemMinSize.y 和 NativeWindow.systemMaxSize.y 的值。
• 在 Adobe AIR 中，窗口宽度的最大值是 4095 像素（在 AIR 1.5 及早期版本中是 2880 像素）。

在 Linux 上，设置 width 属性是一种异步操作。

要检测宽度更改是否完成，请侦听 resize 事件，所有平台上都会调度该事件。

当窗口的宽度更改时，像素值将舍入为最近的整数。

相关 API 元素

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

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

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

在 Linux 上，设置 x 属性是一种异步操作。

要检测位置更改是否完成，请侦听 move 事件，所有平台上都会调度该事件。

当窗口的 x 坐标更改时，像素值将舍入为最近的整数。

相关 API 元素

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

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

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

在 Linux 上，设置 y 属性是一种异步操作。

要检测位置更改是否完成，请侦听 move 事件，所有平台上都会调度该事件。

当窗口的 y 坐标更改时，像素值将舍入为最近的整数。

相关 API 元素

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

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

默认窗口大小由操作系统决定，并且窗口是在不可见状态下创建。要防止将窗口更改为可见，请不要将窗口的 visible 属性更改为 true 或者在窗口更改完成前调用 activate()。

相关 API 元素

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

激活此窗口。

激活一个窗口将会：

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

在 Linux 上，activate() 是一种异步操作。

在所有平台上，NativeWindow 对象都会调度 activate 事件。

相关 API 元素

displayObject.stage.nativeWindow.activate();

windowObj.activate();

window.nativeWindow.activate();

关闭此窗口。

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

关闭一个窗口时，它所拥有的任何窗口也将被关闭。拥有的窗口不调度 closing 事件。

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

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

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

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

相关 API 元素

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>

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

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

参数

相关 API 元素

返回此窗口所拥有的 NativeWindow 对象的列表。

您不能通过在返回的矢量中添加或删除对象来更改 NativeWindows 的所有权。创建窗口后，不能更改窗口所有权。

相关 API 元素

使此窗口最大化。

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

maximize() 方法异步执行。要检测状态更改是否完成，请侦听 displayStateChange 事件。如果窗口已经最大化，则不执行任何动作，也不调度任何事件。

操作系统行为注意事项：

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

相关 API 元素

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 事件，所有平台上都会调度该事件。如果窗口已经最小化，则不执行任何动作，也不调度任何事件。

此窗口拥有的任何窗口在该窗口最小化时隐藏起来。拥有的窗口不调度 displayStateChanging 或 displayStateChange 事件。

注意：

• 在 Windows 中，最小化不可见窗口 (visible == false) 将显示窗口。
• 某些 Linux 窗口管理器不允许将实用程序窗口最小化。

相关 API 元素

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 事件，当用户启动还原命令时可取消该事件，如果需要，您的还原逻辑必须实现此行为。

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

要检测状态更改是否完成，请侦听 displayStateChange 事件，所有平台上都会调度该事件。

相关 API 元素

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 事件，则移动序列将立即终止。

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

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

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

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

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

参数

相关 API 元素

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

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

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

AIR for TV 设备从不自动调度此事件。 但是您可以手动调度。

此事件具有以下属性：

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

此事件具有以下属性：

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

此事件具有以下属性：

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

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

AIR for TV 设备从不自动调度此事件。 但是您可以手动调度。

此事件具有以下属性：

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

不要调整窗口大小或更改其在 displayStateChange 事件处理程序中的显示状态。

此事件具有以下属性：

在窗口更改其显示状态的前一刻由此 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 事件的处理函数中，避免可能会同时打开操作系统对话框的动作。例如，如果两个处理函数都引发错误，则可能发生这种情况。如果真的发生这种情况，则打开的第二个对话框将不会注册鼠标单击，必须使用键盘才能取消。

此事件具有以下属性：

注意：在 Linux 上，此事件不支持 preventDefault() 方法。

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

此事件具有以下属性：

相关 API 元素

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

此事件具有以下属性：

注意：在 Linux 上，此事件不支持 preventDefault() 方法。

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