NativeWindow  - AS3

Indica se esta janela é a janela do aplicativo ativo.

Use o método activate() para tornar uma janela ativa.

Elementos da API relacionados

Especifica se esta janela estará sempre à frente das demais janelas (incluindo as de outros aplicativos).

Há dois grupos de janelas na ordem de profundidade do sistema. As janelas do grupo alwaysInFront são sempre exibidas à frente das demais janelas. A ordem de profundidade entre janelas dentro do mesmo grupo é determinada normalmente. Em outras palavras, ativar uma janela a traz à frente das demais janelas do respectivo grupo.

Alterar o alwaysInFront de false para true traz a janela sobre todas as demais janelas. Alterar a propriedade de true para false envia a janela para trás de janelas "alwaysInFront", porém ainda à frente de outras janelas. Configurar a propriedade para seu valor atual não altera a ordem de profundidade da janela. A configuração da propriedade alwaysInFrontde uma janela subordinada a uma janela proprietária não tem nenhum efeito.

O alwaysInFront raramente deve ser configurado como true, pois as janelas com esta configuração são exibidas à frente das janelas de outros aplicativos, mesmo quando nenhum outro aplicativo estiver ativo.

Observações sobre o comportamento do sistema operacional:

• Alguns gerenciadores de janelas do Linux não exibem janelas de visualização que têm o conjunto de propriedades alwaysInFront definido como em frente de janelas de tela cheia.
• Nota: no Mac^® OS X, a configuração de alwaysInFront como true não terá efeito quando a propriedade displayState da tomada de janela for fullScreen ou fullScreenInteractive.

windowObj.alwaysInFront = true;

displayObject.stage.nativeWindow.alwaysInFront=true;

window.nativeWindow.alwaysInFront = true;

O tamanho e o local dessa janela.

As dimensões de uma janela, incluindo qualquer cromo do sistema. As dimensões do palco de uma janela equivalem às dimensões da janela menos o tamanho de qualquer cromo do sistema. Alterar a largura e a altura da janela muda a stageWidth e stageHeight do palco. O inverso também se aplica: alterar as dimensões do palco mudará o tamanho da janela.

Em uma janela HTML raiz, as propriedades outerWidth e outerHeigth são equivalentes às propriedades de altura e largura (height e width, respectivamente) da janela. As propriedades innerWidth e innerHeight equivalem às propriedades stage.stageWidth e stage.stageHeight menos a espessura de qualquer barra de rolagem automática exibida na janela.

Um evento resize é despachado sempre que se altera a largura ou a altura dessa janela. Da mesma forma, um evento move é despachado sempre que se altera a origem (x,y) dessa janela. Em Mac OS e Windows, definir a propriedade bounds diretamente não despachará o evento moving ou resizing. Contudo, no Linux o NativeWindow emite os eventos moving e resizing quando você define a propriedade bounds.

Configurar a propriedade bounds de uma janela equivale a configurar as respectivas propriedades x, y, width e height. Da mesma forma, configurar qualquer uma das dimensões equivale a configurar a propriedade bounds. Ao configurar todas as dimensões ao mesmo tempo usando a propriedade bounds, são despachados menos eventos.

A ordem em que as dimensões individuais são definidas não é garantida. Em gerenciadores de janelas do Linux que não permitem a extensão de janelas até a área de trabalho, uma alteração feita em uma propriedade individual pode ser bloqueada, mesmo que o efeito prático da aplicação de todas as alterações feitas na propriedade resultaria em uma janela legal.

Se a largura ou a altura especificada forem menores do que o mínimo ou maiores do que a largura ou altura máximas permitidas, então a largura ou a altura da janela são definidas para o tamanho legal mais próximo. Os fatores que determinam a largura e altura mínimas e máximas são os seguintes:

• As propriedades minSize e maxSize do objeto NativeWindow
• Os limites mínimos e máximos do sistema operacional, que são os valores NativeWindow.systemMinSize e NativeWindow.systemMaxSize.
• A largura e altura máximas de uma janela no Adobe AIR, que é de 4095 pixels cada. (No AIR 1.5 e anteriores, a largura e a altura máximas de uma janela é de 2880 pixels cada uma.)
• A largura e a altura mínimas necessárias por qualquer cromo do sistema exibido.

Os valores de pixel são arredondados para o número inteiro mais próximo quando a posição ou as dimensões de uma janela são modificadas.

Elementos da API relacionados

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

Indica se esta janela foi fechada.

Acessar as propriedades seguintes em uma janela fechada lança um erro de operação ilegal:

• title
• bounds
• x, y, width, height
• displayState
• visible

De igual modo, chamar os seguintes métodos em uma janela fechada também lançará um erro de operação ilegal:

• minimize()
• maximize()
• restore()
• startResize()
• startMove()

var isWindowClosed:Boolean = windowObj.closed;

var isWindowClosed:Boolean = displayObject.stage.nativeWindow.closed;

var isWindowClosed = window.nativeWindow.closed;

O estado de exibição desta janela.

As constantes dos possíveis valores são definidas na classe NativeWindowDisplayState:

• NativeWindowDisplayState.NORMAL
• NativeWindowDisplayState.MINIMIZED
• NativeWindowDisplayState.MAXIMIZED

Elementos da API relacionados

var state:String = windowObj.displayState;

A altura desta janela, em pixels.

As dimensões de uma janela incluem qualquer cromo da janela do sistema exibido. A largura da área de exibição utilizável dentro de uma janela está disponível na propriedade Stage.stageHeight.

Alterar a propriedade height de uma janela equivale a alterar a altura por meio da propriedade bounds.

Se a altura especificada for menor que o mínimo ou maior que a altura máxima permitida, então a altura da janela é definida para o tamanho permitido mais próximo. Os fatores que determinam a altura mínima e máxima são os seguintes:

• As propriedades minSize.x e maxSize.x do objeto NativeWindow
• Os limites mínimos e máximos do sistema operacional, que são os valores de NativeWindow.systemMinSize.x e NativeWindow.systemMaxSize.x.
• A altura máxima de uma janela no Adobe AIR, que é de 4095 pixels (2880 pixels no AIR 1.5 e anteriores).

No Linux, definir a propriedade height é uma operação assíncrona.

Para detectar a conclusão da alteração de altura, monitore o evento resize, que é Despachadoem todas as plataformas.

Os valores de pixel são arredondados para o número inteiro mais próximo quando a altura de uma janela é modificada.

Elementos da API relacionados

Indica se as janelas nativas são suportadas no sistema cliente.

Relata a configuração de maximizável usada para criar esta janela.

A configuração maximizable não pode ser alterada depois que se cria uma janela.

Nota: alguns gerenciadores de janelas do Linux permitem que as janelas, sejam maximizadas pelo usuário, mesmo quando a propriedade maximizable é definida como false.

Elementos da API relacionados

O tamanho máximo desta janela.

O tamanho limite é especificado como as coordenadas de um objeto Point. A propriedade x do ponto corresponde à largura da janela, e a propriedade y, à altura.

A restrição maxSize é imposta para operações de redimensionamento de janela chamadas pelo código ActionScript e através do sistema operacional.

Configurar maxSize altera os limites da janela se os limites atuais forem maiores do que o tamanho máximo.

Se a largura ou a altura especificada forem maiores do que a largura ou altura máximas permitidas, então a largura da janela é definida para o tamanho permitido mais próximo. Os fatores que determinam a largura e altura mínimas e máximas são os seguintes:

• O limite máximo do sistema operacional, que é o valor NativeWindow.systemMaxSize.
• A largura e a altura máxima de uma janela no Adobe AIR, que é 4095 pixels cada. (No AIR 1.5 e anteriores, a largura e a altura máximas de uma janela é de 2880 pixels cada uma.)

Observação: Em alguns sistemas operacionais como, por exemplo, o Mac OS X, maximizar uma janela só a aumentará até o valor maxSize, mesmo que a janela maximizada seja menor que a tela do sistema operacional. A janela ainda estará no estado de exibição maximizado.

Elementos da API relacionados

windowObj.maxSize = new Point(1040,920);

displayObject.stage.nativeWindow.maxSize = new Point(800,600);

window.nativeWindow.maxSize = new air.Point(960,960);

O menu nativo desta janela.

Quando um objeto NativeMenu é atribuído à propriedade menu da janela, um menu nativo é exibido em uma janela, se NativeWindow.supportsMenu for true, a menos que a propriedade systemChrome da janela seja NativeWindowSystemChrome.NONE.

Observação: Você pode atribuir um menu a uma janela quando NativeWindow.supportsMenu for false ou quando a propriedade systemChrome da janela for NativeWindowSystemChrome.NONE, mas essa ação não executa nada. Certifique-se de usar a propriedade NativeWindow.supportsMenu para determinar se o sistema operacional suporta menus de janela. Usar outros meios (tais como Capabilities.os) para determinar o suporte que podem causar erros programados (se algum sistema operacional de destino não foi considerado).

Elementos da API relacionados

Relata a configuração de minimizável usada para criar esta janela.

A configuração minimizable não pode ser alterada depois que se cria uma janela.

Nota: alguns gerenciadores de janelas Linux permitem que as janelas sejam minimizadas pelo usuário, mesmo quando a propriedade minimizable é definida como false.

Elementos da API relacionados

O tamanho mínimo desta janela.

O tamanho limite é especificado como as coordenadas de um objeto Point. A propriedade x do ponto corresponde à largura da janela, e a propriedade y, à altura.

Configurar o minSize alterará os limites da janela se os limites atuais forem menores do que o tamanho mínimo.

A restrição minSize é imposta para operações de redimensionamento de janela chamadas pelo código ActionScript e pelo sistema operacional.

Observação: a largura e a altura de qualquer cromo do sistema exibido pode impossibilitar definir uma janela no tamanho mínimo especificado.

Elementos da API relacionados

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

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

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

O objeto NativeWindow proprietário desta janela.

A propriedade da janela é estabelecida quando uma janela é criada e não pode ser alterada. Para criar uma janela subordinada, defina o objeto proprietário NativeWindow como a propriedade owner do objeto NativeWindowInitOptions usado para criar a janela subordinada.

Nota: no Linux, alguns gerenciadores de janelas não exibem janelas subordinadas pela exposição em frente da janela proprietária quando essa está sendo exibida no modo de tela inteira.

Elementos da API relacionados

Indica a configuração renderMode de janela utilizada para criar essa janela.

Os valores retornados por NativeWindow.renderMode serão uma das constantes definidas na classe NativeWindowRenderMode.

A configuração renderMode não pode ser alterada após uma janela ser criada.

Elementos da API relacionados

Relata a configuração de redimensionável usada para criar esta janela.

A configuração resizable não pode ser alterada depois que se cria uma janela.

Elementos da API relacionados

O objeto Stage desta janela. O objeto Stage é o objeto raiz na arquitetura da lista de exibição usada no conteúdo do SWF com base no ActionScript 3.0.

O palco é a raiz da lista de exibição da janela. Adicione objetos de exibição visual a uma janela adicionando-os ao palco ou a outro objeto já existente na lista de exibição desse palco. As dimensões do palco são aquelas da área do cliente da janela quando a janela utiliza cromo do sistema. As dimensões do palco equivalem às dimensões da janela caso o cromo do sistema não seja usado.

Elementos da API relacionados

import flash.display.StageAlign;

windowObj.stage.align = StageAlign.TOP_LEFT;

Indica se o AIR dá suporte a menus de janelas nativas no computador atual.

Quando NativeWindow.supportsMenu for true, será exibido um menu nativo em uma janela quando o objeto NativeMenu for atribuído à propriedade menu da janela (a menos que a propriedade systemChrome da janela seja NativeWindowSystemChrome.NONE). Certifique-se de usar a propriedade NativeWindow.supportsMenu para determinar o uso ou não de menus de janela nativos do sistema operacional. Usar outros meios (tais como Capabilities.os) para determinar o suporte que podem causar erros programados (se algum sistema operacional de destino não foi considerado).

Observação: Você pode atribuir um menu a uma janela quando NativeWindow.supportsMenu for false ou quando a propriedade systemChrome da janela for NativeWindowSystemChrome.NONE, mas essa ação não executa nada.

Elementos da API relacionados

Indica se o AIR dá suporte à notificação de janela sinalizando no sistema do computador atual.

Quando NativeWindow.supportsNotification for true, chamar o método notifyUser() da janela resultará em uma sinalização visual para o usuário de que ocorreu um evento de interesse. Essa sinalização visual se ajustará ao sistema operacional do sistema nativo. Por exemplo, no Windows^®, o ícone da barra de tarefas pisca nesse caso.

Você pode Observação: chamar notifyUser() quando NativeWindow.supportsNotification for false, mas essa ação não executa nada.

Elementos da API relacionados

Indica se o AIR suporta janelas nativas com pixels transparentes.

Quando NativeWindow.supportsTransparency for true, a transparência em pixels de uma janela nativa será aceita, se a propriedade transparent da janela estiver definida como true. A opacidade de todos os pixels será definida como 1 se NativeWindow.supportsTransparency for false, independentemente do valor da propriedade transparent da janela. Os pixels totalmente transparentes serão renderizados como preto quando NativeWindow.supportsTransparency for false. Certifique-se de usar a propriedade NativeWindow.supportsTransparency para determinar se o sistema operacional suporta a transparência. Usar outros meios (tais como Capabilities.os) para determinar o suporte que podem causar erros programados (se algum sistema operacional de destino não foi considerado).

Nota: o valor dessa propriedade pode ser alterado durante a execução de um aplicativo, com base nas preferências do usuário definidas para o sistema operacional.

Elementos da API relacionados

Relata a configuração do como do sistema usada para criar esta janela.

Os valores retornados pelo NativeWindow.systemChrome serão uma das constantes definidas na classe NativeWindowSystemChrome.

A configuração do cromo do sistema não pode ser alterada depois que uma janela é criada.

Elementos da API relacionados

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

O maior tamanho de janela permitido pelo sistema operacional.

O tamanho limite é especificado como as coordenadas de um objeto Point. A propriedade x do ponto corresponde à largura da janela, e a propriedade y, à altura.

Além do limite de tamanho de sistema operacional, o AIR tem um limite de tamanho de janela máximo de 4095 por 4095 pixels (2880 pixels por 2880 pixels no AIR 1.5 e anteriores). E um aplicativo pode definir um limite utilizando a propriedade maxSize do objeto de NativeWindow.

O menor tamanho de janela permitido pelo sistema operacional.

O tamanho limite é especificado como as coordenadas de um objeto Point. A propriedade x do ponto corresponde à largura da janela, e a propriedade y, à altura.

O título da janela.

O título será exibido no cromo do sistema da janela, se exibida, bem como em outros locais dependentes do sistema (como a barra de tarefas).

windowObj.title = "Window Title";

Relata a configuração de transparência usada para criar esta janela.

A propriedade transparent não pode ser alterada depois que se cria uma janela. A transparência afeta tanto a aparência visual quanto o comportamento do mouse da janela. No Windows e no Mac OS X, a janela não captura eventos do mouse quando o valor alfa do pixel está abaixo de um determinado limite, que varia entre cerca de 0,06 e 0,01, dependendo do sistema operacional. No Linux, a janela captura eventos de mouse acima de áreas completamente transparentes e, portanto, impedirá que usuários acessem outras janelas e itens na área de trabalho.

Observação: nem sempre há suporte à transparência da janela. Se a configuração do sistema operacional do usuário não tiver a transparência disponível, a janela será criada sem transparência. Áreas que seriam transparentes são compostas com preto. Use a propriedade NativeWindow.supportsTransparency para determinar se a transparência de janela é suportada.

Elementos da API relacionados

Relata a configuração type de janela usada para criar esta janela.

Os valores retornados pelo NativeWindow.type serão uma das constantes definidas na classe NativeWindowType.

A configuração type não pode ser alterada depois que se cria uma janela.

Elementos da API relacionados

Especifica se esta janela está visível.

Uma janela invisível não é exibida na área de trabalho, mas todas as propriedades e métodos da janela são válidos.

Por padrão, visible está definido como set to false. Para exibir uma janela, defina visible como true ou chame NativeWindow.activate().

Se esta janela tiver um proprietário, o estado visível da janela proprietária determinará se esta janela deve ser exibida. Se a janela proprietária não for exibida, nenhuma janela subordinada será exibida, mesmo que suas propriedades visible estejam definidas como true.

Note: No Mac OS X, configurar visible=false em uma janela minimizada não remove o ícone da janela do encaixe. Se um usuário clicar em seguida no ícone de encaixe, a janela retornará ao estado visível e será exibida na área de trabalho.

Elementos da API relacionados

windowObj.visible = true;

displayObj.stage.nativeWindow.visible = true;

window.nativeWindow.visible = true;

A largura desta janela, em pixels.

As dimensões reportadas para uma janela nativa incluem qualquer cromo da janela do sistema que seja exibido. A largura da área de exibição utilizável dentro de uma janela está disponível na propriedade Stage.stageWidth.

Alterar a propriedade width de uma janela equivale a alterar a largura por meio da propriedade bounds.

Se a largura especificada for menor do que o mínimo ou maior do que a largura máxima permitida, então a largura da janela é definida para o tamanho permitido mais próximo. Os fatores que determinam a largura mínima e máxima são os seguintes:

• As propriedades minSize.y e maxSize.y do objeto de NativeWindow
• Os limites mínimos e máximos do sistema operacional, que são os valores de NativeWindow.systemMinSize.y e NativeWindow.systemMaxSize.y.
• A largura máxima de uma janela em Adobe AIR, que é 4095 pixels (2880 pixels no AIR 1.5 e anteriores).

No Linux, definir a propriedade width é uma operação assíncrona.

Para detectar a conclusão da alteração de largura, escute o evento resize, que é Despachadoem todas as plataformas.

Os valores de pixel são arredondados para o número inteiro mais próximo quando a largura de uma janela é modificada.

Elementos da API relacionados

A coordenada do eixo horizontal do canto superior esquerdo desta janela em relação à origem da área de trabalho do sistema operacional.

Nos sistemas com mais de um monitor, x pode ser negativo. Se você salvar o valor, talvez para reposicionar uma janela em seu local anterior, você deve sempre verificar se a janela está colocada em um local utilizável quando a posição for restaurada. As alterações na resolução de tela ou na posição do monitor podem fazer com que a janela fique fora da tela. Use a classe Screen para obter informações sobre a geometria da área de trabalho.

Alterar a propriedade x de uma janela equivale a alterar o local por meio da propriedade bounds.

No Linux, definir a propriedade x é uma operação assíncrona.

Para detectar a conclusão da alteração da posição, escute o evento move, que é Despachadoem todas as plataformas.

Os valores de pixel são arredondados para o número inteiro mais próximo quando a coordenada x de uma janela é modificada.

Elementos da API relacionados

A coordenada do eixo vertical do canto superior esquerdo desta janela em relação ao canto superior esquerdo da área de trabalho do sistema operacional.

Nos sistemas com mais de um monitor, y pode ser negativo. Se você salvar o valor, talvez para reposicionar uma janela em seu local anterior, você deve sempre verificar se a janela está colocada em um local utilizável quando a posição for restaurada. As alterações na resolução de tela ou na posição do monitor podem fazer com que a janela fique fora da tela. Use a classe Screen para obter informações sobre a geometria da área de trabalho.

Alterar a propriedade y de uma janela equivale a alterar o local por meio da propriedade bounds.

No Linux, definir a propriedade y é uma operação assíncrona.

Para detectar a conclusão da alteração da posição, escute o evento move, que é Despachadoem todas as plataformas.

Os valores de pixel são arredondados para o número inteiro mais próximo quando a coordenada y de uma janela é modificada.

Elementos da API relacionados

Cria uma nova ocorrência NativeWindow e uma janela correspondente do sistema operacional.

As configurações definidas no parâmetro initOptions não podem ser alteradas depois que a janela é criada. As configurações initOptions farão com que seja lançado um erro de operação ilegal. Configurações válidas porém não disponíveis no sistema atual não lançam uma exceção. Recursos da janela específicos do sistema operacional atual podem ser detectados, se desejado, por meio dos membros NativeWindow estáticos, como systemMaxSize.

O tamanho de janela de padrão é determinado pelo sistema operacional, e as janelas são criadas em um estado invisível. Para impedir que alterações na janela sejam visíveis, não altera a propriedade visible da janela para true nem chame activate() até que as alterações na janela estejam concluidas.

Elementos da API relacionados

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

Ativa esta janela.

Ativar uma janela faz o seguinte:

• Torna a janela visível
• Traz a janela para frente
• Dá o foco de teclado e mouse da janela

No Linux, activate() é uma operação assíncrona.

O objeto de NativeWindow emite um evento activate em todas as plataformas.

Elementos da API relacionados

displayObject.stage.nativeWindow.activate();

windowObj.activate();

window.nativeWindow.activate();

Fecha esta janela.

Um evento close é despachado assim que a operação de fechar é concluída. Um evento closing não será despachado. Se for preciso permitir o cancelamento da operação de fechar, despache um evento closing e verifique se algum ouvinte registrado cancela o comportamento padrão antes de chamar o método close().

Quando uma janela é fechada, todas as suas janelas subordinadas também são fechadas. As janelas subordinadas não despacham eventos closing.

Caso as ocorrências do objeto de exibição que estão atualmente na janela não forem mencionadas em outro lugar, elas serão coletadas como lixo e destruídas, com exceção da janela do aplicativo inicial criada pelo AIR. Para permitir que os objetos de exibição na janela inicial sejam coletados como lixo, remova-os do palco da janela.

Depois de fechado, o objeto NativeWindow ainda é uma referência válida, mas acessar a maioria das propriedades e métodos lançará um erro de operação ilegal.

Janelas fechadas não podem ser reabertas. Se a janela já estiver fechada, nenhuma ação será executada e nenhum evento será despachado.

Nota: para ocultar uma janela sem fechá-la, defina a propriedade visible da janela como false.

Elementos da API relacionados

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>

Converte um ponto em coordenadas de pixel relativas à origem do palco da janela (um ponto global em termos da lista de exibição), em um ponto na área de trabalho virtual.

As coordenadas da área de trabalho virtual são relativas ao canto superior esquerdo do monitor principal.

Parâmetros

Elementos da API relacionados

Retorna uma lista dos objetos NativeWindow de propriedade desta janela.

Você não pode alterar a propriedade do NativeWindows adicionando ou removendo objetos a partir do vetor retornado. A propriedade da janela não pode ser alterada depois que uma janela é criada.

Elementos da API relacionados

Maximiza esta janela.

A chamada ao evento maximize() despacha um evento displayStateChange e, se aplicável, um evento move e resize. Considerando que um cromo do sistema despacha um evento displayStateChanging que pode ser cancelado quando o comando maximizar é iniciado por um usuário, sua lógica de maximizar deve implementar esse comportamento, se desejável.

O método maximize() é executado assincronamente. Para detectar a conclusão da alteração de estado, monitore o evento displayStateChange. Se a janela já estiver maximizada, nenhuma ação será executada e nenhum evento será despachado.

Observações sobre o comportamento do sistema operacional:

• Em sistemas operacionais como Mac OS X, no qual maximizar uma janela também não impede o redimensionamento, chamar o maximize() ampliará a janela para preencher a tela, mas não impedirá o redimensionamento subsequente da janela. Redimensionar uma janela ampliada também restaura o estado de exibição.
• Em alguns sistemas operacionais como, por exemplo, o Mac OS X, bem como em alguns gerenciadores de janelas do Linux; maximizar uma janela não a expandirá além da largura e da altura especificadas na propriedade maxSize. Em outros, a janela será expandida para preencher a tela, caso ela seja maior que maxSize.
• Alguns gerenciadores de janelas do Linux não permitem que janelas de utilitários sejam maximizadas.

Elementos da API relacionados

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

Minimiza esta janela.

A chamada ao evento minimize() despacha um evento displayStateChange e, se aplicável, um evento move e resize. Considerando que um cromo do sistema despacha um evento displayStateChanging que pode ser cancelado quando um comando minimizar é iniciado por um usuário, a chamada a minimize() diretamente não faz isso. Sua lógica de minimizar pode implementar esse comportamento, se desejável.

O minimize() é executado assincronamente. Para detectar a conclusão da alteração de palco, monitore o evento displayStateChange, que é despachado em todas as plataformas. Se a janela já estiver minimizada, nenhuma ação será executada e nenhum evento será despachado.

Qualquer janela subordinada a esta janela é ocultada quando a janela proprietária é minimizada. As janelas subordinadas não despacham eventos displayStateChanging e displayStateChange.

Observações:

• No Windows, minimizar uma janela invisível (visible == false ) torna a janela visível.
• Alguns gerenciadores de janelas do Linux não permitem que janelas de utilitários sejam minimizadas.

Elementos da API relacionados

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

Dispara uma sinalização visual por meio do sistema operacional informando que ocorreu um evento de interesse.

Quando NativeWindow.supportsNotification for true, a sinalização visual se conformará à convenção do sistema operacional do sistema nativo. Por exemplo, no Windows, o ícone da barra de tarefas pisca nesse caso.

O parâmetro type determina a intensidade da sinalização. As constantes dos valores permitidos são definidas na classe NotificationType, e podem ser:

• NotificationType.INFORMATIONAL
• NotificationType.CRITICAL

As sinalizações apresentadas em notificações de informações são de curta duração; as apresentadas em notificações críticas duram até que o último usuário ative essa janela. Nem todos os gerenciadores de janelas do Linux oferecem suporte a dois níveis de notificação. Para esses gerenciadores de janelas, notifyUser() terá o mesmo efeito, independentemente da opção especificada.

Você pode Observação: chamar notifyUser() quando NativeWindow.supportsNotification for false, mas essa ação não executa nada.

Parâmetros

Envia esta janela diretamente para trás da janela especificada.

Não ativa nem adquire o foco da janela nem do aplicativo. Janelas minimizadas ou ocultas (visible é false) não podem ser reordenadas.

Uma janela subordinada jamais pode ser movida para trás de sua proprietária. Se essa janela for subordinada a uma janela proprietária, então a janela proprietária e outras janelas a ela subordinadas serão ordenadas atrás do destino. Se a janela de destino tiver uma janela proprietária, será ordenada atrás dessa.

Alguns gerenciadores de janelas do Linux não permitem que janelas de utilitários sejam ordenadas atrás das janelas normais.

Parâmetros

windowBehind.orderInBackOf(windowFront);

displayObjBehind.stage.nativeWindow.orderInBackOf(displayObjectFront.stage.nativeWindow);

jsWindowObjBehind.nativeWindow.orderInBackOf(jsWindowObjFront.nativeWindow);

Coloca esta janela diretamente à frente da janela especificada.

Não ativa nem adquire o foco da janela nem do aplicativo. Janelas minimizadas ou ocultas (visible é false) não podem ser reordenadas.

Uma janela proprietária nunca pode ser movida para a frente de uma janela subordinada. Se esta janela for subordinada a uma janela proprietária, então essa e outras janelas por ela subordinadas também serão ordenadas adiante do destino. Se a janela de destino for subordinada a uma janela proprietária, também será ordenada adiante de qualquer outra janela que seja subordinada à mesma janela que a janela de destino.

Alguns gerenciadores de janelas do Linux não permitem que janelas normais sejam ordenadas à frente das janelas dos utilitários.

Parâmetros

windowFront.orderInFrontOf(windowBehind);

displayObjFront.stage.nativeWindow.orderInFrontOf(displayObjectBehind.stage.nativeWindow);

jsWindowObjFront.nativeWindow.orderInFrontOf(jsWindowObjBehind.nativeWindow);

Envia esta janela para trás de qualquer outra janela visível.

Não ativa nem obtém o foco para esta janela nem este aplicativo. Janelas minimizadas ou ocultas (visible é false) não podem ser reordenadas.

Se alwaysInFront for true, chamar este método não enviará esta janela atrás de nenhuma outra janela que tenha alwaysInFront definido como false.

Uma janela subordinada jamais pode ser movida para trás de sua proprietária. Se esta janela for subordinada a uma janela proprietária, essa e outras janelas por ela subordinadas também serão ordenadas na parte inferior da lista de exibição em janelas. Esta janela moverá para trás qualquer outra janela subordinada à pela mesma janela. Se esta janela tiver outras janelas subordinada, essas janelas também serão movidas para trás, mantendo a sua ordem atual relativamente umas às outras.

Alguns gerenciadores de janelas do Linux não permitem que janelas de utilitários sejam ordenadas atrás das janelas normais.

windowObj.orderToBack();

displayObj.stage.nativeWindow.orderToBack();

window.nativeWindow.orderToBack();

Coloca esta janela à frente de qualquer outra janela visível.

Não ativa nem obtém o foco para esta janela nem este aplicativo. Janelas minimizadas ou ocultas (visible é false) não podem ser reordenadas.

Se alwaysInFront for false, chamar este método não enviará esta janela na frente de nenhuma outra janela que tenha alwaysInFront definido como true.

Uma janela proprietária nunca pode ser movida para a frente de uma janela subordinada. Se esta janela tiver outras janelas subordinadas, essas janelas também serão movidas para a frente, mantendo a sua ordem atual relativamente umas às outras. Se esta janela for subordinada a uma janela proprietária, então essa e outras janelas a ela subordinadas serão ordenadas adiante na ordem de exibição de janelas. Esta janela é movida para a frente de outras janelas subordinadas à mesma janela proprietária.

Alguns gerenciadores de janelas do Linux não permitem que janelas normais sejam ordenadas à frente das janelas dos utilitários.

windowObj.orderToFront();

displayObj.stage.nativeWindow.orderToFront();

window.nativeWindow.orderToFront();

Restaura esta janela a partir de um estado minimizado ou maximizado.

A chamada ao evento restore() despacha um evento displayStateChange e, se aplicável, um evento move e resize. Considerando que um cromo do sistema despacha um evento displayStateChanging que pode ser cancelado quando o comando restaurar é iniciado por um usuário, sua lógica de restaurar deve implementar esse comportamento, se desejável.

Se a janela já está no estado NativeWindowDisplayState.NORMAL, nenhuma ação será executada e nenhum evento será despachado.

Para detectar a conclusão da alteração de palco, monitore o evento displayStateChange, que é Despachadoem todas as plataformas.

Elementos da API relacionados

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

Inicia uma movimentação controlada pelo sistema em relação a esta janela.

Quando chamado de um evento mouseDown, este método inicia uma movimentação orientada pela sequência do mouse, que continua até que ocorra um evento mouseUp.

Quando chamado de outro código, este método inicia uma sequência de movimentação orientada pelo teclado ou pelo mouse, consistente com a sequência padrão do sistema operacional.

Durante uma sequência de movimentação, uma série de eventos são despachados conforme a origem da janela se movimenta. Para cada movimentação incremental, primeiramente é despachado um evento moving e, então, se o evento moving não for cancelado, o local da janela será atualizado e um evento move será despachado. Se um evento moving for cancelado, a sequência de movimentação será encerrada imediatamente.

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

Inicia uma operação de redimensionamento controlado pelo sistema em relação a esta janela.

Quando chamado de um manipulador de eventos mouseDown, este método inicia uma sequência de redimensionamento orientada pelo mouse, que continua até que ocorra um evento mouseUp.

Quando chamado de outro código, este método inicia uma sequência de redimensionamento orientada pelo teclado ou pelo mouse, consistente com a sequência padrão do sistema operacional.

Durante a sequência de redimensionamento, uma série de eventos são despachados conforme as dimensões da janela são alteradas. Para cada alteração incremental, primeiramente é despachado um evento resizing e, então, se o evento resizing não for cancelado, as dimensões da janela serão atualizadas e um evento resize será despachado. Se um evento resizing for cancelado, a sequência será encerrada imediatamente.

Parâmetros

Elementos da API relacionados

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

Despachado por este objeto NativeWindow depois que a janela tiver sido ativada.

Observação: Esse evento não tem uma "fase de captura" nem "fase de bubble", significando que os ouvintes de evento precisam ser adicionados diretamente a qualquer destino possível que esteja ou não na lista de exibição.

Dispositivos AIR for TV nunca emitem este evento automaticamente. Você pode, contudo, emiti-lo manualmente.

Esse evento tem as seguintes propriedades:

Despachado por este objeto NativeWindow depois que a janela tiver sido fechada.

Esse evento tem as seguintes propriedades:

Despachado por este objeto NativeWindow imediatamente antes de a janela ser fechada. Este evento pode ser cancelado para impedir que a janela seja fechada.

Esse evento tem as seguintes propriedades:

Despachado por este objeto NativeWindow depois que a janela tiver sido desativada.

Observação: Esse evento não tem uma "fase de captura" nem "fase de bubble", significando que os ouvintes de evento precisam ser adicionados diretamente a qualquer destino possível que esteja ou não na lista de exibição.

Dispositivos AIR for TV nunca emitem este evento automaticamente. Você pode, contudo, emiti-lo manualmente.

Esse evento tem as seguintes propriedades:

Despachado por este objeto NativeWindow depois que a propriedade displayState da janela tiver sido alterada.

Não redimensione a janela nem altere seu estado de exibição no controlador de eventos displayStateChange.

Esse evento tem as seguintes propriedades:

Despachado por este objeto NativeWindow imediatamente antes que a janela altere o estado de exibição. Este evento pode ser cancelado para impedir a alteração.

Esse evento tem as seguintes propriedades:

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

Despachado por este objeto NativeWindow depois que a janela tiver sido movida na área de trabalho.

Um evento move é despachado sempre que se altera a origem (propriedades x or y) da janela, o que pode ocorrer em razão de uma movimentação, minimização, maximização ou restauração da janela controlada pelo sistema, ou, ainda, à restauração da janela ou à alteração do local da janela, definindo as propriedades x, y ou bounds.

Observação: evite ações que possam abrir caixas de diálogo de sistemas operacionais simultâneos nas funções do manipulador, tanto para eventos moving quanto eventos move de uma NativeWindow. Isso poderá ocorrer, por exemplo, se ambas as funções de manipulador lançarem um erro. Se isso efetivamente acontecer, a segunda caixa de diálogo aberta não registrará cliques do mouse e deverá ser fechada usando o teclado.

Esse evento tem as seguintes propriedades:

Despachado por este objeto NativeWindow imediatamente antes de a janela ser movida na área de trabalho. Este evento pode ser cancelado para impedir ou modificar a movimentação.

Observação: evite ações que possam abrir caixas de diálogo de sistemas operacionais simultâneos nas funções do manipulador, tanto para eventos moving quanto eventos move de uma NativeWindow. Isso poderá ocorrer, por exemplo, se ambas as funções de manipulador lançarem um erro. Se isso efetivamente acontecer, a segunda caixa de diálogo aberta não registrará cliques do mouse e deverá ser fechada usando o teclado.

Esse evento tem as seguintes propriedades:

Nota: no Linux, o método preventDefault() não é suportado para este evento.

Despachado por este objeto NativeWindow depois que a janela tiver sido redimensionada. Um evento resize é despachado sempre que se altera o tamanho (propriedades width ou height) da janela, o que pode ocorrer em razão de um redimensionamento, minimização, maximização ou restauração da janela controlada pelo sistema, ou, ainda, à restauração da janela ou alteração do tamanho da janela, definindo as propriedades width, height ou bounds. Os eventos resize do NativeWindow são despachados durante as repetições de redimensionamento controladas pelo sistema. Por outro lado, os eventos resize do objeto Stage são despachados quando o palco está pronto para o desenho.

Esse evento tem as seguintes propriedades:

Elementos da API relacionados

Despachado por este objeto NativeWindow imediatamente antes de a janela ser redimensionada na área de trabalho. Este evento pode ser cancelado para impedir ou modificar o redimensionamento.

Esse evento tem as seguintes propriedades:

Nota: no Linux, o método preventDefault() não é suportado para este evento.

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