open pdf and draw c# : Chrome pdf from link software SDK dll winforms windows web page web forms %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D71-part1605

• You can use the 
createObjectURL()
function to obtain a special 
blob://
URL that
refers to the content of a Blob, and then use this URL with the DOM or with CSS.
§22.6.4 demonstrates this.
• You can use a FileReader object to asynchronously (or synchronously, in a worker
thread) extract the content of a Blob into a string or ArrayBuffer. §22.6.5 demon-
strates the basic technique.
• You can use the Filesystem API and the FileWriter object described in §22.7 to
write a Blob into a local file.
The subsections below demonstrate simple ways to obtain and use Blobs. The more
complicated techniques involving the local filesystem and client-side databases are
covered later, in sections of their own.
22.6.1  Files As Blobs
The 
<input type="file">
element was originally intended to enable file uploads in
HTML forms. Browsers have always been careful to implement this element so that it
only allows the upload of files explicitly selected by the user. Scripts cannot set the
value
property of this element to a filename, so they cannot go uploading arbitrary files
from the user’s computer. More recently, browser vendors have extended this element
to allow client-side access to user-selected files. Note that allowing a client-side script
to read the contents of selected files is no more or less secure than allowing those files
to be uploaded to the server.
In browsers that support local  file access,  the 
files
property of an 
<input
type="file">
element will be a FileList object. This is an array-like object whose ele-
ments are zero or more user-selected File objects. A File object is a Blob that also has
name
and 
lastModifiedDate
properties:
<script>
// Log information about a list of selected files
function fileinfo(files) {
for(var i = 0; i < files.length; i++) { // files is an array-like object
var f = files[i];
console.log(f.name,                 // Name only: no path
f.size, f.type,         // size and type are Blob properties
f.lastModifiedDate);    // another File property
}
}
</script>
<!-- Allow selection of multiple image files and pass them to fileinfo()-->
<input type="file" accept="image/*" multiple onchange="fileinfo(this.files)"/>
Being able to display the names, types, and sizes of selected files isn’t terribly interesting.
In §22.6.4 and §22.6.5, we’ll see how you can actually make use of the content of
the file.
In addition to selecting files with an 
<input>
element, a user can also give a script access
to local files by dropping them into the browser. When an application receives a drop
22.6  Blobs | 693
Client-Side
JavaScript
Chrome pdf from link - insert, remove PDF links in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Free C# example code is offered for users to edit PDF document hyperlink (url), like inserting and deleting
chrome pdf from link; add hyperlinks pdf file
Chrome pdf from link - VB.NET PDF url edit library: insert, remove PDF links in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Help to Insert a Hyperlink to Specified PDF Document Page
convert a word document to pdf with hyperlinks; add links in pdf
event, the 
dataTransfer.files
property of the event object will be the FileList associated
with the drop, if there was one. The drag-and-drop API was covered in §17.7 and
Example 22-10 below demonstrates its use with files.
22.6.2  Downloading Blobs
Chapter 18 covered scripted HTTP with the XMLHttpRequest object and also docu-
mented some of the new features of the XMLHttpRequest Level 2 (XHR2) draft spec-
ification. At the time of this writing, XHR2 defines a way to download the contents of
a URL as a Blob, but browser implementations do not yet support it. Because the code
cannot yet be tested, this section is only a simple sketch of the XHR2 API for working
with Blobs.
Example 22-9 shows the basic technique for downloading a Blob from the Web. Con-
trast this example with Example 18-2, which downloads the contents of a URL as plain
text:
Example 22-9. Downloading a Blob with XMLHttpRequest
// GET the contents of the url as a Blob and pass it to the specified callback.
// This code is untested: no browsers supported this API when it was written.
function getBlob(url, callback) {
var xhr = new XMLHttpRequest();  // Create new XHR object
xhr.open("GET", url);            // Specify URL to fetch
xhr.responseType = "blob"        // We'd like a Blob, please
xhr.onload = function() {        // onload is easier than onreadystatechange
callback(xhr.response);      // Pass the blob to our callback
}                                // Note .response, not .responseText
xhr.send(null);                  // Send the request now
}
If the Blob you’re downloading is quite large and you want to start processing it while
it is downloading, you can use an 
onprogress
event handler, along with the Blob reading
techniques demonstrated in §22.6.5.
22.6.3  Building Blobs
Blobs often represent chunks of data from an external source such as a local file, a URL,
or a database. But sometimes a web application wants to create its own Blobs to be
uploaded to the Web or stored in a file or database or passed to another thread. To
create a Blob from your own data, use a BlobBuilder:
// Create a new BlobBuilder
var bb = new BlobBuilder();
// Append a string to the blob, and mark the end of the string with a NUL char
bb.append("This blob contains this text and 10 big-endian 32-bit signed ints.");
bb.append("\0");  // NUL-terminate the string to mark its end
// Store some data into an ArrayBuffer
var ab = new ArrayBuffer(4*10);
var dv = new DataView(ab);
for(var i = 0; i < 10; i++) dv.setInt32(i*4,i);
// Append the ArrayBuffer to the Blob
694 | Chapter 22: HTML5 APIs
C# Image: How to Integrate Web Document and Image Viewer
modern browsers, such as IE, Chrome, Firefox, and RasterEdge DocImage SDK for .NET link directly. RasterEdgeImagingDeveloperGuide8.0.pdf: from this user manual
adding hyperlinks to pdf files; pdf link to attached file
VB.NET PDF: Create PDF Document Viewer in C#.NET for Document
supports multiple common browsers, such as IE, Chrome, Firefox, Safari information on them, just click the link and go VB.NET PDF Web Viewer, VB.NET PDF Windows
accessible links in pdf; clickable pdf links
bb.append(ab);
// Now get the blob from the builder, specifying a made-up MIME type
var blob = bb.getBlob("x-optional/mime-type-here");
We saw at the beginning of this section that Blobs have a 
slice()
method that breaks
them into pieces. You can join Blobs together by passing Blobs to the 
append()
method
of a BlobBuilder.
22.6.4  Blob URLs
The preceding sections have shown how you can obtain or create Blobs. We’ll now
shift gears and start talking about what you can actually do with the Blobs you obtain
or create. One of the simplest things you can do with a Blob is create a URL that refers
to the Blob. You can then use this URL anywhere you’d use a regular URL: in the DOM,
in a stylesheet, or even as the target of an XMLHttpRequest.
Create a Blob URL with the function 
createObjectURL()
. At the time of this writing,
the draft specification and Firefox 4 put this function in a global object named 
URL
, and
Chrome and Webkit prefix that new global, calling it 
webkitURL
. Earlier versions of the
specification (and earlier browser implementations) put the function directly on the
Window object. To create Blob URLs portably across browsers, you can define a utility
like this:
var getBlobURL = (window.URL && URL.createObjectURL.bind(URL)) ||
(window.webkitURL && webkitURL.createObjectURL.bind(webkitURL)) ||
window.createObjectURL;
Web workers are also allowed to use this API and have access to these same functions,
in the same 
URL
(or 
webkitURL
) object.
Pass a blob to 
createObjectURL()
and it returns a URL (as an ordinary string). The URL
will begin with 
blob://
, and that URL scheme will be followed by a short string of text
that identifies the Blob with some kind of opaque unique identifier. Note that this is
very different than a 
data://
URL, which encodes its own contents. A Blob URL is
simply a reference to a Blob that is stored by the browser in memory or on the disk.
blob://
URLs are also quite different from 
file://
URLs, which refer directly to a file
in the local filesystem, exposing the path of the file, allowing directory browsing, and
otherwise raising security issues.
Example 22-10 demonstrates two important techniques. First, it implements a “drop
target” that listens for drag-and-drop events involving files. Then, when the user drops
one or more files on the drop target, it uses 
createObjectURL()
to obtain a URL for each
one and then creates 
<img>
elements to display thumbnails of the images referenced by
those URLs.
Example 22-10. Displaying dropped image files with Blob URLs
<!DOCTYPE html>
<html><head>
<script>
22.6  Blobs | 695
Client-Side
JavaScript
VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
Major browser supported, include chrome, firefox, ie, edge, safari, etc. Embed converted html files in html page or iframe. Export PDF form data to html form in
add page number to pdf hyperlink; convert doc to pdf with hyperlinks
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
Use JS (jquery) to control PDF page navigation. Cross browser supported, like chrome, firefox, ie, edge, safari. Embed zoom setting (fit page, fit width).
adding links to pdf document; pdf link to email
// At the time of this writing, Firefox and Webkit disagree on the
// name of the createObjectURL() function
var getBlobURL = (window.URL && URL.createObjectURL.bind(URL)) ||
(window.webkitURL && webkitURL.createObjectURL.bind(webkitURL)) ||
window.createObjectURL;
var revokeBlobURL = (window.URL && URL.revokeObjectURL.bind(URL)) ||
(window.webkitURL && webkitURL.revokeObjectURL.bind(webkitURL)) ||
window.revokeObjectURL;
// When the document is loaded, add event handlers to the droptarget element
// so that it can handle drops of files
window.onload = function() {
// Find the element we want to add handlers to.
var droptarget = document.getElementById("droptarget");
// When the user starts dragging files over the droptarget, highlight it.
droptarget.ondragenter = function(e) {
// If the drag is something other than files, ignore it.
// The HTML5 dropzone attribute will simplify this when implemented.
var types = e.dataTransfer.types;
if (!types ||
(types.contains && types.contains("Files")) ||
(types.indexOf && types.indexOf("Files") != -1)) {
droptarget.classList.add("active"); // Highlight droptarget
return false;                       // We're interested in the drag
}
};
// Unhighlight the drop zone if the user moves out of it
droptarget.ondragleave = function() {
droptarget.classList.remove("active");
};
// This handler just tells the browser to keep sending notifications
droptarget.ondragover = function(e) { return false; };
// When the user drops files on us, get their URLs and display thumbnails.
droptarget.ondrop = function(e) {
var files = e.dataTransfer.files;            // The dropped files
for(var i = 0; i < files.length; i++) {      // Loop through them all
var type = files[i].type;
if (type.substring(0,6) !== "image/")    // Skip any nonimages
continue;
var img = document.createElement("img"); // Create an <img> element
img.src = getBlobURL(files[i]);          // Use Blob URL with <img>
img.onload = function() {                // When it loads
this.width = 100;                    // adjust its size and
document.body.appendChild(this);     // insert into document.
revokeBlobURL(this.src);             // But don't leak memory!
}
}
droptarget.classList.remove("active");       // Unhighlight droptarget
return false;                                // We've handled the drop
}
};
</script>
696 | Chapter 22: HTML5 APIs
C# HTML5 PDF Viewer SDK to view, annotate, create and convert PDF
various ASP.NET platforms. Support to view PDF document online in browser such as firefox, chrome, safari and so on. Support ASP.NET MVC
add hyperlink pdf file; pdf link open in new window
C# PDF Markup Drawing Library: add, delete, edit PDF markups in C#
A web based markup tool able to annotate PDF in browser such as chrome, firefox and safari in ASP.NET WebForm application. Support
add a link to a pdf file; add link to pdf acrobat
<style> /* Simple styles for the file drop target */
#droptarget { border: solid black 2px; width: 200px; height: 200px; }
#droptarget.active { border: solid red 4px; }
</style>
</head>
<body> <!-- The document starts off with just the file drop target -->
<div id="droptarget">Drop Image Files Here</div>
</body>
</html>
Blob URLs have the same origin (§13.6.2) as the script that creates them. This makes
them much more versatile than 
file://
URLs, which have a distinct origin and are
therefore difficult to use within a web application. A Blob URL is only valid in docu-
ments of the same origin. If, for example, you passed a Blob URL via 
postMessage()
to
a window with a different origin, the URL would be meaningless to that window.
Blob URLs are not permanent. A Blob URL is no longer valid once the user has closed
or navigated away from the document whose script created the URL. It is not possible,
for example, to save a Blob URL to local storage and then reuse it when the user begins
a new session with a web application.
It is also possible to manually “revoke” the validity of a Blob URL by calling
URL.revokeObjectURL()
(or 
webkitURL.revokeObjectURL()
) and you may have noticed
that Example 22-10 does this. This is a memory management issue. Once the thumbnail
image has been displayed, the Blob is no longer needed and it should be allowed to be
garbage collected. But if the web browser is maintaining a mapping from the Blob URL
we’ve created to the Blob, that Blob cannot be garbage collected even if we’re not using
it. The JavaScript interpreter cannot track the usage of strings, and if the URL is still
valid, it has to assume that it might still be used. This means that it cannot garbage
collect the Blob until the URL has been revoked. Example 22-10 uses local files that
don’t require any cleanup, but you can imagine a more serious memory management
issue if the Blob in question were one that had been built in memory with a BlobBuilder
or one that had been downloaded with XMLHttpRequest and stored in a temporary file.
The 
blob://
URL scheme is explicitly designed to work like a simplified 
http://
URL,
and browsers are required to act like mini HTTP servers when 
blob://
URLs are re-
quested. If a Blob URL that is no longer valid is requested, the browser must send a
404 Not Found status code. If a Blob URL from a different origin is requested, the
browser must respond with 403 Not Allowed. Blob URLs only work with GET requests,
and when one is successfully requested, the browser sends an HTTP 200 OK status
code and also sends a 
Content-Type
header that uses the 
type
property of the Blob.
Because Blob URLs work like simple HTTP URLs, you can “download” their content
with XMLHttpRequest. (As we’ll see in the next section, however, you can read the
content of a Blob more directly using a FileReader object.)
22.6  Blobs | 697
Client-Side
JavaScript
C# PDF Text Highlight Library: add, delete, update PDF text
An ASP.NET web-server compliant library able to highlight text in PDF file online in browser such as chrome, firefox, safari, etc.
add links to pdf document; add hyperlink pdf
VB.NET Word: Create VB.NET Word Document Viewer in Web, Windows
in one of above mentioned VB.NET Word document viewers, please follow the link to see If needed, you can try VB.NET PDF document file viewer SDK, and VB.NET
change link in pdf file; adding hyperlinks to pdf documents
22.6.5  Reading Blobs
So far, Blobs have been opaque chunks of data that allow only indirect access, through
Blob URLs, to their contents. The FileReader object allows us read access to the
characters or bytes contained in a Blob, and you can think of it as the opposite of a
BlobBuilder. (A better name would be BlobReader, since it works with any Blob, not
just Files.) Since Blobs can be very large objects stored in the filesystem, the API for
reading them is asynchronous, much like the XMLHttpRequest API. A synchronous
version of the API, FileReaderSync, is available in worker threads, although workers
can also use the asynchronous version.
To use a FileReader, first create an instance with the 
FileReader()
constructor. Next,
define event handlers. Typically you’ll define handlers for load and error events and
possibly also for progress events. You can do this with 
onload
onerror
, and
onprogress
or with the standard 
addEventListener()
method. FileReader objects also
trigger loadstart, loadend, and abort events, which are like the XMLHttpRequest events
with the same names: see §18.1.4.
Once you’ve created a FileReader and registered suitable event handlers, you must pass
the Blob you want to read to one of four methods: 
readAsText()
readAsArray
Buffer()
readAsDataURL()
, and 
readAsBinaryString()
. (You can, of course, call one of
these methods first and then register event handlers—the single-threaded nature of
JavaScript, described in §22.4, means that event handlers will never be called until your
function has returned and the browser is back in its event loop.) The first two methods
are the most important and are the ones covered here. Each of these read methods takes
a Blob as its first argument. 
readAsText()
takes an optional second argument that
specifies the name of a text encoding. If you omit the encoding, it will automatically
work with ASCII and UTF-8 text (and also UTF-16 text with a byte-order mark
or BOM).
As the FileReader reads the Blob you’ve specified, it updates its 
readyState
property.
The value starts off at 0, indicating that nothing has been read. It changes to 1 when
some data is available, and changes to 2 when the read has completed. The 
result
property holds a partial or complete result as a string or ArrayBuffer. You do not nor-
mally poll the 
state
and 
result
properties, but instead use them from your
onprogress
or 
onload
event handler.
Example 22-11 demonstrates how to use the 
readAsText()
method to read local text
files that the user selects.
Example 22-11. Reading text files with FileReader
<script>
// Read the specified text file and display it in the <pre> element below
function readfile(f) {
var reader = new FileReader();  // Create a FileReader object
reader.readAsText(f);           // Read the file
reader.onload = function() {    // Define an event handler
var text = reader.result;   // This is the file contents
698 | Chapter 22: HTML5 APIs
C# TIFF: C#.NET Code to Create Online TIFF Document Viewer
modern browsers, including IE, Chrome, Firefox, Safari more web viewers on PDF and Word <link href="RasterEdge_Imaging_Files/RasterEdge.css" rel="stylesheet"type
add links pdf document; add hyperlink to pdf acrobat
C# Word: How to Create Word Online Viewer in C# Application
including IE (Internet Explorer), Chrome, Firefox, Safari you can go to PDF Web Viewer <link href="RasterEdge_Imaging_Files/RasterEdge.css" rel="stylesheet"type
add hyperlink pdf; add hyperlink in pdf
var out = document.getElementById("output");    // Find output element
out.innerHTML = "";                             // Clear it
out.appendChild(document.createTextNode(text)); // Display file contents
}
reader.onerror = function(e) {  // If anything goes wrong
console.log("Error", e);    // Just log it
};
}
</script>
Select the file to display:
<input type="file" onchange="readfile(this.files[0])"></input>
<pre id="output"></pre>
The 
readAsArrayBuffer()
method is similar to 
readAsText()
, except that it generally
takes a little more effort to make use of an ArrayBuffer result than a string result.
Example 22-12 is an example that uses 
readAsArrayBuffer()
to read the first four bytes
of a file as a big-endian integer.
Example 22-12. Reading the first four bytes of a file
<script>
// Examine the first 4 bytes of the specified blob. If this "magic number"
// identifies the type of the file, asynchronously set a property on the Blob.
function typefile(file) {
var slice = file.slice(0,4);       // Only read the start of the file
var reader = new FileReader();     // Create an asynchronous FileReader
reader.readAsArrayBuffer(slice);   // Read the slice of the file
reader.onload = function(e) {
var buffer = reader.result;           // The result ArrayBuffer
var view = new DataView(buffer);      // Get access to the result bytes
var magic = view.getUint32(0, false); // Read 4 bytes, big-endian 
switch(magic) {                       // Determine file type from them
case 0x89504E47: file.verified_type = "image/png"; break;
case 0x47494638: file.verified_type = "image/gif"; break;
case 0x25504446: file.verified_type = "application/pdf"; break;
case 0x504b0304: file.verified_type = "application/zip"; break;
}
console.log(file.name, file.verified_type);
};
}
</script>
<input type="file" onchange="typefile(this.files[0])"></input>
In worker threads, you can use FileReaderSync instead of FileReader. The synchronous
API defines the same 
readAsText()
and 
readAsArrayBuffer()
methods that take the
same arguments as the asynchronous methods. The difference is that the synchronous
methods block until the operation is complete and return the resulting string or
ArrayBuffer directly, with no need for event handlers. Example 22-14 below uses
FileReaderSync.
22.6  Blobs | 699
Client-Side
JavaScript
22.7  The Filesystem API
In §22.6.5, you saw the FileReader class used to read the content of user-selected files,
or of any Blob. The File and Blob types are defined by a draft specification known as
the File API. Another draft specification, even newer than the File API, gives web ap-
plications controlled access to a private local filesystem “sandbox” in which they can
write files, read files, create directories, list directories, and so on. At the time of this
writing, this Filesystem API is implemented only by Google’s Chrome browser, but it
is a powerful and important form of local storage, so it is covered here, even though
the API is even less stable than most of the other APIs described in this chapter. This
section covers basic filesystem tasks but does not demonstrate all features of the API.
Because the API is new and unstable, it is not documented in the reference section of
this book.
Working with files in the local filesystem is a multistep process. First, you must obtain
an object that represents the filesystem itself. There is a synchronous API for doing this
in worker threads and an asynchronous API for use on the main thread:
// Obtaining a filesystem synchronously.  Pass filesystem lifetime and size.
// Returns a filesystem object or raises an exception.
var fs = requestFileSystemSync(PERSISTENT, 1024*1024);
// The asynchronous version uses callback functions for success and error
requestFileSystem(TEMPORARY,       // lifetime
50*1024*1024,    // size: 50Mb
function(fs) {   // called with the filesystem object
// Use fs here 
}
function(e) {    // called with an error object onerror
console.log(e);  // Or handle it some other way
});
In both the synchronous and asynchronous versions of the API, you specify the lifetime
and the size of the filesystem you want. A 
PERSISTENT
filesystem is suitable for web apps
that want to store user data permanently. The browser won’t delete it except at the
user’s explicit request. A 
TEMPORARY
filesystem is appropriate for web apps that want to
cache data but can still operate if the web browser deletes the filesystem. The size of
the filesystem is specified in bytes and should be a reasonable upper bound on the
amount of data you need to store. A browser may enforce this as a quota.
The filesystem obtained with these functions depends on the origin of the containing
document. All documents or web apps from the same origin (host, port, and protocol)
share a filesystem. Two documents or applications from different origins have com-
pletely distinct and disjoint filesystems. The filesystem is also walled off from the rest
of the files on the user’s hard drive: there is no way for a web application to “break out”
beyond the local root directory or otherwise access arbitrary files.
Note that these functions have “request” in their names. The first time you call one,
the browser may ask the user for permission before creating a filesystem and granting
700 | Chapter 22: HTML5 APIs
access.
2
Once permission has been granted, subsequent calls to the request method
should simply return an object that represents the already existing local filesystem.
The filesystem object you obtain with one of the methods above has a 
root
property
that refers to the root directory of the filesystem. This is a DirectoryEntry object, and
it may have nested directories that are themselves represented by DirectoryEntry
objects. Each directory in the file system may contain files, represented by FileEntry
objects. The DirectoryEntry object defines methods for obtaining DirectoryEntry and
FileEntry objects by pathname (they will optionally create new directories or files if you
specify a name that doesn’t exist). DirectoryEntry also defines a 
createReader()
factory
method that returns a DirectoryReader for listing the contents of a directory.
The FileEntry class defines a method for obtaining the File object (a Blob) that repre-
sents the contents of a file. You can then use a FileReader object (as shown in
§22.6.5) to read the file. FileEntry defines another method to return a FileWriter object
that you can use to write content into a file.
Reading or writing a file with this API is a multistep process. First you obtain the file-
system object. Then you use the root directory of that object to look up (and optionally
create) the FileEntry object for the file you’re interested in. Then you use the FileEntry
object to obtain the File or FileWriter object for reading or writing. This multistep
process is particularly complex when using the asynchronous API:
// Read the text file "hello.txt" and log its contents.
// The asynchronous API nests functions four deep.
// This example doesn't include any error callbacks.
requestFileSystem(PERSISTENT, 10*1024*1024, function(fs) { // Get filesystem
fs.root.getFile("hello.txt", {}, function(entry) {     // Get FileEntry
entry.file(function(file) {                        // Get File
var reader = new FileReader();
reader.readAsText(file);                      
reader.onload = function() {                   // Get file content
console.log(reader.result);
};
});
});
});
Example 22-13 is a more fully fleshed-out example. It demonstrates how to use the
asynchronous API to read files, write files, delete files, create directories, and list
directories.
Example 22-13. Using the asynchronous filesystem API
/*
* These functions have been tested in Google Chrome 10.0 dev.
* You may need to launch Chrome with these options:
* --unlimited-quota-for-files       : enables filesystem access
* --allow-file-access-from-files    : allows testing from file:// URLs
2.At the time of this writing, Chrome doesn’t ask for permission, but it requires you to launch it with the
--unlimited-quota-for-files
command-line flag.
22.7  The Filesystem API | 701
Client-Side
JavaScript
*/
// Lots of the asynchronous functions we use accept an optional error callback.
// This one just logs the error.
function logerr(e) { console.log(e); }
// requestFileSystem() gets us a sandboxed local filesystem accessible only
// to apps from this origin. We can read and write files at will, but
// can't get out of the sandbox to access the rest of the system.
var filesystem; // Assume this is initialized before the funcs below are called.
requestFileSystem(PERSISTENT,             // Or TEMPORARY for cache files
10*1024*1024,           // We'd like 10 megabytes, please
function(fs) {          // When done, call this function
filesystem = fs;    // Just save the filesystem into
},                      // a global variable.
logerr);                // Call this if an error occurs
// Read the contents of the specified file as text and pass them to callback.
function readTextFile(path, callback) {
// Call getFile() to find the FileEntry for the specified filename
filesystem.root.getFile(path, {}, function(entry) {
// This function is called with the FileEntry for the file
// Now we call the FileEntry.file() method to get the File object
entry.file(function(file) {          // Call this with the File
var reader = new FileReader();   // Create a FileReader
reader.readAsText(file);         // And read the file
reader.onload = function() {     // When read successful
callback(reader.result);     // Pass it to the callback
reader.onerror = logerr;         // Log readAsText() errors
}, logerr);                          // Log file() errors
}, 
logerr);                                 // Log getFile() errors
}
// Append the specified contents to the file at the specified path, creating
// a new file if no file by that name already exists.  Call callback when done.
function appendToFile(path, contents, callback) {
// filesystem.root is the root directory.
filesystem.root.getFile( // Get a FileEntry object 
path,                // The name and path of the file we want
{create:true},       // Create it if it doesn't already exist
function(entry) {    // Call this when it has been found
entry.createWriter(     // Create a FileWriter object for the file
function(writer) {  // Call this function when created
// By default a writer starts at the beginning of the file.
// We want to start writing at the end of the file
writer.seek(writer.length);  // Move to end of file
// Convert file contents to a Blob. The contents argument
// can be a string or a Blob or an ArrayBuffer.
var bb = new BlobBuilder()
bb.append(contents);
var blob = bb.getBlob();
702 | Chapter 22: HTML5 APIs
Documents you may be interested
Documents you may be interested