working with pdf in c# : Copy pdf bookmarks application Library utility azure asp.net .net visual studio air_htmldevguide9-part488

85
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
HTML windows
When you create HTML windows, you use HTML, CSS, and JavaScript to display content. To add a visual object to an 
HTML window, you add that content to the HTML DOM. HTML windows are a special category of NativeWindow. 
The AIR host defines a 
nativeWindow
property in HTML windows that provides access to the underlying 
NativeWindow instance. You can use this property to access the NativeWindow properties, methods, and events 
described here. 
Note: The JavaScript Window object also has methods for scripting the containing window, such as 
moveTo()
and 
close()
. Where overlapping methods are available, you can use whichever method that is convenient.
Flex Framework windows
The Flex Framework defines its own window components. These components, mx:WindowedApplication and 
mx:Window, cannot be used outside the framework and thus cannot be used in HTML-based AIR applications.
The initial application window
The first window of your application is automatically created for you by AIR. AIR sets the properties and content of 
the window using the parameters specified in the 
initialWindow
element of the application descriptor file. 
If the root content is a SWF file, AIR creates a NativeWindow instance, loads the SWF file, and adds it to the window 
stage. If the root content is an HTML file, AIR creates an HTML window and loads the HTML. 
Native window classes
Adobe AIR 1.0 and later
The native window API contains the following classes:
Package
Classes
flash.display
NativeWindow
NativeWindowInitOptions
NativeWindowDisplayState
NativeWindowResize
NativeWindowSystemChrome
NativeWindowType
flash.events
NativeWindowBoundsEvent
NativeWindowDisplayStateEvent
Copy pdf bookmarks - 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
bookmarks pdf; add bookmarks pdf
Copy pdf bookmarks - 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
edit pdf bookmarks; add bookmark to pdf reader
86
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
Native window event flow
Adobe AIR 1.0 and later
Native windows dispatch events to notify interested components that an important change is about to occur or has 
already occurred. Many window-related events are dispatched in pairs. The first event warns that a change is about to 
happen. The second event announces that the change has been made. You can cancel a warning event, but not a 
notification event. The following sequence illustrates the flow of events that occurs when a user clicks the maximize 
button of a window: 
The NativeWindow object dispatches a 
displayStateChanging
event.
If no registered listeners cancel the event, the window maximizes.
The NativeWindow object dispatches a 
displayStateChange
event.
In addition, the NativeWindow object also dispatches events for related changes to the window size and position. 
The window does not dispatch warning events for these related changes. The related events are:
move
event is dispatched if the top, left corner of the window moved because of the maximize operation. 
resize
event is dispatched if the window size changed because of the maximize operation. 
A NativeWindow object dispatches a similar sequence of events when minimizing, restoring, closing, moving, and 
resizing a window.
The warning events are only dispatched when a change is initiated through window chrome or other operating-
system controlled mechanism. When you call a window method to change the window size, position, or display 
state, the window only dispatches an event to announce the change. You can dispatch a warning event, if desired, 
using the window 
dispatchEvent()
method, then check to see if your warning event has been canceled before 
proceeding with the change.
For detailed information about the window API classes, methods, properties, and events, see the Adobe AIR API 
Reference for HTML Developers
Properties controlling native window style and behavior
Flash Player 9 and later, Adobe AIR 1.0 and later
The following properties control the basic appearance and behavior of a window: 
type
systemChrome
transparent
owner
When you create a window, you set these properties on the NativeWindowInitOptions object passed to the window 
constructor. AIR reads the properties for the initial application window from the application descriptor. (Except the 
type
property, which cannot be set in the application descriptor and is always set to 
normal
.) The properties cannot 
be changed after window creation.
Some settings of these properties are mutually incompatible: 
systemChrome
cannot be set to 
standard
when either 
transparent
is 
true
or 
type
is 
lightweight
.
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
document file. Remove bookmarks, annotations, watermark, page labels and article threads from PDF while compressing. Also a preview
create bookmarks pdf; bookmark pdf in preview
VB.NET PDF File Split Library: Split, seperate PDF into multiple
Demo Code in VB.NET. The following VB.NET codes explain how to split a PDF file into multiple ones by PDF bookmarks or outlines.
how to create bookmark in pdf automatically; copy bookmarks from one pdf to another
87
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
Window types
Adobe AIR 1.0 and later
The AIR window types combine chrome and visibility attributes of the native operating system to create three 
functional types of window. Use the constants defined in the NativeWindowType class to reference the type names in 
code. AIR provides the following window types:
Window chrome
Adobe AIR 1.0 and later
Window chrome is the set of controls that allow users to manipulate a window in the desktop environment. Chrome 
elements include the title bar, title bar buttons, border, and resize grippers.
System chrome
You can set the 
systemChrome
property to 
standard
or 
none
. Choose 
standard
system chrome to give your window 
the set of standard controls created and styled by the user’s operating system. Choose 
none
to provide your own 
chrome for the window. Use the constants defined in the NativeWindowSystemChrome class to reference the system 
chrome settings in code.
System chrome is managed by the system. Your application has no direct access to the controls themselves, but can 
react to the events dispatched when the controls are used. When you use standard chrome for a window, the 
transparent
property must be set to 
false
and the 
type
property must be 
normal
or 
utility
Custom chrome
When you create a window with no system chrome, then you must add your own chrome controls to handle the 
interactions between a user and the window. You are also free to make transparent, non-rectangular windows. 
Window transparency
Adobe AIR 1.0 and later
To allow alpha blending of a window with the desktop or other windows, set the window 
transparent
property to 
true
. The 
transparent
property must be set before the window is created and cannot be changed. 
A transparent window has no default background. Any window area not containing an object drawn by the application 
is invisible. If a displayed object has an alpha setting of less than one, then anything below the object shows through, 
including other display objects in the same window, other windows, and the desktop. 
Transparent windows are useful when you want to create applications with borders that are irregular in shape or that 
“fade out” or appear to be invisible. However, rendering large alpha-blended areas can be slow, so the effect should be 
used conservatively. 
Type
Description
Normal
A typical window. Normal windows use the full-size style of chrome and appear on the Windows taskbar and 
the Mac OS X window menu.
Utility
A tool palette. Utility windows use a slimmer version of the system chrome and do not appear on the Windows 
taskbar and the Mac OS X window menu.
Lightweight
Lightweight windows have no chrome and do not appear on the Windows taskbar or the Mac OS X window 
menu. In addition, lightweight windows do not have the System (Alt+Space) menu on Windows. Lightweight 
windows are suitable for notification bubbles and controls such as combo-boxes that open a short-lived display 
area. When the lightweight type is used, systemChrome must be set to none.
C# PDF File Compress Library: Compress reduce PDF size in C#.net
NET framework. Remove bookmarks, annotations, watermark, page labels and article threads from PDF while compressing. C# class demo
creating bookmarks in pdf files; convert word pdf bookmarks
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.
how to bookmark a page in pdf document; export pdf bookmarks
88
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
Important: On Linux, mouse events do not pass through fully transparent pixels. You should avoid creating windows 
with large, fully transparent areas since you may invisibly block the user’s access to other windows or items on their 
desktop. On Mac OS X and Windows, mouse events do pass through fully transparent pixels.
Transparency cannot be used with windows that have system chrome. In addition, SWF and PDF content in HTML 
may not display in transparent windows. For more information, see “Considerations when loading SWF or PDF 
content in an HTML page” on page 48. 
The static 
NativeWindow.supportsTransparency
property reports whether window transparency is available. 
When transparency is not supported, the application is composited against a black background. In these cases, any 
transparent areas of the application display as an opaque black. It is a good practice to provide a fallback in case this 
property tests 
false
. For example, you could display a warning dialog to the user, or display a rectangular, non-
transparent user interface. 
Note that transparency is always supported by the Mac and Windows operating systems. Support on Linux operating 
systems requires a compositing window manager, but even when a compositing window manager is active, 
transparency can be unavailable because of user display options or hardware configuration.
Transparency in an HTML application window
Adobe AIR 1.0 and later
By default the background of HTML content displayed in HTML windows and HTMLLoader objects is opaque, event 
if the containing window is transparent. To turn off the default background displayed for HTML content, set the 
paintsDefaultBackground
property to 
false
. The following example creates an HTMLLoader and turns off the 
default background:
var htmlView:HTMLLoader = new HTMLLoader();  
htmlView.paintsDefaultBackground = false;
This example uses JavaScript to turn off the default background of an HTML window:
window.htmlLoader.paintsDefaultBackground = false;
If an element in the HTML document sets a background color, the background of that element is not transparent. 
Setting a partial transparency (or opacity) value is not supported. However, you can use a transparent PNG-format 
graphic as the background for a page or a page element to achieve a similar visual effect.
Window ownership
One window can own one or more other windows. These owned windows always appear in front of the master 
window, are minimized and restored along with the master window, and are closed when the master window is closed. 
Window ownership cannot be transfered to another window or removed. A window can only be owned by one master 
window, but can own any number of other windows.
You can use window ownership to make it easier to manage windows used for tool palettes and dialogs. For example, 
if you displayed a Save dialog in association with a document window, making the document window own the dialog 
will keep the dialog in front of the document window automatically.
• NativeWindow.owner
• Christian Cantrell: Owned windows in AIR 2.6
How to C#: Basic SDK Concept of XDoc.PDF for .NET
create, load, combine, and split PDF file(s), and add, create, insert, delete, re-order, copy, paste, cut This class describes bookmarks in a PDF document.
copy pdf bookmarks to another pdf; create bookmarks in pdf reader
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.
create pdf bookmarks; adding bookmarks to pdf document
89
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
A visual window catalog
Adobe AIR 1.0 and later
The following table illustrates the visual effects of different combinations of window property settings on the Mac OS 
X, Windows, and Linux operating systems:
Window settings
Mac OS X
Microsoft Windows
Linux*
Type: normal 
SystemChrome: standard 
Transparent: false
Type: utility 
SystemChrome: standard 
Transparent: false
VB.NET PDF: Basic SDK Concept of XDoc.PDF
create, load, combine, and split PDF file(s), and add, create, insert, delete, re-order, copy, paste, cut This class describes bookmarks in a PDF document.
excel print to pdf with bookmarks; export pdf bookmarks to text file
VB.NET PDF Page Replace Library: replace PDF pages in C#.net, ASP.
edit, C#.NET PDF pages extract, copy, paste, C# page with another PDF page from another PDF file text, images, interactive elements, such as links and bookmarks.
pdf create bookmarks; add bookmarks to pdf preview
90
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
*
Ubuntu with Compiz window manager
Note: The following system chrome elements are not supported by AIR: the Mac OS X Toolbar, the Mac OS X Proxy Icon, 
Windows title bar icons, and alternate system chrome.
Creating windows 
Adobe AIR 1.0 and later
AIR automatically creates the first window for an application, but you can create any additional windows you need. 
To create a native window, use the NativeWindow constructor method. 
To create an HTML window, either use the HTMLLoader 
createRootWindow()
method or, from an HTML 
document, call the JavaScript 
window.open()
method. The window created is a NativeWindow object whose display 
list contains an HTMLLoader object. The HTMLLoader object interprets and displays the HTML and JavaScript 
content for the window. You can access the properties of the underlying NativeWindow object from JavaScript using 
the 
window.nativeWindow
property. (This property is only accessible to code running in the AIR application 
sandbox.)
Type: Any 
SystemChrome: none 
Transparent: false
Type: Any 
SystemChrome: none 
Transparent: true
mxWindowedApplication or 
mx:Window
Type: Any 
SystemChrome: none 
Transparent: true
Window settings
Mac OS X
Microsoft Windows
Linux*
91
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
When you initialize a window—including the initial application window—you should consider creating the window 
in the invisible state, loading content or executing any graphical updates, and then making the window visible. This 
sequence prevents any jarring visual changes from being visible to your users. You can specify that the initial window 
of your application should be created in the invisible state by specifying the 
<visible>false</visible>
tag in the 
application descriptor (or by leaving the tag out altogether since 
false
is the default value). New NativeWindows are 
invisible by default. When you create an HTML window with the HTMLLoader 
createRootWindow()
method, you 
can set the 
visible
argument to 
false
. Call the NativeWindow 
activate()
method or set the 
visible
property to 
true
to make a window visible.
Specifying window initialization properties
Adobe AIR 1.0 and later
The initialization properties of a native window cannot be changed after the desktop window is created. These 
immutable properties and their default values include:
Set the properties for the initial window created by AIR in the application descriptor file. The main window of an AIR 
application is always type, normal. (Additional window properties can be specified in the descriptor file, such as 
visible
width
, and 
height
, but these properties can be changed at any time.)
Set the properties for other native and HTML windows created by your application using the 
NativeWindowInitOptions class. When you create a window, you must pass a NativeWindowInitOptions object 
specifying the window properties to either the NativeWindow constructor function or the HTMLLoader 
createRootWindow()
method. 
The following code creates a NativeWindowInitOptions object for a utility window:
var options = new air.NativeWindowInitOptions();  
options.systemChrome = air.NativeWindowSystemChrome.STANDARD;  
options.type = air.NativeWindowType.UTILITY  
options.transparent = false;  
options.resizable = false;  
options.maximizable = false;
Setting systemChrome to standard when transparent is 
true
or 
type
is 
lightweight
is not supported. 
Note: You cannot set the initialization properties for a window created with the JavaScript 
window.open()
function. 
You can, however, override how these windows are created by implementing your own HTMLHost class. See “Handling 
JavaScript calls to window.open()” on page 61 for more information.
Property 
Default value
systemChrome 
standard
type 
normal
transparent 
false
owner
null
maximizable 
true
minimizable 
true
resizable 
true
92
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
Creating the initial application window
Adobe AIR 1.0 and later
Use a standard HTML page for the initial window of your application. This page is loaded from the application install 
directory and placed in the application sandbox. The page serves as the initial entry point for your application.
When your application launches, AIR creates a window, sets up the HTML environment, and loads your HTML page. 
Before parsing any scripts or adding any elements to the HTML DOM, AIR adds the 
runtime
htmlLoader
, and 
nativeWindow
properties to the JavaScript Window object. You can use these properties to access the runtime classes 
from JavaScript. The 
nativeWindow
property gives you direct access to the properties and methods of the desktop 
window. 
The following example illustrates the basic skeleton for the main page of an AIR application built with HTML. The 
page waits for the JavaScript window 
load
event and then shows the native window.
<html>  
<head>  
<script language="javascript" type="text/javascript" src="AIRAliases.js"></script>  
<script language="javascript">  
window.onload=init;  
function init(){  
window.nativeWindow.activate();  
}  
</script>  
</head>  
<body></body>  
</html>
Note: The 
AIRAliases.js
file referenced in this example is a script file that defines convenient alias variables for the 
commonly used built-in AIR classes. The file is available inside the 
frameworks
directory of the AIR SDK.
Creating a NativeWindow
Adobe AIR 1.0 and later
To create a NativeWindow, pass a NativeWindowInitOptions object to the NativeWindow constructor: 
var options = new air.NativeWindowInitOptions();  
options.systemChrome = air.NativeWindowSystemChrome.STANDARD;  
options.transparent = false;  
var newWindow = new air.NativeWindow(options);
The window is not shown until you set the 
visible
property to 
true
or call the 
activate()
method. 
Once the window is created, you can initialize its properties and load content into the window using the stage property 
and Flash display list techniques. 
In almost all cases, you should set the stage 
scaleMode
property of a new native window to 
noScale
(use the 
StageScaleMode.NO_SCALE
constant). The Flash scale modes are designed for situations in which the application 
author does not know the aspect ratio of the application display space in advance. The scale modes let the author 
choose the least-bad compromise: clip the content, stretch or squash it, or pad it with empty space. Since you control 
the display space in AIR (the window frame), you can size the window to the content or the content to the window 
without compromise. 
The scale mode for HTML windows is set to 
noScale
automatically.
93
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
Note: To determine the maximum and minimum window sizes allowed on the current operating system, use the following 
static NativeWindow properties: 
var maxOSSize = air.NativeWindow.systemMaxSize;  
var minOSSize = air.NativeWindow.systemMinSize;
Creating an HTML window
Adobe AIR 1.0 and later
To create an HTML window, you can either call the JavaScript 
Window.open()
method, or you can call the AIR 
HTMLLoader class 
createRootWindow()
method.
HTML content in any security sandbox can use the standard JavaScript 
Window.open()
method. If the content is 
running outside the application sandbox, the 
open()
method can only be called in response to user interaction, such 
as a mouse click or keypress. When 
open()
is called, a window with system chrome is created to display the content 
at the specified URL. For example:
newWindow = window.open("xmpl.html", "logWindow", "height=600, width=400, top=10, left=10");
Note: You can extend the HTMLHost class in ActionScript to customize the window created with the JavaScript 
window.open()
function. See “About extending the HTMLHost class” on pag e52.
Content in the application security sandbox has access to the more powerful method of creating windows, 
HTMLLoader.createRootWindow()
. With this method, you can specify all the creation options for a new window. For 
example, the following JavaScript code creates a lightweight type window without system chrome that is 300x400 
pixels in size:
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"));
Note: If the content loaded by a new window is outside the application security sandbox, the window object does not have 
the AIR properties: 
runtime
nativeWindow
, or 
htmlLoader
If you create a transparent window, then SWF content embedded in the HTML loaded into that window is not always 
displayed. You must set the 
wmode
parameter of the object or embed tag used to reference the SWF file to either 
opaque
or 
transparent
. The default value of 
wmode
is 
window
, so, by default, SWF content is not displayed in transparent 
windows. PDF content cannot be displayed in transparent windows, no matter which 
wmode
value is set. (Prior to AIR 
1.5.2, SWF content could not be displayed in transparent windows, either.)
Windows created with the 
createRootWindow()
method remain independent from the opening window. The 
parent
and 
opener
properties of the JavaScript Window object are 
null
. The opening window can access the 
Window object of the new window using the HTMLLoader reference returned by the 
createRootWindow()
function. 
In the context of the previous example, the statement 
newHTMLLoader.window
would reference the JavaScript 
Window object of the created window.
Note: The 
createRootWindow()
function can be called from both JavaScript and ActionScript.
94
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with AIR native windows
Last updated 9/28/2011
Creating a mx:Window
Adobe AIR 1.0 and later
To create a mx:Window, you can create an MXML file using mx:Window as the root tag, or you can call the Window 
class constructor directly.
The following example creates and shows a mx:Window by calling the Window constructor:
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);
Adding content to a window 
Adobe AIR 1.0 and later
How you add content to an AIR window depends on the type of window. For example, MXML and HTML let you 
declaratively define the basic content of the window. You can embed resources in the application SWF files or you can 
load them from separate application files. Flex, Flash, and HTML content can all be created on the fly and added to a 
window dynamically.
When you load SWF content, or HTML content containing JavaScript, you must take the AIR security model into 
consideration. Any content in the application security sandbox, that is, content installed with your application and 
loadable with the app: URL scheme, has full privileges to access all the AIR APIs. Any content loaded from outside this 
sandbox cannot access the AIR APIs. JavaScript content outside the application sandbox is not able to use the 
runtime
nativeWindow
, or 
htmlLoader
properties of the JavaScript Window object.
To allow safe cross-scripting, you can use a sandbox bridge to provide a limited interface between application content 
and non-application content. In HTML content, you can also map pages of your application into a non-application 
sandbox to allow the code on that page to cross-script external content. See “AIR security” on page  69.
Loading HTML content into a NativeWindow
To load HTML content into a NativeWindow, you can either add an HTMLLoader object to the window stage and 
load the HTML content into the HTMLLoader, or create a window that already contains an HTMLLoader object by 
using the 
HTMLLoader.createRootWindow()
method. The following example displays HTML content within a 300 
by 500 pixel display area on the stage of a native window:
//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) );
Documents you may be interested
Documents you may be interested