Gerenciamento de janelas

Para manipular uma janela, primeiro você deve obter a ocorrência dela. A ocorrência da janela pode ser obtida em um dos seguintes lugares:

• O construtor nativo de janela usado para criar a janela:

  var win:NativeWindow = new NativeWindow(initOptions);

• A propriedade nativeWindow do estágio da janela:

  var win:NativeWindow = stage.nativeWindow;

• A propriedade stage de um objeto de exibição na janela:

  var win:NativeWindow = displayObject.stage.nativeWindow;

• A propriedade target de um evento de janela nativa despachada pela janela:

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

• A propriedade nativeWindow de uma página HTML exibida na janela:

  var win:NativeWindow = htmlLoader.window.nativeWindow;

• As propriedades activeWindow e openedWindows do objeto NativeApplication:

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

  NativeApplication.nativeApplication.activeWindow faz referência à janela ativa de um aplicativo (mas retorna null se a janela ativa não é uma janela deste aplicativo do AIR). A matriz NativeApplication.nativeApplication.openedWindows contém todas as janelas de um aplicativo do AIR que não foram fechadas.

Como os objetos mx:WindowedApplication e Window do Flex são objetos de exibição, você pode fazer referência facilmente à janela do aplicativo em um arquivo MXML usando a propriedade stage , da seguinte maneira:

<?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 ativar uma janela, chame o método activate() de NativeWindow. A ativação de uma janela a traz para frente, dá a ela foco do teclado e do mouse e, se necessário, a torna visível mediante a restauração da janela ou a definição da propriedade visible como true . A ativação de uma janela não altera a ordem de outras janelas do aplicativo. A chamada do método activate() faz com que a janela despache um evento activate .

Para mostrar uma janela oculta sem ativá-la, defina a propriedade visible como true . Isso traz a janela para frente, mas não atribui o foco para ela.

Para ocultar uma janela de forma que não seja exibida, defina sua propriedade visible como false . Ocultar uma janela suprime a exibição tanto da janela quanto de qualquer ícone relacionado na barra de tarefas e, no Mac OS X, a entrada no menu Janelas.

Quando você altera a visibilidade de uma janela, a visibilidade de quaisquer janelas de propriedade dessa janela também é alterada. Por exemplo, se você ocultar uma janela, todas as janelas de sua propriedade também ficarão ocultas.

O AIR oferece diversos métodos para alterar diretamente a ordem de exibição das janelas. É possível mover uma janela para o começo ou o final da ordem de exibição, bem como colocar uma janela em cima de outra ou atrás dela. Ao mesmo tempo, o usuário pode reordenar as janelas ativando-as.

Você pode manter uma janela em frente de outras definindo sua propriedade alwaysInFront como true . Se mais de uma janela tiver essa configuração, a ordem de exibição dessas janelas será definida entre elas, mas sempre serão organizadas acima das janelas cuja propriedade alwaysInFront esteja definida como false.

As janelas que estão no primeiro grupo também são exibidas acima das janelas de outros aplicativos, mesmo quando o aplicativo do AIR não está ativo. Como esse comportamento pode interromper o trabalho do usuário, definir alwaysInFront como true é algo que só deve ser feito quando necessário e apropriado. Os exemplos de usos justificados incluem:

• Janelas pop-up temporárias de controles, como dicas de ferramentas, listas pop-up, menus personalizados e caixas de combinação. Como essas janelas devem ser fechadas quando perdem o foco, pode-se evitar a dor de cabeça de impedir um usuário de ver outra janela.

• Mensagens de erro e alertas extremamente urgentes. Quando pode ocorrer uma alteração irrevogável se o usuário não responde de imediato, pode ser justificável trazer uma janela de alerta para frente. No entanto, a maioria dos erros e alertas pode ser tratada na ordem de exibição normal das janelas.

• Janelas pop-up de curta duração.

Se uma janela for proprietária de outras, essas outras são sempre ordenadas à sua frente. Se você chamar orderToFront() ou definir alwaysInFront como true em uma janela que seja proprietária de outras, as janelas subordinadas são reordenadas com a janela proprietária em frente às outras janelas, mas as janelas subordinadas ainda são exibidas na frente da proprietária.

Chamar os métodos de ordenação de janelas em janelas subordinadas funciona normalmente entre janelas de propriedade da mesma janela, mas também pode alterar a ordem de todo o grupo de janelas subordinadas em relação a janelas fora desse grupo. Por exemplo, se você chamar orderToFront() em uma janela subordinada, essa janela, sua proprietária e quaisquer outras janelas subordinadas à mesma proprietária são movidos para a frente da ordem de exibição de janelas.

A classe NativeWindow oferece estas propriedades e métodos para definir a ordem de exibição de uma janela em relação a outras janelas:

No sistema operacional Linux, diferentes gerenciadores de janela forçam regras diferentes, dependendo da ordem de exibição da janela:

• Em alguns gerenciadores de janela, as janelas do utilitário são sempre exibidas em frente às janelas normais.

• Em alguns gerenciadores de janela, uma janela de tela cheia com alwaysInFront definida como true é sempre exibida na frente de outras janelas que também tenham alwaysInFront definida como true .

Para fechar uma janela, use o método NativeWindow.close() .

Fechar uma janela descarrega o conteúdo dela; porém, se outros objeto tiverem referências a esse conteúdo, os objetos de conteúdo não serão destruídos. O método NativeWindow.close() é executado de forma assíncrona, e o aplicativo que está contido na janela continua a executar durante o processo de fechamento. O método close despacha um evento close quando a operação de fechamento é concluída. O objeto NativeWindow ainda é tecnicamente válido, mas o acesso à maioria das propriedades e dos métodos em uma janela fechada gera IllegalOperationError. Não é possível reabrir uma janela fechada. Verifique a propriedade closed de uma janela para testar se a janela foi fechada. Para simplesmente ocultar a exibição de uma janela, defina a propriedade NativeWindow.visible como false .

Se a propriedade Nativeapplication.autoExit é true , o padrão, o aplicativo é encerrado ao ser fechada sua última janela.

Quaisquer janelas que tenham uma proprietária são fechadas quando a proprietária é fechada. As janelas que são propriedade de outra não despacham um evento closing e, portanto, não podem impedir seu fechamento. Um evento close é despachado.

Quando uma janela usa o cromo do sistema, a interação do usuário com ela pode ser cancelada monitorando ou cancelando o comportamento padrão dos eventos apropriados. Por exemplo, quando um usuário clica no botão Fechar do cromo do sistema, o evento closing é despachado. Se algum ouvinte registrado chamar o método preventDefault() do evento, a janela não será fechada.

Quando uma janela não usa o cromo do sistema, os eventos de notificação referentes às alterações pretendidas não são despachados automaticamente antes de a alteração ser feita. Por isso, se você chamar os métodos para fechar uma janela ou se alterar o estado dela ou definir qualquer uma das propriedades de limites de janela, a alteração não poderá ser cancelada. Para notificar os componentes do seu aplicativo antes que seja feita uma alteração de janela, a lógica do aplicativo poderá despachar o evento de notificação relevante usando o método dispatchEvent() da janela.

Por exemplo, a seguinte lógica implementa um manipulador de eventos cancelável para o botão Fechar de uma janela:

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

O método dispatchEvent() retorna false se o método preventDefault() do evento é chamado por um ouvinte. No entanto, ele também pode retornar false por outros motivos, portanto é melhor usar o método isDefaultPrevented() explicitamente para testar se a alteração deve ser cancelada.

Para maximizar a janela, use o método maximize() da classe NativeWindow.

myWindow.maximize(); 

Para minimizar a janela, use o método minimize() de NativeWindow.

myWindow.minimize(); 

Para restaurar a janela (isto é, colocá-la novamente no tamanho em que estava antes de ser minimizada ou maximizada), use o método restore() de NativeWindow.

myWindow.restore(); 

Uma janela que tenha uma proprietária é minimizada e restaurada quando a janela proprietária é minimizada ou restaurada. Nenhum evento é despachado pela janela subordinada quando é minimizada porque sua proprietária está minimizada.

No sistema operacional Linux, diferentes gerenciadores de janela forçam regras diferentes com relação a configuração do estado de exibição da janela:

• Em alguns gerenciadores de janela, não é possível maximizar as janelas dos utilitários.

• Se um tamanho máximo for definido para a janela, algumas janelas não permitirão a maximização. Alguns outros gerenciadores de janela definem o estado de exibição como maximizado, mas não redimensionam a janela. Em qualquer um dos casos, não é despachado nenhum evento de alteração do estado de exibição.

• Alguns gerenciadores de janela não cumprem as configurações maximizable ou minimizable de janela.

O seguinte aplicativo MXML demonstra os métodos maximize() , minimize() , restore() e close() de janela:

<?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>

O seguinte exemplo do ActionScript para Flash cria quatro campos de texto clicáveis que acionam os métodos minimize() , maximize() , restore() e 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(); 
        } 
    } 
}

Quando uma janela usa o cromo do sistema, o cromo oferece controles de arrastar que permitem redimensionar a janela e movimentá-la na área de trabalho. Se uma janela não usa o cromo do sistema, adicione seus próprios controles para que o usuário possa redimensionar e movimentar a janela.

O exemplo abaixo mostra como iniciar operações de redimensionamento e movimentação em uma janela:

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