working with pdf in c# : How to bookmark a pdf page software SDK project winforms wpf web page UWP air_htmldevguide7-part486

65
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with vectors
Last updated 9/28/2011
Base type 
The data type of the objects that a Vector instance is allowed to store.
Element 
A single item in a vector.
Index 
The numeric “address” used to identify a single element in an indexed array.
The standard convention that’s used in this documentation to represent the base type of a Vector instance, whatever 
that base type happens to be. The T convention is used to represent a class name, as shown in the Type parameter 
description. (“T” stands for “type,” as in “data type.”).
Type parameter 
The syntax that’s used with the Vector class name to specify the Vector’s base type (the data type of 
the objects that it stores). The syntax consists of a period (
.
), then the data type name surrounded by angle brackets 
(
<>
). Put together, it looks like this: 
Vector.<T>
. In this documentation, the class specified in the type parameter is 
represented generically as 
T
.
Vector 
A type of array whose elements are all instances of the same data type.
Creating vectors
AIR 1.5 and later
You create a Vector instance by calling the 
air.Vector["<T>"]()
constructor. When you call this constructor, you 
specify the base type of the Vector variable. You specify the Vector’s base type using type parameter syntax. The type 
parameter immediately follows the word 
Vector
in the code. It consists of a left bracket, then a string containing the 
base class name surrounded by angle brackets (
<>
), followed by a right bracket. This example shows this syntax:
var v = new air.Vector["<String>"]();
In this example, the variable 
v
is declared as a vector of String objects. In other words, it represents an indexed array 
that can only hold String instances.
If you use the 
air.Vector["<T>"]()
constructor without any arguments, it creates an empty Vector instance. You 
can test that a Vector is empty by checking its 
length
property. For example, the following code calls the 
Vector["<T>"]()
constructor with no arguments:
var names = new air.Vector["<String>"]();  
air.
trace(names.length); // output: 0
If you know ahead of time how many elements a Vector initially needs, you can pre-define the number of elements in 
the Vector. To create a Vector with a certain number of elements, pass the number of elements as the first parameter 
(the 
length
parameter). Because Vector elements can’t be empty, the elements are filled with instances of the base 
type. If the base type is a reference type that allows 
null
values, the elements all contain 
null
. Otherwise, the elements 
all contain the default value for the class. For example, a Number variable can’t be 
null
. Consequently, in the following 
code listing the Vector named 
ages
is created with three elements, each containing the default Number value 
NaN
:
var ages = new air.Vector["<Number>"](3);  
air.trace(ages); // output: NaN, NaN, NaN
Using the 
Vector["<T>"]()
constructor you can also create a fixed-length Vector by passing 
true
for the second 
parameter (the 
fixed
parameter). In that case the Vector is created with the specified number of elements and the 
number of elements can’t be changed. Note, however, that you can still change the values of the elements of a fixed-
length Vector.
If you create a Vector of AIR runtime objects (classes defined in the 
window.runtime
object), reference the class’s fully 
qualified ActionScript 3.0 name when calling the Vector constructor. For example, the following code creates a Vector 
of File objects:
How to bookmark a pdf page - 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
how to add bookmarks to pdf document; create pdf with bookmarks from word
How to bookmark a pdf page - 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 editor; how to bookmark a page in pdf document
66
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with vectors
Last updated 9/28/2011
var files = new air.Vector["flash.filesystem.File"](3);
Inserting elements into a vector
Adobe AIR 1.5 and later
The most basic way to add an element to vector is to use the array access (
[]
) operator:
songTitles[5] = "Happy Birthday";
If the Vector doesn’t already have an element at that index, the index is created and the value is stored there.
With a Vector object, you can only assign a value to an existing index or to the next available index. The next available 
index corresponds to the Vector object’s 
length
property. The safest way to add a new element to a Vector object is 
to use code like this listing:
myVector[myVector.length] = valueToAdd;
As with arrays, three of the Vector class methods—
push()
unshift()
, and 
splice()
—allow you to insert elements 
into a vector.
Note: If a Vector object’s 
fixed
property is 
true
, the total number of elements in the Vector can’t change. If you try to 
add a new element to a fixed-length Vector using the 
push()
method or other means, an error occurs.
Retrieving values and removing vector elements
Adobe AIR 1.5 and later
The simplest way to retrieve the value of an element from vector is to use the array access (
[]
) operator. To retrieve 
the value of an vector element, use the vector object name and index number on the right side of an assignment 
statement:
var myFavoriteSong = songTitles[3];
It’s possible to attempt to retrieve a value from a vector using an index where no element exists. In that case, a Vector 
throws a RangeError exception.
Three methods of the Array and Vector classes—
pop()
shift()
, and 
splice()
—allow you to remove elements.
var vegetables = new air.Vector["<String>"];  
vegetables.push("spinach");  
vegetables.push("green pepper");  
vegetables.push("cilantro");  
vegetables.push("onion");  
var spliced = vegetables.splice(2, 2);  
air.trace(spliced); // output: spinach,green pepper
You can truncate a vector using the
length
property. 
If you set the 
length
property of a vector to a length that is less than the current length of the vector, the vector is 
truncated. Any elements stored at index numbers higher than the new value of 
length
minus 1 are removed.
Note: If a Vector object’s 
fixed
property is 
true
, the total number of elements in the Vector can’t change. If you try to 
remove an element from or truncate a fixed-length Vector using the techniques described here, an error occurs.
VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
XDoc.PDF ›› VB.NET PDF: Delete PDF Page. using RasterEdge.Imaging.Basic; using RasterEdge.XDoc.PDF; How to VB.NET: Delete a Single PDF Page from PDF File.
adding bookmarks to a pdf; bookmarks pdf files
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
PDF Pages. |. Home ›› XDoc.PDF ›› VB.NET PDF: Insert PDF Page. Professional .NET PDF control for inserting PDF page in Visual Basic .NET class application.
creating bookmarks in pdf files; copy bookmarks from one pdf to another
67
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with vectors
Last updated 9/28/2011
Properties and methods of Vector objects
Adobe AIR 1.5 and later
Many of the same methods and properties of Array objects are available for vector object. For example, you can call 
the 
reverse()
method to change the order of elements of a Vector. You can call the 
sort()
method to sort the 
elements of a Vector. However, the Vector class does not include a 
sortOn()
method. 
For details on supported properties and methods, see the Vector class documentation in the Adobe AIR Language 
Reference for HTML Developers. 
Example: Using AIR APIs that require vectors
Adobe AIR 1.5 and later
Some Adobe AIR runtime classes use vectors as properties or method return values. For example, the 
findInterfaces()
method of the NetworkInfo class returns an array of NetworkInterface objects. The 
arguments
property NativeProcessStartupInfo class is a vector of strings.
Accessing AIR APIs that return vector objects
Adobe AIR 2.0 and later
The 
findInterfaces()
method of the NetworkInfo class returns an array of NetworkInterface objects. For example, 
the following code lists the computer’s network interfaces:
var netInfo = air.NetworkInfo;  
var interfaces = netInfo.findInterfaces();  
for (i = 0; i < interfaces.length; i++)  
{  
air.trace(interfaces[i].name];  
air.trace(" hardware address: ", interface.hardwareAddress);  
}
You iterate through the vector of NetworkInfo objects just as you would iterate through an array. You use a 
for
loop 
and use square brackets to access indexed elements of the vector.
The 
interfaces
property of the NetworkInterface object is a vector of InterfaceAddress objects. The following code 
extends the previous example, adding a function to enumerate interface addresses for each network interface:
C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
Pages. |. Home ›› XDoc.PDF ›› C# PDF: Delete PDF Page. Demo Code: How to Delete a Single PDF Page from PDF File in C#.NET. How
add bookmark pdf file; convert excel to pdf with bookmarks
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
C#.NET PDF Library - Rotate PDF Page in C#.NET. How to Use C#.NET Demo Code to Rotate a PDF Page Using C#.NET. Output a New PDF File in C#.NET.
convert word pdf bookmarks; pdf reader with bookmarks
68
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with vectors
Last updated 9/28/2011
var netInfo = air.NetworkInfo;  
var interfaces = netInfo.findInterfaces();  
for (i = 0; i < interfaces.length; i++)  
{  
air.trace(interfaces[i].name];  
air.trace(" hardware address: ", interface.hardwareAddress);  
air.trace(" addresses: ", traceAddresses(i);  
}  
function traceAddresses(i)  
{  
returnString = new String();  
for (j = 0; j < interfaces[i].addresses.length; j++)  
returnString += interfaces[i],addresses[j].address + " ";  
 
}
Setting AIR APIs that are vectors
Adobe AIR 2.0 and later
The 
arguments
property NativeProcessStartupInfo class is a vector of strings. To set this property, create a vector of 
strings using the 
air.Vector()
constructor. You can use the 
push()
method to add strings to the vector:
var arguments = new air.Vector["<String>"]();  
arguments.push("test");  
arguments.push("44");  
var startupInfo = new air.NativeProcessStartupInfo();  
startupInfo.arguments = arguments;  
startupInfo.executable = File.applicationDirectory.resolvePath("myApplication.exe");  
process = new air.NativeProcess();  
process.start(startupInfo);
For more information on using the native process API, see “Communicating with Native Processes” in Networking 
and communication.
VB.NET PDF Page Rotate Library: rotate PDF page permanently in vb.
Page: Rotate a PDF Page. |. Home ›› XDoc.PDF ›› VB.NET PDF: Rotate PDF Page. Rotate a PDF Page Using VB.NET. Output a New PDF File.
bookmark a pdf file; how to add bookmarks to a pdf
C# PDF Page Extract Library: copy, paste, cut PDF pages in C#.net
If using x86, the platform target should be x86. C#.NET Sample Code: Clone a PDF Page Using C#.NET. Load the PDF file that provides the page object.
create bookmarks pdf; bookmarks in pdf files
69
Last updated 9/28/2011
Chapter 6: AIR security
Adobe AIR 1.0 and later
AIR security basics
Adobe AIR 1.0 and later
AIR applications run with the same security restrictions as native applications. In general, AIR applications, like native 
applications, have broad access to operating system capabilities such as reading and writing files, starting applications, 
drawing to the screen, and communicating with the network. Operating system restrictions that apply to native 
applications, such as user-specific privileges, equally apply to AIR applications.
Although the Adobe® AIR® security model is an evolution of the Adobe® Flash® Player security model, the security 
contract is different from the security contract applied to content in a browser. This contract offers developers a secure 
means of broader functionality for rich experiences with freedoms that would be inappropriate for a browser-based 
application.
AIR applications are written using either compiled bytecode (SWF content) or interpreted script (JavaScript, HTML) 
so that the runtime provides memory management. This minimizes the chances of AIR applications being affected by 
vulnerabilities related to memory management, such as buffer overflows and memory corruption. These are some of 
the most common vulnerabilities affecting desktop applications written in native code. 
Installation and updates
Adobe AIR 1.0 and later
AIR applications are distributed via AIR installer files which use the 
air
extension or via native installers, which use 
the file format and extension of the native platform. For example, the native installer format of Windows is an EXE 
file, and for Android the native format is an APK file. 
When Adobe AIR is installed and an AIR installer file is opened, the AIR runtime administers the installation process. 
When a native installer is used, the operating system administers the installation process.
Note: Developers can specify a version, and application name, and a publisher source, but the initial application 
installation workflow itself cannot be modified. This restriction is advantageous for users because all AIR applications 
share a secure, streamlined, and consistent installation procedure administered by the runtime. If application 
customization is necessary, it can be provided when the application is first executed.
Runtime installation location
Adobe AIR 1.0 and later
AIR applications first require the runtime to be installed on a user's computer, just as SWF files first require the Flash 
Player browser plug-in to be installed.
VB.NET PDF Page Replace Library: replace PDF pages in C#.net, ASP.
Image: Insert Image to PDF. Image: Remove Image from PDF Page. Image: Copy, Paste, Cut Image in Page. Link: Edit URL. Bookmark: Edit Bookmark. Metadata: Edit
export pdf bookmarks; excel hyperlink to pdf bookmark
VB.NET PDF remove image library: remove, delete images from PDF in
Image: Insert Image to PDF. Image: Remove Image from PDF Page. Image: Copy, Paste, Cut Image in Page. Link: Edit URL. Bookmark: Edit Bookmark. Metadata: Edit
adding bookmarks in pdf; adding bookmarks to pdf reader
70
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
AIR security
Last updated 9/28/2011
The runtime is installed to the following location on desktop computers:
• Mac OS: 
/Library/Frameworks/
• Windows: 
C:\Program Files\Common Files\Adobe AIR
• Linux: 
/opt/Adobe AIR/
On Mac OS, to install an updated version of an application, the user must have adequate system privileges to install to 
the application directory. On Windows and Linux, a user must have administrative privileges. 
Note: On iOS, the AIR runtime is not installed separately; every AIR app is a self-contained application.
The runtime can be installed in two ways: using the seamless install feature (installing directly from a web browser) or 
via a manual install.
Seamless install (runtime and application)
Adobe AIR 1.0 and later
The seamless install feature provides developers with a streamlined installation experience for users who do not have 
Adobe AIR installed yet. In the seamless install method, the developer creates a SWF file that presents the application 
for installation. When a user clicks in the SWF file to install the application, the SWF file attempts to detect the 
runtime. If the runtime cannot be detected it is installed, and the runtime is activated immediately with the installation 
process for the developer's application.
Manual install
Adobe AIR 1.0 and later
Alternatively, the user can manually download and install the runtime before opening an AIR file. The developer can 
then distribute an AIR file by different means (for instance, via e-mail or an HTML link on a website). When the AIR 
file is opened, the runtime begins to process the application installation.
Application installation flow
Adobe AIR 1.0 and later
The AIR security model allows users to decide whether to install an AIR application. The AIR install experience 
provides several improvements over native application install technologies that make this trust decision easier for 
users:
• The runtime provides a consistent installation experience on all operating systems, even when an AIR application 
is installed from a link in a web browser. Most native application install experiences depend upon the browser or 
other application to provide security information, if it is provided at all.
• The AIR application install experience identifies the source of the application and information about what 
privileges are available to the application (if the user allows the installation to proceed).
• The runtime administers the installation process of an AIR application. An AIR application cannot manipulate the 
installation process the runtime uses. 
In general, users should not install any desktop application that comes from a source that they do not trust, or that 
cannot be verified. The burden of proof on security for native applications is equally true for AIR applications as it is 
for other installable applications.
71
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
AIR security
Last updated 9/28/2011
Application destination
Adobe AIR 1.0 and later
The installation directory can be set using one of the following two options:
The user customizes the destination during installation. The application installs to wherever the user specifies.
If the user does not change the install destination, the application installs to the default path as determined by the 
runtime:
• Mac OS: 
~/Applications/
• Windows XP and earlier: 
C:\Program Files\
• Windows Vista: 
~/Apps/
• Linux: /opt/
If the developer specifies an 
installFolder
setting in the application descriptor file, the application is installed to 
a subpath of this directory.
The AIR file system
Adobe AIR 1.0 and later
The install process for AIR applications copies all files that the developer has included within the AIR installer file onto 
the user's local computer. The installed application is composed of:
• Windows: A directory containing all files included in the AIR installer file. The runtime also creates an exe file 
during the installation of the AIR application.
• Linux: A directory containing all files included in the AIR installer file. The runtime also creates a bin file during 
the installation of the AIR application.
• Mac OS: An 
app
file that contains all of the contents of the AIR installer file. It can be inspected using the "Show 
Package Contents" option in Finder. The runtime creates this app file as part of the installation of the AIR 
application.
An AIR application is run by:
• Windows: Running the .exe file in the install folder, or a shortcut that corresponds to this file (such as a shortcut 
on the Start Menu or desktop).
• Linux: Launching the .bin file in the install folder, choosing the application from the Applications menu, or running 
from an alias or desktop shortcut.
• Mac OS: Running the .app file or an alias that points to it.
The application file system also includes subdirectories related to the function of the application. For example, 
information written to encrypted local storage is saved to a subdirectory in a directory named after the application 
identifier of the application. 
72
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
AIR security
Last updated 9/28/2011
AIR application storage
Adobe AIR 1.0 and later
AIR applications have privileges to write to any location on the user's hard drive; however, developers are encouraged 
to use the 
app-storage:/
path for local storage related to their application. Files written to 
app-storage:/
from an 
application are located in a standard location depending on the user's operating system:
• On Mac OS: the storage directory of an application is 
<appData>/<appId>/Local Store/
where 
<appData>
is 
the user's “preferences folder,” 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,” typically:
C:\Documents and Settings\<user>\Application Data
• On Linux: 
<appData>/<appID>/Local Store/
where 
<appData>
is 
/home/<user>/.appdata
You can access the application storage directory via the 
air.File.applicationStorageDirectory
property. You 
can access its contents using the 
resolvePath()
method of the File class. For details, see “Working with the file 
system” on page 145.
Updating Adobe AIR
Adobe AIR 1.0 and later
When the user installs an AIR application that requires an updated version of the runtime, the runtime automatically 
installs the required runtime update.
To update the runtime, a user must have administrative privileges for the computer.
Updating AIR applications
Adobe AIR 1.0 and later
Development and deployment of software updates are one of the biggest security challenges facing native code 
applications. The AIR API provides a mechanism to improve this: the 
Updater.update()
method can be invoked 
upon launch to check a remote location for an AIR file. If an update is appropriate, the AIR file is downloaded, 
installed, and the application restarts. Developers can use this class not only to provide new functionality but also 
respond to potential security vulnerabilities.
The Updater class can only be used to update applications distributed as AIR files. Applications distributed as native 
applications must use the update facilities, if any, of the native operating system.
Note: Developers can specify the version of an application by setting the versionNumber property of the application 
descriptor file. 
Uninstalling an AIR application
Adobe AIR 1.0 and later
Removing an AIR application removes all files in the application directory. However, it does not remove all files that 
the application may have written to outside of the application directory. Removing AIR applications does not revert 
changes the AIR application has made to files outside of the application directory.
73
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
AIR security
Last updated 9/28/2011
Windows registry settings for administrators
Adobe AIR 1.0 and later
On Windows, administrators can configure a machine to prevent (or allow) AIR application installation and runtime 
updates. These settings are contained in the Windows registry under the following key: 
HKLM\Software\Policies\Adobe\AIR. They include the following:
HTML security in Adobe AIR
Adobe AIR 1.0 and later
This topic describes the AIR HTML security architecture and how to use iframes, frames, and the sandbox bridge to 
set up HTML-based applications and safely integrate HTML content into SWF-based applications.
The runtime enforces rules and provides mechanisms for overcoming possible security vulnerabilities in HTML and 
JavaScript. The same rules are enforced whether your application is primarily written in JavaScript or whether you load 
the HTML and JavaScript content into a SWF-based application. Content in the application sandbox and the non-
application security sandbox have different privileges. When loading content into an iframe or frame, the runtime 
provides a secure sandbox bridge mechanism that allows content in the frame or iframe to communicate securely with 
content in the application security sandbox.
The AIR SDK provides three classes for rendering HTML content. 
The HTMLLoader class provides close integration between JavaScript code and the AIR APIs. 
The StageWebView class is an HTML rendering class and has very limited integration with the host AIR application. 
Content loaded by the StageWebView class is never placed in the application security sandbox and cannot access data 
or call functions in the host AIR application. On desktop platforms, the StageWebView class uses the built-in AIR 
HTML engine, based on Webkit, which is also used by the HTMLLoader class. On mobile platforms, the 
StageWebView class uses the HTML control provided by the operating system. Thus, on mobile platforms the 
StageWebView class has the same security considerations and vulnerabilities as the system web browser.
The TextField class can display strings of HTML text. No JavaScript can be executed, but the text can include links and 
externally loaded images.
For more information, see “Avoiding security-related JavaScript errors” on page  22.
Registry setting
Description
AppInstallDisabled
Specifies that AIR application installation and uninstallation are allowed. Set to 0 for “allowed,” set to 1 
for “disallowed.” 
UntrustedAppInstallDisabled
Specifies that installation of untrusted AIR applications (applications that do not includes a trusted 
certificate) is allowed. Set to 0 for “allowed,” set to 1 for “disallowed.” 
UpdateDisabled
Specifies that updating the runtime is allowed, either as a background task or as part of an explicit 
installation. Set to 0 for “allowed,” set to 1 for “disallowed.” 
74
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
AIR security
Last updated 9/28/2011
Overview on configuring your HTML-based application
Adobe AIR 1.0 and later
Frames and iframes provide a convenient structure for organizing HTML content in AIR. Frames provide a means 
both for maintaining data persistence and for working securely with remote content. 
Because HTML in AIR retains its normal, page-based organization, the HTML environment completely refreshes if 
the top frame of your HTML content “navigates” to a different page. You can use frames and iframes to maintain data 
persistence in AIR, much the same as you would for a web application running in a browser. Define your main 
application objects in the top frame and they persist as long as you don’t allow the frame to navigate to a new page. Use 
child frames or iframes to load and display the transient parts of the application. (There are a variety of ways to 
maintain data persistence that can be used in addition to, or instead of, frames. These include cookies, local shared 
objects, local file storage, the encrypted file store, and local database storage.)
Because HTML in AIR retains its normal, blurred line between executable code and data, AIR puts content in the top 
frame of the HTML environment into the application sandbox. After the page 
load
event, AIR restricts any 
operations, such as 
eval()
, that can convert a string of text into an executable object. This restriction is enforced even 
when an application does not load remote content. To allow HTML content to execute these restricted operations, you 
must use frames or iframes to place the content into a non-application sandbox. (Running content in a sandboxed 
child frame may be necessary when using some JavaScript application frameworks that rely on the 
eval()
function.) 
For a complete list of the restrictions on JavaScript in the application sandbox, see “Code restrictions for content in 
different sandboxes” on page 76.
Because HTML in AIR retains its ability to load remote, possibly insecure content, AIR enforces a same-origin policy 
that prevents content in one domain from interacting with content in another. To allow interaction between 
application content and content in another domain, you can set up a bridge to serve as the interface between a parent 
and a child frame. 
Setting up a parent-child sandbox relationship
Adobe AIR 1.0 and later
AIR adds the 
sandboxRoot
and 
documentRoot
attributes to the HTML frame and iframe elements. These attributes 
let you treat application content as if it came from another domain:
The following example maps content installed in the sandbox subdirectory of the application to run in the remote 
sandbox and the www.example.com domain:
<iframe  
src="ui.html"   
sandboxRoot="http://www.example.com/local/"   
documentRoot="app:/sandbox/">  
</iframe>
Attribute
Description
sandboxRoot
The URL to use for determining the sandbox and domain in which to place the 
frame content. The file:, http:, or https: URL schemes must be used.
documentRoot
The URL from which to load the frame content. The file:app:, or app-
storage: URL schemes must be used.
Documents you may be interested
Documents you may be interested