working with pdf in c# : How to create bookmark in pdf with software SDK project winforms wpf web page UWP air_htmldevguide8-part487

75
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
AIR security
Last updated 9/28/2011
Setting up a bridge between parent and child frames in different sandboxes or domains
Adobe AIR 1.0 and later
AIR adds the 
childSandboxBridge
and 
parentSandboxBridge
properties to the 
window
object of any child frame. 
These properties let you define bridges to serve as interfaces between a parent and a child frame. Each bridge goes in 
one direction:
childSandboxBridge
— The 
childSandboxBridge
property allows the child frame to expose an interface to content 
in the parent frame. To expose an interface, you set the 
childSandbox
property to a function or object in the child 
frame. You can then access the object or function from content in the parent frame. The following example shows how 
a script running in a child frame can expose an object containing a function and a property to its parent:
var interface = {};  
interface.calculatePrice = function(){  
return .45 + 1.20;  
}  
interface.storeID = "abc"  
window.childSandboxBridge = interface;
If this child content is in an iframe assigned an 
id
of 
"child"
, you can access the interface from parent content by 
reading the 
childSandboxBridge
property of the frame:
var childInterface = document.getElementById("child").childSandboxBridge;  
air.trace(childInterface.calculatePrice()); //traces "1.65"  
air.trace(childInterface.storeID)); //traces "abc"
parentSandboxBridge 
— The 
parentSandboxBridge
property allows the parent frame to expose an interface to 
content in the child frame. To expose an interface, you set the 
parentSandbox
property of the child frame to a function 
or object in the parent frame. You can then access the object or function from content in the child frame. The following 
example shows how a script running in the parent frame can expose an object containing a save function to a child:
var interface = {};  
interface.save = function(text){  
var saveFile = air.File("app-storage:/save.txt");  
//write text to file  
}  
document.getElementById("child").parentSandboxBridge = interface;
Using this interface, content in the child frame could save text to a file named save.txt. However, it would not have any 
other access to the file system. In general, application content should expose the narrowest possible interface to other 
sandboxes. The child content could call the save function as follows:
var textToSave = "A string.";  
window.parentSandboxBridge.save(textToSave);
If child content attempts to set a property of the 
parentSandboxBridge
object, the runtime throws a SecurityError 
exception. If parent content attempts to set a property of the 
childSandboxBridge
object, the runtime throws a 
SecurityError exception.
How to create bookmark in pdf with - 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
add bookmarks to pdf preview; excel pdf bookmarks
How to create bookmark in pdf with - 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
bookmark pdf in preview; how to create bookmark in pdf with
76
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
AIR security
Last updated 9/28/2011
Code restrictions for content in different sandboxes
Adobe AIR 1.0 and later
As discussed in the introduction to this topic, “HTML security in Adobe AIR” on page  73, the runtime enforces rules 
and provides mechanisms for overcoming possible security vulnerabilities in HTML and JavaScript. This topic lists 
those restrictions. If code attempts to call these restricted APIs, the runtime throws an error with the message “Adobe 
AIR runtime security violation for JavaScript code in the application security sandbox.” 
For more information, see “Avoiding security-related JavaScript errors” on page  22.
Restrictions on using the JavaScript eval() function and similar techniques
Adobe AIR 1.0 and later
For HTML content in the application security sandbox, there are limitations on using APIs that can dynamically 
transform strings into executable code after the code is loaded (after the 
onload
event of the 
body
element has been 
dispatched and the 
onload
handler function has finished executing). This is to prevent the application from 
inadvertently injecting (and executing) code from non-application sources (such as potentially insecure network 
domains). 
For example, if your application uses string data from a remote source to write to the innerHTML property of a DOM 
element, the string could include executable (JavaScript) code that could perform insecure operations. However, while 
the content is loading, there is no risk of inserting remote strings into the DOM.
One restriction is in the use of the JavaScript 
eval()
function. Once code in the application sandbox is loaded and 
after processing of the onload event handler, you can only use the 
eval()
function in limited ways. The following rules 
apply to the use of the 
eval()
function after code is loaded from the application security sandbox:
• Expressions involving literals are allowed. For example: 
eval("null");  
eval("3 + .14");  
eval("'foo'");
• Object literals are allowed, as in the following:
{ prop1: val1, prop2: val2 }
• Object literal setter/getters are prohibited, as in the following:
{ get prop1() { ... }, set prop1(v) { ... } }
• Array literals are allowed, as in the following:
[ val1, val2, val3 ]
• Expressions involving property reads are prohibited, as in the following:
a.b.c
• Function invocation is prohibited.
• Function definitions are prohibited.
• Setting any property is prohibited.
• Function literals are prohibited.
However, while the code is loading, before the 
onload
event, and during execution the 
onload
event handler function, 
these restrictions do not apply to content in the application security sandbox.
For example, after code is loaded, the following code results in the runtime throwing an exception: 
VB.NET Create PDF from Excel Library to convert xlsx, xls to PDF
C#, C#.NET PDF Reading, C#.NET Annotate PDF in WPF, C#.NET PDF Create, C#.NET NET rotate PDF pages, C#.NET search text in PDF, C#.NET edit PDF bookmark, C#.NET
bookmarks pdf documents; how to bookmark a pdf file in acrobat
VB.NET Create PDF from Word Library to convert docx, doc to PDF in
Easy to create searchable and scanned PDF files from Word. Ability to get word count of PDF pages. Change Word hyperlink to PDF hyperlink and bookmark.
export bookmarks from pdf to excel; bookmarks in pdf
77
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
AIR security
Last updated 9/28/2011
eval("alert(44)");  
eval("myFunction(44)");  
eval("NativeApplication.applicationID");
Dynamically generated code, such as that which is made when calling the 
eval()
function, would pose a security risk 
if allowed within the application sandbox. For example, an application may inadvertently execute a string loaded from 
a network domain, and that string may contain malicious code. For example, this could be code to delete or alter files 
on the user’s computer. Or it could be code that reports back the contents of a local file to an untrusted network 
domain.
Ways to generate dynamic code are the following:
• Calling the 
eval()
function.
• Using 
innerHTML
properties or DOM functions to insert script tags that load a script outside of the application 
directory.
• Using 
innerHTML
properties or DOM functions to insert script tags that have inline code (rather than loading a 
script via the 
src
attribute).
• Setting the 
src
attribute for a 
script
tags to load a JavaScript file that is outside of the application directory.
• Using the 
javascript
URL scheme (as in 
href="javascript:alert('Test')"
).
• Using the 
setInterval()
or 
setTimout()
function where the first parameter (defining the function to run 
asynchronously) is a string (to be evaluated) rather than a function name (as in 
setTimeout('x = 4', 1000)
).
• Calling 
document.write()
or 
document.writeln()
.
Code in the application security sandbox can only use these methods while content is loading.
These restrictions do not prevent using 
eval()
with JSON object literals. This lets your application content work with 
the JSON JavaScript library. However, you are restricted from using overloaded JSON code (with event handlers).
For other Ajax frameworks and JavaScript code libraries, check to see if the code in the framework or library works 
within these restrictions on dynamically generated code. If they do not, include any content that uses the framework 
or library in a non-application security sandbox. For details, see Restrictions for JavaScript inside AIR and “Scripting 
between application and non-application content” on page 81. Adobe maintains a list of Ajax frameworks known to 
support the application security sandbox, at http://www.adobe.com/products/air/develop/ajax/features/.
Unlike content in the application security sandbox, JavaScript content in a non-application security sandbox can call 
the 
eval()
function to execute dynamically generated code at any time. 
Restrictions on access to AIR APIs (for non-application sandboxes)
Adobe AIR 1.0 and later
JavaScript code in a non-application sandbox does not have access to the 
window.runtime
object, and as such this 
code cannot execute AIR APIs. If content in a non-application security sandbox calls the following code, the 
application throws a TypeError exception:
try {  
window.runtime.flash.system.NativeApplication.nativeApplication.exit();  
  
catch (e)   
{  
alert(e);  
}
C# Create PDF from Word Library to convert docx, doc to PDF in C#.
Easy to create searchable and scanned PDF files from Word. Able to get word count in PDF pages. Change Word hyperlink to PDF hyperlink and bookmark.
create bookmarks pdf file; creating bookmarks in pdf documents
VB.NET PDF Convert to Tiff SDK: Convert PDF to tiff images in vb.
Qualified Tiff files are exported with high resolution in VB.NET. Create multipage Tiff image files from PDF in VB.NET project. Support
pdf bookmark; add bookmark pdf
78
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
AIR security
Last updated 9/28/2011
The exception type is TypeError (undefined value), because content in the non-application sandbox does not 
recognize the 
window.runtime
object, so it is seen as an undefined value. 
You can expose runtime functionality to content in a non-application sandbox by using a script bridge. For details, see 
and “Scripting between application and non-application content” on page  81.
Restrictions on using XMLHttpRequest calls
Adobe AIR 1.0 and later
HTML content in the application security sandbox cannot use synchronous XMLHttpRequest methods to load data 
from outside of the application sandbox while the HTML content is loading and during 
onLoad
event.
By default, HTML content in non-application security sandboxes are not allowed to use the JavaScript 
XMLHttpRequest object to load data from domains other than the domain calling the request. A 
frame
or 
iframe
tag 
can include an 
allowcrosscomainxhr
attribute. Setting this attribute to any non-null value allows the content in the 
frame or iframe to use the JavaScript XMLHttpRequest object to load data from domains other than the domain of the 
code calling the request:
<iframe id="UI"  
src="http://example.com/ui.html"  
sandboxRoot="http://example.com/"  
allowcrossDomainxhr="true"  
documentRoot="app:/">  
</iframe>
For more information, see “Scripting between content in different domains” on page  79.
Restrictions on loading CSS, frame, iframe, and img elements (for content in non-application 
sandboxes)
Adobe AIR 1.0 and later
HTML content in remote (network) security sandboxes can only load CSS, 
frame
iframe
, and 
img
content from 
remote sandboxes (from network URLs).
HTML content in local-with-filesystem, local-with-networking, or local-trusted sandboxes can only load CSS, frame, 
iframe, and 
img
content from local sandboxes (not from application or remote sandboxes).
Restrictions on calling the JavaScript window.open() method
Adobe AIR 1.0 and later
If a window that is created via a call to the JavaScript 
window.open()
method displays content from a non-application 
security sandbox, the window’s title begins with the title of the main (launching) window, followed by a colon 
character. You cannot use code to move that portion of the title of the window off screen.
Content in non-application security sandboxes can only successfully call the JavaScript 
window.open()
method in 
response to an event triggered by a user mouse or keyboard interaction. This prevents non-application content from 
creating windows that might be used deceptively (for example, for phishing attacks). Also, the event handler for the 
mouse or keyboard event cannot set the 
window.open()
method to execute after a delay (for example by calling the 
setTimeout()
function).
Content in remote (network) sandboxes can only use the 
window.open()
method to open content in remote network 
sandboxes. It cannot use the 
window.open()
method to open content from the application or local sandboxes.
C# Create PDF from Tiff Library to convert tif images to PDF in C#
Create PDF from Tiff. |. Home ›› XDoc.PDF ›› C# PDF: Create PDF from Tiff. Create PDF from Tiff in both .NET WinForms and ASP.NET application.
add bookmarks to pdf online; bookmarks in pdf from word
C# Create PDF from Excel Library to convert xlsx, xls to PDF in C#
C#.NET PDF SDK- Create PDF from Word in Visual C#. Online C#.NET Tutorial for Create PDF from Microsoft Office Excel Spreadsheet Using .NET XDoc.PDF Library.
convert word to pdf with bookmarks; how to add bookmark in pdf
79
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
AIR security
Last updated 9/28/2011
Content in the local-with-filesystem, local-with-networking, or local-trusted sandboxes (see Security sandboxes) can 
only use the 
window.open()
method to open content in local sandboxes. It cannot use 
window.open()
to open 
content from the application or remote sandboxes.
Errors when calling restricted code 
Adobe AIR 1.0 and later
If you call code that is restricted from use in a sandbox due to these security restrictions, the runtime dispatches a 
JavaScript error: "Adobe AIR runtime security violation for JavaScript code in the application security sandbox."
For more information, see “Avoiding security-related JavaScript errors” on page  22.
Sandbox protection when loading HTML content from a string
Adobe AIR 1.0 and later
The 
loadString()
method of the HTMLLoader class lets you create HTML content at run time. However, data that 
you use as the HTML content can be corrupted if the data is loaded from an insecure Internet source. For this reason, 
by default, HTML created using the 
loadString()
method is not placed in the application sandbox and it has no 
access to AIR APIs. However, you can set the 
placeLoadStringContentInApplicationSandbox
property of an 
HTMLLoader object to true to place HTML created using the 
loadString()
method into the application sandbox. 
For more information, see Loading HTML content from a string.
Scripting between content in different domains
Adobe AIR 1.0 and later
AIR applications are granted special privileges when they are installed. It is crucial that the same privileges not be 
leaked to other content, including remote files and local files that are not part of the application.
About the AIR sandbox bridge
Adobe AIR 1.0 and later
Normally, content from other domains cannot call scripts in other domains.
There are still cases where the main AIR application requires content from a remote domain to have controlled access 
to scripts in the main AIR application, or vice versa. To accomplish this, the runtime provides a sandbox bridge 
mechanism, which serves as a gateway between the two sandboxes. A sandbox bridge can provide explicit interaction 
between remote and application security sandboxes.
The sandbox bridge exposes two objects that both loaded and loading scripts can access:
• The 
parentSandboxBridge
object lets loading content expose properties and functions to scripts in the loaded 
content.
• The 
childSandboxBridge
object lets loaded content expose properties and function to scripts in the loading 
content.
C# Create PDF from PowerPoint Library to convert pptx, ppt to PDF
C#.NET PDF SDK- Create PDF from PowerPoint in C#. How to Use C#.NET PDF Control to Create PDF from Microsoft PowerPoint Presentation in .NET Project.
delete bookmarks pdf; adding bookmarks to pdf reader
VB.NET PDF - Create PDF Online with VB.NET HTML5 PDF Viewer
C#, C#.NET PDF Reading, C#.NET Annotate PDF in WPF, C#.NET PDF Create, C#.NET NET rotate PDF pages, C#.NET search text in PDF, C#.NET edit PDF bookmark, C#.NET
bookmark page in pdf; editing bookmarks in pdf
80
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
AIR security
Last updated 9/28/2011
Objects exposed via the sandbox bridge are passed by value, not by reference. All data is serialized. This means that the 
objects exposed by one side of the bridge cannot be set by the other side, and that objects exposed are all untyped. Also, 
you can only expose simple objects and functions; you cannot expose complex objects. 
If child content attempts to set a property of the parentSandboxBridge object, the runtime throws a SecurityError 
exception. Similarly, if parent content attempts to set a property of the childSandboxBridge object, the runtime throws 
a SecurityError exception.
Sandbox bridge example (HTML)
Adobe AIR 1.0 and later
In HTML content, the 
parentSandboxBridge
and 
childSandboxBridge
properties are added to the JavaScript 
window object of a child document. For an example of how to set up bridge functions in HTML content, see “Setting 
up a sandbox bridge interface” on page 36.
Limiting API exposure
Adobe AIR 1.0 and later
When exposing sandbox bridges, it's important to expose high-level APIs that limit the degree to which they can be 
abused. Keep in mind that the content calling your bridge implementation may be compromised (for example, via a 
code injection). So, for example, exposing a 
readFile(path)
method (that reads the contents of an arbitrary file) via 
a bridge is vulnerable to abuse. It would be better to expose a 
readApplicationSetting()
API that doesn't take a 
path and reads a specific file. The more semantic approach limits the damage that an application can do once part of 
it is compromised.
More Help topics 
Cross-scripting content in different security sandboxes” on page  34
Writing to disk
Adobe AIR 1.0 and later
Applications running in a web browser have only limited interaction with the user's local file system. Web browsers 
implement security policies that ensure that a user's computer cannot be compromised as a result of loading web 
content. For example, SWF files running through Flash Player in a browser cannot directly interact with files already 
on a user's computer. Shared objects and cookies can be written to a user's computer for the purpose of maintaining 
user preferences and other data, but this is the limit of file system interaction. Because AIR applications are natively 
installed, they have a different security contract, one which includes the capability to read and write across the local 
file system.
This freedom comes with high responsibility for developers. Accidental application insecurities jeopardize not only 
the functionality of the application, but also the integrity of the user's computer. For this reason, developers should 
read “Best security practices for developers” on page  82.
AIR developers can access and write files to the local file system using several URL scheme conventions:
81
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
AIR security
Last updated 9/28/2011
Note: AIR applications cannot modify content using the app: URL scheme. Also, the application directory may be read 
only because of administrator settings.
Unless there are administrator restrictions to the user's computer, AIR applications are privileged to write to any 
location on the user's hard drive. Developers are advised to use the 
app-storage:/
path for local storage related to 
their application. Files written to 
app-storage:/
from an application are put in a standard location:
• On Mac OS: the storage directory of an application is 
<appData>/<appId>/Local Store/
where 
<appData>
is 
the user's preferences folder. This is typically 
/Users/<user>/Library/Preferences
• On Windows: the storage directory of an application is 
<appData>\<appId>\Local Store\
where 
<appData>
is 
the user's CSIDL_APPDATA Special Folder. This is typically 
C:\Documents and 
Settings\<userName>\Application Data
• On Linux: 
<appData>/<appID>/Local Store/
where 
<appData>
is 
/home/<user>/.appdata
If an application is designed to interact with existing files in the user's file system, be sure to read “Best security 
practices for developers” on page 82.
Working securely with untrusted content
Adobe AIR 1.0 and later
Content not assigned to the application sandbox can provide additional scripting functionality to your application, but 
only if it meets the security criteria of the runtime. This topic explains the AIR security contract with non-application 
content.
Scripting between application and non-application content
Adobe AIR 1.0 and later
AIR applications that script between application and non-application content have more complex security 
arrangements. Files that are not in the application sandbox are only allowed to access the properties and methods of 
files in the application sandbox through the use of a sandbox bridge. A sandbox bridge acts as a gateway between 
application content and non-application content, providing explicit interaction between the two files. When used 
correctly, sandbox bridges provide an extra layer of security, restricting non-application content from accessing object 
references that are part of application content.
The benefit of sandbox bridges is best illustrated through example. Suppose an AIR music store application wants to 
provide an API to advertisers who want to create their own SWF files, with which the store application can then 
communicate. The store wants to provide advertisers with methods to look up artists and CDs from the store, but also 
wants to isolate some methods and properties from the third-party SWF file for security reasons.
URL scheme
Description
app:/
An alias to the application directory. Files accessed from this path are assigned the application sandbox and have 
the full privileges granted by the runtime.
app-storage:/
An alias to the local storage directory, standardized by the runtime. Files accessed from this path are assigned a 
non-application sandbox.
file:///
An alias that represents the root of the user's hard disk. A file accessed from this path is assigned an application 
sandbox if the file exists in the application directory, and a non-application sandbox otherwise.
82
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
AIR security
Last updated 9/28/2011
A sandbox bridge can provide this functionality. By default, content loaded externally into an AIR application at 
runtime does not have access to any methods or properties in the main application. With a custom sandbox bridge 
implementation, a developer can provide services to the remote content without exposing these methods or properties. 
Consider the sandbox bridge as a pathway between trusted and untrusted content, providing communication between 
loader and loadee content without exposing object references.
For more information on how to securely use sandbox bridges, see “Scripting between content in different domains” 
on page  79.
Best security practices for developers
Adobe AIR 1.0 and later
Although AIR applications are built using web technologies, it is important for developers to note that they are not 
working within the browser security sandbox. This means that it is possible to build AIR applications that can do harm 
to the local system, either intentionally or unintentionally. AIR attempts to minimize this risk, but there are still ways 
where vulnerabilities can be introduced. This topic covers important potential insecurities.
Risk from importing files into the application security sandbox
Adobe AIR 1.0 and later
Files that exist in the application directory are assigned to the application sandbox and have the full privileges of the 
runtime. Applications that write to the local file system are advised to write to 
app-storage:/
. This directory exists 
separately from the application files on the user's computer, hence the files are not assigned to the application sandbox 
and present a reduced security risk. Developers are advised to consider the following:
• Include a file in an AIR file (in the installed application) only if it is necessary.
• Include a scripting file in an AIR file (in the installed application) only if its behavior is fully understood and trusted.
• Do not write to or modify content in the application directory. The runtime prevents applications from writing or 
modifying files and directories using the 
app:/
URL scheme by throwing a SecurityError exception.
• Do not use data from a network source as parameters to methods of the AIR API that may lead to code execution. 
This includes use of the 
Loader.loadBytes()
method and the JavaScript 
eval()
function.
Risk from using an external source to determine paths
Adobe AIR 1.0 and later
An AIR application can be compromised when using external data or content. For this reason, take special care when 
using data from the network or file system. The onus of trust is ultimately on the developer and the network 
connections they make, but loading foreign data is inherently risky, and should not be used for input into sensitive 
operations. Developers are advised against the following:
• Using data from a network source to determine a file name
• Using data from a network source to construct a URL that the application uses to send private information
83
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
AIR security
Last updated 9/28/2011
Risk from using, storing, or transmitting insecure credentials
Adobe AIR 1.0 and later
Storing user credentials on the user's local file system inherently introduces the risk that these credentials may be 
compromised. Developers are advised to consider the following:
• If credentials must be stored locally, encrypt the credentials when writing to the local file system. The runtime 
provides an encrypted storage unique to each installed application, via the EncryptedLocalStore class. For details, 
see “Encrypted local storage” on page  256.
• Do not transmit unencrypted user credentials to a network source unless that source is trusted and the transmission 
uses the HTTPS: or Transport Layer Security (TLS) protocols.
• Never specify a default password in credential creation — let users create their own. Users who leave the default 
unchanged expose their credentials to an attacker who already knows the default password.
Risk from a downgrade attack
Adobe AIR 1.0 and later
During application install, the runtime checks to ensure that a version of the application is not currently installed. If 
an application is already installed, the runtime compares the version string against the version that is being installed. 
If this string is different, the user can choose to upgrade their installation. The runtime does not guarantee that the 
newly installed version is newer than the older version, only that it is different. An attacker can distribute an older 
version to the user to circumvent a security weakness. For this reason, the developer is advised to make version checks 
when the application is run. It is a good idea to have applications check the network for required updates. That way, 
even if an attacker gets the user to run an old version, that old version will recognize that it needs to be updated. Also, 
using a clear versioning scheme for your application makes it more difficult to trick users into installing a downgraded 
version.
Code signing
Adobe AIR 1.0 and later
All AIR installer files are required to be code signed. Code signing is a cryptographic process of confirming that the 
specified origin of software is accurate. AIR applications can be signed using either by a certificate issued by an external 
certificate authority (CA) or by a self-signed certificate you create yourself. A commercial certificate from a well-
known CA is strongly recommended and provides assurance to your users that they are installing your application, 
not a forgery. However, self-signed certificates can be created using 
adt
from the SDK or using either Flash, Flash 
Builder, or another application that uses 
adt
for certificate generation. Self-signed certificates do not provide any 
assurance that the application being installed is genuine and should only be used for testing an application prior to 
public release.
84
Last updated 9/28/2011
Chapter 7: Working with AIR native 
windows
Adobe AIR 1.0 and later
You use the classes provided by the Adobe® AIR® native window API to create and manage desktop windows. 
Basics of native windows in AIR
Adobe AIR 1.0 and later
For quick explanations and code examples of working with native windows in AIR, see the following quick start articles 
on the Adobe Developer Connection:
• Customizing the look and feel of a window
AIR provides an easy-to-use, cross-platform window API for creating native operating system windows using Flash®, 
Flex™, and HTML programming techniques. 
With AIR, you have a wide latitude in developing the appearance of your application. The windows you create can look 
like a standard desktop application, matching Apple style when run on the Mac, conforming to Microsoft conventions 
when run on Windows, and harmonizing with the window manager on Linux—all without including a line of 
platform-specific code. Or you can use the skinnable, extensible chrome provided by the Flex framework to establish 
your own style no matter where your application is run. You can even draw your own window chrome with vector and 
bitmap artwork with full support for transparency and alpha blending against the desktop. Tired of rectangular 
windows? Draw a round one. 
Windows in AIR
Adobe AIR 1.0 and later
AIR supports three distinct APIs for working with windows: 
• The ActionScript-oriented NativeWindow class provides the lowest level window API. Use NativeWindows in 
ActionScript and Flash Professional-authored applications. Consider extending the NativeWindow class to 
specialize the windows used in your application.
• In the HTML environment, you can use the JavaScript Window class, just as you would in a browser-based web 
application. Calls to JavaScript Window methods are forwarded to the underlying native window object. 
• The Flex framework mx:WindowedApplication and mx:Window classes provide a Flex “wrapper” for the 
NativeWindow class. The WindowedApplication component replaces the Application component when you create 
an AIR application with Flex and must always be used as the initial window in your Flex application.
ActionScript windows
When you create windows with the NativeWindow class, use the Flash Player stage and display list directly. To add a 
visual object to a NativeWindow, add the object to the display list of the window stage or to another display object 
container on the stage. 
Documents you may be interested
Documents you may be interested