The source code

    /**
     * @class Ext.air.NativeWindow
     * @extends Ext.air.NativeObservable
     *
     * Wraps the AIR NativeWindow class to give an Ext friendly API.

    This class also adds
     * automatic state management (position and size) for the window (by id) and it can be used
     * for easily creating "minimize to system tray" for the main window in your application.

     *
     * Note: Many of the config options for this class can only be applied to NEW windows. Passing
     * in an existing instance of a window along with those config options will have no effect.
     *
     * @constructor
     * @param {Object} config
     */
    Ext.air.NativeWindow = function(config){
    	Ext.apply(this, config);

    	/**
    	 * @type String
    	 */
    	this.id = this.id || Ext.uniqueId();

    	this.addEvents(
    		/**
    		 * @event close
    		 * @param {Object} e The air event object
    		 */
    		'close',
    		/**
    		 * @event closing
    		 * @param {Object} e The air event object
    		 */
    		'closing',
    		/**
    		 * @event move
    		 * @param {Object} e The air event object
    		 */
    		'move',
    		/**
    		 * @event moving
    		 * @param {Object} e The air event object
    		 */
    		'moving',
    		/**
    		 * @event resize
    		 * @param {Object} e The air event object
    		 */
    		'resize',
    		/**
    		 * @event resizing
    		 * @param {Object} e The air event object
    		 */
    		'resizing',
    		/**
    		 * @event displayStateChange
    		 * @param {Object} e The air event object
    		 */
    		'displayStateChange',
    		/**
    		 * @event displayStateChanging
    		 * @param {Object} e The air event object
    		 */
    		'displayStateChanging'
    	);

    	Ext.air.NativeWindow.superclass.constructor.call(this);

    	if(!this.instance){
    		var options = new air.NativeWindowInitOptions();
    		options.systemChrome = this.chrome;
    		options.type = this.type;
    		options.resizable = this.resizable;
    		options.minimizable = this.minimizable;
    		options.maximizable = this.maximizable;
    		options.transparent = this.transparent;

    		this.loader = window.runtime.flash.html.HTMLLoader.createRootWindow(false, options, false);
    		this.loader.load(new air.URLRequest(this.file));

    		this.instance = this.loader.window.nativeWindow;
    	}else{
    		this.loader = this.instance.stage.getChildAt(0);
    	}

    	var provider = Ext.state.Manager;
    	var b = air.Screen.mainScreen.visibleBounds;

    	var state = provider.get(this.id) || {};
    	provider.set(this.id, state);

    	var win = this.instance;

    	var width = Math.max(state.width || this.width, 100);
    	var height = Math.max(state.height || this.height, 100);

    	var centerX = b.x + ((b.width/2)-(width/2));
    	var centerY = b.y + ((b.height/2)-(height/2));

    	var x = !Ext.isEmpty(state.x, false) ? state.x : (!Ext.isEmpty(this.x, false) ? this.x : centerX);
    	var y = !Ext.isEmpty(state.y, false) ? state.y : (!Ext.isEmpty(this.y, false) ? this.y : centerY);

    	win.width = width;
    	win.height = height;
    	win.x = x;
    	win.y = y;

    	win.addEventListener('move', function(){
    		if(win.displayState != air.NativeWindowDisplayState.MINIMIZED && win.width > 100 && win.height > 100) {
    			state.x = win.x;
    			state.y = win.y;
    		}
    	});
    	win.addEventListener('resize', function(){
    		if (win.displayState != air.NativeWindowDisplayState.MINIMIZED && win.width > 100 && win.height > 100) {
    			state.width = win.width;
    			state.height = win.height;
    		}
    	});

    	Ext.air.NativeWindowManager.register(this);
    	this.on('close', this.unregister, this);

    	/**
    	 * @cfg {Boolean} minimizeToTray
    	 * True to enable minimizing to the system tray. Note: this should only be applied
    	 * to the primary window in your application. A trayIcon is required.
    	 */
    	if(this.minimizeToTray){
    		this.initMinimizeToTray(this.trayIcon, this.trayMenu);
    	}

    };

    Ext.extend(Ext.air.NativeWindow, Ext.air.NativeObservable, {

    	/**
    	 * @cfg {air.NativeWindow} instance
    	 * The native window instance to wrap. If undefined, a new window will be created.
    	 */

    	/**
    	 * @cfg {String} trayIcon
    	 * The icon to display when minimized in the system tray
    	 */
    	/**
    	 * @cfg {NativeMenu} trayMenu
    	 * Menu to display when the tray icon is right clicked
    	 */
    	/**
    	 * @cfg {String} trayTip
    	 * Tooltip for the tray icon
    	 */

    	/**
    	 * @cfg {String} chrome
    	 * The native window chrome (defaults to 'standard', can also be 'none').
    	 */
    	chrome: 'standard', // can also be none
    	/**
    	 * @cfg {String} type
    	 * The native window type - normal, utility or lightweight. (defaults to normal)
    	 */
    	type: 'normal',	// can be normal, utility or lightweight
    	/**
    	 * @cfg {Number} width
    	 */
    	width:600,
    	/**
    	 * @cfg {Number} height
    	 */
    	height:400,
    	/**
    	 * @cfg {Boolean} resizable
    	 */
    	resizable: true,
    	/**
    	 * @cfg {Boolean} minimizable
    	 */
    	minimizable: true,
    	/**
    	 * @cfg {Boolean} maximizable
    	 */
    	maximizable: true,
    	/**
    	 * @cfg {Boolean} transparent
    	 */
    	transparent: false,

    	/**
    	 * Returns the air.NativeWindow instance
    	 * @return air.NativeWindow
    	 */
    	getNative : function(){
    		return this.instance;
    	},

    	/**
    	 * Returns the x/y coordinates for centering the windw on the screen
    	 * @return {x: Number, y: Number}
    	 */
    	getCenterXY : function(){
    		var b = air.Screen.mainScreen.visibleBounds;
    		return {
    			x: b.x + ((b.width/2)-(this.width/2)),
    			y: b.y + ((b.height/2)-(this.height/2))
    		};
    	},

    	/**
    	 * Shows the window
    	 */
    	show :function(){
    		if(this.trayed){
    			Ext.air.SystemTray.hideIcon();
    			this.trayed = false;
    		}
    		this.instance.visible = true;
    	},

    	/**
    	 * Shows and activates the window
    	 */
    	activate : function(){
    		this.show();
    		this.instance.activate();
    	},

    	/**
    	 * Hides the window
    	 */
    	hide :function(){
    		this.instance.visible = false;
    	},

    	/**
    	 * Closes the window
    	 */
    	close : function(){
    		this.instance.close();
    	},

    	/**
    	 * Returns true if this window is minimized
    	 * @return Boolean
    	 */
    	isMinimized :function(){
    		return this.instance.displayState == air.NativeWindowDisplayState.MINIMIZED;
    	},

    	/**
    	 * Returns true if this window is maximized
    	 * @return Boolean
    	 */
    	isMaximized :function(){
    		return this.instance.displayState == air.NativeWindowDisplayState.MAXIMIZED;
    	},

    	/**
    	 * Moves the window to the passed xy and y coordinates
    	 * @param {Number} x
    	 * @param {Number} y
    	 */
    	moveTo : function(x, y){
    		this.x = this.instance.x = x;
    		this.y = this.instance.y = y;
    	},

    	/**
    	 * @param {Number} width
    	 * @param {Number} height
    	 */
    	resize : function(width, height){
    		this.width = this.instance.width = width;
    		this.height = this.instance.height = height;
    	},

    	unregister : function(){
    		Ext.air.NativeWindowManager.unregister(this);
    	},

    	initMinimizeToTray : function(icon, menu){
    		var tray = Ext.air.SystemTray;

    		tray.setIcon(icon, this.trayTip);
    		this.on('displayStateChanging', function(e){
    			if(e.afterDisplayState == 'minimized'){
    				e.preventDefault();
    				this.hide();
    				tray.showIcon();
    				this.trayed = true;
    			}
    		}, this);

    		tray.on('click', function(){
    			this.activate();
    		}, this);

    		if(menu){
    			tray.setMenu(menu);
    		}
    	}
    });

    /**
     * Returns the first opened window in your application
     * @return air.NativeWindow
     * @static
     */
    Ext.air.NativeWindow.getRootWindow = function(){
    	return air.NativeApplication.nativeApplication.openedWindows[0];
    };

    /**
     * Returns the javascript "window" object of the first opened window in your application
     * @return Window
     * @static
     */
    Ext.air.NativeWindow.getRootHtmlWindow = function(){
    	return Ext.air.NativeWindow.getRootWindow().stage.getChildAt(0).window;
    };

    /**
     * @class Ext.air.NativeWindowGroup
     *
     * A collection of NativeWindows.
     */
    Ext.air.NativeWindowGroup = function(){
        var list = {};

        return {
    		/**
    		 * @param {Object} win
    		 */
            register : function(win){
                list[win.id] = win;
            },

            /**
    		 * @param {Object} win
    		 */
            unregister : function(win){
                delete list[win.id];
            },

            /**
    		 * @param {String} id
    		 */
            get : function(id){
                return list[id];
            },

            /**
    		 * Closes all windows
    		 */
            closeAll : function(){
                for(var id in list){
                    if(list.hasOwnProperty(id)){
                        list[id].close();
                    }
                }
            },

            /**
             * Executes the specified function once for every window in the group, passing each
             * window as the only parameter. Returning false from the function will stop the iteration.
             * @param {Function} fn The function to execute for each item
             * @param {Object} scope (optional) The scope in which to execute the function
             */
            each : function(fn, scope){
                for(var id in list){
                    if(list.hasOwnProperty(id)){
                        if(fn.call(scope || list[id], list[id]) === false){
                            return;
                        }
                    }
                }
            }
        };
    };

    /**
     * @class Ext.air.NativeWindowManager
     * @extends Ext.air.NativeWindowGroup
     *
     * Collection of all NativeWindows created.
     *
     * @singleton
     */
    Ext.air.NativeWindowManager = new Ext.air.NativeWindowGroup();