95
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
To load an HTML page into a Flex application, you can use the Flex HTML component.
SWF content in an HTML file is not displayed if the window uses transparency (that is the 
transparent
property of 
the window is 
true
) unless the 
wmode
parameter of the object or embed tag used to reference the SWF file is set to 
either 
opaque
or 
transparent
. Since the default 
wmode
value is 
window
, by default, SWF content is not displayed in 
a transparent window. PDF content is not displayed in a transparent window no matter what 
wmode
value is used. 
Also, neither SWF nor PDF content is displayed if the HTMLLoader control is scaled, rotated, or if the HTMLLoader 
alpha
property is set to a value other than 1.0.
Adding SWF content as an overlay on an HTML window
Because HTML windows are contained within a NativeWindow instance, you can add Flash display objects both above 
and below the HTML layer in the display list. 
To add a display object above the HTML layer, use the 
addChild() 
method of the 
window.nativeWindow.stage
property. The 
addChild()
method adds content layered above any existing content in the window. 
To add a display object below the HTML layer, use the 
addChildAt()
method of the 
window.nativeWindow.stage
property, passing in a value of zero for the 
index
parameter. Placing an object at the zero index moves existing content, 
including the HTML display, up one layer and insert the new content at the bottom. For content layered underneath 
the HTML page to be visible, you must set the 
paintsDefaultBackground
property of the 
HTMLlLoader
object to 
false
. In addition, any elements of the page that set a background color, will not be transparent. If, for example, you 
set a background color for the body element of the page, none of the page will be transparent. 
The following example illustrates how to add a Flash display objects as overlays and underlays to an HTML page. The 
example creates two simple shape objects, adds one below the HTML content and one above. The example also updates 
the shape position based on the 
enterFrame
event.
<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  
Create bookmarks pdf file - add, remove, update PDF bookmarks in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your C# Project with Rapid PDF Internal Navigation Via Bookmark and Outline
create bookmark in pdf automatically; delete bookmarks pdf
Create bookmarks pdf file - VB.NET PDF bookmark library: add, remove, update PDF bookmarks in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your VB.NET Project with Rapid PDF Internal Navigation Via Bookmark and Outline
pdf bookmark; add bookmarks to pdf
96
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
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>
This example provides a rudimentary introduction to some advanced techniques that cross over the boundaries 
between JavaScript and ActionScript in AIR. If your are unfamiliar with using ActionScript display objects, refer to 
Display programming in the ActionScript 3.0 Developer’s Guide.
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Bookmarks. below is mainly to optimize PDF file with multiple String outputFilePath = Program.RootPath + "\\" 3_optimized.pdf"; 'create optimizing options
display bookmarks in pdf; how to add bookmarks to pdf files
C# PDF File Split Library: Split, seperate PDF into multiple files
Split PDF file by top level bookmarks. The following C# codes explain how to split a PDF file into multiple ones by PDF bookmarks or outlines.
bookmarks pdf files; creating bookmarks pdf files
97
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
Note: To access the runtime, nativeWindow and htmlLoader properties of the JavaScript Window object, the HTML page 
must be loaded from the application directory. This will always be the case for the root page in an HTML-based 
application, but may not be true for other content. In addition, documents loaded into frames even within the application 
sandbox do not receive these properties, but can access those of the parent document.
Example: Creating a native window
Adobe AIR 1.0 and later
The following example illustrates how to create a native window:
function createNativeWindow() {  
//create the init options  
var options = new air.NativeWindowInitOptions();  
options.transparent = false;  
options.systemChrome = air.NativeWindowSystemChrome.STANDARD;  
options.type = air.NativeWindowType.NORMAL;  
//create the window  
var newWindow = new air.NativeWindow(options);  
newWindow.title = "A title";  
newWindow.width = 600;  
newWindow.height = 400;  
//activate and show the new window  
newWindow.activate();  
}
Managing windows
Adobe AIR 1.0 and later
You use the properties and methods of the NativeWindow class to manage the appearance, behavior, and life cycle of 
desktop windows. 
Note: When using the Flex framework, it is generally better to manage window behavior using the framework classes. 
Most of the NativeWindow properties and methods can be accessed through the mx:WindowedApplication and 
mx:Window classes.
Getting a NativeWindow instance 
Adobe AIR 1.0 and later
To manipulate a window, you must first get the window instance. You can get a window instance from one of the 
following places: 
• The native window constructor used to create the window: 
var nativeWin = new air.NativeWindow(initOptions);
• The 
stage
property of a display object in the window: 
var nativeWin = window.htmlLoader.stage.nativeWindow;
VB.NET PDF File Split Library: Split, seperate PDF into multiple
how to split a PDF file into multiple ones by PDF bookmarks or outlines. value for each index: 1 to (Page Count - 1). ' Create output PDF file path list
bookmark a pdf file; bookmarks pdf reader
C# PDF File Compress Library: Compress reduce PDF size in C#.net
Bookmarks. below is mainly to optimize PDF file with multiple String outputFilePath = Program.RootPath + "\\" 3_optimized.pdf"; // create optimizing options
how to bookmark a pdf document; creating bookmarks in pdf files
98
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
• The 
target
property of a native window event dispatched by the window: 
function onNativeWindowEvent(event)  
{  
var nativeWin = event.target;  
}
• The 
nativeWindow
property of an HTML page displayed in the window: 
var nativeWin = window.nativeWindow;
• The 
activeWindow
and 
openedWindows
properties of the NativeApplication object: 
var win = NativeApplication.nativeApplication.activeWindow;  
var firstWindow = NativeApplication.nativeApplication.openedWindows[0];
NativeApplication.nativeApplication.activeWindow
references the active window of an application (but 
returns 
null
if the active window is not a window of this AIR application). The 
NativeApplication.nativeApplication.openedWindows
array contains all of the windows in an AIR 
application that have not been closed.
Because the Flex mx:WindowedApplication, and mx:Window objects are display objects, you can easily reference the 
application window in an MXML file using the 
stage
property, as follows: 
<?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
Note: Until the WindowedApplication or Window component is added to the window stage by the Flex framework, the 
component's 
stage
property is 
null
. This behavior is consistent with that of the Flex Application component, but does 
mean that it is not possible to access the stage or the NativeWindow instance in listeners for events that occur earlier in 
the initialization cycle of the WindowedApplication and Window components, such as 
creationComplete
. It is safe to 
access the stage and NativeWindow instance when the 
applicationComplete
event is dispatched.
Activating, showing, and hiding windows
Adobe AIR 1.0 and later
To activate a window, call the NativeWindow 
activate()
method. Activating a window brings the window to the 
front, gives it keyboard and mouse focus, and, if necessary, makes it visible by restoring the window or setting the 
visible
property to 
true
. Activating a window does not change the ordering of other windows in the application. 
Calling the 
activate()
method causes the window to dispatch an 
activate
event.
To show a hidden window without activating it, set the 
visible
property to 
true
. This brings the window to the front, 
but will not assign the focus to the window.
C# Create PDF Library SDK to convert PDF from other file formats
Create multipage PDF from OpenOffice and CSV file. Create and save editable PDF with a blank page, bookmarks, links, signatures, etc.
create pdf with bookmarks from word; pdf create bookmarks
VB.NET Create PDF Library SDK to convert PDF from other file
Create multipage PDF from OpenOffice and CSV file. Create and save editable PDF with a blank page, bookmarks, links, signatures, etc.
add bookmark to pdf reader; export bookmarks from pdf to excel
99
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
To hide a window from view, set its 
visible
property to 
false
. Hiding a window suppresses the display of both the 
window, any related taskbar icons, and, on Mac OS X, the entry in the Windows menu.
When you change the visibility of a window, the visibility of any windows that window owns is also changed. For 
example, if you hide a window, all of its owned windows are also hidden.
Note: On Mac OS X, it is not possible to completely hide a minimized window that has an icon in the window portion of 
the dock. If the 
visible
property is set to 
false
on a minimized window, the dock icon for the window is still displayed. 
If the user clicks the icon, the window is restored to a visible state and displayed.
Changing the window display order
Adobe AIR 1.0 and later
AIR provides several methods for directly changing the display order of windows. You can move a window to the front 
of the display order or to the back; you can move a window above another window or behind it. At the same time, the 
user can reorder windows by activating them.
You can keep a window in front of other windows by setting its 
alwaysInFront
property to 
true
. If more than one 
window has this setting, then the display order of these windows is sorted among each other, but they are always sorted 
above windows which have 
alwaysInFront
set to false. 
Windows in the top-most group are also displayed above windows in other applications, even when the AIR 
application is not active. Because this behavior can be disruptive to a user, setting 
alwaysInFront
to 
true
should only 
be done when necessary and appropriate. Examples of justified uses include:
• Temporary pop-up windows for controls such as tool tips, pop-up lists, custom menus, or combo boxes. Because 
these windows should close when they lose focus, the annoyance of blocking a user from viewing another window 
can be avoided.
• Extremely urgent error messages and alerts. When an irrevocable change may occur if the user does not respond in 
a timely manner, it may be justified to push an alert window to the forefront. However, most errors and alerts can 
be handled in the normal window display order. 
• Short-lived toast-style windows.
Note: AIR does not enforce proper use of the 
alwaysInFront
property. However, if your application disrupts a user’s 
workflow, it is likely to be consigned to that same user’s trash can.
If a window owns other windows, those windows are always ordered in front of it. If you call 
orderToFront()
or set 
alwaysInFront
to 
true
on a window that owns other windows, then the owned windows are re-ordered along with 
the owner window in front of other windows, but the owned windows still display in front of the owner. 
Calling the window ordering methods on owned windows works normally among windows owned by the same 
window, but can also change the ordering of the entire group of owned windows compared to windows outside that 
group. For example, if you call 
orderToFront()
on an owned window, then both that window, its owner, and any 
other windows owned by the same owner are moved to the front of the window display order. 
The NativeWindow class provides the following properties and methods for setting the display order of a window 
relative to other windows:
.NET PDF SDK - Description of All PDF Processing Control Feastures
page navigation, zooming & rotation; Outlines, bookmarks, & thumbnail Create PDF from Jpeg images; Create PDF from CSV. to Jpeg images; More about PDF Conversion
how to bookmark a pdf in reader; how to create bookmark in pdf automatically
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
by C#.NET PDF to HTML converter toolkit SDK, preserves all the original anchors, links, bookmarks and font style that are included in target PDF document file.
bookmark pdf reader; bookmarks in pdf reader
100
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
Note: If a window is hidden (
visible
is 
false
) or minimized, then calling the display order methods has no effect.
On the Linux operating system, different window managers enforce different rules regarding the window display 
order:
• On some window managers, utility windows are always displayed in front of normal windows.
• On some window managers, a full screen window with 
alwaysInFront
set to 
true
is always displayed in front of 
other windows that also have 
alwaysInFront
set to 
true
.
Closing a window 
Adobe AIR 1.0 and later
To close a window, use the 
NativeWindow.close()
method. 
Closing a window unloads the contents of the window, but if other objects have references to this content, the content 
objects will not be destroyed. The 
NativeWindow.close()
method executes asynchronously, the application that is 
contained in the window continues to run during the closing process. The close method dispatches a close event when 
the close operation is complete. The NativeWindow object is still technically valid, but accessing most properties and 
methods on a closed window generates an IllegalOperationError. You cannot reopen a closed window. Check the 
closed
property of a window to test whether a window has been closed. To simply hide a window from view, set the 
NativeWindow.visible
property to 
false
.
If the 
Nativeapplication.autoExit
property is 
true
, which is the default, then the application exits when its last 
window closes. 
Any windows that have an owner are closed when the owner is closed. The owned windows do not dispatch a closing 
event and hence cannot prevent closure. A close event is dispatched.
Member
Description
alwaysInFront property
Specifies whether the window is displayed in the top-most group of windows. 
In almost all cases, false is the best setting. Changing the value from false to true brings the window 
to the front of all windows (but does not activate it). Changing the value from true to false orders the 
window behind windows remaining in the top-most group, but still in front of other windows. Setting the 
property to its current value for a window does not change the window display order.
The alwaysInFront setting has no affect on windows owned by another window.
orderToFront()
Brings the window to the front.
orderInFrontOf()
Brings the window directly in front of a particular window. 
orderToBack()
Sends the window behind other windows.
orderBehind()
Sends the window directly behind a particular window.
activate()
Brings the window to the front (along with making the window visible and assigning focus).
101
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
Allowing cancellation of window operations
Adobe AIR 1.0 and later
When a window uses system chrome, user interaction with the window can be canceled by listening for, and canceling 
the default behavior of the appropriate events. For example, when a user clicks the system chrome close button, the 
closing
event is dispatched. If any registered listener calls the 
preventDefault()
method of the event, then the 
window does not close. 
When a window does not use system chrome, notification events for intended changes are not automatically 
dispatched before the change is made. Hence, if you call the methods for closing a window, changing the window state, 
or set any of the window bounds properties, the change cannot be canceled. To notify components in your application 
before a window change is made, your application logic can dispatch the relevant notification event using the 
dispatchEvent()
method of the window. 
For example, the following logic implements a cancelable event handler for a window close button: 
function onCloseCommand(event){  
var closingEvent = new air.Event(air.Event.CLOSING,true,true);  
dispatchEvent(closingEvent);  
if(!closingEvent.isDefaultPrevented()){  
win.close();  
 
}
The 
dispatchEvent()
method returns 
false
if the event 
preventDefault()
method is called by a listener. 
However, it can also return 
false
for other reasons, so it is better to explicitly use the 
isDefaultPrevented()
method to test whether the change should be canceled. 
Maximizing, minimizing, and restoring a window 
Adobe AIR 1.0 and later
To maximize the window, use the NativeWindow 
maximize()
method. 
window.nativeWindow.maximize();
To minimize the window, use the NativeWindow 
minimize()
method. 
window.nativeWindow.minimize();
To restore the window (that is, return it to the size that it was before it was either minimized or maximized), use the 
NativeWindow 
restore()
method. 
window.nativeWindow.restore();
A window that has an owner is minimized and restored when the owning window is minimized or restored. No events 
are dispatched by the owned window when it is minimized because its owner is minimized.
Note: The behavior that results from maximizing an AIR window is different from the Mac OS X standard behavior. 
Rather than toggling between an application-defined “standard” size and the last size set by the user, AIR windows toggle 
between the size last set by the application or user and the full usable area of the screen.
102
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
On the Linux operating system, different window managers enforce different rules regarding setting the window 
display state:
• On some window managers, utility windows cannot be maximized.
• If a maximum size is set for the window, then some windows do not allow a window to be maximized. Some other 
window managers set the display state to maximized, but do not resize the window. In either of these cases, no 
display state change event is dispatched.
• Some window managers do not honor the window 
maximizable
or 
minimizable
settings.
Note: On Linux, window properties are changed asynchronously. If you change the display state in one line of your 
program, and read the value in the next, the value read will still reflect the old setting. On all platforms, the 
NativeWindow object dispatches the 
displayStateChange
event when the display state changes. If you need to take 
some action based on the new state of the window, always do so in a 
displayStateChange
event handler. See “Listening 
for window events” on page 105.
Example: Minimizing, maximizing, restoring and closing a window 
Adobe AIR 1.0 and later
The following short HTML page demonstrates the NativeWindow 
maximize()
minimize()
restore()
, and 
close()
methods:
<html>  
<head>  
<title>Change Window Display State</title>  
<script src="AIRAliases.js"/>  
<script type="text/javascript">  
function onMaximize(){  
window.nativeWindow.maximize();  
}  
function onMinimize(){  
window.nativeWindow.minimize();  
}  
function onRestore(){  
window.nativeWindow.restore();  
}  
function onClose(){  
window.nativeWindow.close();  
}  
</script>  
</head>  
<body>  
<h1>AIR window display state commands</h1>  
<button onClick="onMaximize()">Maximize</button>  
<button onClick="onMinimize()">Minimize</button>  
<button onClick="onRestore()">Restore</button>  
<button onClick="onClose()">Close</button>  
</body>  
</html>
103
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
Resizing and moving a window
Adobe AIR 1.0 and later
When a window uses system chrome, the chrome provides drag controls for resizing the window and moving around 
the desktop. If a window does not use system chrome you must add your own controls to allow the user to resize and 
move the window.
Note: To resize or move a window, you must first obtain a reference to the NativeWindow instance. For information 
about how to obtain a window reference, see “Getting a NativeWindow instance” on pag e97. 
Resizing a window
To allow a user to resize a window interactively, use the NativeWindow 
startResize()
method. When this method 
is called from a 
mouseDown
event, the resizing operation is driven by the mouse and completes when the operating 
system receives a 
mouseUp
event. When calling 
startResize()
, you pass in an argument that specifies the edge or 
corner from which to resize the window.
To set the window size programmatically, set the 
width
height
, or 
bounds
properties of the window to the desired 
dimensions. When you set the bounds, the window size and position can all be changed at the same time. However, 
the order that the changes occur is not guaranteed. Some Linux window managers do not allow windows to extend 
outside the bounds of the desktop screen. In these cases, the final window size may be limited because of the order in 
which the properties are set, even though the net affect of the changes would otherwise have resulted in a legal window. 
For example, if you change both the height and y position of a window near the bottom of the screen, then the full 
height change might not occur when the height change is applied before the y position change.
Note: On Linux, window properties are changed asynchronously. If you resize a window in one line of your program, and 
read the dimensions in the next, they will still reflect the old settings. On all platforms, the NativeWindow object 
dispatches the 
resize
event when the window resizes. If you need to take some action, such as laying out controls in the 
window, based on the new size or state of the window, always do so in a 
resize
event handler. See “Listening for window 
events” on page 105.
Moving a window
To move a window without resizing it, use the NativeWindow 
startMove()
method. Like the 
startResize()
method, when the 
startMove()
method is called from a 
mouseDown
event, the move process is mouse-driven and 
completes when the operating system receives a 
mouseUp
event. 
For more information about the 
startResize()
and 
startMove()
methods, see the Adobe AIR API Reference for 
HTML Developers.
To move a window programmatically, set the 
x
y
, or 
bounds
properties of the window to the desired position. When 
you set the bounds, the window size and position can both be changed at the same time.
Note: On Linux, window properties are changed asynchronously. If you move a window in one line of your program, and 
read the position in the next, the value read will still reflect the old setting. On all platforms, the NativeWindow object 
dispatches the 
move
event when the position changes. If you need to take some action based on the new position of the 
window, always do so in a 
move
event handler. See “Listening for window events” on pag e105.
Example: Resizing and moving windows 
Adobe AIR 1.0 and later
The following example shows how to initiate resizing and moving operations on a window: 
104
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
<html xmlns="http://www.w3.org/1999/xhtml">  
<head>  
<script src="AIRAliases.js"/>  
<script type="text/javascript">  
function onResize(type){  
nativeWindow.startResize(type);  
}  
function onNativeMove(){  
nativeWindow.startMove();  
}  
</script>  
<style type="text/css" media="screen">  
.drag {  
width:200px;  
height:200px;  
margin:0px auto;  
padding:15px;  
border:1px dashed #333;  
background-color:#eee;  
 
.resize {  
background-color:#FF0000;  
padding:10px;  
 
.left {  
float:left;  
}
.right {  
float:right;  
}
</style>  
<title>Move and Resize the Window</title>  
</head>  
<body>  
<div class="resize left" onmousedown="onResize(air.NativeWindowResize.TOP_LEFT)">Drag to 
resize</div>  
<div class="resize right" onmousedown="onResize(air.NativeWindowResize.TOP_RIGHT)">Drag to 
resize</div>  
<div class="drag" onmousedown="onNativeMove()">Drag to move</div>  
<div class="resize left" onmousedown="onResize(air.NativeWindowResize.BOTTOM_LEFT)">Drag to 
resize</div>  
<div class="resize right" onmousedown="onResize(air.NativeWindowResize.BOTTOM_RIGHT)">Drag to 
resize</div>  
</body>  
</html>
Documents you may be interested
Documents you may be interested