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.

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.

See also

      public function setBounds(newBounds:Rectangle):void{
          var resizingEvent:NativeWindowBoundsEvent = 
                new NativeWindowBoundsEvent(NativeWindowBoundsEvent.RESIZING,true,true);
          //"this" must be a reference to the window being changed
          this.dispatchEvent(resizingEvent);
          if(!resizingEvent.isDefaultPrevented()){
              this.bounds = newBounds.clone();
          }
      }  
      

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:

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

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

The NativeWindowInitOptions structure used to create this window.

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 passed to the operating system and is enforced for window resizing operations invoked both through ActionScript and through the operating system.

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

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.

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

See also

The Stage of this window.

The stage is the root of the display list for the window. Add visual 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.

See also

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

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 true. To create a window in an invisible state, set the visible parameter passed to the window constructor to false.

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 x 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 y 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. Entirely 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. These cases can be detected, if desired, using NativeWindowCapabilities.

See also

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 temporarily, set the window's visible property to false.

See also

      public function closeCommand():Boolean{
          var closeEvent:Event = new Event(Event.CLOSING,true,true);
          dispatchEvent(closeEvent);
          if(!closeEvent.isDefaultPrevented()){
              nativeWin.close();
              return true;
          } else {
            return false;
          }
      }  
      

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.

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.

See also

      public function maximizeCommand():Boolean{
          var beforeState:String = this.displayState;
          var afterState:String = NativeWindowDisplayState.MAXIMIZED;
          var displayStateChangingEvent:NativeWindowDisplayStateEvent = 
              new NativeWindowDisplayStateEvent(NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                                true,true,beforeState,afterState);
          dispatchEvent(displayStateChangingEvent);
          if(!displayStateChangingEvent.isDefaultPrevented()){
              nativeWin.maximize();
              return true;
          } else {
            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, your minimize logic must 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 minimizeCommand():Boolean{
          var beforeState:String = this.displayState;
          var afterState:String = NativeWindowDisplayState.NORMAL;
          var displayStateChangingEvent:NativeWindowDisplayStateEvent = 
              new NativeWindowDisplayStateEvent(NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                                true,true,beforeState,afterState);
          dispatchEvent(displayStateChangingEvent);
          if(!displayStateChangingEvent.isDefaultPrevented()){
              nativeWin.minimize();
              return true;
          } else {
            return false;
          }
      }  
      

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 restoreCommand():Boolean{
          var beforeState:String = this.displayState;
          var afterState:String = NativeWindowDisplayState.NORMAL;
          var displayStateChangingEvent:NativeWindowDisplayStateEvent = 
              new NativeWindowDisplayStateEvent(NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                                true,true,beforeState,afterState);
          dispatchEvent(displayStateChangingEvent);
          if(!displayStateChangingEvent.isDefaultPrevented()){
              nativeWin.restore();
              return true;
          } else {
            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 the 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.

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.

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

Defines the value of the type property of a close event object.

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.

Defines the value of the type property of a closing event object.

This event has the following properties:

 function closing_handler(closingEvent:Event):void
 {
   if (document.isDirty)
   {
     closingEvent.preventDefault();
     // raise save dialog...
   }
 }
 

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

Defines the value of the type property of a displayStateChange event object. This event has the following properties:

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

Defines the value of the type property of a displayStateChanging event object. This event has the following properties:

 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.

Defines the value of the type property of a move event object. This event has the following properties:

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.

Defines the value of the type property of a moving event object. This event has the following properties:

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.

Defines the value of the type property of a resize event object. This event has the following properties:

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.

Defines the value of the type property of a resizing event object. This event has the following properties:

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