NativeWindow  - AS3

指出此視窗是否為作用中的應用程式視窗。

您可以使用 activate() 方法，讓視窗成為作用中狀態。

相關 API 元素

指定此視窗是否一律顯示在其它視窗 (包括其它應用程式的視窗) 的前面。

系統深度順序中有兩個視窗群組。alwaysInFront 群組中的視窗一定會顯示在其它所有視窗的前面。在相同群組中排列視窗的深度順序時，是依照一般方式判定。換句話說，啟動某個視窗時，便會將該視窗顯示在相同群組中其它視窗的前面。

將 alwaysInFront 從 false 變更為 true 時，會將該視窗顯示在其它所有視窗的前面。將此屬性從 true 變更為 false 時，則會將該視窗顯示在 "alwaysInFront" 視窗的後面，但是仍然在其它視窗的前面。將此屬性設定為它目前的值將不會變更視窗的深度順序。為具有擁有者的視窗設定 alwaysInFront 屬性將不會有任何作用。

請盡可能避免將 alwaysInFront 屬性設定為 true，因為使用此設定的視窗將會顯示在其它應用程式視窗的前面，即使這些應用程式正在作用中也一樣。

OS 行為備註：

• 如果視窗將 alwaysInFront 屬性設為在全螢幕視窗之前，部分 Linux 視窗管理員不會予以顯示。
• 在 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 設定。

注意：部分 Linux 視窗管理員允許使用者將視窗放到最大，即使當 maximizable 屬性設為 false。

相關 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 屬性時，除非該視窗的 systemChrome 屬性為 NativeWindowSystemChrome.NONE，否則如果 NativeWindow.supportsMenu 為 true，該視窗便可以顯示原生選單。

注意：當 NativeWindow.supportsMenu 為 false 或視窗的 systemChrome 屬性為 NativeWindowSystemChrome.NONE 時，您可以將選單指派給視窗，但是不會有任何作用。請務必使用NativeWindow.supportsMenu 屬性來判斷作業系統是否支援視窗選單。使用其他方法 (例如 Capabilities.os) 來判斷這種支援是否會造成程式設計錯誤 (如果未考慮到部分可能的目標作業系統)。

相關 API 元素

報告用來建立此視窗的可最小化設定。

建立視窗之後，便無法變更 minimizable 設定。

注意：部分 Linux 視窗管理員允許使用者將視窗縮到最小，即使當 minimizable 屬性設為 false。

相關 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 內容中使用之顯示清單架構內的根物件。

此 Stage 為視窗之顯示清單的根。將視覺顯示物件加入舞台或已經在此舞台之顯示清單中的其它物件，便可將這些顯示物件加入視窗。舞台尺寸就是當視窗使用系統顏色時，視窗用戶端區域的尺寸。如果未使用系統顏色，舞台尺寸便等於視窗的尺寸。

相關 API 元素

import flash.display.StageAlign;

windowObj.stage.align = StageAlign.TOP_LEFT;

指出 AIR 是否支援在目前的電腦系統上使用原生視窗選單。

當 NativeWindow.supportsMenu 為 true 時，除非視窗的 systemChrome 屬性為 NativeWindowSystemChrome.NONE，否則如果將 NativeMenu 物件指定給該視窗的 menu 屬性，該視窗便可以顯示原生選單。請務必使用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，所有像素的不透明度都會設定為 1，不論視窗的 transparent 屬性值為何。當 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 值低於特定臨界值 (視作業系統而定，介於 0.06 和 0.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 事件。若視窗已經最大化，則不會採取任何動作，也不會傳回任何事件。

OS 行為備註：

• 對於類似 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 已經準備好可供繪製時，便會傳送 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();
  }
}