open pdf and draw c# : Add links pdf document Library software class asp.net windows winforms ajax %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D59-part1591

jQuery.isArray()
Returns 
true
if the argument is a native Array object.
jQuery.isEmptyObject
Returns 
true
if the argument has no enumerable properties.
jQuery.isFunction()
Returns 
true
if the argument is a native Function object. Note that in IE8 and
earlier, browser methods like 
Window.alert()
and 
Element.attachEvent()
are not
functions in this sense.
jQuery.isPlainObject()
Returns 
true
if the argument is a “plain” object rather than an instance of some
more specialized type or class of objects.
jQuery.makeArray()
If the argument is an array-like object, this function copies the elements of that
object into a new (true) array and returns that array. If the argument is not array-
like, this function simply returns a new array with the argument as its single
element.
jQuery.map()
This function is like the ES5 
map()
method of the Array object. It expects an array
or array-like object as its first argument and a function as its second. It passes each
array element along with the index of that element to the function and returns a
new array that collects the values returned by the function. 
jQuery.map()
differs
from the ES5 
map()
method in a couple of ways. If your mapping function returns
null
, that value will not be included in the result array. And if your mapping func-
tion returns an array, the elements of that array will be added to the result rather
than the array itself.
jQuery.merge()
This function expects two arrays or array-like objects. It appends the elements of
the second to the first and returns the first. The first array is modified, the second
is not. Note that you can use this function to shallowly clone an array like this:
var clone = jQuery.merge([], original);
jQuery.parseJSON()
This function parses a JSON-formatted string and returns the resulting value. It
throws an exception when passed malformed input. jQuery uses the standard
JSON.parse()
function in browsers that define it. Note that jQuery defines only a
JSON parsing function, not a JSON serialization function.
jQuery.proxy()
This function is something like the ES5 
bind()
(§8.7.4) method of the Function
object. It takes a function as its first argument and an object as its second and
returns a new function that invokes the function as a method of the object. It does
not perform partial application of arguments like the 
bind()
method does.
19.7  Utility Functions | 573
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
add hyperlink pdf document; adding links to pdf document
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
add hyperlink to pdf online; add hyperlink to pdf in preview
jQuery.proxy()
can also be invoked with an object as its first argument and a prop-
erty name as its second. The value of the named property should be a function.
Invoked in this way, the function 
jQuery.proxy(o,n)
returns the same thing that
jQuery.proxy(o[n],o)
does.
jQuery.proxy()
is intended for use with jQuery’s event handler binding mecha-
nism. If you bind a proxied function, you can unbind it using the original function.
jQuery.support
This is a property like 
jQuery.browser
, but it is intended for portable feature testing
(§13.4.3) rather than more brittle browser testing. The value of 
jQuery.support
is
an object whose properties are all boolean values that specify the presence or ab-
sence of browser features. Most of these 
jQuery.support
properties are low-level
details used internally by jQuery. They may be of interest to plug-in writers, but
most  are  not  generally  useful  to  application  writers.  One  exception  is
jQuery.support.boxModel
: this property is 
true
if the browser uses the CSS standard
“context-box” model and is 
false
in IE6 and IE7 in quirks mode (see §16.2.3.1).
jQuery.trim()
This function is like the 
trim()
method added to strings in ES5. It expects a string
as its only argument and returns a copy of that string with leading and trailing
whitespace removed.
19.8  jQuery Selectors and Selection Methods
Throughout this chapter, we’ve been using the jQuery selection function, 
$()
, with
simple CSS selectors. It is now time to study the jQuery selector grammar in depth,
along with a number of methods for refining and augmenting the set of selected
elements.
19.8.1  jQuery Selectors
jQuery supports a fairly complete subset of the selector grammar defined by the CSS3
Selectors draft standard, with the addition of some nonstandard but very useful pseu-
doclasses. Basic CSS selectors were described in §15.2.5. We repeat that material here,
and add explanations for more advanced selectors as well. Bear in mind that this section
documents jQuery selectors. Many, but not all, of these selectors can also be used in
CSS stylesheets.
The selector grammar has three layers. You’ve undoubtedly seen the simplest kind of
selectors before. “#test” selects an element with an 
id
attribute of “test”. “blockquote”
selects all 
<blockquote>
elements in the document, and “div.note” selects all 
<div>
elements with a 
class
attribute of “note”. Simple selectors can be combined into “se-
lector combinations” such as “div.note>p” and “blockquote i” by separating them with
a combinator character. And simple selectors and selector combinations can be grouped
into comma-separated lists. These selector groups are the most general kind of selector
574 | 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:
add hyperlink pdf; pdf link to email
.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
clickable pdf links; pdf email link
that we pass to 
$()
. Before explaining selector combinations and selector groups, we
must explain the syntax of simple selectors.
19.8.1.1  Simple selectors
A simple selector begins (explicitly or implicitly) with a tag type specification. If you
are only interested in 
<p>
elements, for example, your simple selector would begin with
“p”. If you want to select elements without regard to their tagname, use the wildcard
“*” instead. If a selector does not begin with either a tagname or a wildcard, the wildcard
is implicit.
The tagname or wildcard specifies an initial set of document elements that are candi-
dates for selection. The portion of the simple selector that follows this type specification
consists of zero or more filters. The filters are applied left-to-right, in the order that
they appear, and each one narrows the set of selected elements. Table 19-1 lists the
filters supported by jQuery.
Table 19-1. jQuery Selector Filters
Filter
Meaning
#id
Matches the element with an 
id
attribute of 
id
. Valid HTML documents never have more than one
element with the same ID, so this filter is usually used as a stand-alone selector.
.class
Matches any elements whose 
class
attribute (when interpreted as a list of words separated by
spaces) includes the word 
class
.
[attr]
Matches any elements that have an 
attr
attribute (regardless of its value).
[attr=val]
Matches any elements that have an 
attr
attribute whose value is 
val
.
[attr!=val]
Matches elements that have no 
attr
attribute, or whose 
attr
attribute is not equal to 
val
(jQuery
extension).
[attr^=val]
Matches elements whose 
attr
attribute has a value that begins with 
val
.
[attr$=val]
Matches elements whose 
attr
attribute has a value that ends with 
val
.
[attr*=val]
Matches elements whose 
attr
attribute has a value that contains 
val
.
[attr~=val]
Matches elements whose 
attr
attribute, when interpreted as a list of words separated by spaces,
includes the word 
val
. Thus the selector “div.note” is the same as “div[class~=note]”.
[attr|=val]
Matches elements whose 
attr
attribute has a value that begins with 
val
and is optionally followed
by a hyphen and any other characters.
:animated
Matches elements that are currently being animated by jQuery.
:button
Matches 
<button type="button">
and 
<input type="button">
elements (jQuery
extension).
:checkbox
Matches 
<input type="checkbox">
elements (jQuery extension). This filter is most efficient
when explicitly prefixed with the input tag: “input:checkbox”.
:checked
Matches input elements that are checked.
:contains(text)
Matches elements that contain the specified 
text
(jQuery extension). The parentheses of this filter
delimit the text—no quotation marks are required. The text of the elements being filtered is
19.8  jQuery Selectors and Selection Methods | 575
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:
adding links to pdf; pdf link open in new window
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
convert doc to pdf with hyperlinks; adding a link to a pdf in preview
Filter
Meaning
determined with their 
textContent
or 
innerText
properties—this is the raw document text,
with tags and comments stripped out.
:disabled
Matches disabled elements.
:empty
Matches elements that have no children, including no text content.
:enabled
Matches elements that are not disabled.
:eq(n)
Matches only the 
n
th element of the document-order zero-indexed list of matches (jQuery extension).
:even
Matches elements with even indexes in the list. Since the first element has an index of 0, this actually
matches the first, third, and fifth (and so on) elements (jQuery extension).
:file
Matches 
<input type="file">
elements (jQuery extension).
:first
Matches only the first element in the list. Same as 
:eq(0)
(jQuery extension).
:first-child
Matches only elements that are the first child of their parent. Note that this is completely different
than 
:first
.
:gt(n)
Matches elements in the document-order list of matches whose zero-based index is greater than 
n
(jQuery extension).
:has(sel)
Matches elements that have a descendant matching the nested selector 
sel
.
:header
Matches any header element: 
<h1>
<h2>
<h3>
<h4>
<h5>
, or 
<h6>
(jQuery extension).
:hidden
Matches any element that is not visible on the screen: roughly those elements whose 
offset
Width
and 
offsetHeight
are 0.
:image
Matches 
<input type="image">
elements. Note that this does not match 
<img>
elements
(jQuery extension).
:input
Matches user input elements: 
<input>
<textarea>
<select>
, and 
<button>
(jQuery
extension).
:last
Matches the last element in the list of matches (jQuery extension).
:last-child
Matches any element that is the last child of its parent. Note that this is not the same as :
last
.
:lt(n)
Matches all elements in the document-order list of matches whose zero-based index is less than 
n
(jQuery extension).
:not(sel)
Matches elements that are not matched by the nested selector 
sel
.
:nth(n)
A synonym for 
:eq(n)
(jQuery extension).
:nth-child(n)
Matches elements that are the 
n
th child of their parent. 
n
can be a number, the word “even”, the
word “odd”, or a formula. Use 
:nth-child(even)
to select elements that are the second and
fourth (and so on) in their parent’s list of children. Use 
:nth-child(odd)
to select elements that
are first, third, and so on.
Most generally, 
n
can be a formula of the form 
xn
or 
xn+y
where 
x
and 
y
are integers and 
n
is the
literal letter n. Thus 
nth-child(3n+1)
selects the first, fourth, and seventh (and so on) elements.
Note that this filter uses one-based indexes, so an element that is the first child of its parent is considered
odd and is matched by 
3n+1
, not 
3n
. Contrast this with the 
:even
and 
:odd
filters that filter based
on an element’s zero-based position in the list of matches.
:odd
Matches elements with odd (zero-based) indexes in the list. Note that elements 1 and 3 are the second
and fourth matched element, respectively (jQuery extension).
576 | 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 links to pdf; convert a word document to pdf with hyperlinks
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 link to pdf; add links in pdf
Filter
Meaning
:only-child
Matches elements that are the only child of their parent.
:parent
Matches elements that are parents. This is the opposite of 
:empty
(jQuery extension).
:password
Matches 
<input type="password">
elements (jQuery extension).
:radio
Matches 
<input type="radio">
elements (jQuery extension).
:reset
Matches 
<input type="reset">
and 
<button type="reset">
elements (jQuery
extension).
:selected
Matches 
<option>
elements that are selected. Use 
:checked
for selected checkboxes and radio
buttons (jQuery extension).
:submit
Matches 
<input type="submit">
and 
<button type="submit">
elements (jQuery
extension).
:text
Matches 
<input type="text">
elements (jQuery extension).
:visible
Matches all elements that are currently visible: roughly those that have nonzero 
offsetWidth
and
offsetHeight
. This is the opposite of 
:hidden
.
Notice that some of the filters listed in Table 19-1 accept arguments within parentheses.
The following selector, for example, selects paragraphs that are the first or every third
subsequent child of their parent, as long as they contain the word “JavaScript” and do
not contain an 
<a>
element.
p:nth-child(3n+1):text(JavaScript):not(:has(a))
Filters typically run most efficiently if prefixed with a tag type. Rather than simply using
“:radio” to select radio buttons, for example, it is better to use “input:radio”. The
exception is ID filters, which are most efficient when they stand alone. The selector
“#address” is typically more efficient than the more explicit “form#address”, for
example.
19.8.1.2  Selector combinations
Simple selectors can be combined using special operators or “combinators” to represent
relationships between elements in the document tree. Table 19-2 lists the selector com-
binations supported by jQuery. These are the same selector combinations that CSS3
supports.
Table 19-2. jQuery Selector Combinations
Combination
Meaning
A B
Selects document elements that match selector B that are descendants of elements that match selector A.
Note that the combinator character is simply whitespace for this combination.
A > B
Selects document elements that match selector B that are direct children of elements that match selector A.
A + B
Selects document elements that match selector B and immediately follow (ignoring text nodes and comments)
elements that match selector A.
A ~ B
Selects document elements matching B that are sibling elements that come after elements that match A.
19.8  jQuery Selectors and Selection Methods | 577
Client-Side
JavaScript
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
pdf edit hyperlink; add a link to a pdf in preview
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 email link to pdf; add hyperlinks pdf file
Here are some example selector combinations:
"blockquote i"        // Matches an <i> element within a <blockquote>
"ol > li"             // An <li> element as a direct child of an <ol>
"#output + *"         // The sibling after the element with id="output"
"div.note > h1 + p"   // A <p> following a <h1> inside a <div class="note">
Note that selector combinations are not limited to combinations of two selectors: three
or more selectors are allowed, too. Selector combinations are processed left to right.
19.8.1.3  Selector groups
A selector group, which is the kind of selector that we pass to 
$()
(or use in a stylesheet),
is simply a comma-separated list of one or more simple selectors or selector combina-
tions. A selector group matches all elements that match any of the selector combina-
tions in the group. For our purposes here, even a simple selector can be considered a
selector combination. Here are some example selector groups:
"h1, h2, h3"          // Matches <h1>, <h2>, and <h3> elements
"#p1, #p2, #p3"       // Matches elements with id p1, p2, and p3
"div.note, p.note"    // Matches <div> and <p> elements with class="note"
"body>p,div.note>p"   // <p> children of <body> and <div class="note">
Note that the CSS and jQuery selector syntax uses parentheses for some of the filters
in simple selectors, but it does not allow parentheses to be used more generally for
grouping. You cannot put a selector group or selector combination in parentheses and
treat it like a simple selector, for example:
(h1, h2, h3)+p        // Not legal
h1+p, h2+p, h3+p      // Write this instead
19.8.2  Selection Methods
In addition to the selector grammar supported by 
$()
, jQuery defines a number of
selection methods. Most of the jQuery methods we’ve seen so far in this chapter per-
form some action on the selected elements. The selection methods are different: they
alter the set of selected elements by refining it, augmenting it, or just using it as a starting
point for a new selection.
This section describes these selection methods. You’ll notice that many of the methods
provide the same functionality as the selector grammar itself.
The simplest way to refine a selection is by position within the selection. 
first()
returns
a jQuery object that contains only the first selected element, and 
last()
returns a jQuery
object that contains only the last element. More generally, the 
eq()
method returns a
jQuery object that contains only the single selected element at the specified index. (In
jQuery 1.4, negative indexes are allowed and count from the end of the selection.) Note
that these methods return a jQuery object with a single element. This is different than
regular array indexing, which returns a single element with no jQuery object wrapped
around it:
578 | Chapter 19: The jQuery Library
var paras = $("p");
paras.first()         // Select only the first <p> element
paras.last()          // Select only the last <p>
paras.eq(1)           // Select the second <p>
paras.eq(-2)          // Select the second to last <p>
paras[1]              // The second <p> element, itself
The general method for refining a selection by position is 
slice()
. The jQuery
slice()
method works like the 
Array.slice()
method: it accepts a start and an end
index (with negative indexes measured from the end of the array) and returns a jQuery
object that contains elements from the start index up to, but not including, the end
index. If the end index is omitted, the returned object includes all elements at or after
the start index:
$("p").slice(2,5)      // Select the 3rd, 4th, and 5th <p> elements
$("div").slice(-3)     // The last three <div> elements
filter()
is a general-purpose selection filtering method, and you can invoke it in three
different ways:
• If you pass a selector string to 
filter()
, it returns a jQuery object containing only
those selected elements that also match that selector.
• If you pass another jQuery object to 
filter()
, it returns a new jQuery object that
contains the intersection of the two jQuery objects. You can also pass an array of
elements, or even a single document element, to 
filter()
.
• If you pass a predicate function to 
filter()
, that function is called for each matched
element, and 
filter()
returns a jQuery object containing only those elements for
which the predicate returned 
true
(or any truthy value). The predicate function is
called with the element as its 
this
value and the element index as an argument.
(See also 
jQuery.grep()
in §19.7.)
$("div").filter(".note")                            // Same as $("div.note")
$("div").filter($(".note"))                         // Same as $("div.note")
$("div").filter(function(idx) { return idx%2==0 })  // Same as $("div:even")
The 
not()
method is just like 
filter()
, except that it inverts the sense of the filter. If
you pass a selector string to 
not()
, it returns a new jQuery object containing only the
selected elements that do not match the selector. If you pass a jQuery object or an array
of elements or a single element, 
not()
returns all of the selected elements except for the
elements you’ve explicitly excluded. If you pass a predicate function to 
not()
, it is
invoked just as it is for 
filter()
, but the returned jQuery object includes only those
elements for which the predicate returns 
false
or a falsy value:
$("div").not("#header, #footer");  // All <div> elements except two special ones
In jQuery 1.4, the 
has()
method is another way to refine a selection. If you pass a
selector, it returns a new jQuery object that contains only the selected elements that
have a descendant that matches the selector. If you pass a document element to
has()
, it refines the selection to match only those elements that are ancestors of the
specified element:
19.8  jQuery Selectors and Selection Methods | 579
Client-Side
JavaScript
$("p").has("a[href]")    // Paragraphs that include links
The 
add()
method augments a selection rather than filtering or refining it. You can
invoke 
add()
with any arguments (other than a function) that you would pass to 
$()
.
add()
returns the originally selected elements plus whatever elements would be selected
(or created) by the arguments if those arguments were passed to 
$()
add()
removes
duplicate elements and sorts the combined selection so that the elements are in docu-
ment order:
// Equivalent ways to select all <div> and all <p> elements
$("div, p")            // Use a selector group
$("div").add("p")      // Pass a selector to add()
$("div").add($("p"))   // Pass a jQuery object to add()
var paras = document.getElementsByTagName("p");  // An array-like object
$("div").add(paras);   // Pass an array of elements to add()
19.8.2.1  Using a selection as context
The 
filter()
add()
, and 
not()
methods described above perform set intersection, un-
ion, and subtraction operations on independent selections. jQuery defines a number
of other selection methods that use the current selection as the context. For each se-
lected element, these methods make a new selection using the selected element as the
context or starting point, and then return a new jQuery object that contains the union
of those selections. As with the 
add()
method, duplicates are removed and the elements
are sorted so that they are in document order.
The most general of this category of selection methods is 
find()
. It searches the de-
scendants of each of the currently selected elements for elements that match the speci-
fied selector string, and it returns a new jQuery object that represents that new set of
matching descendants. Note that the newly selected elements are not merged with the
existing selection; they are returned as a new set of elements. Note also that 
find()
is
not the same as 
filter()
, which simply narrows the currently selected set of elements
without selecting new elements:
$("div").find("p")  // find <p> elements inside <div>s.  Same as $("div p")
The other methods in this category return new jQuery objects that represent the chil-
dren, siblings, or parents of each of the currently selected elements. Most accept an
optional selector string as an argument. With no selector, they return all appropriate
children, siblings, or parents. With the selector, they filter the list to return only those
that match.
The 
children()
method returns the immediate child elements of each selected element,
filtering them with an optional selector:
// Find all <span> elements that are direct children of the elements with
// ids "header" and "footer". Same as $("#header>span,#footer>span")
$("#header, #footer").children("span")
The 
contents()
method is similar to 
children()
, but it returns all child nodes, including
text nodes, of each element. Also, if any of the selected elements is an 
<iframe>
,
580 | Chapter 19: The jQuery Library
contents()
returns the document object for the content of that 
<iframe>
. Note that
contents()
does not accept an optional selector string—this is because it returns docu-
ment nodes that are not elements, and selector strings only describe element nodes.
The 
next()
and 
prev()
methods return the next and previous sibling of each selected
element that has one. If a selector is specified, the sibling is selected only if it matches
the selector:
$("h1").next("p")            // Same as $("h1+p")
$("h1").prev()               // Sibling elements before <h1> elements
nextAll()
and 
prevAll()
return all siblings following and all siblings preceding (if there
are any) each selected element. And the 
siblings()
method returns all siblings of each
selected element (elements are not considered siblings of themselves). If a selector is
passed to any of these methods, only siblings that match are returned:
$("#footer").nextAll("p")    // All <p> siblings following the #footer element
$("#footer").prevAll()       // All siblings before the #footer element
In jQuery 1.4 and later, the 
nextUntil()
and 
prevUntil()
methods take a selector ar-
gument and select all siblings following or preceding the selected element until a sibling
is found that matches the selector. If you omit the selector, these methods work just
like 
nextAll()
and 
prevAll()
with no selector.
The 
parent()
method returns the parent of each selected element:
$("li").parent()          // Parents of list items, like <ul> and <ol> elements
The 
parents()
method returns the ancestors (up to the 
<html>
element) of each selected
element. Both 
parent()
and 
parents()
accept an optional selector string argument:
$("a[href]").parents("p") // <p> elements that contain links
parentsUntil()
returns the ancestors of each selected element until the first ancestor
that matches the specified selector. The 
closest()
method requires a selector string
and returns the closest ancestor (if any) of each selected element that matches the se-
lector. For this method, an element is considered an ancestor of itself. In jQuery 1.4,
you can also pass an ancestor element as the second argument to 
closest()
, to prevent
jQuery from climbing the ancestor tree beyond the specified element:
$("a[href]").closest("div")            // Innermost <div>s that contain links
$("a[href]").parentsUntil(":not(div)") // All <div> wrappers directly around <a>
19.8.2.2  Reverting to a previous selection
To facilitate method chaining, most jQuery object methods return the object on which
they are called. The methods we’ve covered in this section all return new jQuery objects,
however. Method chaining works, but you must keep in mind that methods called later
in the chain may be operating on a different set of elements than those near the start
of the chain.
The situation is a little more complicated than this, however. When the selection
methods described here create and return a new jQuery object, they give that object an
19.8  jQuery Selectors and Selection Methods | 581
Client-Side
JavaScript
internal reference to the older jQuery object from which it was derived. This creates a
linked list or stack of jQuery objects. The 
end()
method pops this stack, returning the
saved jQuery object. Calling 
end()
in a method chain restores the set of matched ele-
ments to its previous state. Consider the following code:
// Find all <div> elements, then find the <p> elements inside them.  
// Highlight the <p> elements and then give the <div> elements a border.
// First, without method chaining
var divs = $("div");                    
var paras = divs.find("p");
paras.addClass("highlight");
divs.css("border", "solid black 1px");
// Here's how we could do it with a method chain
$("div").find("p").addClass("highlight").end().css("border", "solid black 1px");
// Or we can reorder the operations and avoid the call to end()
$("div").css("border", "solid black 1px").find("p").addClass("highlight");
If you ever want to manually define the set of selected elements in a way that is com-
patible with the 
end()
method, pass the new set of elements as an array or array-like
object to the 
pushStack()
method. The elements you specify become the new selected
elements, and the previous set of selected elements is pushed on the stack, where they
can be restored with 
end()
:
var sel = $("div");                                // Select all <div> elements
sel.pushStack(document.getElementsByTagName("p")); // Modify it to all <p> elts
sel.end();                                         // Restore <div> elements
Now that we’ve covered the 
end()
method and the selection stack that it uses, there is
one final method we can cover. 
andSelf()
returns a new jQuery object that includes all
of the elements of the current selection plus all of the elements (minus duplicates) of
the previous selection. 
andSelf()
works like the 
add()
method, and “addPrev” might
be a more descriptive name for it. As an example, consider the following variant on the
code above: it highlights 
<p>
elements and the 
<div>
elements that hold them, and then
adds a border to the 
<div>
elements:
$("div").find("p").andSelf().          // find <p>s in <div>s, and merge them
addClass("highlight").             // Highlight them all
end().end().                       // Pop stack twice back to $("div")
css("border", "solid black 1px");  // Give the divs a border
19.9  Extending jQuery with Plug-ins
jQuery is written so that it is easy to add new functionality. Modules that add new
functionality are called plug-ins, and you can find many of them at http://plugins.jquery
.com. jQuery plug-ins are just ordinary files of JavaScript code, and to use them in your
web pages, you just include them with a 
<script>
element as you would any other
JavaScript library (you must include plug-ins after you include jQuery itself, of course).
582 | Chapter 19: The jQuery Library
Documents you may be interested
Documents you may be interested