open pdf and draw c# : Adding links to pdf document software SDK cloud windows .net wpf class %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D61-part1594

storageArea
This property will equal either the 
localStorage
or the 
sessionStorage
property of
the target Window object.
url
The URL (as a string) of the document whose script made this storage change.
Finally, note that 
localStorage
and the storage event can serve as a broadcast mecha-
nism by which a browser sends a message to all windows that are currently visiting the
same website. If a user requests that a website stop performing animations, for example,
the site might store that preference in 
localStorage
so that it can honor it in future
visits. And by storing the preference, it generates an event that allows other windows
displaying the same site to honor the request as well. As another example, imagine a
web-based image editing application that allows the user to display tool palettes in
separate windows. When the user selects a tool, the application uses 
localStorage
to
save the current state and to generate a notification to other windows that a new tool
has been selected.
20.2  Cookies
A cookie is a small amount of named data stored by the web browser and associated
with a particular web page or website. Cookies were originally designed for server-side
programming, and at the lowest level, they are implemented as an extension to the
HTTP protocol. Cookie data is automatically transmitted between the web browser
and web server, so server-side scripts can read and write cookie values that are stored
on the client. This section demonstrates how client-side scripts can also manipulate
cookies using the 
cookie
property of the Document object.
Why “Cookie?”
The name “cookie” does not have a lot of significance, but it is not used without prec-
edent. In the annals of computing history, the term “cookie” or “magic cookie” has
been used to refer to a small chunk of data, particularly a chunk of privileged or secret
data, akin to a password, that proves identity or permits access. In JavaScript, cookies
are used to save state and can establish a kind of identity for a web browser. Cookies
in JavaScript do not use any kind of cryptography, however, and are not secure in any
way (although transmitting them across an 
https:
connection helps).
The API for manipulating cookies is a very old one, which means that it is universally
supported. Unfortunately, the API is also quite cryptic. There are no methods involved:
cookies are queried, set, and deleted by reading and writing the 
cookie
property of the
Document object using specially formatted strings. The lifetime and scope of each
cookie can be individually specified with cookie attributes. These attributes are also
specified with specially formatted strings set on the same 
cookie
property.
20.2  Cookies | 593
Client-Side
JavaScript
Adding links to 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
add a link to a pdf in preview; pdf edit hyperlink
Adding links to 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 link; adding an email link to a pdf
The subsections that follow explain the cookie attributes that specify lifetime and
scope, and then demonstrate how to set and query cookie values in JavaScript. The
section concludes with an example that implements the Storage API on top of cookies.
Determining Whether Cookies Are Enabled
Cookies have gotten a bad reputation for many web users because of the unscrupulous
use of third-party cookies—cookies associated with the images on a web page rather
than the web page itself. Third-party cookies enable an ad-hosting company to track a
user from one client site to another client site, for example, and the privacy implications
of this practice cause some users to disable cookies in their web browsers. Before using
cookies in your JavaScript code, you may want to first check that they are enabled. In
most browsers, you can do this by checking the 
navigator.cookieEnabled
property. If
true
, cookies are enabled, and if 
false
, cookies are disabled (although nonpersistent
cookies that last for only the current browsing session may still be enabled). This is not
a standard property, and if you find that it is undefined in the browser your code is
running in, you must test for cookie support by trying to write, read, and delete a test
cookie using the techniques explained below.
20.2.1  Cookie Attributes: Lifetime and Scope
In addition to a name and a value, each cookie has optional attributes that control its
lifetime and scope. Cookies are transient by default; the values they store last for the
duration of the web browser session but are lost when the user exits the browser. Note
that this is a subtly different lifetime than 
sessionStorage
: cookies are not scoped to a
single window, and their default lifetime is the same as the entire browser process, not
the lifetime of any one window. If you want a cookie to last beyond a single browsing
session, you must tell the browser how long (in seconds) you would like it to retain the
cookie by specifying a max-age attribute. If you specify a lifetime, the browser will store
cookies in a file and delete them only once they expire.
Cookie visibility is scoped by document origin as 
localStorage
and 
sessionStorage
are,
and also by document path. This scope is configurable through cookie attributes
path and domain. By default, a cookie is associated with, and accessible to, the web
page that created it and any other web pages in the same directory or any subdirectories
of that directory. If the web page http://www.example.com/catalog/index.html creates a
cookie, for example, that cookie is also visible to http://www.example.com/catalog/order
.html and http://www.example.com/catalog/widgets/index.html, but it is not visible to
http://www.example.com/about.html.
This default visibility behavior is often exactly what you want. Sometimes, though,
you’ll want to use cookie values throughout a website, regardless of which page creates
the cookie. For instance, if the user enters his mailing address in a form on one page,
you may want to save that address to use as the default the next time he returns to the
page and also as the default in an entirely unrelated form on another page where he is
asked to enter a billing address. To allow this usage, you specify a path for the cookie.
594 | Chapter 20: Client-Side Storage
C# Create PDF Library SDK to convert PDF from other file formats
Create and save editable PDF with a blank page, bookmarks, links, signatures, etc. Besides, using this PDF document metadata adding control, you can
add a link to a pdf in acrobat; add hyperlink pdf file
VB.NET PowerPoint: Add Image to PowerPoint Document Slide/Page
detail guides on these functions through left menu links. on C#.NET PPT image adding library. powerful & profession imaging controls, PDF document, tiff files
add email link to pdf; add a link to a pdf
Then, any web page from the same web server whose URL begins with the path prefix
you specified can share the cookie. For example, if a cookie set by http://www.example
.com/catalog/widgets/index.html has its path set to “/catalog”, that cookie is also visible
to http://www.example.com/catalog/order.html. Or, if the path is set to “/”, the cookie
is visible to any page on the http://www.example.com web server.
Setting the path of a cookie to “/” gives scoping like that of 
localStorage
and also
specifies that the browser must transmit the cookie name and value to the server when-
ever it requests any web page on the site. Note that cookie path attribute should not
be treated as any kind of access-control mechanism. If a web page wants to read the
cookies from some other page of the same website, it can simply load that other page
into a hidden 
<iframe>
and read the cookies from the framed document. The same-
origin policy (§13.6.2) prevents this kind of cookie-snooping from happening across
sites, but it is perfectly legal for documents from the same site.
By default, cookies are scoped by document origin. Large websites may want cookies
to be shared across subdomains, however. For example, the server at order.exam-
ple.com may need to read cookie values set from catalog.example.com. This is where
the domain attribute comes in. If a cookie created by a page on catalog.example.com
sets its path attribute to “/” and its domain attribute to “.example.com”, that cookie is
available to all web pages on catalog.example.com, orders.example.com, and any other
server in the example.com domain. If the domain attribute is not set for a cookie, the
default is the hostname of the web server that serves the page. Note that you cannot
set the domain of a cookie to a domain other than the domain of your server.
The final cookie attribute is a boolean attribute named secure that specifies how cookie
values are transmitted over the network. By default, cookies are insecure, which means
that they are transmitted over a normal, insecure HTTP connection. If a cookie is
marked secure, however, it is transmitted only when the browser and server are con-
nected via HTTPS or another secure protocol.
20.2.2  Storing Cookies
To associate a transient cookie value with the current document, simply set the
cookie
property to a string of the form:
name=value
For example:
document.cookie = "version=" + encodeURIComponent(document.lastModified);
The next time you read the 
cookie
property, the name/value pair you stored is included
in the list of cookies for the document. Cookie values cannot include semicolons, com-
mas, or whitespace. For this reason, you may want to use the core JavaScript global
function 
encodeURIComponent()
to encode the value before storing it in the cookie. If
you do this, you’ll have to use the corresponding 
decodeURIComponent()
function when
you read the cookie value.
20.2  Cookies | 595
Client-Side
JavaScript
View Images & Documents in Web Image Viewer | Online Tutorials
document or image file, like Word, PDF or TIFF other mature image viewing features, like adding or deleting page And you can find the links to these professional
add links to pdf online; adding a link to a pdf in preview
A cookie written with a simple name/value pair lasts for the current web-browsing
session but is lost when the user exits the browser. To create a cookie that can last
across browser sessions, specify its lifetime (in seconds) with a 
max-age
attribute. You
can do this by setting the 
cookie
property to a string of the form:
name=value; max-age=seconds
The following function sets a cookie with an optional 
max-age
attribute:
// Store the name/value pair as a cookie, encoding the value with 
// encodeURIComponent() in order to escape semicolons, commas, and spaces.
// If daysToLive is a number, set the max-age attribute so that the cookie
// expires after the specified number of days. Pass 0 to delete a cookie.
function setCookie(name, value, daysToLive) {
var cookie = name + "=" + encodeURIComponent(value);
if (typeof daysToLive === "number") 
cookie += "; max-age=" + (daysToLive*60*60*24);
document.cookie = cookie;
}
Similarly, you can set the 
path
domain
, and 
secure
attributes of a cookie by appending
strings of the following format to the cookie value before that value is written to the
cookie
property:
; path=path
; domain=domain
; secure
To change the value of a cookie, set its value again using the same name, path, and
domain along with the new value. You can change the lifetime of a cookie when you
change its value by specifying a new 
max-age
attribute.
To delete a cookie, set it again using the same name, path, and domain, specifying an
arbitrary (or empty) value, and a 
max-age
attribute of 0.
20.2.3  Reading Cookies
When you use the 
cookie
property in a JavaScript expression, the value it returns is a
string that contains all the cookies that apply to the current document. The string is a
list of 
name
=
value
pairs separated from each other by a semicolon and a space. The
cookie 
value
does not include any of the attributes that may have been set for the cookie.
In order to make use of the 
document.cookie
property, you must typically call the
split()
method to break it into individual name=value pairs.
Once you have extracted the value of a cookie from the 
cookie
property, you must
interpret that value based on whatever format or encoding was used by the cookie’s
creator. You might, for example, pass the cookie value to 
decodeURIComponent()
and
then to 
JSON.parse()
.
Example 20-1 defines a 
getCookie()
function that parses the 
document.cookie
property
and returns an object whose properties specify the name and values of the document’s
cookies.
596 | Chapter 20: Client-Side Storage
Example 20-1. Parsing the document.cookies property
// Return the document's cookies as an object of name/value pairs.
// Assume that cookie values are encoded with encodeURIComponent().
function getCookies() {
var cookies = {};           // The object we will return
var all = document.cookie;  // Get all cookies in one big string
if (all === "")             // If the property is the empty string
return cookies;         // return an empty object
var list = all.split("; "); // Split into individual name=value pairs
for(var i = 0; i < list.length; i++) {  // For each cookie
var cookie = list[i];
var p = cookie.indexOf("=");        // Find the first = sign
var name = cookie.substring(0,p);   // Get cookie name
var value = cookie.substring(p+1);  // Get cookie value
value = decodeURIComponent(value);  // Decode the value
cookies[name] = value;              // Store name and value in object
}
return cookies;
}
20.2.4  Cookie Limitations
Cookies are intended for storage of small amounts of data by server-side scripts, and
that data is transferred to the server each time a relevant URL is requested. The standard
that defines cookies encourages browser manufacturers to allow unlimited numbers of
cookies of unrestricted size but does not require browsers to retain more than 300
cookies total, 20 cookies per web server, or 4 KB of data per cookie (both name and
value count toward this 4 KB limit). In practice, browsers allow many more than 300
cookies total, but the 4 KB size limit may still be enforced by some.
20.2.5  Storage with Cookies
Example 20-2 demonstrates how to implement the methods of the Storage API on top
of cookies. Pass the desired max-age and path attributes to the 
CookieStorage()
con-
structor, and then use the resulting object as you would use 
localStorage
or 
session
Storage
. Note, though, that the example does not implement the storage event and it
does not automatically store and retrieve values when you set and query properties of
the CookieStorage object.
Example 20-2. Implementing the Storage API using cookies
/*
* CookieStorage.js
* This class implements the Storage API that localStorage and sessionStorage
* do, but implements it on top of HTTP Cookies.
*/
function CookieStorage(maxage, path) {  // Arguments specify lifetime and scope
// Get an object that holds all cookies
var cookies = (function() { // The getCookies() function shown earlier
var cookies = {};           // The object we will return
var all = document.cookie;  // Get all cookies in one big string
20.2  Cookies | 597
Client-Side
JavaScript
if (all === "")             // If the property is the empty string
return cookies;         // return an empty object
var list = all.split("; "); // Split into individual name=value pairs
for(var i = 0; i < list.length; i++) {  // For each cookie
var cookie = list[i];
var p = cookie.indexOf("=");        // Find the first = sign
var name = cookie.substring(0,p);   // Get cookie name
var value = cookie.substring(p+1);  // Get cookie value
value = decodeURIComponent(value);  // Decode the value
cookies[name] = value;              // Store name and value
}
return cookies;
}());
// Collect the cookie names in an array
var keys = [];
for(var key in cookies) keys.push(key);
// Now define the public properties and methods of the Storage API
// The number of stored cookies
this.length = keys.length;
// Return the name of the nth cookie, or null if n is out of range
this.key = function(n) {
if (n < 0 || n >= keys.length) return null;
return keys[n];
};
// Return the value of the named cookie, or null.
this.getItem = function(name) { return cookies[name] || null; };
// Store a value
this.setItem = function(key, value) {
if (!(key in cookies)) { // If no existing cookie with this name
keys.push(key);      // Add key to the array of keys
this.length++;       // And increment the length
}
// Store this name/value pair in the set of cookies.
cookies[key] = value;
// Now actually set the cookie.
// First encode value and create a name=encoded-value string
var cookie = key + "=" + encodeURIComponent(value);
// Add cookie attributes to that string
if (maxage) cookie += "; max-age=" + maxage;
if (path) cookie += "; path=" + path;
// Set the cookie through the magic document.cookie property
document.cookie = cookie;
};
// Remove the specified cookie
this.removeItem = function(key) {
598 | Chapter 20: Client-Side Storage
if (!(key in cookies)) return;  // If it doesn't exist, do nothing
// Delete the cookie from our internal set of cookies
delete cookies[key];
// And remove the key from the array of names, too.
// This would be easier with the ES5 array indexOf() method.
for(var i = 0; i < keys.length; i++) {  // Loop through all keys
if (keys[i] === key) {              // When we find the one we want
keys.splice(i,1);               // Remove it from the array.
break;
}
}
this.length--;                          // Decrement cookie length
// Finally actually delete the cookie by giving it an empty value
// and an immediate expiration date.
document.cookie = key + "=; max-age=0";
};
// Remove all cookies
this.clear = function() {
// Loop through the keys, removing the cookies
for(var i = 0; i < keys.length; i++)
document.cookie = keys[i] + "=; max-age=0";
// Reset our internal state
cookies = {};
keys = [];
this.length = 0;
};
}
20.3  IE userData Persistence
IE5 and later enable client-side storage by attaching a proprietary “DHTML behavior”
to a document element. You can do that with code like this:
var memory = document.createElement("div");         // Create an element
memory.id = "_memory";                              // Give it a name
memory.style.display = "none";                      // Never display it
memory.style.behavior = "url('#default#userData')"; // Attach a magic behavior
document.body.appendChild(memory);                  // Add it to the document
Once you add the “userData” behavior to an element, that element gets new 
load()
and 
save()
methods. Call 
load()
to load stored data. You must pass a string to this
method—it is like a file name, identifying a particular batch of stored data. When data
is loaded, the name/value pairs become available as attributes of the element, and you
can  query  them  with 
getAttribute()
 To  save  new  data,  set  attributes  with
setAttribute()
and then call the 
save()
method. To delete a value, use 
removeAttri
bute()
and 
save()
. Here is an example, using the 
memory
element initialized above:
memory.load("myStoredData");                // Load a named batch of saved data
var name = memory.getAttribute("username"); // Get one piece of stored data
if (!name) {                                // If it wasn't defined
20.3  IE userData Persistence | 599
Client-Side
JavaScript
name = prompt("What is your name?);     // Get user input
memory.setAtttribute("username", name); // Set it as an attribute
memory.save("myStoredData");            // And save it for next time
}
By default, data saved with userData has an indefinite lifetime and lasts until you delete
it. But you can specify an expiration date by setting the 
expires
property. For example,
you might add the following lines to the previous code to specify an expiration date
100 days in the future:
var now = (new Date()).getTime();              // Now, in milliseconds
var expires = now + 100 * 24 * 60 * 60 * 1000; // 100 days from now in ms
expires = new Date(expires).toUTCString();     // Convert it to a string
memory.expires = expires;                      // Set userData expiration
IE userData is scoped to documents in the same directory as the document that set it.
This is a narrower scope than cookies, which also make cookies available to documents
in subdirectories of the original directory. The userData mechanism does not have any
equivalent of the cookie path and domain attributes to widen the scope of the data.
userData allows much more data to be stored than cookies do, but much less than
localStorage
and 
sessionStorage
do.
Example 20-3 implements the 
getItem()
setItem()
, and 
removeItem()
methods of the
Storage API on top of IE’s userData. (It does not implement 
key()
or 
clear()
, because
userData does not define a way to iterate through all stored items.)
Example 20-3. A partial Storage API based on IE’s userData
function UserDataStorage(maxage)  {
// Create a document element and install the special userData 
// behavior on it so it gets save() and load() methods.
var memory = document.createElement("div");         // Create an element
memory.style.display = "none";                      // Never display it
memory.style.behavior = "url('#default#userData')"; // Attach magic behavior
document.body.appendChild(memory);                  // Add to the document
// If maxage is specified, expire the userData in maxage seconds
if (maxage) {
var now = new Date().getTime();     // The current time
var expires = now + maxage * 1000;  // maxage seconds from now
memory.expires = new Date(expires).toUTCString();
}
// Initialize memory by loading saved values.
// The argument is arbitrary, but must also be passed to save()
memory.load("UserDataStorage");                     // Load any stored data
this.getItem = function(key) {     // Retrieve saved values from attributes
return memory.getAttribute(key) || null;
};
this.setItem = function(key, value) {
memory.setAttribute(key,value); // Store values as attributes
memory.save("UserDataStorage"); // Save state after any change
};
600 | Chapter 20: Client-Side Storage
this.removeItem = function(key) {
memory.removeAttribute(key);    // Remove stored value attribute
memory.save("UserDataStorage"); // Save new state
};
}
Because the code in Example 20-3 can only work in IE, you might use IE conditional
comments to prevent browsers other than IE from loading it:
<!--[if IE]>
<script src="UserDataStorage.js"></script>
<![endif]-->
20.4  Application Storage and Offline Webapps
HTML5 adds an “application cache” that web applications can use to store themselves
locally in a user’s browser. 
localStorage
and 
sessionStorage
store data for a web ap-
plication, but the application cache stores the application itself—all the files (HTML,
CSS, JavaScript, images, and so on) the application needs to run. The application cache
is different from a web browser’s regular cache: it isn’t cleared when the user clears the
regular cache. And cached applications aren’t cleared out on a LRU (least-recently used)
basis as they might be in an ordinary fixed-size cache. Applications aren’t temporarily
stored in the cache: they’re installed there, and they remain there until they uninstall
themselves or the user deletes them. The application cache is really not a cache at all:
a better name would be “application storage.”
The reason to allow web applications to be locally installed is to guarantee their avail-
ability when offline (such as when on an airplane or when a cellphone isn’t receiving a
signal). Web applications that work while offline install themselves in the application
cache, use localStorage to store their data, and have a synchronization mechanism to
transfer stored data to the server when they go back online. We’ll see an example offline
webapp in §20.4.3. First, however, we’ll see how an application can install itself in the
application cache.
20.4.1  The Application Cache Manifest
In order to install an application in the application cache, you must create a manifest:
a file that lists all of the URLs the application requires. Then, simply link the main
HTML page of your application to the manifest by setting the 
manifest
attribute of the
<html>
tag:
<!DOCTYPE HTML>
<html manifest="myapp.appcache">
<head>...</head>
<body>...</body>
</html>
Manifest files must begin with the string “CACHE MANIFEST” as their first line. The
lines that follow should list URLs to be cached, one URL per line. Relative URLs are
20.4  Application Storage and Offline Webapps | 601
Client-Side
JavaScript
relative to the URL of the manifest file. Blank lines are ignored. Lines that begin with
# are comments and are ignored. Comments may have space before them, but they
cannot follow any nonspace characters on the same line. Here is a simple manifest file:
CACHE MANIFEST
# The line above identifies the file type. This line is a comment
# The lines below specify the resources the application needs to run
myapp.html
myapp.js
myapp.css
images/background.png
Cache Manifest MIME Type
By  convention,  application  cache  manifest  files  are  given  the  filename  exten-
sion .appcache. This is a convention only, however, and to actually identify the file type,
the web server must serve a manifest with MIME type “text/cache-manifest”. If the
server sets the manifest’s Content-Type header to any other MIME type, your appli-
cation will not be cached. You may have to configure your web server to use this MIME
type by, for example, creating an Apache .htaccess file in the web app directory.
It is the manifest file that serves as the identity of the cached application. If a web app
has more than one web page (more than one HTML file that the user can link to), each
one of these pages should use the 
<html manifest=>
attribute to link to the manifest
file. The fact that these pages all link to the same manifest file makes it clear that they
are all to be cached together as part of the same web app. If there are only a few HTML
pages in the application, it is conventional to list those pages explicitly in the manifest
file. But this is not required: any file that links to the manifest file will be considered
part of the web app and will be cached along with it.
A simple manifest like the one shown above must list all of the resources required by
the web application. Once a web app has been downloaded the first time and cached,
any subsequent loads will be from the cache. When an application is loaded from the
cache, any resources it requires must be listed in the manifest. Resources that are not
listed will not be loaded. This policy simulates being offline. If a simple cached appli-
cation can run from the cache, it will also be able to run while the browser is offline.
More complicated web apps cannot, in general, cache every single resource they re-
quire. They can still use the application cache if they have a more complex manifest.
20.4.1.1  Complex manifests
When an application is loaded from the application cache, only resources listed in its
manifest file will be loaded. The example manifest file shown previously lists resources
one URL at a time. Manifest files actually have a more complicated syntax than that
example shows, and there are two other ways to list resources in a manifest file. Special
section header lines are used to identify the type of manifest entry that follows the
602 | Chapter 20: Client-Side Storage
Documents you may be interested
Documents you may be interested