open pdf and draw c# : Adding links to pdf document application SDK tool html .net asp.net online %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D55-part1587

});
// Removing CSS classes
$("p").removeClass("hilite");          // Remove a class from all <p> elements
$("p").removeClass("hilite first");    // Multiple classes are allowed
$("section").removeClass(function(n) { // Remove custom classes from elements
return "section" + n;              
});
$("div").removeClass();                // Remove all classes from all <div>s
// Toggling CSS classes
$("tr:odd").toggleClass("oddrow");     // Add the class if it is not there
// or remove it if it is
$("h1").toggleClass("big bold");       // Toggle two classes at once
$("h1").toggleClass(function(n) {      // Toggle a computed class or classes
return "big bold h1-" + n;
});
$("h1").toggleClass("hilite", true);   // Works like addClass
$("h1").toggleClass("hilite", false);  // Works like removeClass
// Testing for CSS classes
$("p").hasClass("first")               // Does any p element have this class?
$("#lead").is(".first")                // This does the same thing
$("#lead").is(".first.hilite")         // is() is more flexible than hasClass()
Note that the 
hasClass()
method is less flexible than 
addClass()
removeClass()
, and
toggleClass()
hasClass()
works for only a single class name and does not support
function arguments. It returns 
true
if any of the selected elements has the specified CSS
class and returns 
false
if none of them do. The 
is()
method (described in §19.1.2) is
more flexible and can be used for the same purpose.
These jQuery methods are like the 
classList
methods described in §16.5, but the
jQuery methods work in all browsers, not just those that support the HTML5 
class
List
property. Also, of course, the jQuery methods work for multiple elements and can
be chained.
19.2.4  Getting and Setting HTML Form Values
val()
is a method for setting and querying the 
value
attribute of HTML form elements
and also for querying and setting the selection state of checkboxes, radio buttons, and
<select>
elements:
$("#surname").val()              // Get value from the surname text field
$("#usstate").val()              // Get single value from <select> 
$("select#extras").val()         // Get array of values from <select multiple>
$("input:radio[name=ship]:checked").val()  // Get val of checked radio button
$("#email").val("Invalid email address")   // Set value of a text field
$("input:checkbox").val(["opt1", "opt2"])  // Check any checkboxes with 
// these names or values
$("input:text").val(function() { // Reset all text fields to their default
return this.defaultValue;
})
19.2  jQuery Getters and Setters | 533
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 url pdf; pdf links
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
add links to pdf; add page number to pdf hyperlink
19.2.5  Getting and Setting Element Content
The 
text()
and 
html()
methods query and set the plain-text or HTML content of an
element or elements. When invoked with no arguments, 
text()
returns the plain-text
content of all descendant text nodes of all matched elements. This works even in
browsers that do not support the 
textContent
or 
innerText
properties (§15.5.2).
If you invoke the 
html()
method with no arguments, it returns the HTML content of
just the first matched element. jQuery uses the 
innerHTML
property  to do this:
x.html()
is effectively the same as 
x[0].innerHTML
.
If you pass a string to 
text()
or 
html()
, that string will be used for the plain-text or
HTML-formatted text content of the element, and it will replace all existing content.
As with the other setter methods we’ve seen, you can also pass a function, which will
be used to compute the new content string:
var title = $("head title").text()   // Get document title
var headline = $("h1").html()        // Get html of first <h1> element
$("h1").text(function(n,current) {   // Give each heading a section number
return "§" + (n+1) + ": " + current
});
19.2.6  Getting and Setting Element Geometry
We learned in §15.8 that it can be tricky to correctly determine the size and position
of an element, especially in browsers that do not support 
getBoundingClientRect()
(§15.8.2). jQuery simplifies these computations with methods that work in any brows-
er. Note that all of the methods described here are getters, but only some can also be
used as setters.
To query or set the position of an element, use the 
offset()
method. This method
measures positions relative to the document and returns them in the form of an object
with 
left
and 
top
properties that hold the X and Y coordinates. If you pass an object
with these properties to the method, it sets the position you specify. It sets the CSS
position
attribute as necessary to make elements positionable:
var elt = $("#sprite");      // The element we want to move
var position = elt.offset(); // Get its current position
position.top += 100;         // Change its Y coordinate
elt.offset(position);        // Set the new position
// Move all <h1> elements to the right by a distance that depends on their
// position in the document
$("h1").offset(function(index,curpos) {
return {left: curpos.left + 25*index, top:curpos.top};
});
The 
position()
method is like 
offset()
, except that it is a getter only and it returns
element positions relative to their offset parent, rather than relative to the document
as a whole. In §15.8.5, we saw that every element has an 
offsetParent
property that
its position is relative to. Positioned elements always serve as the offset parents for their
534 | Chapter 19: The jQuery Library
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
change link in pdf file; add links to 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
adding hyperlinks to pdf documents; add hyperlink to pdf
descendants, but some browsers also make other elements, such as table cells, into
offset parents. jQuery only considers positioned elements to be offset parents, and the
offsetParent()
method of a jQuery object maps each element to the nearest positioned
ancestor element or to the 
<body>
element. Note the unfortunate naming mismatch for
these methods: 
offset()
returns the absolute position of an element, in document co-
ordinates. And 
position()
returns the offset of an element relative to its 
offsetParent()
.
There are three getters for querying the width of an element and three for querying the
height. The 
width()
and 
height()
methods return the basic width and height and do
not include padding, borders, or margins. 
innerWidth()
and 
innerHeight()
return the
width and height of an element plus the width and height of its padding (the word
“inner” refers to the fact that these methods return the dimensions measured to the
inside of the border). 
outerWidth()
and 
outerHeight()
normally return the element’s
dimensions plus its padding and border. If you pass the value 
true
to either of these
methods, they also add in the size of the element’s margins. The code below shows four
different widths that you can compute for an element:
var body = $("body");
var contentWidth = body.width();
var paddingWidth = body.innerWidth();
var borderWidth = body.outerWidth();
var marginWidth = body.outerWidth(true);
var padding = paddingWidth-contentWidth; // sum of left and right padding
var borders = borderWidth-paddingWidth;  // sum of left and right border widths
var margins = marginWidth-borderWidth;   // sum of left and right margins
The 
width()
and 
height()
methods have features that the other four methods (the inner
and outer methods) do not. First, if the first element of the jQuery object is a Window
or Document object, they return the size of the window’s viewport or the full size of
the document. The other methods only work for elements, not windows or documents.
The other feature of the 
width()
and 
height()
methods is that they are setters as well
as getters. If you pass a value to these methods, they set the width or height of every
element in the jQuery object. (Note, however, that they cannot set the width or height
of Window and Document objects.) If you pass a number, it is taken as a dimension
in pixels. If you pass a string value, it is used as the value of the CSS 
width
or 
height
attribute and can therefore use any CSS unit. Finally, as with other setters, you can pass
a function that will be called to compute the width or height.
There is a minor asymmetry between the getter and setter behavior of 
width()
and
height()
. When used as getters, these methods return the dimensions of an element’s
content box, excluding padding, borders, and margins. When you use them as setters,
however, they simply set the CSS 
width
and 
height
attributes. By default, those attrib-
utes also specify the size of the content box. But if an element has its CSS 
box-sizing
attribute (§16.2.3.1) set to 
border-box
, the 
width()
and 
height()
methods set dimen-
sions that include the padding and border. For an element 
e
that uses the content-box
box model, calling 
$(e).width(x).width()
returns the value 
x
. For elements that use
the border-box model, however, this is not generally the case.
19.2  jQuery Getters and Setters | 535
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
pdf link open in new window; pdf hyperlinks
The final pair of geometry-related jQuery methods are 
scrollTop()
and 
scrollLeft()
,
which query the scrollbar positions for an element or set the scrollbar positions for all
elements. These methods work for the Window object as well as for document ele-
ments, and when invoked on a Document, they query or set the scrollbar positions of
the Window that holds the document. Unlike with other setters, you cannot pass a
function to 
scrollTop()
or 
scrollLeft()
.
We can use 
scrollTop()
as a getter and a setter, along with the 
height()
method to
define a method that scrolls the window up or down by the number of pages you specify:
// Scroll the window by n pages. n can be fractional or negative
function page(n) {      
var w = $(window);                  // Wrap the window in a jQuery object
var pagesize = w.height();          // Get the size of a page
var current = w.scrollTop();        // Get the current scrollbar position
w.scrollTop(current + n*pagesize);  // Set new scrollbar position
}
19.2.7  Getting and Setting Element Data
jQuery defines a getter/setter method named 
data()
that sets or queries data associated
with any document element or with the Document or Window objects. The ability to
associate data with any element is an important and powerful one: it is the basis for
jQuery’s event handler registration and effects queuing mechanisms, and you may
sometimes want to use the 
data()
method in your own code.
To associate data with the elements in a jQuery object, call 
data()
as a setter method,
passing a name and a value as the two arguments. Alternatively, you can pass a single
object to the 
data()
setter and each property of that object will be used as a name/value
pair to associate with the element or elements of the jQuery object. Note, however,
that when you pass an object to 
data()
, the properties of that object replace any data
previously associated with the element or elements. Unlike many of the other setter
methods we’ve seen, 
data()
does not invoke functions you pass. If you pass a function
as the second argument to 
data()
, that function is stored, just as any other value
would be.
The 
data()
method can also serve as a getter, of course. When invoked with no argu-
ments, it returns an object containing all name/value pairs associated with the first
element in the jQuery object. When you invoke 
data()
with a single string argument,
it returns the value associated with that string for the first element.
Use the 
removeData()
method to remove data from an element or elements. (Using
data()
to set a named value to 
null
or 
undefined
is not the same thing as actually deleting
the named value.) If you pass a string to 
removeData()
, the method deletes any value
associated with that string for the element or elements. If you call 
removeData()
with
no arguments, it removes all data associated with the element or elements:
$("div").data("x", 1);            // Set some data
$("div.nodata").removeData("x");  // Remove some data
var x = $('#mydiv').data("x");    // Query some data
536 | Chapter 19: The jQuery Library
jQuery also defines utility function forms of the 
data()
and 
removeData()
methods. You
can associate data with an individual element 
e
using either the method or function
form of 
data()
:
$(e).data(...)   // The method form
$.data(e, ...)   // The function form
jQuery’s data framework does not store element data as properties of the elements
themselves, but it does need to add one special property to any element that has data
associated with it. Some browsers do not allow properties to be added to 
<applet>
,
<object>
, and 
<embed>
elements, so jQuery simply does not allow data to be associated
with elements of these types.
19.3  Altering Document Structure
In §19.2.5 we saw the 
html()
and 
text()
methods for setting element content. This
section covers methods for making more complex changes to a document. Because
HTML documents are represented as a tree of nodes rather than a linear sequence of
characters, insertions, deletions, and replacements are not as simple as they are for
strings and arrays. The subsections that follow explain the various jQuery methods for
document modification.
19.3.1  Inserting and Replacing Elements
Let’s begin with basic methods for insertions and replacements. Each of the methods
demonstrated below takes an argument that specifies the content that is to be inserted
into the document. This can be a string of plain text or of HTML to specify new content,
or it can be a jQuery object or an Element or text Node. The insertion is made into or
before or after or in place of (depending on the method) each of the selected elements.
If the content to be inserted is an element that already exists in the document, it is
moved from its current location. If it is to be inserted more than once, the element is
cloned as necessary. These methods all return the jQuery object on which they are
called. Note, however, that after 
replaceWith()
runs, the elements in the jQuery object
are no longer in the document:
$("#log").append("<br/>"+message); // Add content at end of the #log element
$("h1").prepend("§");              // Add section sign at start of each <h1>
$("h1").before("<hr/>");           // Insert a rule before each <h1>
$("h1").after("<hr/>");            // And after as well
$("hr").replaceWith("<br/>");      // Replace <hr/> elements with <br/>
$("h2").each(function() {          // Replace <h2> with <h1>, keeping content
var h2 = $(this);
h2.replaceWith("<h1>" + h2.html() + "</h1>");
});
// after() and before() can be called on text nodes, as well
// This is another way to add a section sign at the start of each <h1>
$("h1").map(function() { return this.firstChild; }).before("§");
19.3  Altering Document Structure | 537
Client-Side
JavaScript
Download from Wow! eBook <www.wowebook.com>
Each of these five structure-altering methods can also be passed a function that will be
invoked to compute the value to be inserted. As usual, if you supply such a function,
it will be invoked once for each selected element. The 
this
value will be that element
and the first argument will be the index of that element within the jQuery object. For
append()
prepend()
, and 
replaceWith()
, the second argument is the current content of
the element as an HTML string. For 
before()
and 
after()
, the function is invoked with
no second argument.
The five methods demonstrated above are all invoked on target elements and are passed
the content that is to be inserted as an argument. Each of those five methods can be
paired with another method that works the other way around: invoked on the content
and passed the target elements as the argument. This table shows the method pairs:
Operation
$(target).method(content)
$(content).method(target)
insert content at end of target
append()
appendTo()
insert content at start of target
prepend()
prependTo()
insert content after target
after()
insertAfter()
insert content before target
before()
insertBefore()
replace target with content
replaceWith()
replaceAll()
The methods demonstrated in the example code above are the ones in the second col-
umn. The methods in the third column are demonstrated below. There are a couple of
important things to understand about these pairs of methods:
• If you pass a string to one of the second column methods, it is taken as a string of
HTML to insert. If you pass a string to one of the third column methods, it is taken
as a selector that identifies the target elements. (You can also identify the target
elements directly by passing a jQuery object or Element or text node.)
• The third column methods do not accept function arguments like the second col-
umn methods do.
• The second column methods return the jQuery object on which they were invoked.
The elements in that jQuery object may have new content or new siblings, but they
are not themselves altered. The third column methods are invoked on the content
that is being inserted and they return a new jQuery object that represents the new
content after its insertion. In particular, note that if content is inserted at multiple
locations, the returned jQuery object will include one element for each location.
With those differences listed, the code below performs the same operations as the code
above, using the methods in the third column instead of the methods in the second
column. Notice that in the second line we can’t pass plain text (without angle brackets
to identify it as HTML) to the 
$()
method—it thinks we’re specifying a selector. For
this reason, we must explicitly create the text node that we want to insert:
$("<br/>+message").appendTo("#log");             // Append html to #log
$(document.createTextNode("§")).prependTo("h1"); // Append text node to <h1>s
538 | Chapter 19: The jQuery Library
$("<hr/>").insertBefore("h1");                   // Insert rule before <h1>s
$("<hr/>").insertAfter("h1");                    // Insert rule after <h1>s
$("<br/>").replaceAll("hr");                     // Replace <hr/> with <br/>
19.3.2  Copying Elements
As noted above, if you insert elements that are already part of the document, those
elements will simply be moved, not copied, to their new location. If you are inserting
the elements in more than one place, jQuery will make copies as needed, but copies
are not made when only one insertion is done. If you want to copy elements to a new
location instead of moving them, you must first make a copy with the 
clone()
method.
clone()
makes and returns a copy of each selected element (and of all of the descendants
of those elements). The elements in the returned jQuery object are not part of the
document yet, but you can insert them with one of the methods above:
// Append a new div, with id "linklist", to the end of the document
$(document.body).append("<div id='linklist'><h1>List of Links</h1></div>");
// Copy all links in the document and insert them into that new div
$("a").clone().appendTo("#linklist");
// Insert <br/> elements after each link so they display on separate lines
$("#linklist > a").after("<br/>");
clone()
does not normally copy event handlers (§19.4) or other data you have associ-
ated with elements (§19.2.7); pass 
true
if you want to clone that additional data as well.
19.3.3  Wrapping Elements
Another type of insertion into an HTML document involves wrapping a new element
(or elements) around one or more elements. jQuery defines three wrapping functions.
wrap()
wraps each of the selected elements. 
wrapInner()
wraps the contents of each
selected element. And 
wrapAll()
wraps the selected elements as a group. These methods
are usually passed a newly created wrapper element or a string of HTML used to create
a wrapper. The HTML string can include multiple nested elements, if desired, but there
must be a single innermost element. If you pass a function to any of these methods, it
will be invoked once in the context of each element (with the element index as its only
argument) and should return the wrapper string, Element, or jQuery object. Here are
some examples:
// Wrap all <h1> elements with <i> elements
$("h1").wrap(document.createElement("i")); // Produces <i><h1>...</h1></i>
// Wrap the content of all <h1> elements. Using a string argument is easier.
$("h1").wrapInner("<i/>");                 // Produces <h1><i>...</i></h1>
// Wrap the first paragraph in one anchor and div
$("body>p:first").wrap("<a name='lead'><div class='first'></div></a>");
// Wrap all the other paragraphs in another div
$("body>p:not(:first)").wrapAll("<div class='rest'></div>");
19.3  Altering Document Structure | 539
Client-Side
JavaScript
19.3.4  Deleting Elements
Along with insertions and replacements, jQuery also defines methods for deleting ele-
ments. 
empty()
removes all children (including text nodes) of each of the selected
elements, without altering the elements themselves. The 
remove()
method, by contrast,
removes the selected elements (and all of their content) from the document. 
remove()
is normally invoked with no arguments and removes all elements in the jQuery object.
If you pass an argument, however, that argument is treated as a selector, and only
elements of the jQuery object that also match the selector are removed. (If you just
want to remove elements from the set of selected elements, without removing them
from the document, use the 
filter()
method, which is covered in §19.8.2.) Note that
it is not necessary to remove elements before reinserting them into the document: you
can simply insert them at a new location and they will be moved.
The 
remove()
method  removes  any event handlers (see §19.4)  and  other  data
(§19.2.7) you may have bound to the removed elements. The 
detach()
method works
just like 
remove()
but does not remove event handlers and data. 
detach()
may be more
useful when you want to temporarily remove elements from the document for later
reinsertion.
Finally, the 
unwrap()
method performs element removal in a way that is the opposite
of the 
wrap()
or 
wrapAll()
method: it removes the parent element of each selected
element without affecting the selected elements or their siblings. That is, for each se-
lected  element, it replaces the parent of that element with  its children. Unlike
remove()
and 
detach()
unwrap()
does not accept an optional selector argument.
19.4  Handling Events with jQuery
As we saw in Chapter 17, one of the difficulties of working with events is that IE (until
IE9) implements a different event API than all other browsers do. To address this dif-
ficulty, jQuery defines a uniform event API that works in all browsers. In its simple
form, the jQuery API is easier to use than the standard or IE event APIs. And in its more
complex full-featured form, the jQuery API is more powerful than the standard API.
The subsections below have all the details.
19.4.1  Simple Event Handler Registration
jQuery defines simple event-registration methods for each of the commonly used and
universally implemented browser events. To register an event handler for click events,
for example, just call the 
click()
method:
// Clicking on any <p> gives it a gray background
$("p").click(function() { $(this).css("background-color", "gray"); });
Calling a jQuery event-registration method registers your handler on all of the selected
elements. This is typically much easier than one-at-a-time event handler registration
with 
addEventListener()
or 
attachEvent()
.
540 | Chapter 19: The jQuery Library
These are the simple event handler registration methods jQuery defines:
blur()          focusin()       mousedown()     mouseup()
change()        focusout()      mouseenter()    resize()
click()         keydown()       mouseleave()    scroll()
dblclick()      keypress()      mousemove()     select()
error()         keyup()         mouseout()      submit()
focus()         load()          mouseover()     unload()
Most of these registration methods are for common event types you are already familiar
with from Chapter 17. A few notes are in order, however. Focus and blur events do not
bubble, but the focusin and focusout events do, and jQuery ensures that these events
work in all browsers. Conversely, the mouseover and mouseout events do bubble, and
this is often inconvenient because it is difficult to know whether the mouse has left the
element you’re interested in or whether it has simply moved out of one of the descend-
ants of that element. mouseenter and mouseleave are nonbubbling events that solve
this problem. These event types were originally introduced by IE, and jQuery ensures
that they work correctly in all browsers.
The resize and unload event types are only ever fired on the Window object, so if you
want to register handlers for these event types, you should invoke the 
resize()
and
unload()
methods on 
$(window)
. The 
scroll()
method is also most often used on
$(window)
, but it can also be used on any element that has scrollbars (such as when the
CSS 
overflow
attribute is set to “scroll” or “auto”). The 
load()
method can be called
on 
$(window)
to register a load event handler for the window, but it is usually better to
pass your initialization function directly to 
$()
as shown in §19.1.1. You can use the
load()
method on iframes and images, however. Note that when invoked with different
arguments, 
load()
is also used to load new content (via scripted HTTP) into an
element—see §19.6.1. The 
error()
method can be used on 
<img>
elements to register
handlers that are invoked if an image fails to load. It should not be used to set the
Window 
onerror
property that was described in §14.6.
In addition to these simple event registration methods, there are two special forms that
are sometimes useful. The 
hover()
method registers handlers for mouseenter and
mouseleave events. Calling 
hover(f,g)
is like calling 
mouseenter(f)
and then calling
mouseleave(g)
. If you pass just one argument to 
hover()
, that function is used as the
handler for both enter and leave events.
The other special event registration method is 
toggle()
. This method binds event han-
dler functions to the click event. You specify two or more handler functions and jQuery
invokes one of them each time a click event occurs. If you call 
toggle(f,g,h)
, for ex-
ample, the function 
f()
is invoked to handle the first click event, 
g()
is invoked to
handle the second, 
h()
is invoked to handle the third, and 
f()
is invoked again to handle
the fourth click event. Be careful when using 
toggle()
: as we’ll see in §19.5.1, this
method can also be used to show or hide (i.e., toggle the visibility of) the selected
elements.
We’ll learn about other more general ways to register event handlers in §19.4.4, and
we’ll end this section with one more simple and convenient way to register handlers.
19.4  Handling Events with jQuery | 541
Client-Side
JavaScript
Recall that you can pass a string of HTML to 
$()
to create the elements described by
that string, and that you can pass (as a second argument) an object of attributes to be
set on the newly created elements. This second argument can be any object that you
would pass to the 
attr()
method. But in addition, if any of the properties have the same
name as the event registration methods listed above, the property value is taken as a
handler function and is  registered  as a handler for the named event type. For
example:
$("<img/>", {
src: image_url,
alt: image_description,
className: "translucent_image",
click: function() { $(this).css("opacity", "50%"); }
});
19.4.2  jQuery Event Handlers
The event handler functions in the examples above expect no arguments and return no
values. It is quite normal to write event handlers like that, but jQuery does invoke every
event handler with one or more arguments, and it does pay attention to the return value
of your handlers. The most important thing you should know is that every event handler
is passed a jQuery event object as its first argument. The fields of this object provide
details (like mouse pointer coordinates) about the event. The properties of the standard
Event object were described in Chapter 17. jQuery simulates that standard Event ob-
ject, even in browsers (like IE8 and before) that do not support it, and jQuery event
objects have the same set of fields in all browsers. This is explained in detail in §19.4.3.
Normally, event handlers are invoked with only the single event object argument. But
if you explicitly trigger an event with 
trigger()
(see §19.4.6), you can pass an array of
extra arguments. If you do this, those arguments will be passed to the event handler
after the first event object argument.
Regardless of how they are registered, the return value of a jQuery event handler func-
tion is always significant. If a handler returns 
false
, both the default action associated
with the event and any future propagation of the event are canceled. That is, returning
false
is the same as calling the 
preventDefault()
and 
stopPropagation()
methods of
the Event object. Also, when an event handler returns a value (other than 
undefined
),
jQuery stores that value in the 
result
property of the Event object where it can be
accessed by subsequently invoked event handlers.
19.4.3  The jQuery Event Object
jQuery hides implementation differences between browsers by defining its own Event
object. When a jQuery event handler is invoked, it is always passed a jQuery Event
object as its first argument. The jQuery Event object is based heavily on W3C standards,
but it also codifies some de facto event standards. jQuery copies all of the following
fields from the native Event object into every jQuery Event object (though some of them
will be 
undefined
for certain event types):
542 | Chapter 19: The jQuery Library
Documents you may be interested
Documents you may be interested