open pdf and draw c# : Add links pdf document SDK application API .net windows asp.net sharepoint %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D60-part1593

It is almost trivially easy to write your own jQuery extensions. The trick is to know that
jQuery.fn
is the prototype object for all jQuery objects. If you add a function to this
object, that function becomes a jQuery method. Here is an example:
jQuery.fn.println = function() {
// Join all the arguments into a space-separated string
var msg = Array.prototype.join.call(arguments, " ");
// Loop through each element in the jQuery object
this.each(function() {
// For each one, append the string as plain text, then append a <br/>.
jQuery(this).append(document.createTextNode(msg)).append("<br/>");
});
// Return the unmodified jQuery object for method chaining
return this;
};
With that 
jQuery.fn.println
function defined, we can now invoke a 
println()
method
on any jQuery object like this:
$("#debug").println("x = ", x, "; y = ", y);
It is common practice to add new methods to 
jQuery.fn
. If you find yourself using the
each()
method to “manually” iterate through the elements in a jQuery object and per-
form some kind of operation on them, ask yourself whether it might make sense to re-
factor your code so that the 
each()
invocation is moved into an extension method. If
you follow basic modular coding practices when writing your extension and abide by
a few jQuery-specific conventions, you can call your extension a plug-in and share it
with others. These are the jQuery plug-in conventions to be aware of:
• Don’t  rely  on  the 
$
identifier:  the  including  page  may  have  called
jQuery.noConflict()
and 
$()
may no longer be a synonym for the 
jQuery()
func-
tion. In short plug-ins like the one shown above, you can just use 
jQuery
instead
of 
$
. If you are writing a longer extension, you are likely to wrap it all within one
anonymous function to avoid the creation of global variables. If you do so, you can
use the idiom of passing the jQuery as an argument to your anonymous function,
and receiving that value in a parameter named 
$
:
(function($) {  // An anonymous function with one parameter named $
// Put your plugin code here
}(jQuery));     // Invoke the function with the jQuery object as its argument
• If your extension method does not return a value of its own, be sure to return a
jQuery object that can be used in a method chain. Usually this will just be the
this
object and you can return it unmodified. In the example above, the method
ended with the line 
return this;
. The method could have been made slightly
shorter (and less readable) following another jQuery idiom: returning the result of
the 
each()
method. Then the 
println()
method would have included the code
return this.each(function() {...});
• If your extension method has more than a couple of parameters or configuration
options, allow the user to pass options in the form of an object (as we saw with the
animate()
method in §19.5.2 and the 
jQuery.ajax()
function in §19.6.3).
19.9  Extending jQuery with Plug-ins | 583
Client-Side
JavaScript
Add links pdf document - 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
adding hyperlinks to pdf documents; change link in pdf file
Add links pdf document - 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
pdf links; convert excel to pdf with hyperlinks
• Don’t pollute the jQuery method namespace. Well-behaved jQuery plug-ins define
the smallest number of methods consistent with a usable API. It is common for
jQuery plug-ins to define only a single method in 
jQuery.fn
. This one method takes
a string as its first argument and interprets that string as the name of a function to
pass its remaining arguments to. When you are able to limit your plug-in to a single
method, the name of that method should be the same as the name of the plug-in.
If you must define more than one method, use the plug-in name as a prefix for each
of your method names.
• If your plug-in binds event handlers, put all of those handlers in an event namespace
(§19.4.4). Use your plug-in name as the namespace name.
• If your plug-in uses the 
data()
method to associate data with elements, place all of
your data values in a single object, and store that object as a single value, giving it
the same name as your plug-in.
• Save your plug-in code in a file with a name of the form “jquery.plugin.js”, replacing
“plugin” with the name of your plug-in.
A plug-in can add new utility functions to jQuery by adding them to the jQuery object
itself. For example:
// This method prints its arguments (using the println() plugin method)
// to the element with id "debug". If no such element exists, it is created
// and added to the document.
jQuery.debug = function() {
var elt = jQuery("#debug");         // Find the #debug element
if (elt.length == 0) {              // Create it if it doesn't exist
elt = jQuery("<div id='debug'><h1>Debugging Output</h1></div>");
jQuery(document.body).append(elt);
}
elt.println.apply(elt, arguments);  // Output the arguments to it
};
In addition to defining new methods, it is also possible to extend other parts of the
jQuery library. In §19.5, for example, we saw that it is possible to add new effect
duration names (in addition to “fast” and “slow”) by adding properties to
jQuery.fx.speeds
and that it is possible to add new easing functions by adding them
to 
jQuery.easing
. Plug-ins can even extend the jQuery CSS selector engine! You can
add new pseudoclass filters (like 
:first
and 
:input
) by adding properties to the
jQuery.expr[':']
object. Here is an example that defines a new 
:draggable
filter that
returns only elements that have a 
draggable=true
attribute:
jQuery.expr[':'].draggable = function(e) {  return e.draggable === true; };
With this selector defined, we can select draggable images with 
$("img:draggable")
instead of the more verbose 
$("img[draggable=true]")
.
As you can see from the code above, a custom selector function is passed a candidate
DOM element as its first argument. It should return 
true
if the element matches the
selector and 
false
otherwise. Many custom selectors need only the one element argu-
ment, but they are actually invoked with four arguments. The second argument is an
584 | Chapter 19: The jQuery Library
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
converter toolkit SDK, preserves all the original anchors, links, bookmarks and Use C#.NET Demo Code to Convert PDF Document to HTML5 Add necessary references:
clickable links in pdf files; c# read pdf from url
.NET PDF Document Viewing, Annotation, Conversion & Processing
edit, delete links. Form Process. Fill in form data programmatically. Read form data from PDF form file. Add, Update, Delete form fields programmatically. Document
add link to pdf file; add hyperlink in pdf
integer index that gives the position of this element within an array of candidate ele-
ments. That array is passed as the fourth argument and your selector must not modify
it. The third argument is an interesting one: it is the array result of a call to the
RegExp.exec()
method. The fourth element of this array (at index 3) is the value, if any,
within parentheses after the pseudoclass filter. The parentheses and any quotes inside
are stripped, leaving only the argument string. Here, for example, is how you could
implement a 
:data(x)
pseudoclass that returns 
true
only for arguments that have a
data-x
attribute (see §15.4.3):
jQuery.expr[':'].data = function(element, index, match, array) {
// Note: IE7 and before do not implement hasAttribute()
return element.hasAttribute("data-" + match[3]);
};
19.10  The jQuery UI Library
jQuery limits itself to providing core DOM, CSS, event handling, and Ajax function-
ality. These provide an excellent foundation for building higher-level abstractions, such
as user interface widgets, and the jQuery UI library does just that. Full coverage of
jQuery UI is beyond the scope of this book, and all we can do here is offer a simple
overview. You can find the library and its documentation at http://jqueryui.com.
As its name implies, jQuery UI defines a number of user interface widgets: autocom-
pletion input fields, date pickers for entering dates, accordions and tabs for organizing
information, sliders and progress bars for visually displaying numbers, and modal di-
alogs for urgent communication with the user. In addition to these widgets, jQuery UI
implements more general “interactions”, which allow any document element to be
easily made draggable, droppable, resizable, selectable, or sortable. Finally, jQuery UI
adds a number of new visual effects methods (including the ability to animate colors)
to those offered by jQuery itself, and it defines lots of new easing functions as well.
Think of jQuery UI as a bunch of related jQuery plug-ins packed into a single JavaScript
file. To use it, simply include the jQuery UI script in your web page after including the
jQuery code. The Download page at http://jqueryui.com allows you to select the com-
ponents you plan to use and will build a custom download bundle for you that may
reduce your page load times compared to the full jQuery UI library.
jQuery UI is fully themeable, and its themes take the form of CSS files. So in addition
to loading the jQuery UI JavaScript code into your web pages, you’ll have to include
the CSS file for your selected theme as well. The jQuery UI website features a number
of prebuilt themes and also a “ThemeRoller” page that allows you to customize and
download your own theme.
jQuery UI widgets and interactions are structured as jQuery plug-ins, and each defines
a single jQuery method. Typically, when you call this method on an existing document
element, it transforms that element into the widget. For example, to alter a text input
19.10  The jQuery UI Library | 585
Client-Side
JavaScript
VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
Turn PDF images to HTML images in VB.NET. Embed PDF hyperlinks to HTML links in VB.NET. Convert PDF to HTML in VB.NET Demo Code. Add necessary references:
add url link to pdf; accessible links in pdf
How to C#: Basic SDK Concept of XDoc.PDF for .NET
You may add PDF document protection functionality into your C# program. to edit hyperlink of PDF document, including editing PDF url links and quick
add links to pdf in preview; clickable pdf links
field so that it pops up a date picker widget when clicked or focused, simply call the
datepicker()
method with code like this:
// Make <input> elements with class="date" into date picker widgets
$("input.date").datepicker();
In order to make full use of a jQuery UI widget, you must be familiar with three things:
its configuration options, its methods, and its events. All jQuery UI widgets are con-
figurable, and some have many configuration options. You can customize the behavior
and appearance of your widgets by passing an options object (like the animations op-
tions object passed to 
animate()
) to the widget method.
jQuery UI widgets usually define at least a handful of “methods” for interacting with
the widget. In order to avoid a proliferation of jQuery methods, however, jQuery UI
widgets do not define their “methods” as true methods. Each widget has only a single
method (like the 
datepicker()
method in the example above). When you want to call
a “method” of the widget, you pass the name of the desired “method” to the single true
method defined by the widget. To disable a date picker widget, for example, you don’t
call a 
disableDatepicker()
method; instead, you call 
datepicker("disable")
.
jQuery UI widgets generally define custom events that they trigger in response to user
interaction. You can bind event handlers for these custom events with the normal
bind()
method, and you can also usually specify event handler functions as properties
in the options object you pass to the widget method. The first argument to these handler
methods is an Event object as usual. Some widgets pass a second “UI” object as the
second argument to the event handler. This object typically provides state information
about the widget.
Note that the jQuery UI documentation sometimes describes “events” that are not truly
custom events and could better be described as callback functions set through the con-
figuration options object. The date picker widget, for example, supports a number of
callback functions that it can call at various times. None of these functions have the
standard event handler signature, however, and you cannot register handlers for these
“events” with 
bind()
. Instead, you specify appropriate callbacks when you configure
the widget in your initial call to the 
datepicker()
method.
586 | Chapter 19: The jQuery Library
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
the original text style (including font, size, color, links and boldness). C#.NET DLLs and Demo Code: Convert PDF to Word Document in C# Add necessary references
add hyperlink to pdf acrobat; add links pdf document
C# Create PDF Library SDK to convert PDF from other file formats
PDF with a blank page, bookmarks, links, signatures, etc. a PDF document in C#.NET using this PDF document creating toolkit, if you need to add some text
add links to pdf; convert a word document to pdf with hyperlinks
CHAPTER 20
Client-Side Storage
Web applications can use browser APIs to store data locally on the user’s computer.
This client-side storage serves to give the web browser a memory. Web apps can store
user preferences, for example, or even store their complete state, so that they can resume
exactly where you left off at the end of your last visit. Client-side storage is segregated
by origin, so pages from one site can’t read the data stored by pages from another site.
But two pages from the same site can share storage and can use it as a communication
mechanism. Data input in a form on one page can be displayed in a table on another
page, for example. Web applications can choose the lifetime of the data they store: data
can be stored temporarily so that it is retained only until the window closes or the
browser exits, or it can be saved to the hard drive and stored permanently, so that it is
available months or years later.
There are a number of forms of client-side storage:
Web Storage
Web Storage is an API that was originally defined as part of HTML5 but was spun
off as a standalone specification. That specification is still in draft form, but it is
partially (and interoperably) implemented in all current browsers including IE8.
This API consists of the 
localStorage
and 
sessionStorage
objects, which are es-
sentially persistent associative arrays that map string keys to string values. Web
Storage is very easy to use, is suitable for storing large (but not huge) amounts of
data, and is available on all current browsers, but it is not supported by older
browsers. 
localStorage
and 
sessionStorage
are covered in §20.1.
Cookies
Cookies are an old client-side storage mechanism that was designed for use by
server-side scripts. An awkward JavaScript API makes cookies scriptable on the
client-side, but they are hard to use and are suitable only for storing small amounts
of textual data. Also, any data stored as cookies is always transmitted to the server
with every HTTP request, even if the data is only of interest to the client. Cookies
continue to be of interest to client-side programmers because all browsers, old and
new, support them. Once Web Storage is universally available, however, cookies
587
C# Image: Tutorial for Document Management Using C#.NET Imaging
detailed C# tutorials on each part by following the links respectively. are dedicated to provide powerful & profession imaging controls, PDF document, image to
check links in pdf; active links in pdf
VB.NET PDF: Basic SDK Concept of XDoc.PDF
You may add PDF document protection functionality into your VB.NET program. to edit hyperlink of PDF document, including editing PDF url links and quick
add hyperlink pdf; clickable links in pdf
will revert to their original role as a client-side storage mechanism for server-side
scripts. Cookies are covered in §20.2.
IE User Data
Microsoft implements its own proprietary client-side storage mechanism, known
as “userData,” in IE5 and later. userData enables the storage of medium amounts
of string data and can be used as an alternative to Web Storage in versions of IE
before IE8. The userData API is covered in §20.3.
Offline Web Applications
HTML5 defines an “Offline Web Applications” API that allows the caching of web
pages and their associated resources (scripts, CSS files, images, and so on). This is
client-side storage for web applications themselves rather than just their data, and
it allows web apps to install themselves so that they are available even when there
is no connection to the Internet. Offline web apps are covered in §20.4.
Web Databases
Developers who need to work with really huge amounts of data like to use data-
bases, and the most recent browsers have started to integrate client-side database
functionality into their browsers. Safari, Chrome, and Opera include a client-side
API to a SQL database. The standardization effort for that API has failed, however,
and it is unlikely to be implemented by Firefox or IE. An alternative database API
is being standardized under the name “Indexed Database API.” This is an API to
a simple object database without a query language. Both of the client-side database
APIs are asynchronous and require the use of event handlers, which makes them
somewhat complicated. They are not documented in this chapter, but see §22.8
for an overview and an example of the IndexedDB API.
Filesystem API
We saw in Chapter 18 that modern browsers support a File object that allows user-
selected files to be uploaded through an XMLHttpRequest. Related draft standards
define an API for obtaining a private local filesystem and for reading and writing
files from and to that filesystem. These emerging APIs are described in §22.7. When
they are more widely implemented, web applications will be able to use the kind
of file-based storage mechanisms that are already familiar to many programmers.
Storage, Security, and Privacy
Web browsers often offer to remember web passwords for you, and they store them
safely in encrypted form on the disk. But none of the forms of client-side data storage
described in this chapter involve encryption: anything you save resides on the user’s
hard disk in unencrypted form. Stored data is therefore accessible to curious users who
share access to the computer and to malicious software (such as spyware) that exists
on the computer. For this reason, no form of client-side storage should ever be used
for passwords, financial account numbers, or other similarly sensitive information. Re-
member: just because a user types something into a form field when interacting with
your website doesn’t mean that he wants a copy of that value stored on disk. Consider
a credit card number as an example. This is sensitive information that people keep
588 | Chapter 20: Client-Side Storage
hidden in their wallets. If you save this information using client-side persistence, it is
almost as if you wrote the credit card number on a sticky note and stuck it to the user’s
keyboard.
Also, bear in mind that many web users mistrust websites that use cookies or other
client-side storage mechanisms to do anything that resembles “tracking.” Try to use
the storage mechanisms discussed in this chapter to enhance a user’s experience at your
site; don’t use them as a privacy-invading data collection mechanism. If too many sites
abuse client-side storage, users will disable it or clear it frequently, which will defeat
the purpose and cripple the sites that depend on it.
20.1  localStorage and sessionStorage
Browsers that implement the “Web Storage” draft specification define two properties
on the Window object: 
localStorage
and 
sessionStorage
. Both properties refer to a
Storage object—a persistent associative array that maps string keys to string values.
Storage objects work much like regular JavaScript objects: simply set a property of the
object to a string, and the browser will store that string for you. The difference between
localStorage
and 
sessionStorage
has to do with lifetime and scope: how long the data
is saved for and who the data is accessible to.
Storage lifetime and scope are explained in more detail below. First, however, let’s look
at some examples. The following code uses 
localStorage
, but it would also work with
sessionStorage
:
var name = localStorage.username;         // Query a stored value.
name = localStorage["username"];          // Array notation equivalent
if (!name) {
name = prompt("What is your name?");  // Ask the user a question.
localStorage.username = name;         // Store the user's response.
}
// Iterate through all stored name/value pairs
for(var name in localStorage) {           // Iterate all stored names     
var value = localStorage[name];       // Look up the value of each one
}
Storage objects also define methods for storing, retrieving, iterating, and deleting data.
Those methods are covered in §20.1.2.
The Web Storage draft specification says that we should be able to store structured
data (objects and arrays) as well as primitive values and built-in types such as dates,
regular expressions, and even File objects. At the time of this writing, however, brows-
ers only allow the storage of strings. If you want to store and retrieve other kinds of
data, you’ll have to encode and decode it yourself. For example:
// If you store a number, it is automatically converted to a string.
// Don't forget to parse it when retrieving it from storage.
localStorage.x = 10;
var x = parseInt(localStorage.x);
20.1  localStorage and sessionStorage | 589
Client-Side
JavaScript
// Convert a Date to a string when setting, and parse it when getting
localStorage.lastRead = (new Date()).toUTCString();
var lastRead = new Date(Date.parse(localStorage.lastRead));
// JSON makes a convenient encoding for any primitive or data structure
localStorage.data = JSON.stringify(data);  // Encode and store
var data = JSON.parse(localStorage.data);  // Retrieve and decode.
20.1.1  Storage Lifetime and Scope
The difference between 
localStorage
and 
sessionStorage
involves the lifetime and
scope of the storage. Data stored through 
localStorage
is permanent: it does not expire
and remains stored on the user’s computer until a web app deletes it or the user asks
the browser (through some browser-specific UI) to delete it.
localStorage
is scoped to the document origin. As explained in §13.6.2, the origin of
a document is defined by its protocol, hostname, and port, so each of the following
URLs has a different origin:
http://www.example.com        // Protocol: http; hostname: www.example.com
https://www.example.com       // Different protocol
http://static.example.com     // Different hostname
http://www.example.com:8000   // Different port
All documents with the same origin share the same 
localStorage
data (regardless of
the origin of the scripts that actually access 
localStorage
). They can read each other’s
data. And they can overwrite each other’s data. But documents with different origins
can never read or overwrite each other’s data (even if they’re both running a script from
the same third-party server).
Note that 
localStorage
is also scoped by browser vendor. If you visit a site using Firefox,
and then visit again using Chrome (for example), any data stored during the first visit
will not be accessible during the second visit.
Data stored through 
sessionStorage
has a different lifetime than data stored through
localStorage
: it has the same lifetime as the top-level window or browser tab in which
the script that stored it is running. When the window or tab is permanently closed, any
data stored through 
sessionStorage
is deleted. (Note, however, that modern browsers
have the ability to reopen recently closed tabs and restore the last browsing session, so
the lifetime of these tabs and their associated 
sessionStorage
may be longer than it
seems.)
Like 
localStorage
sessionStorage
is scoped to the document origin so that documents
with different origins will never share 
sessionStorage
. But 
sessionStorage
is also sco-
ped on a per-window basis. If a user has two browser tabs displaying documents from
the same origin, those two tabs have separate 
sessionStorage
data: the scripts running
in one tab cannot read or overwrite the data written by scripts in the other tab, even if
both tabs are visiting exactly the same page and are running exactly the same scripts.
590 | Chapter 20: Client-Side Storage
Download from Wow! eBook <www.wowebook.com>
Note that this window-based scoping of 
sessionStorage
is only for top-level windows.
If one browser tab contains two 
<iframe>
elements, and those frames hold two docu-
ments with the same origin, those two framed documents will share 
sessionStorage
.
20.1.2  Storage API
localStorage
and 
sessionStorage
are often used as if they were regular JavaScript ob-
jects: set a property to store a string and query the property to retrieve it. But these
objects also define a more formal method-based API. To store a value, pass the name
and value to 
setItem()
. To retrieve a value, pass the name to 
getItem()
. To delete a
value, pass the name to 
removeItem()
. (In most browsers you can also use the 
delete
operator to remove a value, just as you would for an ordinary object, but this technique
does not work in IE8.) To delete all stored values, call 
clear()
(with no arguments).
Finally, to enumerate the names of all stored values, use the 
length
property and pass
numbers from 0 to 
length
-1 to the 
key()
method. Here are some examples using 
local
Storage
. The same code would work using 
sessionStorage
instead:
localStorage.setItem("x", 1);        // Store an number with the name "x"
localStorage.getItem("x");           // Retrieve a value
// Enumerate all stored name/value pairs
for(var i = 0; i < localStorage.length; i++) {  // Length gives the # of pairs
var name = localStorage.key(i);             // Get the name of pair i
var value = localStorage.getItem(name);     // Get the value of that pair
}
localStorage.removeItem("x");        // Delete the item "x"
localStorage.clear();                // Delete any other items, too
Although it is usually more convenient to store and retrieve values by setting and
querying properties, there are some times when you might want to use these methods.
First, the 
clear()
method has no equivalent and is the only way to delete all name/value
pairs in a Storage object. Similarly, the 
removeItem()
method is the only portable way
to delete a single name/value pair, since IE8 does not allow the 
delete
operator to be
used in that way.
If browser vendors fully implement the specification and allow objects and arrays to be
stored in a Storage object, there will be another reason to use methods like 
setItem()
and 
getItem()
. Objects and array values are normally mutable, so a Storage object is
required to make a copy when you store a value, so that any subsequent changes to the
original value have no effect on the stored value. The Storage object is also required to
make a copy when you retrieve a value so that any changes you make to the retrieved
value have no effect on the stored value. When this kind of copying is being done, using
the property-based API can be confusing. Consider this (hypothetical, until browsers
support structured values) code:
localStorage.o = {x:1};   // Store an object that has a property x
localStorage.o.x = 2;     // Attempt to set the property of the stored object
localStorage.o.x          // => 1: x is unchanged
20.1  localStorage and sessionStorage | 591
Client-Side
JavaScript
The second line of code above wants to set a property of the stored object, but instead
it retrieves a copy of the stored object, sets a property in that copied object, and then
discards the copy. The stored object remains unchanged. There would be less chance
of confusion if we used 
getItem()
here:
localStorage.getItem("o").x = 2; // We don't expect this to store the value 2
Finally, another reason to use the explicit method-based Storage API is that we can
emulate that API on top of other storage mechanisms in browsers that do not yet sup-
port the Web Storage specification. The sections that follow will implement the Storage
API using cookies and IE userData. If you use the method-based API, you can write
code that makes use of 
localStorage
when available and falls back on one of the other
storage mechanisms in other browsers. Your code might start like this:
// Figure out what memory I'm using
var memory = window.localStorage ||
(window.UserDataStorage && new UserDataStorage()) ||
new CookieStorage();
// Then search my memory
var username = memory.getItem("username");
20.1.3  Storage Events
Whenever the data stored in 
localStorage
or 
sessionStorage
changes, the browser
triggers a storage event on any other Window objects to which that data is visible (but
not on the window that made the change). If a browser has two tabs open to pages with
the same origin, and one of those pages stores a value in 
localStorage
, the other tab
will receive a storage event. Remember that 
sessionStorage
is scoped to the top-level
window, so storage events are only triggered for 
sessionStorage
changes when there
are frames involved. Also note that storage events are only triggered when storage ac-
tually changes. Setting an existing stored item to its current value does not trigger an
event, nor does removing an item that does not exist in storage.
Register a handler for storage events with 
addEventListener()
(or 
attachEvent()
in IE).
In most browsers, you can also set the 
onstorage
property of the Window object, but
at the time of this writing, Firefox does not support that property.
The event object associated with a storage event has five important properties (they are
not supported by IE8, unfortunately):
key
The name or key of the item that was set or removed. If the 
clear()
method was
called, this property will be 
null
.
newValue
Holds the new value of the item, or 
null
if 
removeItem()
was called.
oldValue
Holds the old value of an existing item that changed or was deleted, or 
null
if a
new item was inserted.
592 | Chapter 20: Client-Side Storage
Documents you may be interested
Documents you may be interested