c# pdf diff : Creating bookmarks in pdf from word Library control class asp.net web page .net ajax air_htmldevguide26-part471

255
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with local SQL databases in AIR
Last updated 9/28/2011
Use asynchronous operations as a standard approach, especially with operations that involve large numbers of rows. 
There is a technique for dividing up the processing of large sets of 
SELECT
statement results, described in “Retrieving 
SELECT results in parts” on page 224. However, this technique can only be used in asynchronous execution mode. 
Only use synchronous operations when you can’t achieve certain functionality using asynchronous programming, 
when you’ve considered the performance trade-off that your application’s users will face, and when you’ve tested your 
application so that you know how your application’s performance is affected. Using asynchronous execution can 
involve more complex coding. However, remember that you only have to write the code once, but the application’s 
users have to use it repeatedly, fast or slow.
In many cases, by using a separate SQLStatement instance for each SQL statement to be executed, multiple SQL 
operations can be queued up at one time, which makes asynchronous code like synchronous code in terms of how the 
code is written. For more information, see “Understanding the asynchronous execution model” on page  236.
Use separate SQL statements and don’t change the SQLStatement’s text property
Adobe AIR 1.0 and later
For any SQL statement that is executed more than once in an application, create a separate SQLStatement instance for 
each SQL statement. Use that SQLStatement instance each time that SQL command executes. For example, suppose 
you are building an application that includes four different SQL operations that are performed multiple times. In that 
case, create four separate SQLStatement instances and call each statement’s 
execute()
method to run it. Avoid the 
alternative of using a single SQLStatement instance for all SQL statements, redefining its 
text
property each time 
before executing the statement. 
Use statement parameters
Adobe AIR 1.0 and later
Use SQLStatement parameters—never concatenate user input into statement text. Using parameters makes your 
application more secure because it prevents the possibility of SQL injection attacks. It makes it possible to use objects 
in queries (rather than only SQL literal values). It also makes statements run more efficiently because they can be 
reused without needing to be recompiled each time they’re executed. See “Using parameters in statements” on 
page  216 for more information.
Creating bookmarks in pdf from word - 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
auto bookmark pdf; bookmark pdf reader
Creating bookmarks in pdf from word - 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 bookmarks in pdf reader; creating bookmarks in a pdf document
256
Last updated 9/28/2011
Chapter 15: Encrypted local storage
The Adobe® AIR® runtime provides a persistent encrypted local store (ELS) for each AIR application installed on a 
user's computer. This lets you save and retrieve data that is stored on the user’s local hard drive in an encrypted format 
that cannot easily be deciphered by other users. A separate encrypted local store is used for each AIR application, and 
each AIR application uses a separate encrypted local store for each user. 
Note: In addition to the encrypted local store, AIR also provides encryption for content stored in SQL databases. For 
details, see “Using encryption with SQL databases” on pag e237.
You may want to use the encrypted local store to cache information that must be secured, such as login credentials for 
web services. The ELS is appropriate for storing information that must be kept private from other users. It does not, 
however, protect the data from other processes run under the same user account. It is thus not appropriate for 
protecting secret application data, such as DRM or encryption keys.
On desktop platforms, AIR uses DPAPI on Windows, KeyChain on Mac OS and iOS, and KeyRing or KWallet on 
Linux to associate the encrypted local store to each application and user. The encrypted local store uses AES-CBC 128-
bit encryption.
On Android, the data stored by the EncryptedLocalStorage class are not encrypted. Instead the data is protected by the 
user-level security provided by the operating system. The Android operating system assigns every application a 
separate user ID. Applications can only access their own files and files created in public locations (such as the 
removable storage card). Note that on “rooted” Android devices, applications running with root privileges CAN access 
the files of other applications. Thus on a rooted device, the encrypted local store does not provide as high a level of data 
protection as it does on on a non-rooted device.
Information in the encrypted local store is only available to AIR application content in the application security 
sandbox. 
If you update an AIR application, the updated version retains access to any existing data in the encrypted local store 
unless:
• The items were added with the 
stronglyBound
parameter set to 
true
• The existing and update versions are both published prior to AIR 1.5.3 and the update is signed with a migration 
signature.
Limitations of the encrypted local store
The data in the encrypted local store is protected by the user’s operating system account credentials. Other entities 
cannot access the data in the store unless they can login as that user. However, the data is not secure against access by 
other applications run by an authenticated user. 
Because the user must be authenticated for these attacks to work, the user’s private data is still protected (unless the 
user account itself is compromised). However, data that your application may want to keep secret from users, such as 
keys used for licensing or digital rights management, is not secure. Thus the ELS is not an appropriate location for 
storing such information. It is only an appropriate place for storing a user’s private data, such as passwords.
Data in the ELS can be lost for a variety of reasons. For example, the user could uninstall the application and delete the 
encrypted file. Or, the publisher ID could be changed as a result of an update. Thus the ELS should be treated as a 
private cache, not a permanent data storage. 
C# Create PDF Library SDK to convert PDF from other file formats
Gratis control for creating PDF from multiple image formats such as tiff, jpg, png Create and save editable PDF with a blank page, bookmarks, links, signatures
bookmarks in pdf reader; creating bookmarks pdf
VB.NET Create PDF Library SDK to convert PDF from other file
Gratis control for creating PDF from multiple image formats such as tiff, jpg, png Create and save editable PDF with a blank page, bookmarks, links, signatures
creating bookmarks in pdf documents; bookmarks pdf documents
257
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Encrypted local storage
Last updated 9/28/2011
The 
stronglyBound
parameter is deprecated and should not be set to 
true
. Setting the parameter to 
true
does not 
provide any additional protection for data. At the same time, access to the data is lost whenever the application is 
updated — even if the publisher ID stays the same.
The encrypted local store may perform more slowly if the stored data exceeds 10MB.
When you uninstall an AIR application, the uninstaller does not delete data stored in the encrypted local store. 
The best practices for using the ELS include:
• Use the ELS to store sensitive user data such as passwords (setting stronglyBound to false)
• Do not use the ELS to store applications secrets such as DRM keys or licensing tokens.
• Provide a way for your application to recreate the data stored in the ELS if the ELS data is lost. For example, by 
prompting the user to re-enter their account credentials when necessary.
• Do not use the 
stronglyBound
parameter.
• If you do set 
stronglyBound
to 
true
, do not migrate stored items during an update. Recreate the data after the 
update instead. 
• Only store relatively small amounts of data. For larger amounts of data, use an AIR SQL database with encryption.
More Help topics 
flash.data.EncryptedLocalStore
Adding data to the encrypted local store
Use the 
setItem()
static method of the EncryptedLocalStore class to store data in the local store. The data is stored 
in a hash table, using strings as keys, with the data stored as byte arrays. 
For example, the following code stores a string in the encrypted local store:
var str = "Bob";  
var bytes = new air.ByteArray();  
bytes.writeUTFBytes(str);  
air.EncryptedLocalStore.setItem("firstName", bytes);
The third parameter of the 
setItem()
method, the 
stronglyBound
parameter, is optional. When this parameter is 
set to 
true
, the encrypted local store binds the stored item to the storing AIR application’s digital signature and bits:
var str = "Bob";  
var bytes = new air.ByteArray();  
bytes.writeUTFBytes(str);  
air.EncryptedLocalStore.setItem("firstName", bytes, false);
For an item that is stored with 
stronglyBound
set to 
true
, subsequent calls to 
getItem()
only succeed if the calling 
AIR application is identical to the storing application (if no data in files in the application directory have changed). If 
the calling AIR application is different from the storing application, the application throws an Error exception when 
you call 
getItem()
for a strongly bound item. If you update your application, it will not be able to read strongly bound 
data previously written to the encrypted local store. Setting 
stronglyBound
to 
true
on mobile devices is ignored; the 
parameter is always treated as 
false
.
XDoc.Word for .NET, Advanced .NET Word Processing Features
Viewing, editing, converting, processing, creating, annotating and zooming & rotation; Outlines, bookmarks, & thumbnail Create Word from PDF; Create Word from
creating bookmarks pdf files; create bookmarks in pdf
VB.NET PDF: Basic SDK Concept of XDoc.PDF
features can be integrated into your VB.NET project, such as annotation creating, deleting, modifying This class describes bookmarks in a PDF document.
excel print to pdf with bookmarks; pdf reader with bookmarks
258
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Encrypted local storage
Last updated 9/28/2011
If the 
stronglyBound
parameter is set to 
false
(the default), only the publisher ID needs to stay the same for the 
application to read the data. The bits of the application may change (and they need to be signed by the same publisher), 
but they do not need to be the exact same bits as were in application that stored the data. Updated applications with 
the same publisher ID as the original can continue to access the data.
Note: In practice, setting 
stronglyBound
to 
true
does not add any additional data protection. A “malicious” user could 
still alter an application to gain access to items stored in the ELS. Furthermore, data is protected from external, non-user 
threats just as strongly whether 
stronglyBound
is set to 
true
or 
false
. For these reasons, setting 
stronglyBound
to 
true
is discouraged.
Accessing data in the encrypted local store
Adobe AIR 1.0 and later
You can retrieve a value from the encrypted local store by using the 
EncryptedLocalStore.getItem()
method, as 
in the following example:
var storedValue = air.EncryptedLocalStore.getItem("firstName");  
air.trace(storedValue.readUTFBytes(storedValue.length)); // "foo"
Removing data from the encrypted local store
Adobe AIR 1.0 and later
You can delete a value from the encrypted local store by using the 
EncryptedLocalStore.removeItem()
method, 
as in the following example:
air.EncryptedLocalStore.removeItem("firstName");
You can clear all data from the encrypted local store by calling the 
EncryptedLocalStore.reset()
method, as in the 
following example:
air.EncryptedLocalStore.reset();
How to C#: Basic SDK Concept of XDoc.PDF for .NET
annotation features can be integrated into your C# project, such as annotation creating, deleting, modifying This class describes bookmarks in a PDF document
create bookmarks in pdf from excel; bookmark pdf in preview
How to C#: Basic SDK Concept of XDoc.Word
Conversely, conversion from PDF to Word (.docx) is C# project, such as annotation creating, deleting, modifying This class describes bookmarks in a Word document
excel hyperlink to pdf bookmark; copy bookmarks from one pdf to another
259
Last updated 9/28/2011
Chapter 16: Working with byte arrays
Flash Player 9 and later, Adobe AIR 1.0 and later
The ByteArray class allows you to read from and write to a binary stream of data, which is essentially an array of bytes. 
This class provides a way to access data at the most elemental level. Because computer data consists of bytes, or groups 
of 8 bits, the ability to read data in bytes means that you can access data for which classes and access methods do not 
exist. The ByteArray class allows you to parse any stream of data, from a bitmap to a stream of data traveling over the 
network, at the byte level. 
The 
writeObject()
method allows you to write an object in serialized Action Message Format (AMF) to a ByteArray, 
while the 
readObject()
method allows you to read a serialized object from a ByteArray to a variable of the original 
data type. You can serialize any object except for display objects, which are those objects that can be placed on the 
display list. You can also assign serialized objects back to custom class instances if the custom class is available to the 
runtime. After converting an object to AMF, you can efficiently transfer it over a network connection or save it to a file.
The sample Adobe® AIR® application described here reads a .zip file as an example of processing a byte stream, 
extracting a list of the files that the .zip file contains and writing them to the desktop.
More Help topics 
flash.utils.ByteArray
flash.utils.IExternalizable
Action Message Format specification
Reading and writing a ByteArray
Flash Player 9 and later, Adobe AIR 1.0 and later
The ByteArray class is part of the flash.utils package; you can also use the alias 
air.ByteArray
to refer to the 
ByteArray class if your code includes the AIRAliases.js file. To create a ByteArray, invoke the ByteArray constructor 
as shown in the following example:
var stream = new air.ByteArray();
ByteArray methods
Flash Player 9 and later, Adobe AIR 1.0 and later
Any meaningful data stream is organized into a format that you can analyze to find the information that you want. A 
record in a simple employee file, for example, would probably include an ID number, a name, an address, a phone 
number, and so on. An MP3 audio file contains an ID3 tag that identifies the title, author, album, publishing date, and 
genre of the file that’s being downloaded. The format allows you to know the order in which to expect the data on the 
data stream. It allows you to read the byte stream intelligently. 
How to C#: Basic SDK Concept of XDoc.PowerPoint
Conversely, conversion from PDF to PowerPoint (.PPTX C# project, such as annotation creating, deleting, modifying This class describes bookmarks in a PowerPoint
create pdf bookmarks from word; export pdf bookmarks to text
PDF Image Viewer| What is PDF
such as text extraction, hyperlinks, bookmarks and metadata as to develop specifications for creating, viewing, and convert word document without need for PDF.
create pdf with bookmarks from word; acrobat split pdf bookmark
260
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with byte arrays
Last updated 9/28/2011
The ByteArray class includes several methods that make it easier to read from and write to a data stream. Some of these 
methods include 
readBytes()
and 
writeBytes()
readInt()
and 
writeInt()
readFloat()
and 
writeFloat()
readObject()
and 
writeObject()
, and 
readUTFBytes()
and 
writeUTFBytes()
. These methods enable you to 
read data from the data stream into variables of specific data types and write from specific data types directly to the 
binary data stream.
For example, the following code reads a simple array of strings and floating-point numbers and writes each element 
to a ByteArray. The organization of the array allows the code to call the appropriate ByteArray methods 
(
writeUTFBytes()
and 
writeFloat()
) to write the data. The repeating data pattern makes it possible to read the 
array with a loop.
// The following example reads a simple Array (groceries), made up of strings  
// and floating-point numbers, and writes it to a ByteArray.  
// define the grocery list Array  
var groceries = ["milk", 4.50, "soup", 1.79, "eggs", 3.19, "bread" , 2.35]  
// define the ByteArray  
var bytes = new air.ByteArray();  
// for each item in the array  
for (i = 0; i < groceries.length; i++) {  
bytes.writeUTFBytes(groceries[i++]); //write the string and position to the next item  
bytes.writeFloat(groceries[i]);// write the float  
air.trace("bytes.position is: " + bytes.position); //display the position in ByteArray  
}  
air.trace("bytes length is: " +  bytes.length);// display the length
The position property
Flash Player 9 and later, Adobe AIR 1.0 and later
The position property stores the current position of the pointer that indexes the ByteArray during reading or writing. 
The initial value of the position property is 0 (zero) as shown in the following code: 
var bytes = new air.ByteArray();  
air.trace("bytes.position is initially: " + bytes.position); // 0
When you read from or write to a ByteArray, the method that you use updates the position property to point to the 
location immediately following the last byte that was read or written. For example, the following code writes a string 
to a ByteArray and afterward the position property points to the byte immediately following the string in the 
ByteArray:
var bytes = new air.ByteArray();  
air.trace("bytes.position is initially: " + bytes.position); // 0  
bytes.writeUTFBytes("Hello World!");  
air.trace("bytes.position is now: " + bytes.position);// 12
Likewise, a read operation increments the position property by the number of bytes read.
var bytes = new air.ByteArray();  
air.trace("bytes.position is initially: " + bytes.position); // 0  
bytes.writeUTFBytes("Hello World!");  
air.trace("bytes.position is now: " + bytes.position);// 12  
bytes.position = 0;  
air.trace("The first 6 bytes are: " + (bytes.readUTFBytes(6)));//Hello   
air.trace("And the next 6 bytes are: " + (bytes.readUTFBytes(6)));// World!
How to C#: Basic SDK Concept of XDoc.Excel
Conversely, conversion from PDF to Excel (.XLSX) is also C# project, such as annotation creating, deleting, modifying This class describes bookmarks in a Excel
how to create bookmarks in pdf file; creating bookmarks in pdf files
261
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with byte arrays
Last updated 9/28/2011
Notice that you can set the position property to a specific location in the ByteArray to read or write at that offset.
The bytesAvailable and length properties
Flash Player 9 and later, Adobe AIR 1.0 and later
The 
length
and 
bytesAvailable 
properties tell you how long a ByteArray is and how many bytes remain in it from 
the current position to the end. The following example illustrates how you can use these properties. The example writes 
a String of text to the ByteArray and then reads the ByteArray one byte at a time until it encounters either the character 
“a” or the end (
bytesAvailable <= 0
).
var bytes = new air.ByteArray();  
var text = "Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Vivamus etc.";  
bytes.writeUTFBytes(text); // write the text to the ByteArray  
air.trace("The length of the ByteArray is: " + bytes.length);// 70  
bytes.position = 0; // reset position  
while (bytes.bytesAvailable > 0 && (bytes.readUTFBytes(1) != 'a')) {  
//read to letter a or end of bytes  
}  
if (bytes.position < bytes.bytesAvailable) {  
air.trace("Found the letter a; position is: " + bytes.position); // 23  
air.trace("and the number of bytes available is: " + bytes.bytesAvailable);// 47  
}
The endian property
Flash Player 9 and later, Adobe AIR 1.0 and later
Computers can differ in how they store multibyte numbers, that is, numbers that require more than 1 byte of memory 
to store them. An integer, for example, can take 4 bytes, or 32 bits, of memory. Some computers store the most 
significant byte of the number first, in the lowest memory address, and others store the least significant byte first. This 
attribute of a computer, or of byte ordering, is referred to as being either big endian (most significant byte first) or little 
endian (least significant byte first). For example, the number 0x31323334 would be stored as follows for big endian and 
little endian byte ordering, where a0 represents the lowest memory address of the 4 bytes and a3 represents the highest:
The 
endian
property of the ByteArray class allows you to denote this byte order for multibyte numbers that you are 
processing. The acceptable values for this property are either 
"bigEndian"
or 
"littleEndian"
and the Endian class 
defines the constants 
BIG_ENDIAN
and 
LITTLE_ENDIAN
for setting the 
endian
property with these strings. 
Big 
Endian
Big 
Endian
Big 
Endian
Big 
Endian
a0
a1
a2
a3
31
32
33
34
Little 
Endian
Little 
Endian
Little 
Endian
Little 
Endian
a0
a1
a2
a3
34
33
32
31
262
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with byte arrays
Last updated 9/28/2011
The compress() and uncompress() methods
Flash Player 9 and later, Adobe AIR 1.0 and later
The 
compress()
method allows you to compress a ByteArray in accordance with a compression algorithm that you 
specify as a parameter. The 
uncompress()
method allows you to uncompress a compressed ByteArray in accordance 
with a compression algorithm. After calling 
compress()
and 
uncompress()
, the length of the byte array is set to the 
new length and the position property is set to the end. 
The CompressionAlgorithm class (AIR) defines constants that you can use to specify the compression algorithm. The 
ByteArray class supports both the deflate (AIR-only) and zlib algorithms. The deflate compression algorithm is used 
in several compression formats, such as zlib, gzip, and some zip implementations. The zlib compressed data format is 
described at http://www.ietf.org/rfc/rfc1950.txt and the deflate compression algorithm is described at 
http://www.ietf.org/rfc/rfc1951.txt.
The following example compresses a ByteArray called 
bytes
using the deflate algorithm:
bytes.compress(air.CompressionAlgorithm.DEFLATE);
The following example uncompresses a compressed ByteArray using the deflate algorithm:
bytes.uncompress(CompressionAlgorithm.DEFLATE);
Reading and writing objects
Flash Player 9 and later, Adobe AIR 1.0 and later
The 
readObject()
and 
writeObject()
methods read an object from and write an object to a ByteArray, encoded in 
serialized Action Message Format (AMF). AMF is a proprietary message protocol created by Adobe and used by 
various ActionScript 3.0 classes, including Netstream, NetConnection, NetStream, LocalConnection, and Shared 
Objects. 
A one-byte type marker describes the type of the encoded data that follows. AMF uses the following 13 data types:
value-type = undefined-marker | null-marker | false-marker | true-marker | integer-type |   
double-type | string-type | xml-doc-type | date-type | array-type | object-type |  
xml-type | byte-array-type
The encoded data follows the type marker unless the marker represents a single possible value, such as null or true or 
false, in which case nothing else is encoded. 
There are two versions of AMF: AMF0 and AMF3. AMF 0 supports sending complex objects by reference and allows 
endpoints to restore object relationships. AMF 3 improves AMF 0 by sending object traits and strings by reference, in 
addition to object references, and by supporting new data types that were introduced in ActionScript 3.0. The 
ByteArray.objectEcoding
property specifies the version of AMF that is used to encode the object data. The 
flash.net.ObjectEncoding class defines constants for specifying the AMF version: 
ObjectEncoding.AMF0
and 
ObjectEncoding.AMF3
The following example calls 
writeObject()
to write an XML object to a ByteArray, which it then writes to the 
order
file on the desktop. The example displays the message “Wrote order file to desktop!” in the AIR window when it is 
finished. 
263
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with byte arrays
Last updated 9/28/2011
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html 
xmlns="http://www.w3.org/1999/xhtml">  
<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">  
//define ByteArray  
var inBytes = new air.ByteArray();  
//add objectEncoding value and file heading to output text  
var output = "Object encoding is: " + inBytes.objectEncoding + "\n\n" + "order file: \n\n";  
function init() {  
readFile("order", inBytes);  
inBytes.position = 0;//reset position to beginning  
// read XML from ByteArray  
var orderXML = inBytes.readObject();  
// convert to XML Document object  
var myXML = (new DOMParser()).parseFromString(orderXML, "text/xml");  
document.write(myXML.getElementsByTagName("menuName")[0].childNodes[0].nodeValue + ": ");   
document.write(myXML.getElementsByTagName("price")[0].childNodes[0].nodeValue + 
"<br/>");      // burger: 3.95  
document.write(myXML.getElementsByTagName("menuName")[1].childNodes[0].nodeValue + ": 
");   
document.write(myXML.getElementsByTagName("price")[1].childNodes[0].nodeValue + 
"<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>
264
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with byte arrays
Last updated 9/28/2011
The 
readObject()
method reads an object in serialized AMF from a ByteArray and stores it in an object of the 
specified type. The following example reads the 
order
file from the desktop into a ByteArray (
inBytes
) and calls 
readObject()
to store it in 
orderXML
, which it then converts to an XML object document, 
myXML
, and displays the 
values of two item and price elements. The example also displays the value of the 
objectEncoding
property along with 
a header for the contents of the 
order
file.
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">  
<html xmlns="http://www.w3.org/1999/xhtml">  
<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">  
//define ByteArray  
var inBytes = new air.ByteArray();  
//add objectEncoding value and file heading to output text  
var output = "Object encoding is: " + inBytes.objectEncoding + "<br/><br/>" + "order file 
items:" + "<br/><br/>";  
function init() {  
readFile("order", inBytes);  
inBytes.position = 0;//reset position to beginning  
// read XML from ByteArray  
var orderXML = inBytes.readObject();  
// convert to XML Document object  
var myXML = (new DOMParser()).parseFromString(orderXML, "text/xml");  
document.write(output);  
document.write(myXML.getElementsByTagName("menuName")[0].childNodes[0].nodeValue + ": ");   
document.write(myXML.getElementsByTagName("price")[0].childNodes[0].nodeValue + 
"<br/>");      // burger: 3.95  
document.write(myXML.getElementsByTagName("menuName")[1].childNodes[0].nodeValue + ": 
");   
document.write(myXML.getElementsByTagName("price")[1].childNodes[0].nodeValue + 
Documents you may be interested
Documents you may be interested