c# pdf diff : Add bookmarks to pdf online SDK Library service wpf asp.net winforms dnn air_htmldevguide14-part458

135
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with menus
Last updated 9/28/2011
You can also specify modifier keys that are part of the key equivalent combination. To add a modifier, specify 
true
for 
the 
altKey
ctrlKey
cmdKey
, or 
shiftKey
field. The specified key or keys become part of the key equivalent 
combination. By default the Control key is specified for Windows and the Command key is specified for Mac OS X. 
To override this default behavior, include a 
defaultKeyEquivalentModifiers
field set to 
false
.
The following example shows the data structure for an XML-based menu data source that includes keyboard 
equivalents, in a file named “keyEquivalentMenu.xml”:
<?xml version="1.0" encoding="utf-8" ?>  
<root>  
<menuitem label="File">  
<menuitem label="New" keyEquivalent="n"/>  
<menuitem label="Open" keyEquivalent="o"/>  
<menuitem label="Save" keyEquivalent="s"/>  
<menuitem label="Save As..." keyEquivalent="s" shiftKey="true"/>  
<menuitem label="Close" keyEquivalent="w"/>  
</menuitem>  
<menuitem label="Edit">  
<menuitem label="Cut" keyEquivalent="x"/>  
<menuitem label="Copy" keyEquivalent="c"/>  
<menuitem label="Paste" keyEquivalent="v"/>  
</menuitem>  
</root>
The following example application loads the menu structure from “keyEquivalentMenu.xml” and uses it as the 
structure for the window or application menu for the application:
<html>  
<head>  
<title>XML-based menu with key equivalents example</title>  
<script type="text/javascript" src="AIRAliases.js"></script>  
<script type="text/javascript" src="AIRMenuBuilder.js"></script>  
</head>  
<body>  
<script type="text/javascript">  
// Create a NativeMenu from "keyEquivalentMenu.xml" and set it  
// as the application/window menu  
var keyEquivMenu = air.ui.Menu.createFromXML("keyEquivalentMenu.xml");  
air.ui.Menu.setAsMenu(keyEquivMenu);  
</script>  
</body>  
</html>
Specifying menu item mnemonics
Adobe AIR 1.0 and later
A menu item mnemonic is a key associated with a menu item. When the key is pressed while the menu is displayed, 
the menu item command is triggered. The behavior is the same as if the user had selected the menu item with the 
mouse. Typically the operating system indicates a menu item mnemonic by underlining that character in the name of 
the menu item.
For more information about mnemonics, see “Mnemonics (AIR)” on page  117.
Add bookmarks to pdf online - 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
bookmark pdf in preview; how to bookmark a pdf page
Add bookmarks to pdf online - 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
create bookmark pdf; edit pdf bookmarks
136
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with menus
Last updated 9/28/2011
With the MenuBuilder framework, the simplest way to specify a mnemonic for a menu item is to include an 
underscore character (“
_
”) in the menu item’s 
label
field. Place the underscore immediately to the left of the letter 
that serves as the mnemonic for that menu item. For example, if the following XML node is used in a data source that’s 
loaded using the MenuBuilder framework, the mnemonic for the command is the first character of the second word 
(the letter “A”):
<menuitem label="Save _As"/>
When the NativeMenu object is created, the underscore is not included in the label. Instead, the character following 
the underscore becomes the mnemonic for the menu item. To include a literal underscore character in a menu item’s 
name, use two underscore characters (“
__
”). This sequence is converted to an underscore in the menu item label.
As an alternative to using an underscore character in the 
label
field, you can provide an integer index position for the 
mnemonic character. Specify the index in the 
mnemonicIndex
field in the menu item data source object or XML 
element.
Handling MenuBuilder menu events
Adobe AIR 1.0 and later
User interaction with a NativeMenu is event-driven. When the user selects a menu item or opens a menu or submenu, 
the NativeMenuItem object dispatches an event. With a NativeMenu object created using the MenuBuilder 
framework, you can register event listeners with individual NativeMenuItem objects or with the NativeMenu. You 
subscribe and respond to these events the same way as if you had created the NativeMenu and NativeMenuItem objects 
manually rather than using the MenuBuilder framework. For more information see “Menu events” on page  115.
The MenuBuilder framework supplements the standard event handling, providing a way to specify a 
select
event 
handler function for a menu item within the menu data source. If you specify an 
onSelect
field in the menu item data 
source, the specified function is called when the user selects the menu item. For example, suppose the following XML 
node is included in a data source that’s loaded using the MenuBuilder framework. When the menu item is selected the 
function named 
doSave()
is called:
<menuitem label="Save" onSelect="doSave"/>
The 
onSelect
field is a String when it’s used with an XML data source. With a JSON array, the field can be a String 
with the name of the function. In addition, for a JSON array only, the field can also be a variable reference to the 
function as an object. However, if the JSON array uses a Function variable reference the menu must be created before 
or during the 
onload
event handler or a JavaScript security violation occurs. In all cases, the specified function must 
be defined in the global scope.
When the specified function is called, the runtime passes two arguments to it. The first argument is the event object 
dispatched by the 
select
event. It is an instance of the Event class. The second argument that’s passed to the function 
is an anonymous object containing the data that was used to create the menu item. This object has the following 
properties. Each property’s value matches the value in the original data structure or 
null
if the property is not set in 
the original data structure:
altKey
cmdKey
ctrlKey
defaultKeyEquivalentModifiers
enabled
keyEquivalent
VB.NET PDF File Split Library: Split, seperate PDF into multiple
This online VB tutorial aims to illustrate the process of PDF document Add necessary references split a PDF file into multiple ones by PDF bookmarks or outlines
split pdf by bookmark; how to add bookmarks to a pdf
C# PDF File Split Library: Split, seperate PDF into multiple files
Free download library and use online C# class source codes in .NET Add necessary references: to split a PDF file into multiple ones by PDF bookmarks or outlines
bookmarks pdf file; create bookmarks pdf file
137
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with menus
Last updated 9/28/2011
label
mnemonicIndex
onSelect
shiftKey
toggled
type
The following example lets you experiment with NativeMenu events. The example includes two menus. The window 
and application menu is created using an XML data source. The context menu for the list of items represented by the 
<ul>
and 
<li>
elements is created using a JSON array data source. A text area on the screen displays information 
about each event as the user selects menu items.
The following listing is the source code of the application:
<html>  
<head>  
<title>Menu event handling example</title>  
<script type="text/javascript" src="AIRAliases.js"></script>  
<script type="text/javascript" src="AIRMenuBuilder.js"></script>  
<script type="text/javascript" src="printObject.js"></script>  
<script type="text/javascript">  
function fileMenuCommand(event, data) {  
print("fileMenuCommand", event, data);  
}  
function editMenuCommand(event, data) {  
print("editMenuCommand", event, data);  
}  
function moveItemUp(event, data) {  
print("moveItemUp", event, data);  
}  
function moveItemDown(event, data) {  
print("moveItemDown", event, data);  
}  
function print(command, event, data) {  
var result = "";  
result += "<h1>Command: " + command + '</h1>';  
result += "<p>" + printObject(event) + "</p>";  
result += "<p>Data:</p>";  
result += "<ul>";  
for (var s in data) {  
result += "<li>" + s + ": " + printObject(data[s]) + "</li>";  
 
result += "</ul>";  
var o = document.getElementById("output");  
o.innerHTML = result;  
}  
</script>  
<style type="text/css">  
#contextList {  
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
adding bookmarks to pdf; how to add bookmarks on pdf
C# PDF File Compress Library: Compress reduce PDF size in C#.net
Bookmarks. Comments, forms and multimedia. Flatten visible layers. C#.NET DLLs: Compress PDF Document. Add necessary references: RasterEdge.Imaging.Basic.dll.
convert excel to pdf with bookmarks; excel hyperlink to pdf bookmark
138
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with menus
Last updated 9/28/2011
position: absolute; left: 0; top: 25px; bottom: 0; width: 100px;  
background: #eeeeee;  
}  
#output {  
position: absolute; left: 125px; top: 25px; right: 0; bottom: 0;  
}  
</style>  
</head>  
<body>  
<div id="contextList">  
<ul>  
<li>List item 1</li>  
<li>List item 2</li>  
<li>List item 3</li>  
</ul>  
</div>  
<div id="output">  
Choose menu commands. Information about the events displays here.  
</div>  
<script type="text/javascript">  
var mainMenu = air.ui.Menu.createFromXML("mainMenu.xml");  
air.ui.Menu.setAsMenu(mainMenu);  
var listContextMenu = air.ui.Menu.createFromJSON("listContextMenu.js");  
air.ui.Menu.setAsContextMenu(listContextMenu, "contextList")  
// clear the default context menu  
air.ui.Menu.setAsContextMenu(null);  
</script>  
</body>|  
</html>
The following listing is the data source for the main menu (“mainMenu.xml”):
<?xml version="1.0" encoding="utf-8" ?>  
<root>  
<menuitem label="File">  
<menuitem label="New" keyEquivalent="n" onSelect="fileMenuCommand"/>  
<menuitem label="Open" keyEquivalent="o" onSelect="fileMenuCommand"/>  
<menuitem label="Save" keyEquivalent="s" onSelect="fileMenuCommand"/>  
<menuitem label="Save As..." keyEquivalent="S" onSelect="fileMenuCommand"/>  
<menuitem label="Close" keyEquivalent="w" onSelect="fileMenuCommand"/>  
</menuitem>  
<menuitem label="Edit">  
<menuitem label="Cut" keyEquivalent="x" onSelect="editMenuCommand"/>  
<menuitem label="Copy" keyEquivalent="c" onSelect="editMenuCommand"/>  
<menuitem label="Paste" keyEquivalent="v" onSelect="editMenuCommand"/>  
</menuitem>  
</root>
The following listing is the data source for the context menu (“listContextMenu.js”);
[  
{label: "Move Item Up", onSelect: "moveItemUp"},  
{label: "Move Item Down", onSelect: "moveItemDown"}  
]
.NET PDF SDK - Description of All PDF Processing Control Feastures
Full page navigation, zooming & rotation; Outlines, bookmarks, & thumbnail display; PDF Text Write & Extract. Insert and add text to any page of PDF document with
bookmark pdf documents; pdf bookmark editor
XDoc.Word for .NET, Advanced .NET Word Processing Features
page navigation, zooming & rotation; Outlines, bookmarks, & thumbnail Convert Word to PDF; Convert Word to HTML5; Convert Add and insert a blank page or multiple
acrobat split pdf bookmark; how to create bookmark in pdf automatically
139
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with menus
Last updated 9/28/2011
The following listing contains the code from the printObject.js file. The file includes the 
printObject()
function, 
which the application uses but which doesn’t affect the operation of the menus in the example.
function printObject(obj) {  
if (!obj) {  
if (typeof obj == "undefined") { return "[undefined]"; };  
if (typeof obj == "object") { return "[null]"; };  
return "[false]";  
} else {  
if (typeof obj == "boolean") { return "[true]"; };  
if (typeof obj == "object") {  
if (typeof obj.length == "number") {  
var ret = [];  
for (var i=0; i<obj.length; i++) {  
ret.push(printObject(obj[i]));  
 
return ["[", ret.join(", "), "]"].join(" ");  
} else {  
var ret = [];  
var hadChildren = false;  
for (var k in obj) {  
hadChildren = true;  
ret.push ([k, " => ", printObject(obj[k])]);  
 
if (hadChildren) {  
return ["{\n", ret.join(",\n"), "\n}"].join("");  
 
}  
}  
if (typeof obj == "function") { return "[Function]"; }  
return String(obj);  
 
}
XDoc.PowerPoint for .NET, All Mature Features Introductions
navigation, zooming & rotation; Outlines, bookmarks, & thumbnail Convert PowerPoint to PDF; Convert PowerPoint to HTML5; Add a blank page or multiple pages to
bookmarks pdf file; export pdf bookmarks
XDoc.Excel for .NET, Comprehensive .NET Excel Imaging Features
page navigation, zooming & rotation; Outlines, bookmarks, & thumbnail Convert Excel to PDF; Convert Excel to HTML5; Convert Add a blank page or multiple pages to
bookmarks pdf documents; creating bookmarks in pdf from word
140
Last updated 9/28/2011
Chapter 10: Taskbar icons in AIR
Adobe AIR 1.0 and later
Many operating systems provide a taskbar, such as the Mac OS X dock, that can contain an icon to represent an 
application. Adobe® AIR® provides an interface for interacting with the application task bar icon through the 
NativeApplication.nativeApplication.icon
property.
More Help topics 
flash.desktop.NativeApplication
flash.desktop.DockIcon
flash.desktop.SystemTrayIcon
About taskbar icons
Adobe AIR 1.0 and later
AIR creates the 
NativeApplication.nativeApplication.icon
object automatically. The object type is either 
DockIcon or SystemTrayIcon, depending on the operating system. You can determine which of these InteractiveIcon 
subclasses that AIR supports on the current operating system using the 
NativeApplication.supportsDockIcon
and 
NativeApplication.supportsSystemTrayIcon
properties. The InteractiveIcon base class provides the 
properties 
width
height
, and 
bitmaps
, which you can use to change the image used for the icon. However, accessing 
properties specific to DockIcon or SystemTrayIcon on the wrong operating system generates a runtime error.
To set or change the image used for an icon, create an array containing one or more images and assign it to the 
NativeApplication.nativeApplication.icon.bitmaps
property. The size of taskbar icons can be different on 
different operating systems. To avoid image degradation due to scaling, you can add multiple sizes of images to the 
bitmaps
array. If you provide more than one image, AIR selects the size closest to the current display size of the taskbar 
icon, scaling it only if necessary. The following example sets the image for a taskbar icon using two images:
air.NativeApplication.nativeApplication.icon.bitmaps =   
[bmp16x16.bitmapData, bmp128x128.bitmapData];
To change the icon image, assign an array containing the new image or images to the 
bitmaps
property. You can 
animate the icon by changing the image in response to an 
enterFrame
or 
timer
event.
To remove the icon from the notification area on Windows and Linux, or to restore the default icon appearance on 
Mac OS X, set 
bitmaps
to an empty array:
air.NativeApplication.nativeApplication.icon.bitmaps = [];
141
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Taskbar icons in AIR
Last updated 9/28/2011
Dock icons
Adobe AIR 1.0 and later
AIR supports dock icons when 
NativeApplication.supportsDockIcon
is 
true
. The 
NativeApplication.nativeApplication.icon
property represents the application icon on the dock (not a 
window dock icon).
Note: AIR does not support changing window icons on the dock under Mac OS X. Also, changes to the application dock 
icon only apply while an application is running — the icon reverts to its normal appearance when the application 
terminates.
Dock icon menus
Adobe AIR 1.0 and later
You can add commands to the standard dock menu by creating a NativeMenu object containing the commands and 
assigning it to the 
NativeApplication.nativeApplication.icon.menu
property. The items in the menu are 
displayed above the standard dock icon menu items.
Bouncing the dock
Adobe AIR 1.0 and later
You can bounce the dock icon by calling the 
NativeApplication.nativeApplication.icon.bounce()
method. If 
you set the 
bounce() priority
parameter to informational, then the icon bounces once. If you set it to critical, then 
the icon bounces until the user activates the application. Constants for the 
priority
parameter are defined in the 
NotificationType class.
Note: The icon does not bounce if the application is already active.
Dock icon events
Adobe AIR 1.0 and later
When the dock icon is clicked, the NativeApplication object dispatches an 
invoke
event. If the application is not 
running, the system launches it. Otherwise, the 
invoke
event is delivered to the running application instance.
System Tray icons
Adobe AIR 1.0 and later
AIR supports system tray icons when 
NativeApplication.supportsSystemTrayIcon
is 
true
, which is currently 
the case only on Windows and most Linux distributions. On Windows and Linux, system tray icons are displayed in 
the notification area of the taskbar. No icon is displayed by default. To show an icon, assign an array containing 
BitmapData objects to the icon 
bitmaps
property. To change the icon image, assign an array containing the new 
images to 
bitmaps
. To remove the icon, set 
bitmaps
to 
null
.
142
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Taskbar icons in AIR
Last updated 9/28/2011
System tray icon menus
Adobe AIR 1.0 and later
You can add a menu to the system tray icon by creating a NativeMenu object and assigning it to the 
NativeApplication.nativeApplication.icon.menu
property (no default menu is provided by the operating 
system). Access the system tray icon menu by right-clicking the icon.
System tray icon tooltips
Adobe AIR 1.0 and later
Add a tooltip to an icon by setting the tooltip property:
air.NativeApplication.nativeApplication.icon.tooltip = "Application name";
System tray icon events
Adobe AIR 1.0 and later
The SystemTrayIcon object referenced by the NativeApplication.nativeApplication.icon property dispatches a 
ScreenMouseEvent for 
click
mouseDown
mouseUp
rightClick
rightMouseDown
, and 
rightMouseUp
events. You 
can use these events, along with an icon menu, to allow users to interact with your application when it has no visible 
windows.
Example: Creating an application with no windows
Adobe AIR 1.0 and later
The following example creates an AIR application which has a system tray icon, but no visible windows. (The 
visible
property of the application must not be set to 
true
in the application descriptor, or the window will be visible when 
the application starts up.)
Note: When using the Flex WindowedApplication component, you must set the 
visible
attribute of the 
WindowedApplication tag to 
false
. This attribute supercedes the setting in the application descriptor.
143
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Taskbar icons in AIR
Last updated 9/28/2011
<html>  
<head>  
<script src="AIRAliases.js" language="JavaScript" type="text/javascript"></script>  
<script language="JavaScript" type="text/javascript">  
var iconLoadComplete = function(event)  
 
air.NativeApplication.nativeApplication.icon.bitmaps = 
[event.target.content.bitmapData];  
 
air.NativeApplication.nativeApplication.autoExit = false;  
var iconLoad = new air.Loader();  
var iconMenu = new air.NativeMenu();  
var exitCommand = iconMenu.addItem(new air.NativeMenuItem("Exit"));  
exitCommand.addEventListener(air.Event.SELECT,function(event){  
air.NativeApplication.nativeApplication.icon.bitmaps = [];  
air.NativeApplication.nativeApplication.exit();  
});  
if (air.NativeApplication.supportsSystemTrayIcon) {  
air.NativeApplication.nativeApplication.autoExit = false;  
iconLoad.contentLoaderInfo.addEventListener(air.Event.COMPLETE,iconLoadComplete);  
iconLoad.load(new air.URLRequest("icons/AIRApp_16.png"));  
air.NativeApplication.nativeApplication.icon.tooltip = "AIR application";  
air.NativeApplication.nativeApplication.icon.menu = iconMenu;  
 
if (air.NativeApplication.supportsDockIcon) {  
iconLoad.contentLoaderInfo.addEventListener(air.Event.COMPLETE,iconLoadComplete);  
iconLoad.load(new air.URLRequest("icons/AIRApp_128.png"));  
air.NativeApplication.nativeApplication.icon.menu = iconMenu;  
 
</script>  
</head>  
<body>  
</body>  
</html>
Note: The example assumes that there are image files named 
AIRApp_16.png
and 
AIRApp_128.png
in an 
icons
subdirectory of the application. (Sample icon files, which you can copy to your project folder, are included in the AIR SDK.)
Window taskbar icons and buttons
Adobe AIR 1.0 and later
Iconified representations of windows are typically displayed in the window area of a taskbar or dock to allow users to 
easily access background or minimized windows. The Mac OS X dock displays an icon for your application as well as 
an icon for each minimized window. The Microsoft Windows and Linux taskbars display a button containing the 
progam icon and title for each normal-type window in your application. 
144
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Taskbar icons in AIR
Last updated 9/28/2011
Highlighting the taskbar window button
Adobe AIR 1.0 and later
When a window is in the background, you can notify the user that an event of interest related to the window has 
occurred. On Mac OS X, you can notify the user by bouncing the application dock icon (as described in “Bouncing the 
dock” on page 141). On Windows and Linux, you can highlight the window taskbar button by calling the 
notifyUser()
method of the NativeWindow instance. The 
type
parameter passed to the method determines the 
urgency of the notification:
NotificationType.CRITICAL
: the window icon flashes until the user brings the window to the foreground. 
NotificationType.INFORMATIONAL
: the window icon highlights by changing color. 
Note: On Linux, only the informational type of notification is supported. Passing either type value to the 
notifyUser()
function will create the same effect.
The following statement highlights the taskbar button of a window:
window.nativeWindow.notifyUser(air.NotificationType.INFORMATIONAL);
Calling the 
NativeWindow.notifyUser()
method on an operating system that does not support window-level 
notification has no effect. Use the 
NativeWindow.supportsNotification
property to determine if window 
notification is supported.
Creating windows without taskbar buttons or icons
Adobe AIR 1.0 and later
On the Windows operating system, windows created with the types utility or lightweight do not appear on the taskbar. 
Invisible windows do not appear on the taskbar, either. 
Because the initial window is necessarily of type, normal, in order to create an application without any windows 
appearing in the taskbar, you must either close the initial window or leave it invisible. To close all windows in your 
application without terminating the application, set the 
autoExit
property of the NativeApplication object to 
false
before closing the last window. To simply prevent the initial window from ever becoming visible, add 
<visible>false</visible>
to the 
<initalWindow>
element of the application descriptor file (and do not set the 
visible
property to 
true
or call the 
activate()
method of the window). 
In new windows opened by the application, set the 
type
property of the NativeWindowInitOption object passed to 
the window constructor to 
NativeWindowType.UTILITY
or 
NativeWindowType.LIGHTWEIGHT
.
On Mac OS X, windows that are minimized are displayed on the dock taskbar. You can prevent the minimized icon 
from being displayed by hiding the window instead of minimizing it. The following example listens for a 
nativeWindowDisplayState
change event and cancels it if the window is being minimized. Instead the handler sets 
the window 
visible
property to 
false
:
function preventMinimize(event){  
if(event.afterDisplayState == air.NativeWindowDisplayState.MINIMIZED){  
event.preventDefault();  
event.target.visible = false;  
 
}
If a window is minimized on the Mac OS X dock when you set the 
visible
property to 
false
, the dock icon is not 
removed. A user can still click the icon to make the window reappear.
Documents you may be interested
Documents you may be interested