Criação de janelas

As propriedades de inicialização de uma janela nativa não podem ser alteradas após a criação da janela da área de trabalho. Entre as propriedades imutáveis e seus valores padrão estão os seguintes:

Defina as propriedades da janela inicial criada pelo AIR no arquivo de descrição do aplicativo. A janela principal de um aplicativo do AIR sempre é do tipo normal . (É possível especificar outras propriedades de janela no arquivo de descrição, tais como visible , width e height , mas elas podem ser alteradas a qualquer momento.)

Defina as propriedades de outras janelas nativas e HTML criadas pelo seu aplicativo usando a classe NativeWindowInitOptions. Quando você cria uma janela, deve passar um objeto NativeWindowInitOptions que especifique as propriedades da janela para a função de construtor NativeWindow ou o método createRootWindow() de HTMLLoader.

O seguinte código cria um objeto NativeWindowInitOptions para uma janela de utilitário:

var options:NativeWindowInitOptions = new NativeWindowInitOptions(); 
options.systemChrome = NativeWindowSystemChrome.STANDARD; 
options.type = NativeWindowType.UTILITY 
options.transparent = false; 
options.resizable = false; 
options.maximizable = false; 

Não é permitido definir systemChrome como standard quando transparent é true ou quando type é lightweight .

Quando criar uma janela com a classe mx:Window do Flex, especifique as propriedades de inicialização no próprio objeto Window, seja na declaração MXML correspondente ou no código que cria a janela. O objeto NativeWindow subjacente só é criado quando você chama o método open() . Uma vez aberta uma janela, não é possível alterar essas propriedades de inicialização.

O AIR cria a janela inicial do aplicativo com base nas propriedades especificadas no descritor do aplicativo e carrega o arquivo mencionado no elemento de conteúdo. O elemento de conteúdo deve referenciar um arquivo SWF ou um arquivo HTML.

A janela inicial pode ser a janela principal do seu aplicativo ou pode simplesmente servir para iniciar uma ou mais janelas. Não é necessário torná-la visível.

Para criar um NativeWindow, passe um objeto NativeWindowInitOptions para o construtor NativeWindow:

var options:NativeWindowInitOptions = new NativeWindowInitOptions(); 
options.systemChrome = NativeWindowSystemChrome.STANDARD; 
options.transparent = false; 
var newWindow:NativeWindow = new NativeWindow(options); 

A janela não é exibida até você definir a propriedade visible como true ou chamar o método activate() .

Uma vez criada a janela, você pode inicializar suas propriedades e carregar conteúdo nela usando as técnicas de propriedade de palco e lista de exibição do Flash.

Em quase todos os casos, você deve definir a propriedade de palco scaleMode de uma nova janela nativa como noScale (use a constante StageScaleMode.NO_SCALE ). Os modos de dimensionamento do Flash foram desenvolvidos para situações em que o autor do aplicativo não sabe de antemão a proporção do espaço de exibição do aplicativo. Os modos de dimensionamento permitem que o autor escolha o melhor ajuste: recorte o conteúdo, aumente ou compacte o conteúdo ou preencha-o com espaço vazio. Desde que você controle o espaço de exibição no AIR (o quadro da janela), pode dimensionar a janela conforme o conteúdo ou vice-versa, sem comprometer o resultado final.

O modo de dimensionamento de janelas Flex e HTML é definido como noScale automaticamente.

var maxOSSize:Point = NativeWindow.systemMaxSize; 
var minOSSize:Point = NativeWindow.systemMinSize; 

Para criar uma janela HTML, você pode chamar o método JavaScript Window.open() ou o método createRootWindow() da classe HTMLLoader do AIR.

O conteúdo HTML em qualquer caixa de proteção de segurança pode usar o método JavaScript Window.open() padrão. Se o conteúdo estiver sendo executado fora da caixa de proteção do aplicativo, o método open() só poderá ser chamado em resposta a interações do usuário, como cliques do mouse ou pressionamentos de tecla. Quando open() é chamado, é criada uma janela com o cromo do sistema para exibir o conteúdo na URL especificada. Por exemplo:

newWindow = window.open("xmpl.html", "logWindow", "height=600, width=400, top=10, left=10");

O conteúdo na caixa de proteção de segurança do aplicativo tem acesso ao método de criação de janelas mais eficiente, HTMLLoader.createRootWindow() . Com ele, você pode especificar todas as opções de criação de uma nova janela. Por exemplo, o seguinte código JavaScript cria uma janela do tipo leve sem cromo do sistema e com tamanho de 300x400 pixels:

var options = new air.NativeWindowInitOptions(); 
options.systemChrome = "none"; 
options.type = "lightweight"; 
 
var windowBounds = new air.Rectangle(200,250,300,400); 
newHTMLLoader = air.HTMLLoader.createRootWindow(true, options, true, windowBounds); 
newHTMLLoader.load(new air.URLRequest("xmpl.html"));

Ao criar uma janela transparente, o conteúdo SWF integrado no HTML carregado nessa janela nem sempre é exibido. Você deve definir o parâmetro wmode do objeto ou a tag integrada utilizada para fazer referência ao arquivo SWF para opaque ou transparent . O valor padrão de wmode é window e, por padrão, o conteúdo SWF não é exibido em janelas transparentes. O conteúdo PDF não pode ser exibido em janelas transparentes, não importando com o valor wmode está definido. (Antes da versão AIR 1.5.2, o conteúdo SWF também não podia ser exibido em janelas transparentes.)

As janelas criadas com o método createRootWindow() permanecem independentes da janela de abertura. As propriedades parent e opener do objeto JavaScript Window são null . A janela de abertura pode acessar o objeto Window da nova janela usando a referência a HTMLLoader retornada pela função createRootWindow() . No contexto do exemplo anterior, a instrução newHTMLLoader.window faria referência ao objeto JavaScript Window da janela criada.

Para criar uma classe mx:Window, crie um arquivo MXML usando mx:Window como a tag raiz ou chame o construtor de classe Window diretamente.

O exemplo abaixo cria e mostra uma mx:Window chamando o construtor Window:

var newWindow:Window = new Window(); 
newWindow.systemChrome = NativeWindowSystemChrome.NONE; 
newWindow.transparent = true; 
newWindow.title = "New Window"; 
newWindow.width = 200; 
newWindow.height = 200; 
newWindow.open(true);

O tipo de uma janela do AIR determina a maneira como você adiciona conteúdo a ela. Por exemplo, as linguagens MXML e HTML permitem definir o conteúdo básico da janela declarativamente. É possível incorporar recursos nos arquivos SWF do aplicativo ou carregá-los a partir de arquivos de aplicativo separados. O conteúdo Flex, Flash e HTML pode ser criado dinamicamente e adicionado a uma janela de forma dinâmica.

Quando você carrega conteúdo SWF, ou HTML com JavaScript, deve levar em consideração o modelo de segurança do AIR. Qualquer conteúdo existente na caixa de proteção de segurança do aplicativo, ou seja, conteúdo instalado com seu aplicativo e carregável com o esquema de URL app:, tem privilégios totais para acessar todas as APIs do AIR. Qualquer conteúdo carregado de fora dessa caixa de proteção não pode acessar as APIs do AIR. O conteúdo JavaScript fora da caixa de proteção do aplicativo não pode usar as propriedades runtime , nativeWindow ou htmlLoader do objeto JavaScript Window.

Para permitir código entre scripts seguro, você pode usar uma ponte de caixa de proteção para disponibilizar uma interface limitada entre conteúdo de aplicativo e conteúdo que não é de aplicativo. No conteúdo HTML, também é possível mapear páginas do seu aplicativo para uma caixa de proteção que não seja de aplicativo, de maneira que essa página possa cruzar scripts de conteúdo externo. Consulte Segurança do AIR .

package { 
    import flash.display.Sprite; 
    import flash.events.Event; 
    import flash.net.URLRequest; 
    import flash.display.Loader; 
 
    public class LoadedSWF extends Sprite 
    { 
        public function LoadedSWF(){ 
            var loader:Loader = new Loader(); 
            loader.load(new URLRequest("visual.swf"));                    
            loader.contentLoaderInfo.addEventListener(Event.COMPLETE,loadFlash); 
        } 
 
        private function loadFlash(event:Event):void{ 
            addChild(event.target.loader);  
        } 
    } 
}

//newWindow is a NativeWindow instance 
var htmlView:HTMLLoader = new HTMLLoader(); 
htmlView.width = 300; 
htmlView.height = 500; 
 
//set the stage so display objects are added to the top-left and not scaled 
newWindow.stage.align = "TL"; 
newWindow.stage.scaleMode = "noScale"; 
newWindow.stage.addChild( htmlView ); 
 
//urlString is the URL of the HTML page to load 
htmlView.load( new URLRequest(urlString) );

<html> 
<head> 
<title>Bouncers</title> 
<script src="AIRAliases.js" type="text/javascript"></script> 
<script language="JavaScript" type="text/javascript"> 
air.Shape = window.runtime.flash.display.Shape; 
 
function Bouncer(radius, color){ 
    this.radius = radius; 
    this.color = color; 
 
    //velocity  
    this.vX = -1.3; 
    this.vY = -1; 
 
    //Create a Shape object and draw a circle with its graphics property 
    this.shape = new air.Shape();     
    this.shape.graphics.lineStyle(1,0); 
    this.shape.graphics.beginFill(this.color,.9); 
    this.shape.graphics.drawCircle(0,0,this.radius); 
    this.shape.graphics.endFill(); 
     
    //Set the starting position 
    this.shape.x = 100; 
    this.shape.y = 100; 
 
 
    //Moves the sprite by adding (vX,vY) to the current position 
    this.update = function(){ 
        this.shape.x += this.vX; 
        this.shape.y += this.vY; 
         
        //Keep the sprite within the window 
        if( this.shape.x - this.radius < 0){  
            this.vX = -this.vX; 
        } 
        if( this.shape.y - this.radius < 0){ 
            this.vY = -this.vY; 
        } 
        if( this.shape.x  + this.radius > window.nativeWindow.stage.stageWidth){ 
            this.vX = -this.vX; 
        } 
        if( this.shape.y  + this.radius > window.nativeWindow.stage.stageHeight){ 
            this.vY = -this.vY; 
        } 
         
    }; 
} 
 
function init(){ 
    //turn off the default HTML background 
    window.htmlLoader.paintsDefaultBackground = false; 
    var bottom = new Bouncer(60,0xff2233); 
    var top = new Bouncer(30,0x2441ff); 
 
    //listen for the enterFrame event 
    window.htmlLoader.addEventListener("enterFrame",function(evt){ 
        bottom.update(); 
        top.update(); 
    }); 
     
    //add the bouncing shapes to the window stage 
    window.nativeWindow.stage.addChildAt(bottom.shape,0); 
    window.nativeWindow.stage.addChild(top.shape); 
} 
</script> 
<body onload="init();"> 
<h1>de Finibus Bonorum et Malorum</h1> 
<p>Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium 
doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis 
et quasi architecto beatae vitae dicta sunt explicabo.</p> 
<p style="background-color:#FFFF00; color:#660000;">This paragraph has a background color.</p> 
<p>At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis 
praesentium voluptatum deleniti atque corrupti quos dolores et quas molestias 
excepturi sint occaecati cupiditate non provident, similique sunt in culpa qui 
officia deserunt mollitia animi, id est laborum et dolorum fuga.</p> 
</body> 
</html>

O exemplo abaixo mostra como criar uma janela nativa:

public function createNativeWindow():void { 
    //create the init options 
    var options:NativeWindowInitOptions = new NativeWindowInitOptions(); 
    options.transparent = false; 
    options.systemChrome = NativeWindowSystemChrome.STANDARD; 
    options.type = NativeWindowType.NORMAL; 
     
    //create the window 
    var newWindow:NativeWindow = new NativeWindow(options); 
    newWindow.title = "A title"; 
    newWindow.width = 600; 
    newWindow.height = 400; 
     
    newWindow.stage.align = StageAlign.TOP_LEFT; 
    newWindow.stage.scaleMode = StageScaleMode.NO_SCALE; 
 
    //activate and show the new window 
    newWindow.activate(); 
}