Gestión de ventanas

Para poder manipular una ventana, primero es necesario obtener la instancia de la ventana. Puede obtener una instancia de ventana de uno de los lugares siguientes:

• El constructor de ventanas nativas utilizado para crear la ventana:

  var win:NativeWindow = new NativeWindow(initOptions);

• Propiedad nativeWindow del escenario de la ventana:

  var win:NativeWindow = stage.nativeWindow;

• Propiedad stage de un objeto de visualización en la ventana:

  var win:NativeWindow = displayObject.stage.nativeWindow;

• Propiedad target de un evento de ventana nativa distribuido por la ventana:

  private function onNativeWindowEvent(event:NativeWindowBoundsEvent):void 
  { 
      var win:NativeWindow = event.target as NativeWindow; 
  }

• Propiedad nativeWindow de una página HTML mostrara en la ventana:

  var win:NativeWindow = htmlLoader.window.nativeWindow;

• Propiedades activeWindow y openedWindows del objeto NativeApplication:

  var nativeWin:NativeWindow = NativeApplication.nativeApplication.activeWindow; 
  var firstWindow:NativeWindow = NativeApplication.nativeApplication.openedWindows[0];

  NativeApplication.nativeApplication.activeWindow hace referencia a la ventana activa de una aplicación (pero devuelve null si la ventana activa no es una ventana de esta aplicación de AIR). El conjunto NativeApplication.nativeApplication.openedWindows contiene todas las ventanas de una aplicación de AIR que no se han cerrado.

Dado que los objetos Application, WindowedApplication y Window de Flex son objetos de visualización a los que es muy sencillo hacer referencia a la ventana de aplicación desde un archivo MXML mediante la propiedad stage , como puede verse a continuación:

<?xml version="1.0" encoding="utf-8"?> 
<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml" applicationComplete="init();"> 
    <mx:Script> 
        <![CDATA[ 
            import flash.display.NativeWindow; 
 
            public function init():void{ 
                var appWindow:NativeWindow = this.stage.nativeWindow; 
                //set window properties 
                appWindow.visible = true; 
            } 
        ]]> 
    </mx:Script> 
</WindowedApplication

Para activar una ventana, llame al método activate() de NativeWindow. Al activar una ventana, esta se visualiza en primer plano, recibe la selección del teclado y del ratón y, si es necesario, se hace visible restaurando la ventana o estableciendo la propiedad visible como true . Cuando se activa una ventana, esta no cambia el orden del resto de ventanas de la aplicación. Si se llama al método activate() , la ventana distribuye un evento activate .

Para mostrar una ventana oculta sin activarla, establezca la propiedad visible como true . Esto llevará la ventana al primer plano, pero no recibirá la selección.

Para ocultar la visibilidad de una ventana, establezca su propiedad visible como false . Al ocultar una ventana, se suprime la visualización de la ventana, de los iconos relacionados de la barra de tareas y, en Mac OS X, la entrada del menú Ventana.

Cuando se cambia la visibilidad de una ventana, la visibilidad de cualquier ventana contenida en esa ventana también cambia. Por ejemplo, si se oculta una ventana, todas sus ventanas incluidas también se ocultan.

AIR proporciona varios métodos para poder cambiar directamente el orden de visualización de las ventanas. Puede colocar una ventana delante del orden de visualización o detrás, mover una ventana encima de otra o detrás. Al mismo tiempo, el usuario puede reordenar las ventanas activándolas.

Puede mantener una ventana delante del resto si establece su propiedad alwaysInFront como true . Si hay más de una ventana con este ajuste, el orden de visualización de las ventanas se ajustará entre sí, pero siempre se visualizarán delante de ventanas que tengan la propiedad alwaysInFront como false.

Las ventanas del grupo superior también se visualizan sobre el resto de las aplicaciones, incluso si la aplicación de AIR no está activa. Como este comportamiento no es el habitual del resto de usuarios, solo se debe establecer alwaysInFront como true cuando sea realmente necesario. Entre los ejemplos de usos justificados se incluyen:

• Ventanas emergentes temporales para controles como sugerencias, listas, menús personalizados o cuadros combinados. Como estas ventanas se cierran cuando dejan de recibir la selección, está justificado el comportamiento para evitar que el usuario no pueda ver las ventanas.

• Mensajes de error y alertas realmente importantes. Si se produce un cambio irrevocable y el usuario no responde a tiempo, está justificado el comportamiento para poner la alerta en primer plano. Sin embargo, la mayoría de los errores y alertas se pueden gestionar con el orden de visualización normal de las ventanas.

• Ventanas temporales superpuestas.

Si una ventana contiene otras ventanas, estas siempre se ordenan frente a la misma. Si se llama a orderToFront() o se establece alwaysInFront en true en una ventana que incluya otra ventana, las ventanas incluidas se reordenan junto con la ventana propietaria frente a las demás ventanas, pero las ventanas incluidas aún se muestran frente a la propietaria.

La llamada a los métodos de ordenación de ventanas en las ventanas incluidas funciona normalmente entre las ventanas contenidas en la misma ventana, pero también se puede cambiar el orden de todo el grupo de ventanas incluidas en comparación con las ventanas fuera de ese grupo. Por ejemplo, si se llama a orderToFront() en una ventana incluida, tanto esa ventana como su propietaria y cualquier otra ventana incluida por la misma propietaria, se mueven a la parte frontal del orden de visualización de ventanas.

La clase NativeWindow proporciona las siguientes propiedades y métodos para establecer el orden de visualización de una ventana con respecto a otras:

En el sistema operativo Linux, los diferentes administradores de ventana aplican reglas distintas relacionadas con el orden de visualización de la ventana:

• En algunos administradores, las ventanas de utilidades siempre se muestran delante de las ventanas normales.

• En algunos administradores de ventanas, una ventana de pantalla completa con alwaysInFront establecido en true , siempre se muestra delante de otras ventanas que también tienen el valor alwaysInFront definido como true .

Para cerrar una ventana, utilice el método NativeWindow.close() .

Al cerrar la ventana, se descarga su contenido, pero si otros objetos tienen referencias a él, este no se elimina. El método NativeWindow.close() se ejecuta de forma asíncrona y la aplicación contenida en la ventana se sigue ejecutando durante el proceso de cierre. El método close distribuye un evento close una vez finalizada la operación de cierre. El objeto NativeWindow sigue siendo técnicamente válido, aunque al intentar acceder a la mayoría de propiedades y métodos de una ventana cerrada, se genera un error IllegalOperationError. No es posible volver a abrir una ventana cerrada. Verifique la propiedad closed de una ventana para ver si se ha cerrado o no. Simplemente para ocultar la visibilidad de una ventana, establezca la propiedad NativeWindow.visible como false .

Si la propiedad Nativeapplication.autoExit es true (valor predeterminado), la aplicación se cerrará al cerrarse la última ventana.

Cualquier ventana que tenga una propietaria, se cierra cuando la propietaria se cierra. Las ventanas contenidas no distribuyen un evento de cierre y, por lo tanto, no pueden evitarlo. Se distribuye un evento close.

Si una ventana utiliza fondo cromático del sistema, es posible cancelar la interacción con el usuario que esté detectando cancelar el comportamiento predeterminado de los eventos adecuados. Por ejemplo, cuando un usuario hace clic en el botón para cerrar el fondo cromático del sistema, se distribuye el evento closing . Si algún detector registrado llama al método preventDefault() del evento, la ventana no se cierra.

Si una ventana no utiliza fondo cromático, los eventos de notificación de cambios intencionados no se distribuyen automáticamente antes del cambio. Por ello, si llama a métodos para cerrar una ventana, para cambiar su estado o para definir las propiedades de su contorno, el cambio no se puede cancelar. Para avisar a los componentes de la aplicación antes de que se realice un cambio de ventana, la lógica de la aplicación puede distribuir el evento de notificación correspondiente mediante el método dispatchEvent() de la ventana.

Por ejemplo, la siguiente lógica implementa un controlador de eventos cancelable para un botón de cierre de una ventana:

public function onCloseCommand(event:MouseEvent):void{ 
    var closingEvent:Event = new Event(Event.CLOSING,true,true); 
    dispatchEvent(closing); 
    if(!closingEvent.isDefaultPrevented()){ 
        win.close(); 
    } 
} 

El método dispatchEvent() devuelve false si un detector llama al método preventDefault() del evento. No obstante, también puede devolver false por otros motivos. Por ello, es mejor utilizar explícitamente el método isDefaultPrevented() para probar si se debe cancelar o no el cambio.

Para maximizar la ventana, utilice el método maximize() de NativeWindow.

myWindow.maximize(); 

Para minimizar la ventana, utilice el método minimize() de NativeWindow.

myWindow.minimize(); 

Para restaurar la ventana (es decir, hacer que recupere el tamaño que tenía antes de maximizarla o minimizarla), utilice el método restore() de NativeWindow.

myWindow.restore(); 

Una venta que tenga una propietaria se minimiza y se restaura cuando la ventana propietaria se minimice o se restaure. La ventana incluida no distribuye eventos cuando se minimiza, ya que su propietaria también se minimiza.

En el sistema operativo Linux, los diferentes administradores de ventana aplican reglas distintas relacionadas con la configuración del estado de visualización de la ventana:

• En algunos administradores, las ventanas de utilidades no se puede maximizar.

• Si se define un tamaño máximo para la ventana, algunas ventanas no permiten que se maximice una ventana. Otros administradores de ventanas establecen el estado de visualización como maximizado, pero no cambian el tamaño de la ventana. En cualquier caso, no se distribuye ningún evento de cambio de estado de visualización.

• Algunos administradores de ventanas no aceptan la configuración maximizable o minimizable de la ventana.

La siguiente aplicación corta de MXML muestra los métodos maximize() , minimize() , restore() y close() de Window:

<?xml version="1.0" encoding="utf-8"?> 
 
<mx:WindowedApplication  
    xmlns:mx="http://www.adobe.com/2006/mxml"  
    layout="vertical"> 
     
     
    <mx:Script> 
    <![CDATA[ 
    public function minimizeWindow():void 
    { 
        this.stage.nativeWindow.minimize(); 
    } 
 
    public function maximizeWindow():void 
    { 
        this.stage.nativeWindow.maximize(); 
    }           
     
    public function restoreWindow():void 
    { 
        this.stage.nativeWindow.restore(); 
    }           
 
    public function closeWindow():void 
    { 
        this.stage.nativeWindow.close(); 
    } 
    ]]> 
    </mx:Script> 
 
    <mx:VBox> 
        <mx:Button label="Minimize" click="minimizeWindow()"/> 
        <mx:Button label="Restore" click="restoreWindow()"/> 
        <mx:Button label="Maximize" click="maximizeWindow()"/> 
        <mx:Button label="Close" click="closeWindow()"/> 
    </mx:VBox> 
 
</mx:WindowedApplication>

El siguiente ejemplo de ActionScript para Flash crea cuatro campos de texto en los que se puede hacer clic y que activan los métodos minimize() , maximize() , restore() y close() de NativeWindow:

package 
{ 
    import flash.display.Sprite; 
    import flash.events.MouseEvent; 
    import flash.text.TextField; 
     
    public class MinimizeExample extends Sprite 
    { 
        public function MinimizeExample():void  
        { 
            var minTextBtn:TextField = new TextField(); 
            minTextBtn.x = 10; 
            minTextBtn.y = 10; 
            minTextBtn.text = "Minimize"; 
            minTextBtn.background = true; 
            minTextBtn.border = true; 
            minTextBtn.selectable = false; 
            addChild(minTextBtn); 
            minTextBtn.addEventListener(MouseEvent.CLICK, onMinimize); 
         
            var maxTextBtn:TextField = new TextField(); 
            maxTextBtn.x = 120; 
            maxTextBtn.y = 10; 
            maxTextBtn.text = "Maximize"; 
            maxTextBtn.background = true; 
            maxTextBtn.border = true; 
            maxTextBtn.selectable = false; 
            addChild(maxTextBtn); 
            maxTextBtn.addEventListener(MouseEvent.CLICK, onMaximize); 
         
            var restoreTextBtn:TextField = new TextField(); 
            restoreTextBtn.x = 230; 
            restoreTextBtn.y = 10; 
            restoreTextBtn.text = "Restore"; 
            restoreTextBtn.background = true; 
            restoreTextBtn.border = true; 
            restoreTextBtn.selectable = false; 
            addChild(restoreTextBtn); 
            restoreTextBtn.addEventListener(MouseEvent.CLICK, onRestore); 
             
            var closeTextBtn:TextField = new TextField(); 
            closeTextBtn.x = 340; 
            closeTextBtn.y = 10; 
            closeTextBtn.text = "Close Window"; 
            closeTextBtn.background = true; 
            closeTextBtn.border = true; 
            closeTextBtn.selectable = false; 
            addChild(closeTextBtn); 
            closeTextBtn.addEventListener(MouseEvent.CLICK, onCloseWindow); 
        } 
        function onMinimize(event:MouseEvent):void 
        { 
            this.stage.nativeWindow.minimize(); 
        } 
        function onMaximize(event:MouseEvent):void 
        { 
            this.stage.nativeWindow.maximize(); 
        } 
        function onRestore(event:MouseEvent):void 
        { 
            this.stage.nativeWindow.restore(); 
        } 
        function onCloseWindow(event:MouseEvent):void 
        { 
            this.stage.nativeWindow.close(); 
        } 
    } 
}

Si una ventana utiliza fondo cromático del sistema, este proporciona controles de arrastre para cambiar el tamaño de la ventana y moverla por el escritorio. Si una ventana no utiliza fondo cromático del sistema, deberá añadir sus propios controles para que el usuario pueda cambiarla de tamaño o desplazarla.

El siguiente ejemplo muestra como iniciar el campo de tamaño y las operaciones de desplazamiento de una ventana:

package 
{ 
    import flash.display.Sprite; 
    import flash.events.MouseEvent; 
    import flash.display.NativeWindowResize; 
 
    public class NativeWindowResizeExample extends Sprite 
    { 
        public function NativeWindowResizeExample():void 
        { 
            // Fills a background area. 
            this.graphics.beginFill(0xFFFFFF); 
            this.graphics.drawRect(0, 0, 400, 300); 
            this.graphics.endFill(); 
     
            // Creates a square area where a mouse down will start the resize. 
            var resizeHandle:Sprite =  
                createSprite(0xCCCCCC, 20, this.width - 20, this.height - 20); 
            resizeHandle.addEventListener(MouseEvent.MOUSE_DOWN, onStartResize); 
     
            // Creates a square area where a mouse down will start the move. 
            var moveHandle:Sprite = createSprite(0xCCCCCC, 20, this.width - 20, 0); 
            moveHandle.addEventListener(MouseEvent.MOUSE_DOWN, onStartMove); 
        } 
     
        public function createSprite(color:int, size:int, x:int, y:int):Sprite 
        { 
            var s:Sprite = new Sprite(); 
            s.graphics.beginFill(color); 
            s.graphics.drawRect(0, 0, size, size); 
            s.graphics.endFill(); 
            s.x = x; 
            s.y = y; 
            this.addChild(s);     
            return s;         
        } 
     
        public function onStartResize(event:MouseEvent):void 
        { 
            this.stage.nativeWindow.startResize(NativeWindowResize.BOTTOM_RIGHT); 
        } 
 
        public function onStartMove(event:MouseEvent):void 
        { 
            this.stage.nativeWindow.startMove(); 
        } 
    } 
}