c# pdf diff : Add bookmarks to pdf online SDK software service wpf .net asp.net dnn air_htmldevguide27-part472

265
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with byte arrays
Last updated 9/28/2011
"<br/>");       // fries: 1.45  
}
// end of init()  
// read specified file into byte array  
function readFile(fileName, data) {  
var inFile = air.File.desktopDirectory; // source folder is desktop  
inFile = inFile.resolvePath(fileName);  // name of file to read  
var inStream = new air.FileStream();  
inStream.open(inFile, air.FileMode.READ);  
inStream.readBytes(data, 0, data.length);  
inStream.close();  
}  
</script>  
</head>  
<body onload = "init();">  
<div id="taFiles"></div>  
</body>  
</html>
ByteArray example: Reading a .zip file
Adobe AIR 1.0 and later
This example demonstrates how to read a simple .zip file containing several files of different types. It does so by 
extracting relevant data from the metadata for each file, uncompressing each file into a ByteArray and writing the file 
to the desktop.
The general structure of a .zip file is based on the specification by PKWARE Inc., which is maintained at 
http://www.pkware.com/documents/casestudies/APPNOTE.TXT. First is a file header and file data for the first file in 
the .zip archive, followed by a file header and file data pair for each additional file. (The structure of the file header is 
described later.) Next, the .zip file optionally includes a data descriptor record (usually when the output zip file was 
created in memory rather than saved to a disk). Next are several additional optional elements: archive decryption 
header, archive extra data record, central directory structure, Zip64 end of central directory record, Zip64 end of 
central directory locator, and end of central directory record.
The code in this example is written to only parse zip files that do not contain folders and it does not expect data 
descriptor records. It ignores all information following the last file data.
The format of the file header for each file is as follows:
file header signature
4 bytes
required version
2 bytes
general-purpose bit flag
2 bytes
compression method
2 bytes (8=DEFLATE; 0=UNCOMPRESSED)
last modified file time
2 bytes
last modified file date
2 bytes
crc-32
4 bytes
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
how to bookmark a pdf document; adding bookmarks to pdf document
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
pdf bookmark editor; create bookmark in pdf automatically
266
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with byte arrays
Last updated 9/28/2011
Following the file header is the actual file data, which can be either compressed or uncompressed, depending on the 
compression method flag. The flag is 0 (zero) if the file data is uncompressed, 8 if the data is compressed using the 
DEFLATE algorithm, or another value for other compression algorithms.
The user interface for this example consists of a label and a text area (
taFiles
). The application writes the following 
information to the text area for each file it encounters in the .zip file: the file name, the compressed size, and the 
uncompressed size. The following MXML document defines the user interface for the Flex version of the application:
<?xml version="1.0" encoding="utf-8"?>  
<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml" layout="vertical" 
creationComplete="init();">  
<mx:Script>  
<![CDATA[  
// The application code goes here  
]]>  
</mx:Script>  
<mx:Form>  
<mx:FormItem label="Output">  
<mx:TextArea id="taFiles" width="320" height="150"/>  
</mx:FormItem>  
</mx:Form>  
</mx:WindowedApplication>
The user interface for this example consists of a label and a text area (
taFiles
). The application writes the following 
information to the text area for each file it encounters in the .zip file: the file name, the compressed size, and the 
uncompressed size. The following HTML page defines the user interface for the application:
compressed size
4 bytes
uncompressed size
4 bytes
file name length
2 bytes
extra field length
2 bytes
file name
variable
extra field
variable
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
export pdf bookmarks; export pdf bookmarks to excel
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
add bookmarks to pdf online; display bookmarks in pdf
267
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with byte arrays
Last updated 9/28/2011
<html>  
<head>  
<style type="text/css">  
#taFiles  
{  
border: 1px solid black;  
font-family: Courier, monospace;  
white-space: pre;  
width: 95%;  
height: 95%;  
overflow-y: scroll;  
}  
</style>  
<script type="text/javascript" src="AIRAliases.js"></script>  
<script type="text/javascript">  
// The application code goes here  
</script>  
</head>  
<body onload="init();">  
<div id="taFiles"></div>  
</body>  
</html>
The beginning of the program performs the following tasks:
• Defines the 
bytes
ByteArray
var bytes = new air.ByteArray();
• Defines variables to store metadata from the file header
// variables for reading fixed portion of file header  
var fileName = new String();  
var flNameLength;  
var xfldLength;  
var offset;  
var compSize;  
var uncompSize;  
var compMethod;  
var signature;  
var output;
• Defines File (
zfile
) and FileStream (
zStream
) objects to represent the .zip file, and specifies the location of the 
.zip file from which the files are extracted—a file named “HelloAIR.zip” in the desktop directory.
// File variables for accessing .zip file  
var zfile = air.File.desktopDirectory.resolvePath("HelloAIR.zip");  
var zStream = new air.FileStream();
In Flex, the program code starts in the 
init()
method, which is called as the 
creationComplete
handler for the root 
mx:WindowedApplication
tag.
The program code starts in the 
init()
method, which is called as the 
onload
event handler for the 
body
tag.
function init()  
{
The program begins by opening the .zip file in READ mode.
zStream.open(zfile, air.FileMode.READ);
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
creating bookmarks in pdf from word; how to add bookmarks to a 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.
how to bookmark a page in pdf document; how to create bookmark in pdf automatically
268
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with byte arrays
Last updated 9/28/2011
It then sets the 
endian
property of 
bytes
to 
LITTLE_ENDIAN
to indicate that the byte order of numeric fields has the 
least significant byte first.
bytes.endian = air.Endian.LITTLE_ENDIAN;
Next, a 
while()
statement begins a loop that continues until the current position in the file stream is greater than or 
equal to the size of the file.
while (zStream.position < zfile.size)  
{
The first statement inside the loop reads the first 30 bytes of the file stream into the ByteArray 
bytes
. The first 30 bytes 
make up the fixed-size part of the first file header.
// read fixed metadata portion of local file header  
zStream.readBytes(bytes, 0, 30);
Next, the code reads an integer (
signature
) from the first bytes of the 30-byte header. The ZIP format definition 
specifies that the signature for every file header is the hexadecimal value 
0x04034b50
; if the signature is different it 
means that the code has moved beyond the file portion of the .zip file and there are no more files to extract. In that case 
the code exits the 
while
loop immediately rather than waiting for the end of the byte array.
bytes.position = 0;  
signature = bytes.readInt();  
// if no longer reading data files, quit  
if (signature != 0x04034b50)  
{  
break;  
}
The next part of the code reads the header byte at offset position 8 and stores the value in the variable 
compMethod
This byte contains a value indicating the compression method that was used to compress this file. Several compression 
methods are allowed, but in practice nearly all .zip files use the DEFLATE compression algorithm. If the current file is 
compressed with DEFLATE compression, 
compMethod
is 8; if the file is uncompressed, 
compMethod
is 0.
bytes.position = 8;  
compMethod = bytes.readByte();  // store compression method (8 == Deflate)
Following the first 30 bytes is a variable-length portion of the header that contains the file name and, possibly, an extra 
field. The variable 
offset
stores the size of this portion. The size is calculated by adding the file name length and extra 
field length, read from the header at offsets 26 and 28.
offset = 0;// stores length of variable portion of metadata   
bytes.position = 26;  // offset to file name length  
flNameLength = bytes.readShort();// store file name  
offset += flNameLength; // add length of file name  
bytes.position = 28;// offset to extra field length  
xfldLength = bytes.readShort();  
offset += xfldLength;// add length of extra field
Next the program reads the variable-length portion of the file header for the number of bytes stored in the 
offset
variable.
// read variable length bytes between fixed-length header and compressed file data  
zStream.readBytes(bytes, 30, offset);
The program reads the file name from the variable length portion of the header and displays it in the text area along 
with the compressed (zipped) and uncompressed (original) sizes of the file.
.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
pdf bookmarks; pdf create bookmarks
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
how to add bookmarks to pdf document; bookmark template pdf
269
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with byte arrays
Last updated 9/28/2011
bytes.position = 30;   
fileName = bytes.readUTFBytes(flNameLength); // read file name  
output += fileName + "<br />"; // write file name to text area  
bytes.position = 18;  
compSize = bytes.readUnsignedInt();  // store size of compressed portion  
output += "\tCompressed size is: " + compSize + '<br />';  
bytes.position = 22;  // offset to uncompressed size  
uncompSize = bytes.readUnsignedInt();  // store uncompressed size  
output += "\tUncompressed size is: " + uncompSize + '<br />';
The example reads the rest of the file from the file stream into 
bytes 
for the length specified by the compressed size, 
overwriting the file header in the first 30 bytes. The compressed size is accurate even if the file is not compressed 
because in that case the compressed size is equal to the uncompressed size of the file.
// read compressed file to offset 0 of bytes; for uncompressed files  
// the compressed and uncompressed size is the same  
if (compSize == 0) continue;  
zStream.readBytes(bytes, 0, compSize);
Next, the example uncompresses the compressed file and calls the 
outfile()
function to write it to the output file 
stream. It passes 
outfile()
the file name and the byte array containing the file data.
if (compMethod == 8) // if file is compressed, uncompress  
{  
bytes.uncompress(air.CompressionAlgorithm.DEFLATE);  
}  
outFile(fileName, bytes);   // call outFile() to write out the file 
The closing braces indicate the end of the 
while
loop and of the 
init()
method and the application code, except for 
the 
outFile()
method. Execution loops back to the beginning of the 
while
loop and continues processing the next 
bytes in the .zip file—either extracting another file or ending processing of the .zip file if the last file has been processed. 
When all the files have been processed, the example writes the contents of the 
output
variable to the 
div
element 
taFiles 
to display the file information on the screen.
} // end of while loop  
document.getElementById("taFiles").innerHTML = output;  
} // end of init() method
The 
outfile()
function opens an output file in WRITE mode on the desktop, giving it the name supplied by the 
filename
parameter. It then writes the file data from the 
data
parameter to the output file stream (
outStream
) and 
closes the file.
function outFile(fileName, data)  
{  
var outFile = air.File.desktopDirectory; // dest folder is desktop  
outFile = outFile.resolvePath(fileName);  // name of file to write  
var outStream = new air.FileStream();  
// open output file stream in WRITE mode  
outStream.open(outFile, air.FileMode.WRITE);  
// write out the file  
outStream.writeBytes(data, 0, data.length);  
// close it  
outStream.close();  
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
create bookmarks pdf file; how to create bookmark in pdf with
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
editing bookmarks in pdf; bookmarks pdf files
270
Last updated 9/28/2011
Chapter 17: Adding PDF content in AIR
Adobe AIR 1.0 and later
Applications running in Adobe® AIR® can render not only SWF and HTML content, but also PDF content. AIR 
applications render PDF content using the HTMLLoader class, the WebKit engine, and the Adobe® Reader® browser 
plug-in. In an AIR application, PDF content can either stretch across the full height and width of your application or 
alternatively as a portion of the interface. The Adobe Reader browser plug-in controls display of PDF files in an AIR 
application. modifications to the Reader toolbar interface (such as controls for position, anchoring, and visibility) 
persist in subsequent viewing of PDF files in both AIR applications and the browser.
Important: To render PDF content in AIR, the user must have Adobe Reader or Adobe®  Acrobat®  version 8.1 or higher 
installed. 
Detecting PDF Capability
Adobe AIR 1.0 and later
If the user does not have Adobe Reader or Adobe Acrobat 8.1 or higher, PDF content is not displayed in an AIR 
application. To detect if a user can render PDF content, first check the 
HTMLLoader.pdfCapability
property. This 
property is set to one of the following constants of the HTMLPDFCapability class:
On Windows, if Adobe Acrobat or Adobe Reader version 7.x or above is running on the user's system, that version is 
used even if a later version that supports loading PDF is installed. In this case, if the value of the 
pdfCapability
property is 
HTMLPDFCapability.STATUS_OK
, when an AIR application attempts to load PDF content, the older 
version of Acrobat or Reader displays an alert (and no exception is thrown in the AIR application). If this is a possible 
situation for your end users, consider providing them with instructions to close Acrobat while running your 
application. You may want to display these instructions if the PDF content does not load within an acceptable time 
frame.
On Linux, AIR looks for Adobe Reader in the PATH exported by the user (if it contains the acroread command) and 
in the /opt/Adobe/Reader directory. 
The following code detects whether a user can display PDF content in an AIR application. If the user cannot display 
PDF, the code traces the error code that corresponds to the HTMLPDFCapability error object:
Constant
Description
HTMLPDFCapability.STATUS_OK
A sufficient version (8.1 or greater) of Adobe Reader is detected and 
PDF content can be loaded into an HTMLLoader object. 
HTMLPDFCapability.ERROR_INSTALLED_READER_NOT_FOUND
No version of Adobe Reader is detected. An HTMLLoader object 
cannot display PDF content.
HTMLPDFCapability.ERROR_INSTALLED_READER_TOO_OLD
Adobe Reader has been detected, but the version is too old. An 
HTMLLoader object cannot display PDF content. 
HTMLPDFCapability.ERROR_PREFERRED_READER_TOO_OLD
A sufficient version (8.1 or later) of Adobe Reader is detected, but the 
version of Adobe Reader that is set up to handle PDF content is older 
than Reader 8.1. An HTMLLoader object cannot display PDF content. 
271
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Adding PDF content in AIR
Last updated 9/28/2011
if(air.HTMLLoader.pdfCapability == air.HTMLPDFCapability.STATUS_OK)   
{  
air.trace("PDF content can be displayed");  
}  
else   
{  
air.trace("PDF cannot be displayed. Error code:", HTMLLoader.pdfCapability);  
}
Loading PDF content
Adobe AIR 1.0 and later
You can add a PDF to an AIR application by creating an HTMLLoader instance, setting its dimensions, and loading 
the path of a PDF.
You can add a PDF to an AIR application just as you would in a browser. For example, you can load PDF into the top-
level HTML content of a window, into an object tag, in a frame, or in an iframe. 
The following example loads a PDF from an external site. Replace the value of the src property of the iframe with the 
path to an available external PDF.
<html>  
<body>  
<h1>PDF test</h1>  
<iframe id="pdfFrame"   
width="100%"   
height="100%"   
src="http://www.example.com/test.pdf"/>  
</body>  
</html>
You can also load content from file URLs and AIR-specific URL schemes, such as app and app-storage. For example, 
the following code loads the test.pdf file in the PDFs subdirectory of the application directory:
app:/js_api_reference.pdf
For more information on AIR URL schemes, see “URI schemes on page  318.
Scripting PDF content
Adobe AIR 1.0 and later
You can use JavaScript to control PDF content just as you can in a web page in the browser. 
JavaScript extensions to Acrobat provide the following features, among others:
• Controlling page navigation and magnification
• Processing forms within the document
• Controlling multimedia events
272
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Adding PDF content in AIR
Last updated 9/28/2011
Full details on JavaScript extensions for Adobe Acrobat are provided at the Adobe Acrobat Developer Connection at 
http://www.adobe.com/devnet/acrobat/javascript.html.
HTML-PDF communication basics
Adobe AIR 1.0 and later
JavaScript in an HTML page can send a message to JavaScript in PDF content by calling the 
postMessage()
method 
of the DOM object representing the PDF content. For example, consider the following embedded PDF content:
<object id="PDFObj" data="test.pdf" type="application/pdf" width="100%" height="100%"/>
The following JavaScript code in the containing HTML content sends a message to the JavaScript in the PDF file:
pdfObject = document.getElementById("PDFObj");  
pdfObject.postMessage(["testMsg", "hello"]);
The PDF file can include JavaScript for receiving this message. You can add JavaScript code to PDF files in some 
contexts, including the document-, folder-, page-, field-, and batch-level contexts. Only the document-level context, 
which defines scripts that are evaluated when the PDF document opens, is discussed here.
A PDF file can add a 
messageHandler
property to the 
hostContainer
object. The 
messageHandler
property is an 
object that defines handler functions to respond to messages. For example, the following code defines the function to 
handle messages received by the PDF file from the host container (which is the HTML content embedding the PDF 
file):
this.hostContainer.messageHandler = {onMessage: myOnMessage};  
function myOnMessage(aMessage)  
{  
if(aMessage[0] == "testMsg")  
 
app.alert("Test message: " + aMessage[1]);  
 
else  
 
app.alert("Error");  
 
}
JavaScript code in the HTML page can call the 
postMessage()
method of the PDF object contained in the page. 
Calling this method sends a message (
"Hello from HTML"
) to the document-level JavaScript in the PDF file:
273
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Adding PDF content in AIR
Last updated 9/28/2011
<html>  
<head>  
<title>PDF Test</title>  
<script>  
function init()  
{  
pdfObject = document.getElementById("PDFObj");  
try {  
pdfObject.postMessage(["alert", "Hello from HTML"]);  
}  
catch (e)  
{  
alert( "Error: \n name = " + e.name + "\n message = " + e.message );  
}  
}  
</script>  
</head>  
<body onload='init()'>  
<object  
id="PDFObj"  
data="test.pdf"  
type="application/pdf"  
width="100%" height="100%"/>  
</body>  
</html>
For a more advanced example, and for information on using Acrobat 8 to add JavaScript to a PDF file, see Cross-
scripting PDF content in Adobe AIR.
Known limitations for PDF content in AIR
Adobe AIR 1.0 and later
PDF content in Adobe AIR has the following limitations:
• PDF content does not display in a window (a NativeWindow object) that is transparent (where the 
transparent
property is set to 
true
).
• The display order of a PDF file operates differently than other display objects in an AIR application. Although PDF 
content clips correctly according to HTML display order, it will always sit on top of content in the AIR application's 
display order.
• If certain visual properties of an HTMLLoader object that contains a PDF document are changed, the PDF 
document will become invisible. These properties include the 
filters
alpha
rotation
, and 
scaling
properties. 
Changing these properties renders the PDF content invisible until the properties are reset. The PDF content is also 
invisible if you change these properties of display object containers that contain the HTMLLoader object.
• PDF content is visible only when the 
scaleMode
property of the Stage object of the NativeWindow object 
containing the PDF content (the 
window.nativeWindow.stage
property) is set to 
air.StageScaleMode.NO_SCALE
. When it is set to any other value, the PDF content is not visible.
274
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Adding PDF content in AIR
Last updated 9/28/2011
• Clicking links to content within the PDF file update the scroll position of the PDF content. Clicking links to content 
outside the PDF file redirect the HTMLLoader object that contains the PDF (even if the target of a link is a new 
window). 
• PDF commenting workflows do not function in AIR.
Documents you may be interested
Documents you may be interested