open pdf and draw c# : Change link in pdf file software application dll winforms html windows web forms %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D57-part1589

show()
hide()
toggle()
The 
fadeOut()
method listed above makes elements invisible but retains space for
them in the document layout. The 
hide()
method, by contrast, removes the ele-
ments from the layout as if the CSS 
display
property was set to 
none
. When invoked
with no arguments, 
hide()
and 
show()
simply hide or show the selected elements
immediately. With a duration (or options object) argument, however, they animate
the hiding or showing process. 
hide()
shrinks an element’s 
width
and 
height
to 0
at the same time that it reduces the element’s 
opacity
to 0. 
show()
reverses the
process.
toggle()
changes the visibility state of the elements it is invoked on: if they are
hidden, it calls 
show()
, and if they are visible, it calls 
hide()
. As with 
show()
and
hide()
, you must pass a duration or options object to 
toggle()
to get an animated
effect. Passing 
true
to 
toggle()
is the same as calling 
show()
with no arguments
and passing 
false
is the same as calling 
hide()
with no arguments. Note also that
if you pass two or more function arguments to 
toggle()
it registers event handlers,
as described in §19.4.1.
slideDown()
slideUp()
slideToggle()
slideUp()
hides the elements in the jQuery object by animating their height to 0
and then setting the CSS 
display
property to “none”. 
slideDown()
reverses the
process to make a hidden element visible again. 
slideToggle()
toggles the visibility
of an item using a slide up or slide down animation. Each of the three methods
accepts the optional duration and callback arguments (or the options object
argument).
Here is an example that invokes methods from each of these groups. Keep in mind that
jQuery’s animations are queued by default, so these animations are performed one after
the other:
// Fade all images out, then show them, then slide up, then slide down
$("img").fadeOut().show(300).slideUp().slideToggle();
Various jQuery plug-ins (see §19.9) add additional effect methods to the library. The
jQuery UI library (§19.10) includes a particularly comprehensive set of effects.
19.5.2  Custom Animations
You can use the 
animate()
method to produce more general animated effects than are
available with the simple effects methods. The first argument to 
animate()
specifies
what to animate and the remaining arguments specify how to animate it. The first
argument is required: it must be an object whose properties specify CSS attributes and
their target values. 
animate()
animates the CSS properties of each element from its
current value to the specified target value. So, for example, the 
slideUp()
effect descri-
bed above can also be performed with code like this:
// Shrink the height of all images to 0
$("img").animate({ height: 0 });
19.5  Animated Effects | 553
Client-Side
JavaScript
Change link in pdf file - 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
accessible links in pdf; add links to pdf in preview
Change link in pdf file - 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 pdf document; add a link to a pdf in preview
As an optional second argument, you can pass an options object to 
animate()
:
$("#sprite").animate({
opacity: .25,                // Animate opacity to .25
font-size: 10                // Animate font size to 10 pixels
}, {
duration: 500,               // Animation lasts 1/2 second
complete: function() {       // Call this function when done
this.text("Goodbye");    // Change element text.
});
Instead of passing an options object as the second argument, 
animate()
also allows you
to specify three of the most commonly used options as arguments. You can pass the
duration (as a number or string) as the second argument. You can specify the name of
an easing function as the third argument. (Easing functions will be explained shortly.)
And you can specify a callback function as the fourth argument.
In the most general case, 
animate()
accepts two object arguments. The first specifies
what to animate and the second specifies how to animate it. To fully understand how
to perform animations with jQuery, there are additional details about both objects that
you must be aware of.
19.5.2.1  The animation properties object
The first argument to 
animate()
must be an object. The property names for this object
must be CSS attribute names, and the values of those properties must be the target
values toward which the animation will move. Only numeric properties can be anima-
ted: it is not possible to animate colors, fonts, or enumerated properties such as 
dis
play
. If the value of a property is a number, pixels are assumed. If the value is a string,
you may specify units. If you omit the units, pixels are again assumed. To specify relative
values, prefix the value string with “+=” to increase the value or with “-=” to decrease
the value. For example:
$("p").animate({
"margin-left": "+=.5in",  // Increase paragraph indent
opacity: "-=.1"           // And decrease their opacity
});
Note the use of the quotes around the property name “margin-left” in the object literal
above. The hyphen in this property name means that it is not a legal JavaScript iden-
tifier, so it must be quoted here. jQuery also allows you to use the mixed-case alternative
marginLeft
, of course.
In addition to numeric values (with optional units and “+=” and “-=” prefixes), there
are three other values that can be used in jQuery animation objects. The value “hide”
will save the current state of the property and then animate that property toward 0.
The value “show” will animate a CSS property toward its saved value. If an animation
uses “show”, jQuery will call the 
show()
method when the animation completes. And
if an animation uses “hide”, jQuery will call 
hide()
when the animation completes.
554 | Chapter 19: The jQuery Library
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
list below is mainly to optimize PDF file with multiple Program.RootPath + "\\" 3_optimized.pdf"; 'create optimizing 150.0F 'to change image compression
add link to pdf; change link in pdf
C# PDF File Compress Library: Compress reduce PDF size in C#.net
list below is mainly to optimize PDF file with multiple Program.RootPath + "\\" 3_optimized.pdf"; // create optimizing 150F; // to change image compression
convert a word document to pdf with hyperlinks; pdf email link
You can also use the value “toggle” to perform either a show or a hide, depending on
the current setting of the attribute. You can produce a “slideRight” effect (like the
slideUp()
method, but animating element width) like this:
$("img").animate({
width: "hide",
borderLeft: "hide",
borderRight: "hide",
paddingLeft: "hide",
paddingRight: "hide"
});
Replace the property values with “show” or “toggle” to produce sideways slide effects
analogous to 
slideDown()
and 
slideToggle()
.
19.5.2.2  The animation options object
The second argument to 
animate()
is an optional object that holds options that specify
how the animation is performed. You’ve already seen two of the most important op-
tions. The 
duration
property specifies the length of the animation in milliseconds, or
as the string “fast” or “slow”, or any name you’ve defined in 
jQuery.fx.speeds
.
Another option you’ve already seen is the 
complete
property: it specifies a function that
will be called when the animation is complete. A similar property, 
step
, specifies a
function that is called for each step or frame of the animation. The element being ani-
mated is the 
this
value, and the current value of the property being animated is passed
as the first argument.
The 
queue
property of the options object specifies whether the animation should be
queued—whether it should be deferred until any pending animations have completed.
All animations are queued by default. Set the 
queue
property to 
false
to disable queuing.
Unqueued animations start immediately. Subsequent queued animations are not de-
ferred for unqueued animations. Consider the following code:
$("img").fadeIn(500)
.animate({"width":"+=100"}, {queue:false, duration:1000})
.fadeOut(500);
The 
fadeIn()
and 
fadeOut()
effects are queued, but the call to 
animate()
(which ani-
mates the 
width
property for 1000ms) is not queued. The width animation begins at
the same time the 
fadeIn()
effect begins. The 
fadeOut()
effect begins as soon as the
fadeIn()
effect ends: it does not wait for the width animation to complete.
Easing Functions
The straightforward but naive way to perform animations involves a linear mapping
between time and the value being animated. If we are 100ms into a 400ms animation,
for example, the animation is 25 percent done. If we are animating the 
opacity
property
from 1.0 to 0.0 (for a 
fadeOut()
call, perhaps) in a linear animation, the opacity should
be at 0.75 at this point of the animation. It turns out, however, that visual effects are
more pleasing if they are not linear. So jQuery interposes an “easing function” that
19.5  Animated Effects | 555
Client-Side
JavaScript
VB.NET PDF Password Library: add, remove, edit PDF file password
Dim setting As PasswordSetting = New PasswordSetting(newUserPassword, newOwnerPassword) ' Change password for an encrypted PDF file and output to a new file.
add hyperlinks to pdf online; adding a link to a pdf in preview
C# PDF Password Library: add, remove, edit PDF file password in C#
PasswordSetting setting = new PasswordSetting(newUserPassword, newOwnerPassword); // Change password for an encrypted PDF file and output to a new file.
add hyperlink pdf; add url link to pdf
maps from a time-based completion percentage to the desired effect percentage. jQuery
calls the easing function with a time-based value between 0 and 1. It returns another
value between 0 and 1 and jQuery computes the value of the CSS property based on
this computed value. Generally, easing functions are expected to return 0 when passed
the value 0 and 1 when passed the value 1, of course, but they can be nonlinear between
those two values and this nonlinearity makes the animation appear to accelerate and
decelerate.
jQuery’s default easing function is a sinusoid: it starts off slow, then speeds up, then
slows down again to “ease” the animation to its final value. jQuery gives its easing
functions names. The default one is named “swing”, and jQuery also implements a
linear function named “linear”. You can add your own easing functions to the
jQuery.easing
object:
jQuery.easing["squareroot"] = Math.sqrt;
The jQuery UI library and a plug-in known simply as “the jQuery Easing Plugin” define
a comprehensive set of additional easing functions.
The remaining animation options involve easing functions. The 
easing
property of the
options object specifies the name of an easing function. By default, jQuery uses the
sinusoidal function it calls “swing”. If you want your animations to be linear, use an
options object like this:
$("img").animate({"width":"+=100"}, {duration: 500, easing:"linear"});
Recall that the 
duration
easing
, and 
complete
options can also be specified by argu-
ments to 
animate()
instead of passing an options object. So the animation above could
also be written like this:
$("img").animate({"width":"+=100"}, 500, "linear");
Finally, jQuery’s animation framework even allows you to specify different easing
functions for the different CSS properties you want to animate. There are two different
ways to achieve this, demonstrated by the code below:
// Hide images, as with the hide() method, but animate the image size linearly
// while the opacity is being animated with the default "swing" easing function
// One way to do it:
// Use the specialEasing option to specify custom easing functions 
$("img").animate({ width:"hide", height:"hide", opacity:"hide" },
{ specialEasing: {  width: "linear", height: "linear" }});
// Another way to do it:
// Pass [target value, easing function] arrays in the first object argument.
$("img").animate({
width: ["hide", "linear"], height: ["hide", "linear"], opacity:"hide"
});
556 | Chapter 19: The jQuery Library
C# PDF Library SDK to view, edit, convert, process PDF file for C#
and quick navigation link in PDF bookmark. C#.NET: Edit PDF Metadata. PDF SDK for .NET allows you to read, add, edit, update, and delete PDF file metadata, like
active links in pdf; clickable links in pdf
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
C#.NET PDF Library - Rotate PDF Page in C#.NET. Empower C# Users to Change the Rotation Angle of PDF File Page Using C# Programming Language in .NET Application
pdf link to attached file; add link to pdf acrobat
19.5.3  Canceling, Delaying, and Queuing Effects
jQuery defines a few more animation and queue-related methods that you should know
about. The 
stop()
method is first: it stops any currently executing animations on the
selected elements. 
stop()
accepts two optional boolean arguments. If the first argument
is 
true
, the animation queue will be cleared for the selected elements: this will cancel
any pending animations as well as stopping the current one. The default is 
false
: if this
argument is omitted, queued animations are not canceled. The second argument speci-
fies whether the CSS properties being animated should be left as they are currently or
whether they should be set to their final target values. Passing 
true
sets them to their
final values. Passing false (or omitting the argument) leaves them at whatever their
current value is.
When animations are triggered by user events, you may want to cancel any current or
queued animations before beginning a new one. For example:
// Images become opaque when the mouse moves over them.
// Be careful that we don't keep queueing up animations on mouse events!
$("img").bind({
mouseover: function() { $(this).stop().fadeTo(300, 1.0); },
mouseout: function() { $(this).stop().fadeTo(300, 0.5); }
});
The second animation-related method we’ll cover here is 
delay()
. This simply adds a
timed delay to the animation queue: pass a duration in milliseconds (or a duration
string) as the first argument and a queue name as the optional second argument (the
second argument is not normally needed: we’ll talk about queue names below). You
can use 
delay()
in compound animations like this one:
// Quickly fade out halfway, wait, then slide up
$("img").fadeTo(100, 0.5).delay(200).slideUp();
In the 
stop()
method example above, we used mouseover and mouseout events to
animate the opacity of images. We can refine that example by adding a short delay
before beginning the animation. That way, if the mouse quickly moves through an
image without stopping, no distracting animation occurs:
$("img").bind({
mouseover: function() { $(this).stop(true).delay(100).fadeTo(300, 1.0); },
mouseout: function() { $(this).stop(true).fadeTo(300, 0.5); }
});
The final animation-related methods are ones that give low-level access to the jQuery
queuing mechanism. jQuery queues are lists of functions to be executed in sequence.
Each queue is associated with a document element (or the Document or Window ob-
jects) and each element’s queues are independent of the queues of other elements. You
can add a new function to the queue with the 
queue()
method. When your function
reaches the head of the queue, it will be automatically dequeued and invoked. When
your function is invoked, the 
this
value is the element with which it is associated. Your
function will be passed a function as its single argument. When your function has
completed its operation, it must invoke the function that was passed to it. This runs
19.5  Animated Effects | 557
Client-Side
JavaScript
.NET PDF SDK - Description of All PDF Processing Control Feastures
Easy to change PDF original password; Options for setting PDF security PDF Hyperlink Edit. Support adding and inserting hyperlink (link) to PDF document; Allow to
c# read pdf from url; clickable pdf links
RasterEdge .NET Document Imaging Trial Package Download Link.
PDF Files; Split PDF Document; Remove Password from PDF; Change PDF Permission Settings. PDF to HTML; C#: Convert PDF to Jpeg; C# File: Compress PDF; C# File
check links in pdf; add links in pdf
the next operation in the queue, and if you don’t call the function, the queue will stall
and queued functions will never get invoked.
We’ve seen that you can pass a callback function to jQuery’s effect methods in order
to perform some kind of action after the effect completes. You can achieve the same
effect by queuing up your function:
// Fade an element in, wait, set some text in it, and animate its border
$("#message").fadeIn().delay(200).queue(function(next) {
$(this).text("Hello  World");      // Display some text
next();                            // Run the next item on the queue
}).animate({borderWidth: "+=10px;"});  // Grow its border
The function argument to queued functions is a new feature in jQuery 1.4. In code
written for earlier versions of the library, queued functions dequeue the next function
“manually” by calling the 
dequeue()
method:
$(this).dequeue();  // Instead of next()
If there is nothing in the queue, calling 
dequeue()
does nothing. Otherwise, it removes
a function from the head of the queue and invokes it, setting the 
this
value and passing
the function described above.
There are a few more heavy-handed ways to manipulate the queue as well. 
clear
Queue()
clears the queue. Passing an array of functions to 
queue()
instead of a single
function replaces the queue with the new array of functions. And calling 
queue()
with
neither a function nor an array of functions returns the current queue as an array. Also,
jQuery defines versions of the 
queue()
and 
dequeue()
methods as utility functions. If
you want to add the function 
f
to the queue for an element 
e
, you can use either the
method or the function:
$(e).queue(f);      // Create a jQuery object holding e, and call queue method
jQuery.queue(e,f);  // Just call the jQuery.queue() utility function
Finally, note that 
queue()
dequeue()
, and 
clearQueue()
all take an optional queue name
as their first argument. jQuery’s effects and animation methods use a queue named
“fx”, and this is the queue that is used if you do not specify a queue name. jQuery’s
queue mechanism is useful whenever you need to perform asynchronous operations
sequentially: instead of passing a callback function to each asynchronous operation so
that it can trigger the next function in the sequence, you can use a queue to manage
the sequence instead. Simply pass a queue name other than “fx”, and remember that
queued functions do not execute automatically. You must explicitly call 
dequeue()
to
run the first one, and each operation must dequeue the next one when it finishes.
19.6  Ajax with jQuery
Ajax is the popular name for web application programming techniques that use HTTP
scripting (see Chapter 18) to load data as needed, without causing page refreshes. Be-
cause Ajax techniques are so useful in modern web apps, jQuery includes Ajax utilities
to simplify them. jQuery defines one high-level utility method and four high-level utility
558 | Chapter 19: The jQuery Library
functions. These high-level utilities are all based on a single powerful low-level function,
jQuery.ajax()
. The subsections that follow describe the high-level utilities first, and
then cover the 
jQuery.ajax()
function in detail. In order to fully understand the oper-
ation of the high-level utilities, you’ll need to understand 
jQuery.ajax()
, even if you
never need to use it explicitly.
19.6.1  The load() Method
The 
load()
method is the simplest of all jQuery utilities: pass it a URL and it will
asynchronously load the content of that URL and then insert that content into each of
the selected elements, replacing any content that is already there. For example:
// Load and display the latest status report every 60 seconds
setInterval(function() { $("#stats").load("status_report.html"); }, 60000);
We also saw the 
load()
method in §19.4.1, where it was used to register a handler for
load events. If the first argument to this method is a function instead of a string, it
behaves as an event handler registration method instead of as an Ajax method.
If you only want to display a portion of the loaded document, add a space to the URL
and follow it with a jQuery selector. When the URL has loaded, the selector you speci-
fied will be used to select the portions of the loaded HTML to be displayed:
// Load and display the temperature section of the weather report
$('#temp').load("weather_report.html #temperature");
Note that the selector at the end of this URL looks very much like a fragment identifier
(the 
hash
portion of the URL described in §14.2). The space is required, however, if
you want jQuery to insert only the selected portion (or portions) of the loaded
document.
The 
load()
method accepts two optional arguments in addition to the required URL.
The first is data to append to the URL or to send along with the request. If you pass a
string, it is appended to the URL (after a 
?
or 
&
as needed). If you pass an object, it is
converted to a string of ampersand-separated name=value pairs and sent along with
the request. (The details of object-to-string conversion for Ajax are in the sidebar of
§19.6.2.2). The 
load()
method normally makes an HTTP GET request, but if you pass
a data object, it makes a POST request instead. Here are two examples:
// Load the weather report for a specified zipcode
$('#temp').load("us_weather_report.html", "zipcode=02134");
// Here we use an object as data instead and specify degrees Fahrenheit
$('#temp').load("us_weather_report.html", { zipcode:02134, units:'F' });
Another optional argument to 
load()
is a callback function that will be invoked when
the Ajax request completes successfully or unsuccessfully and (in the case of success)
after the URL has been loaded and inserted into the selected elements. If you don’t
specify any data, you can pass this callback function as the second argument. Other-
wise, it should be the third argument. The callback you specify will be invoked once
as a method of each of the elements in the jQuery object and will be passed three
19.6  Ajax with jQuery | 559
Client-Side
JavaScript
Download from Wow! eBook <www.wowebook.com>
arguments to each invocation: the complete text of the loaded URL, a status code string,
and the XMLHttpRequest object that was used to load the URL. The status argument
is a jQuery status code, not an HTTP status code, and it will be a string like “success”,
“error”, or “timeout”.
jQuery’s Ajax Status Codes
All of jQuery’s Ajax utilities, including the 
load()
method, invoke callback functions
to provide asynchronous notification of the success or failure of the request. The second
argument to these callbacks is a string with one of the following values:
“success”
Indicates that the request completed successfully.
“notmodified”
This code indicates that the request completed normally but that the server sent
an HTTP 304 “Not Modified” response, indicating that the requested URL has
not changed since it was last requested. This status code only occurs if you set the
ifModified
option to true. (See §19.6.3.1.) jQuery 1.4 considers a “notmodified”
status code a success, but earlier versions consider it an error.
“error”
Indicates that the request did not complete successfully, because of an HTTP error
of some sort. For more details, you can check the HTTP status code in the
XMLHttpRequest object, which is also passed to each callback.
“timeout”
If an Ajax request does not complete within the timeout interval that you select,
the error callback is invoked with this status code. By default, jQuery Ajax requests
do not time out; you’ll only see this status code if you set the 
timeout
option
(§19.6.3.1).
“parsererror”
This status code indicates that the HTTP request completed successfully, but that
jQuery could not parse it in the way it expected to. This status code occurs if the
server sends a malformed XML document or malformed JSON text, for example.
Note that this status code is “parsererror”, not “parseerror”.
19.6.2  Ajax Utility Functions
The other high-level jQuery Ajax utilities are functions, not methods, and are invoked
directly through 
jQuery
or 
$
, not on a jQuery object. 
jQuery.getScript()
loads and
executes files of JavaScript code. 
jQuery.getJSON()
loads a URL, parses it as JSON, and
passes the resulting object to the callback you specify. Both of these functions call
jQuery.get()
,  which  is a  more  general-purpose  URL  fetching  function.  Finally,
jQuery.post()
works just like 
jQuery.get()
, but it performs an HTTP POST request
instead of a GET. Like the 
load()
method, all of these functions are asynchronous: they
return to their caller before anything is loaded and notify you of the results by invoking
a callback function you specify.
560 | Chapter 19: The jQuery Library
19.6.2.1  jQuery.getScript()
The 
jQuery.getScript()
function takes the URL of a file of JavaScript code as its first
argument. It asynchronously loads and then executes that code in the global scope. It
can work for both same-origin and cross-origin scripts:
// Dynamically load a script from some other server
jQuery.getScript("http://example.com/js/widget.js");
You can pass a callback function as the second argument, and if you do, jQuery will
invoke that function once after the code has been loaded and executed.
// Load a library and use it once it loads
jQuery.getScript("js/jquery.my_plugin.js", function() {
$('div').my_plugin();  // Use the library we loaded
});
jQuery.getScript()
normally uses an XMLHttpRequest object to fetch the text of the
script to be executed. But for cross-domain requests (when the script is served by a
server other than the one that served the current document), jQuery loads the script
with a 
<script>
element (see §18.2). In the same-origin case, the first argument to your
callback is the text of the script, the second argument is the status code “success”, and
the third argument is the XMLHttpRequest object used to fetch the text of the script.
The return value of 
jQuery.getScript()
is also the XMLHttpRequest object in this case.
For cross-origin requests, there is no XMLHttpRequest object, and the text of the script
is not captured. In this case, the callback function is called with its first and third ar-
guments 
undefined
, and the return value of 
jQuery.getScript()
is also 
undefined
.
The callback function you pass to 
jQuery.getScript()
is invoked only if the request
completes successfully. If you need to be notified of errors as well as success, you’ll
need to use the lower-level 
jQuery.ajax()
function. The same is true of the three other
utility functions described in this section.
19.6.2.2  jQuery.getJSON()
jQuery.getJSON()
is like 
jQuery.getScript()
: it fetches text and then processes it spe-
cially before invoking the callback you specify. Instead of executing the text as a script,
jQuery.getJSON()
parses it as JSON (using the 
jQuery.parseJSON()
function: see §19.7).
jQuery.getJSON()
is only useful when passed a callback argument. If the URL is loaded
successfully and if its content is successfully parsed as JSON, the resulting object will
be passed as the first argument to the callback function. As with 
jQuery.getScript()
,
the second and third arguments to the callback are the status code “success” and the
XMLHttpRequest object:
// Suppose data.json contains the text: '{"x":1,"y":2}'
jQuery.getJSON("data.json", function(data) {
// Now data is the object {x:1, y:2}
});
Unlike 
jQuery.getScript()
jQuery.getJSON()
accepts an optional data argument like
the one passed to the 
load()
method. If you pass data to 
jQuery.getJSON()
, it must be
19.6  Ajax with jQuery | 561
Client-Side
JavaScript
the second argument and the callback must be the third. If you do not pass any data,
the callback may be the second argument. If the data is a string, it is appended to the
URL, following a 
?
or 
&
. If the data is an object, it is converted to a string (see the sidebar)
and then appended to the URL.
Passing Data to jQuery’s Ajax Utilities
Most of jQuery’s Ajax methods accept an argument (or an option) that specifies data
to send to the server along with the URL. Usually this data takes the form of URL-
encoded 
name=value
pairs separated from each other by ampersands. (This data format
is known by the MIME type “application/x-www-form-urlencoded”. You can think of
it as an analog of JSON: a format for converting simple JavaScript objects to and from
strings.) For HTTP GET requests, this string of data is appended to the request URL.
For POST requests, it is sent as the request body, after all the HTTP headers are sent.
One way to obtain a string of data in this format is to call the 
serialize()
method of a
jQuery object that contains forms or form elements. To submit an HTML form using
the 
load()
method, for example, you might use code like this:
$("#submit_button").click(function(event) {
$(this.form).load(              // Replace the form by loading...
this.form.action,           // the form url
$(this.form).serialize());  // with the form data appended to it
event.preventDefault();         // Don't do the default form submission
this.disabled = "disabled";     // Prevent multiple submissions
});
If you set the data argument (or option) of a jQuery Ajax function to an object rather
than a string, jQuery will normally (with an exception described below) convert that
object to a string for you by calling 
jQuery.param()
. This utility function treats object
properties as name=value pairs and converts the object 
{x:1,y:"hello"}
, for example,
to the string 
"x=1&y=hello"
.
In jQuery 1.4, 
jQuery.param()
handles more complicated JavaScript objects. If the value
of an object property is an array, each element of that array will have its own name/
value pair in the resulting string and the property name will have square brackets ap-
pended. And if the value of a property is an object, the property names of that nested
object are placed in square brackets and appended to the outer property name. For
example:
$.param({a:[1,2,3]})       // Returns "a[]=1&a[]=2&a[]=3"
$.param({o:{x:1,y:true}})  // Returns "o[x]=1&o[y]=true"
$.param({o:{x:{y:[1,2]}}}) // Returns "o[x][y][]=1&o[x][y][]=2"
For backward compatibility with jQuery 1.3 and before, you can pass 
true
as the second
argument to 
jQuery.param()
or set the 
traditional
option to 
true
. This will prevent the
advanced serialization of properties whose values are arrays or objects.
Occasionally, you may want to pass a Document (or some other object that should not
be automatically converted) as the body of a POST request. In this case you can set the
contentType
option to specify the type of your data and set the 
processData
option to
false
, to prevent jQuery from passing your data object to 
jQuery.param()
.
562 | Chapter 19: The jQuery Library
Documents you may be interested
Documents you may be interested