2006-09-30 14:32:49 +00:00
|
|
|
jQuery.fn.extend({
|
2006-03-22 03:33:07 +00:00
|
|
|
|
2006-09-30 14:32:49 +00:00
|
|
|
/**
|
|
|
|
* Load HTML from a remote file and inject it into the DOM, only if it's
|
|
|
|
* been modified by the server.
|
|
|
|
*
|
|
|
|
* @example $("#feeds").loadIfModified("feeds.html")
|
|
|
|
* @before <div id="feeds"></div>
|
|
|
|
* @result <div id="feeds"><b>45</b> feeds found.</div>
|
|
|
|
*
|
|
|
|
* @name loadIfModified
|
|
|
|
* @type jQuery
|
|
|
|
* @param String url The URL of the HTML file to load.
|
|
|
|
* @param Hash params A set of key/value pairs that will be sent to the server.
|
|
|
|
* @param Function callback A function to be executed whenever the data is loaded.
|
|
|
|
* @cat AJAX
|
|
|
|
*/
|
|
|
|
loadIfModified: function( url, params, callback ) {
|
|
|
|
this.load( url, params, callback, 1 );
|
|
|
|
},
|
2006-06-19 01:29:54 +00:00
|
|
|
|
2006-09-30 14:32:49 +00:00
|
|
|
/**
|
|
|
|
* Load HTML from a remote file and inject it into the DOM.
|
|
|
|
*
|
|
|
|
* @example $("#feeds").load("feeds.html")
|
|
|
|
* @before <div id="feeds"></div>
|
|
|
|
* @result <div id="feeds"><b>45</b> feeds found.</div>
|
|
|
|
*
|
|
|
|
* @example $("#feeds").load("feeds.html",
|
|
|
|
* {test: true},
|
|
|
|
* function() { alert("load is done"); }
|
|
|
|
* );
|
|
|
|
* @desc Same as above, but with an additional parameter
|
|
|
|
* and a callback that is executed when the data was loaded.
|
|
|
|
*
|
|
|
|
* @name load
|
|
|
|
* @type jQuery
|
|
|
|
* @param String url The URL of the HTML file to load.
|
2006-11-11 12:08:48 +00:00
|
|
|
* @param Object params A set of key/value pairs that will be sent as data to the server.
|
|
|
|
* @param Function callback A function to be executed whenever the data is loaded (parameters: responseText, status and reponse itself).
|
2006-09-30 14:32:49 +00:00
|
|
|
* @cat AJAX
|
|
|
|
*/
|
|
|
|
load: function( url, params, callback, ifModified ) {
|
|
|
|
if ( url.constructor == Function )
|
|
|
|
return this.bind("load", url);
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-09-30 14:32:49 +00:00
|
|
|
callback = callback || function(){};
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-09-30 14:32:49 +00:00
|
|
|
// Default to a GET request
|
|
|
|
var type = "GET";
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-09-30 14:32:49 +00:00
|
|
|
// If the second parameter was provided
|
|
|
|
if ( params ) {
|
|
|
|
// If it's a function
|
|
|
|
if ( params.constructor == Function ) {
|
|
|
|
// We assume that it's the callback
|
|
|
|
callback = params;
|
|
|
|
params = null;
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-09-30 14:32:49 +00:00
|
|
|
// Otherwise, build a param string
|
|
|
|
} else {
|
|
|
|
params = jQuery.param( params );
|
|
|
|
type = "POST";
|
|
|
|
}
|
|
|
|
}
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-09-30 14:32:49 +00:00
|
|
|
var self = this;
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-09-30 14:32:49 +00:00
|
|
|
// Request the remote document
|
2006-11-03 11:30:57 +00:00
|
|
|
jQuery.ajax({
|
|
|
|
url: url,
|
|
|
|
type: type,
|
|
|
|
data: params,
|
|
|
|
ifModified: ifModified,
|
|
|
|
complete: function(res, status){
|
|
|
|
if ( status == "success" || !ifModified && status == "notmodified" ) {
|
|
|
|
// Inject the HTML into all the matched elements
|
|
|
|
self.html(res.responseText)
|
|
|
|
// Execute all the scripts inside of the newly-injected HTML
|
|
|
|
.evalScripts()
|
|
|
|
// Execute callback
|
2006-11-11 12:08:48 +00:00
|
|
|
.each( callback, [res.responseText, status, res] );
|
2006-11-03 11:30:57 +00:00
|
|
|
} else
|
2006-11-11 12:08:48 +00:00
|
|
|
callback.apply( self, [res.responseText, status, res] );
|
2006-11-03 11:30:57 +00:00
|
|
|
}
|
|
|
|
});
|
2006-09-30 14:32:49 +00:00
|
|
|
return this;
|
|
|
|
},
|
2006-05-16 16:18:52 +00:00
|
|
|
|
2006-09-30 14:32:49 +00:00
|
|
|
/**
|
2006-10-02 16:45:35 +00:00
|
|
|
* Serializes a set of input elements into a string of data.
|
2006-11-04 21:09:05 +00:00
|
|
|
* This will serialize all given elements. If you need
|
2006-10-02 16:45:35 +00:00
|
|
|
* serialization similar to the form submit of a browser,
|
|
|
|
* you should use the form plugin. This is also true for
|
|
|
|
* selects with multiple attribute set, only a single option
|
|
|
|
* is serialized.
|
2006-09-30 14:32:49 +00:00
|
|
|
*
|
|
|
|
* @example $("input[@type=text]").serialize();
|
|
|
|
* @before <input type='text' name='name' value='John'/>
|
|
|
|
* <input type='text' name='location' value='Boston'/>
|
|
|
|
* @after name=John&location=Boston
|
|
|
|
* @desc Serialize a selection of input elements to a string
|
|
|
|
*
|
|
|
|
* @name serialize
|
|
|
|
* @type String
|
|
|
|
* @cat AJAX
|
|
|
|
*/
|
|
|
|
serialize: function() {
|
2006-10-06 17:15:33 +00:00
|
|
|
return jQuery.param( this );
|
2006-10-13 13:57:55 +00:00
|
|
|
},
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-11-11 11:34:51 +00:00
|
|
|
/**
|
|
|
|
* Evaluate all script tags inside this jQuery. If they have a src attribute,
|
|
|
|
* the script is loaded, otherwise it's content is evaluated.
|
|
|
|
*
|
|
|
|
* @name evalScripts
|
|
|
|
* @type jQuery
|
|
|
|
* @private
|
|
|
|
* @cat AJAX
|
|
|
|
*/
|
2006-10-13 13:57:55 +00:00
|
|
|
evalScripts: function() {
|
|
|
|
return this.find('script').each(function(){
|
|
|
|
if ( this.src )
|
|
|
|
// for some weird reason, it doesn't work if the callback is ommited
|
2006-11-20 20:37:28 +00:00
|
|
|
jQuery.getScript( this.src );
|
2006-11-21 09:14:29 +00:00
|
|
|
else {
|
2006-12-02 13:43:02 +00:00
|
|
|
jQuery.globalEval( this.text || this.textContent || this.innerHTML || "" );
|
2006-11-21 09:14:29 +00:00
|
|
|
}
|
2006-10-13 13:57:55 +00:00
|
|
|
}).end();
|
2006-09-30 14:32:49 +00:00
|
|
|
}
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-09-30 14:32:49 +00:00
|
|
|
});
|
2006-09-08 10:18:46 +00:00
|
|
|
|
2006-06-19 01:29:54 +00:00
|
|
|
// If IE is used, create a wrapper for the XMLHttpRequest object
|
2006-08-31 06:30:44 +00:00
|
|
|
if ( jQuery.browser.msie && typeof XMLHttpRequest == "undefined" )
|
2006-06-19 01:29:54 +00:00
|
|
|
XMLHttpRequest = function(){
|
|
|
|
return new ActiveXObject(
|
2006-07-10 03:20:56 +00:00
|
|
|
navigator.userAgent.indexOf("MSIE 5") >= 0 ?
|
2006-06-19 01:29:54 +00:00
|
|
|
"Microsoft.XMLHTTP" : "Msxml2.XMLHTTP"
|
|
|
|
);
|
|
|
|
};
|
2006-06-08 17:31:57 +00:00
|
|
|
|
2006-06-19 01:29:54 +00:00
|
|
|
// Attach a bunch of functions for handling common AJAX events
|
2006-09-08 10:18:46 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Attach a function to be executed whenever an AJAX request begins.
|
|
|
|
*
|
|
|
|
* @example $("#loading").ajaxStart(function(){
|
|
|
|
* $(this).show();
|
|
|
|
* });
|
|
|
|
* @desc Show a loading message whenever an AJAX request starts.
|
|
|
|
*
|
|
|
|
* @name ajaxStart
|
|
|
|
* @type jQuery
|
|
|
|
* @param Function callback The function to execute.
|
|
|
|
* @cat AJAX
|
|
|
|
*/
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-09-08 10:18:46 +00:00
|
|
|
/**
|
|
|
|
* Attach a function to be executed whenever all AJAX requests have ended.
|
|
|
|
*
|
|
|
|
* @example $("#loading").ajaxStop(function(){
|
|
|
|
* $(this).hide();
|
|
|
|
* });
|
|
|
|
* @desc Hide a loading message after all the AJAX requests have stopped.
|
|
|
|
*
|
|
|
|
* @name ajaxStop
|
|
|
|
* @type jQuery
|
|
|
|
* @param Function callback The function to execute.
|
|
|
|
* @cat AJAX
|
|
|
|
*/
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-09-08 10:18:46 +00:00
|
|
|
/**
|
|
|
|
* Attach a function to be executed whenever an AJAX request completes.
|
|
|
|
*
|
|
|
|
* @example $("#msg").ajaxComplete(function(){
|
|
|
|
* $(this).append("<li>Request Complete.</li>");
|
|
|
|
* });
|
|
|
|
* @desc Show a message when an AJAX request completes.
|
|
|
|
*
|
|
|
|
* @name ajaxComplete
|
|
|
|
* @type jQuery
|
|
|
|
* @param Function callback The function to execute.
|
|
|
|
* @cat AJAX
|
|
|
|
*/
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-09-08 10:18:46 +00:00
|
|
|
/**
|
|
|
|
* Attach a function to be executed whenever an AJAX request completes
|
|
|
|
* successfully.
|
|
|
|
*
|
|
|
|
* @example $("#msg").ajaxSuccess(function(){
|
|
|
|
* $(this).append("<li>Successful Request!</li>");
|
|
|
|
* });
|
|
|
|
* @desc Show a message when an AJAX request completes successfully.
|
|
|
|
*
|
|
|
|
* @name ajaxSuccess
|
|
|
|
* @type jQuery
|
|
|
|
* @param Function callback The function to execute.
|
|
|
|
* @cat AJAX
|
|
|
|
*/
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-09-08 10:18:46 +00:00
|
|
|
/**
|
|
|
|
* Attach a function to be executed whenever an AJAX request fails.
|
|
|
|
*
|
|
|
|
* @example $("#msg").ajaxError(function(){
|
|
|
|
* $(this).append("<li>Error requesting page.</li>");
|
|
|
|
* });
|
|
|
|
* @desc Show a message when an AJAX request fails.
|
|
|
|
*
|
|
|
|
* @name ajaxError
|
|
|
|
* @type jQuery
|
|
|
|
* @param Function callback The function to execute.
|
|
|
|
* @cat AJAX
|
|
|
|
*/
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
new function(){
|
2006-09-08 10:18:46 +00:00
|
|
|
var e = "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess".split(",");
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
for ( var i = 0; i < e.length; i++ ) new function(){
|
2006-06-19 01:29:54 +00:00
|
|
|
var o = e[i];
|
2006-07-10 03:20:56 +00:00
|
|
|
jQuery.fn[o] = function(f){
|
|
|
|
return this.bind(o, f);
|
|
|
|
};
|
2006-08-17 04:18:32 +00:00
|
|
|
};
|
2006-07-17 01:49:55 +00:00
|
|
|
};
|
$.fn.formValues;
Gets form values and creates a key=>value array of the found values.
What's new?
- Only does this for ENABLED elements.
- Keeps the same order of the form.
- Optionally adds the button which is clicked (marks that name with an 'x' in the list)
example: $('#frmLogin').formValues('oButton');
$.fn.update (PREVIOUSLY: $.update, so beware!!!!)
Calls sURL with sAction (method) and sends the aValues. Puts the results from that call in the jQuery object and calls fCallback if provided.
What's new?
- Renamed $.update to $.fn.update, since it is more obvious to call $('someJQueryObject').update(...) then $.update($('someJQueryObject'), ...). It's also more jQuery-ish
- Added the method you want to use, since i used post before, now you can select between either GET or POST.
example: $('someJQueryObject').update('sURL', 'sAction', 'aValues', 'fCallback');
$.fn.serialize
Calls the form's action with the correct method and the serialized values. Optionally adds the button which is clicked if you provide it. When there are results, the fCallback function is called.
What's new?
- The entire function
example: $('someForm').serialize('sButton', 'fCallback');
2006-05-31 11:14:21 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
jQuery.extend({
|
2006-05-17 18:04:46 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
/**
|
2006-09-08 10:18:46 +00:00
|
|
|
* Load a remote page using an HTTP GET request. All of the arguments to
|
|
|
|
* the method (except URL) are optional.
|
2006-09-01 06:50:35 +00:00
|
|
|
*
|
|
|
|
* @example $.get("test.cgi")
|
|
|
|
*
|
|
|
|
* @example $.get("test.cgi", { name: "John", time: "2pm" } )
|
|
|
|
*
|
2006-09-08 10:18:46 +00:00
|
|
|
* @example $.get("test.cgi", function(data){
|
|
|
|
* alert("Data Loaded: " + data);
|
2006-09-01 06:50:35 +00:00
|
|
|
* })
|
|
|
|
*
|
|
|
|
* @example $.get("test.cgi",
|
|
|
|
* { name: "John", time: "2pm" },
|
2006-09-08 10:18:46 +00:00
|
|
|
* function(data){
|
|
|
|
* alert("Data Loaded: " + data);
|
|
|
|
* }
|
2006-09-01 06:50:35 +00:00
|
|
|
* )
|
|
|
|
*
|
|
|
|
* @name $.get
|
2006-11-04 21:09:05 +00:00
|
|
|
* @type undefined
|
2006-09-08 10:18:46 +00:00
|
|
|
* @param String url The URL of the page to load.
|
2006-09-01 06:50:35 +00:00
|
|
|
* @param Hash params A set of key/value pairs that will be sent to the server.
|
|
|
|
* @param Function callback A function to be executed whenever the data is loaded.
|
|
|
|
* @cat AJAX
|
2006-07-10 03:20:56 +00:00
|
|
|
*/
|
2006-08-17 04:18:32 +00:00
|
|
|
get: function( url, data, callback, type, ifModified ) {
|
2006-11-11 11:34:51 +00:00
|
|
|
// shift arguments if data argument was ommited
|
2006-10-13 13:57:55 +00:00
|
|
|
if ( data && data.constructor == Function ) {
|
2006-07-10 03:20:56 +00:00
|
|
|
callback = data;
|
|
|
|
data = null;
|
|
|
|
}
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-11-11 11:34:51 +00:00
|
|
|
// Delegate
|
2006-11-03 11:30:57 +00:00
|
|
|
jQuery.ajax({
|
|
|
|
url: url,
|
2006-11-11 11:34:51 +00:00
|
|
|
data: data,
|
|
|
|
success: callback,
|
|
|
|
dataType: type,
|
|
|
|
ifModified: ifModified
|
2006-11-03 11:30:57 +00:00
|
|
|
});
|
2006-08-17 04:18:32 +00:00
|
|
|
},
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-09-01 06:50:35 +00:00
|
|
|
/**
|
2006-09-08 10:18:46 +00:00
|
|
|
* Load a remote page using an HTTP GET request, only if it hasn't
|
|
|
|
* been modified since it was last retrieved. All of the arguments to
|
|
|
|
* the method (except URL) are optional.
|
2006-09-01 06:50:35 +00:00
|
|
|
*
|
2006-09-08 10:18:46 +00:00
|
|
|
* @example $.getIfModified("test.html")
|
2006-09-01 06:50:35 +00:00
|
|
|
*
|
2006-09-08 10:18:46 +00:00
|
|
|
* @example $.getIfModified("test.html", { name: "John", time: "2pm" } )
|
|
|
|
*
|
|
|
|
* @example $.getIfModified("test.cgi", function(data){
|
|
|
|
* alert("Data Loaded: " + data);
|
|
|
|
* })
|
2006-09-01 06:50:35 +00:00
|
|
|
*
|
2006-09-08 10:18:46 +00:00
|
|
|
* @example $.getifModified("test.cgi",
|
|
|
|
* { name: "John", time: "2pm" },
|
|
|
|
* function(data){
|
|
|
|
* alert("Data Loaded: " + data);
|
|
|
|
* }
|
|
|
|
* )
|
2006-09-01 06:50:35 +00:00
|
|
|
*
|
|
|
|
* @name $.getIfModified
|
2006-11-04 21:09:05 +00:00
|
|
|
* @type undefined
|
2006-09-08 10:18:46 +00:00
|
|
|
* @param String url The URL of the page to load.
|
2006-09-01 06:50:35 +00:00
|
|
|
* @param Hash params A set of key/value pairs that will be sent to the server.
|
2006-09-08 10:18:46 +00:00
|
|
|
* @param Function callback A function to be executed whenever the data is loaded.
|
2006-09-01 06:50:35 +00:00
|
|
|
* @cat AJAX
|
|
|
|
*/
|
2006-09-08 10:18:46 +00:00
|
|
|
getIfModified: function( url, data, callback, type ) {
|
|
|
|
jQuery.get(url, data, callback, type, 1);
|
|
|
|
},
|
|
|
|
|
2006-09-01 06:50:35 +00:00
|
|
|
/**
|
2006-09-08 10:18:46 +00:00
|
|
|
* Loads, and executes, a remote JavaScript file using an HTTP GET request.
|
|
|
|
* All of the arguments to the method (except URL) are optional.
|
2006-09-01 06:50:35 +00:00
|
|
|
*
|
2006-12-02 13:43:02 +00:00
|
|
|
* Warning: Safari <= 2.0.x is unable to evalulate scripts in a global
|
|
|
|
* context sychronously. If you load functions via getScript, make sure
|
|
|
|
* to call them after a delay.
|
|
|
|
*
|
2006-09-08 10:18:46 +00:00
|
|
|
* @example $.getScript("test.js")
|
|
|
|
*
|
|
|
|
* @example $.getScript("test.js", function(){
|
|
|
|
* alert("Script loaded and executed.");
|
2006-09-01 06:50:35 +00:00
|
|
|
* })
|
|
|
|
*
|
2006-09-08 10:18:46 +00:00
|
|
|
* @name $.getScript
|
2006-11-04 21:09:05 +00:00
|
|
|
* @type undefined
|
2006-09-08 10:18:46 +00:00
|
|
|
* @param String url The URL of the page to load.
|
2006-09-01 06:50:35 +00:00
|
|
|
* @param Function callback A function to be executed whenever the data is loaded.
|
|
|
|
* @cat AJAX
|
|
|
|
*/
|
2006-09-30 14:32:49 +00:00
|
|
|
getScript: function( url, callback ) {
|
2006-10-13 13:57:55 +00:00
|
|
|
if(callback)
|
|
|
|
jQuery.get(url, null, callback, "script");
|
|
|
|
else {
|
|
|
|
jQuery.get(url, null, null, "script");
|
|
|
|
}
|
2006-09-08 10:18:46 +00:00
|
|
|
},
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-09-01 06:50:35 +00:00
|
|
|
/**
|
2006-09-08 10:18:46 +00:00
|
|
|
* Load a remote JSON object using an HTTP GET request.
|
|
|
|
* All of the arguments to the method (except URL) are optional.
|
2006-09-01 06:50:35 +00:00
|
|
|
*
|
2006-09-08 10:18:46 +00:00
|
|
|
* @example $.getJSON("test.js", function(json){
|
|
|
|
* alert("JSON Data: " + json.users[3].name);
|
|
|
|
* })
|
|
|
|
*
|
|
|
|
* @example $.getJSON("test.js",
|
2006-09-01 06:50:35 +00:00
|
|
|
* { name: "John", time: "2pm" },
|
2006-09-08 10:18:46 +00:00
|
|
|
* function(json){
|
|
|
|
* alert("JSON Data: " + json.users[3].name);
|
|
|
|
* }
|
2006-09-01 06:50:35 +00:00
|
|
|
* )
|
|
|
|
*
|
2006-09-08 10:18:46 +00:00
|
|
|
* @name $.getJSON
|
2006-11-04 21:09:05 +00:00
|
|
|
* @type undefined
|
2006-09-08 10:18:46 +00:00
|
|
|
* @param String url The URL of the page to load.
|
2006-09-01 06:50:35 +00:00
|
|
|
* @param Hash params A set of key/value pairs that will be sent to the server.
|
|
|
|
* @param Function callback A function to be executed whenever the data is loaded.
|
|
|
|
* @cat AJAX
|
|
|
|
*/
|
2006-09-08 10:18:46 +00:00
|
|
|
getJSON: function( url, data, callback ) {
|
2006-11-17 09:56:30 +00:00
|
|
|
jQuery.get(url, data, callback, "json");
|
2006-07-10 03:20:56 +00:00
|
|
|
},
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
/**
|
2006-09-08 10:18:46 +00:00
|
|
|
* Load a remote page using an HTTP POST request. All of the arguments to
|
|
|
|
* the method (except URL) are optional.
|
|
|
|
*
|
|
|
|
* @example $.post("test.cgi")
|
|
|
|
*
|
|
|
|
* @example $.post("test.cgi", { name: "John", time: "2pm" } )
|
|
|
|
*
|
|
|
|
* @example $.post("test.cgi", function(data){
|
|
|
|
* alert("Data Loaded: " + data);
|
|
|
|
* })
|
|
|
|
*
|
|
|
|
* @example $.post("test.cgi",
|
|
|
|
* { name: "John", time: "2pm" },
|
|
|
|
* function(data){
|
|
|
|
* alert("Data Loaded: " + data);
|
|
|
|
* }
|
|
|
|
* )
|
|
|
|
*
|
|
|
|
* @name $.post
|
2006-11-04 21:09:05 +00:00
|
|
|
* @type undefined
|
2006-09-08 10:18:46 +00:00
|
|
|
* @param String url The URL of the page to load.
|
|
|
|
* @param Hash params A set of key/value pairs that will be sent to the server.
|
|
|
|
* @param Function callback A function to be executed whenever the data is loaded.
|
|
|
|
* @cat AJAX
|
2006-07-10 03:20:56 +00:00
|
|
|
*/
|
|
|
|
post: function( url, data, callback, type ) {
|
2006-11-11 11:34:51 +00:00
|
|
|
// Delegate
|
2006-11-03 11:30:57 +00:00
|
|
|
jQuery.ajax({
|
|
|
|
type: "POST",
|
|
|
|
url: url,
|
2006-11-11 11:34:51 +00:00
|
|
|
data: data,
|
|
|
|
success: callback,
|
|
|
|
dataType: type
|
2006-07-10 03:20:56 +00:00
|
|
|
});
|
|
|
|
},
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-08-17 04:18:32 +00:00
|
|
|
// timeout (ms)
|
|
|
|
timeout: 0,
|
|
|
|
|
2006-09-08 10:18:46 +00:00
|
|
|
/**
|
|
|
|
* Set the timeout of all AJAX requests to a specific amount of time.
|
|
|
|
* This will make all future AJAX requests timeout after a specified amount
|
|
|
|
* of time (the default is no timeout).
|
|
|
|
*
|
|
|
|
* @example $.ajaxTimeout( 5000 );
|
|
|
|
* @desc Make all AJAX requests timeout after 5 seconds.
|
|
|
|
*
|
|
|
|
* @name $.ajaxTimeout
|
2006-11-04 21:09:05 +00:00
|
|
|
* @type undefined
|
2006-09-08 10:18:46 +00:00
|
|
|
* @param Number time How long before an AJAX request times out.
|
|
|
|
* @cat AJAX
|
|
|
|
*/
|
2006-08-17 04:18:32 +00:00
|
|
|
ajaxTimeout: function(timeout) {
|
|
|
|
jQuery.timeout = timeout;
|
|
|
|
},
|
|
|
|
|
|
|
|
// Last-Modified header cache for next request
|
|
|
|
lastModified: {},
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
/**
|
2006-09-08 10:18:46 +00:00
|
|
|
* Load a remote page using an HTTP request. This function is the primary
|
2006-11-18 10:37:33 +00:00
|
|
|
* means of making AJAX requests using jQuery.
|
2006-09-08 10:18:46 +00:00
|
|
|
*
|
2006-11-17 14:49:44 +00:00
|
|
|
* $.ajax() returns the XMLHttpRequest that it creates. In most cases you won't
|
|
|
|
* need that object to manipulate directly, but it is available if you need to
|
|
|
|
* abort the request manually.
|
|
|
|
*
|
2006-11-18 10:37:33 +00:00
|
|
|
* Please note: Make sure the server sends the right mimetype (eg. xml as
|
|
|
|
* "text/xml"). Sending the wrong mimetype will get you into serious
|
|
|
|
* trouble that jQuery can't solve.
|
2006-09-08 10:18:46 +00:00
|
|
|
*
|
2006-11-18 10:37:33 +00:00
|
|
|
* Supported datatypes (see dataType option) are:
|
|
|
|
*
|
|
|
|
* "xml": Returns a XML document that can be processed via jQuery.
|
|
|
|
*
|
|
|
|
* "html": Returns HTML as plain text, included script tags are evaluated.
|
|
|
|
*
|
|
|
|
* "script": Evaluates the response as Javascript and returns it as plain text.
|
|
|
|
*
|
|
|
|
* "json": Evaluates the response as JSON and returns a Javascript Object
|
|
|
|
*
|
|
|
|
* $.ajax() takes one property, an object of key/value pairs, that are
|
|
|
|
* used to initalize the request. These are all the key/values that can
|
|
|
|
* be passed in to 'prop':
|
2006-09-08 10:18:46 +00:00
|
|
|
*
|
|
|
|
* (String) url - The URL of the page to request.
|
2006-11-04 21:09:05 +00:00
|
|
|
*
|
2006-11-18 10:37:33 +00:00
|
|
|
* (String) type - The type of request to make (e.g. "POST" or "GET"), default is "GET".
|
2006-09-08 10:18:46 +00:00
|
|
|
*
|
|
|
|
* (String) dataType - The type of data that you're expecting back from
|
2006-11-18 10:37:33 +00:00
|
|
|
* the server. No default: If the server sends xml, the responseXML, otherwise
|
|
|
|
* the responseText is is passed to the success callback.
|
2006-09-08 10:18:46 +00:00
|
|
|
*
|
2006-10-01 14:32:29 +00:00
|
|
|
* (Boolean) ifModified - Allow the request to be successful only if the
|
|
|
|
* response has changed since the last request, default is false, ignoring
|
|
|
|
* the Last-Modified header
|
|
|
|
*
|
2006-10-01 14:15:56 +00:00
|
|
|
* (Number) timeout - Local timeout to override global timeout, eg. to give a
|
|
|
|
* single request a longer timeout while all others timeout after 1 seconds,
|
2006-11-18 10:37:33 +00:00
|
|
|
* see $.ajaxTimeout()
|
2006-10-01 14:15:56 +00:00
|
|
|
*
|
2006-10-01 14:05:10 +00:00
|
|
|
* (Boolean) global - Wheather to trigger global AJAX event handlers for
|
2006-11-18 10:37:33 +00:00
|
|
|
* this request, default is true. Set to false to prevent that global handlers
|
2006-10-01 14:05:10 +00:00
|
|
|
* like ajaxStart or ajaxStop are triggered.
|
|
|
|
*
|
2006-09-08 10:18:46 +00:00
|
|
|
* (Function) error - A function to be called if the request fails. The
|
|
|
|
* function gets passed two arguments: The XMLHttpRequest object and a
|
|
|
|
* string describing the type of error that occurred.
|
|
|
|
*
|
|
|
|
* (Function) success - A function to be called if the request succeeds. The
|
|
|
|
* function gets passed one argument: The data returned from the server,
|
|
|
|
* formatted according to the 'dataType' parameter.
|
|
|
|
*
|
|
|
|
* (Function) complete - A function to be called when the request finishes. The
|
|
|
|
* function gets passed two arguments: The XMLHttpRequest object and a
|
|
|
|
* string describing the type the success of the request.
|
|
|
|
*
|
2006-11-28 11:36:54 +00:00
|
|
|
* (Object|String) data - Data to be sent to the server. Converted to a query
|
2006-11-17 09:56:30 +00:00
|
|
|
* string, if not already a string. Is appended to the url for GET-requests.
|
|
|
|
* Override processData option to prevent processing.
|
|
|
|
*
|
|
|
|
* (String) contentType - When sending data to the server, use this content-type,
|
|
|
|
* default is "application/x-www-form-urlencoded", which is fine for most cases.
|
|
|
|
*
|
|
|
|
* (Boolean) processData - By default, data passed in as an object other as string
|
|
|
|
* will be processed and transformed into a query string, fitting to the default
|
|
|
|
* content-type "application/x-www-form-urlencoded". If you want to send DOMDocuments,
|
|
|
|
* set this option to false.
|
|
|
|
*
|
2006-11-17 10:15:31 +00:00
|
|
|
* (Boolean) async - By default, all requests are send asynchronous (set to true).
|
|
|
|
* If you need synchronous requests, set this option to false.
|
|
|
|
*
|
2006-09-08 10:18:46 +00:00
|
|
|
* @example $.ajax({
|
|
|
|
* type: "GET",
|
|
|
|
* url: "test.js",
|
|
|
|
* dataType: "script"
|
|
|
|
* })
|
|
|
|
* @desc Load and execute a JavaScript file.
|
|
|
|
*
|
|
|
|
* @example $.ajax({
|
|
|
|
* type: "POST",
|
|
|
|
* url: "some.php",
|
|
|
|
* data: "name=John&location=Boston",
|
|
|
|
* success: function(msg){
|
|
|
|
* alert( "Data Saved: " + msg );
|
|
|
|
* }
|
|
|
|
* });
|
|
|
|
* @desc Save some data to the server and notify the user once its complete.
|
|
|
|
*
|
|
|
|
* @name $.ajax
|
2006-11-17 14:49:44 +00:00
|
|
|
* @type XMLHttpRequest
|
2006-09-08 10:18:46 +00:00
|
|
|
* @param Hash prop A set of properties to initialize the request with.
|
|
|
|
* @cat AJAX
|
2006-07-10 03:20:56 +00:00
|
|
|
*/
|
2006-11-03 11:30:57 +00:00
|
|
|
ajax: function( s ) {
|
2006-11-11 11:34:51 +00:00
|
|
|
// TODO introduce global settings, allowing the client to modify them for all requests, not only timeout
|
2006-11-03 11:30:57 +00:00
|
|
|
s = jQuery.extend({
|
|
|
|
global: true,
|
|
|
|
ifModified: false,
|
|
|
|
type: "GET",
|
|
|
|
timeout: jQuery.timeout,
|
2006-11-11 11:34:51 +00:00
|
|
|
complete: null,
|
|
|
|
success: null,
|
|
|
|
error: null,
|
2006-11-03 11:30:57 +00:00
|
|
|
dataType: null,
|
2006-11-17 09:56:30 +00:00
|
|
|
url: null,
|
2006-11-03 11:30:57 +00:00
|
|
|
data: null,
|
2006-11-17 09:56:30 +00:00
|
|
|
contentType: "application/x-www-form-urlencoded",
|
2006-11-17 10:15:31 +00:00
|
|
|
processData: true,
|
|
|
|
async: true
|
2006-11-03 11:30:57 +00:00
|
|
|
}, s);
|
|
|
|
|
2006-11-11 11:34:51 +00:00
|
|
|
// if data available
|
|
|
|
if ( s.data ) {
|
|
|
|
// convert data if not already a string
|
2006-11-17 09:56:30 +00:00
|
|
|
if (s.processData && typeof s.data != 'string')
|
2006-11-13 10:37:42 +00:00
|
|
|
s.data = jQuery.param(s.data);
|
2006-11-11 11:34:51 +00:00
|
|
|
// append data to url for get requests
|
|
|
|
if( s.type.toLowerCase() == "get" )
|
|
|
|
// "?" + data or "&" + data (in case there are already params)
|
|
|
|
s.url += ((s.url.indexOf("?") > -1) ? "&" : "?") + s.data;
|
2006-07-10 03:20:56 +00:00
|
|
|
}
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
// Watch for a new set of requests
|
2006-11-03 11:30:57 +00:00
|
|
|
if ( s.global && ! jQuery.active++ )
|
2006-07-10 03:20:56 +00:00
|
|
|
jQuery.event.trigger( "ajaxStart" );
|
2006-08-22 07:32:25 +00:00
|
|
|
|
|
|
|
var requestDone = false;
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
// Create the request object
|
|
|
|
var xml = new XMLHttpRequest();
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
// Open the socket
|
2006-11-17 10:15:31 +00:00
|
|
|
xml.open(s.type, s.url, s.async);
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
// Set the correct header, if data is being sent
|
2006-11-03 11:30:57 +00:00
|
|
|
if ( s.data )
|
2006-11-17 09:56:30 +00:00
|
|
|
xml.setRequestHeader("Content-Type", s.contentType);
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-08-17 04:18:32 +00:00
|
|
|
// Set the If-Modified-Since header, if ifModified mode.
|
2006-11-03 11:30:57 +00:00
|
|
|
if ( s.ifModified )
|
2006-08-17 04:18:32 +00:00
|
|
|
xml.setRequestHeader("If-Modified-Since",
|
2006-11-03 11:30:57 +00:00
|
|
|
jQuery.lastModified[s.url] || "Thu, 01 Jan 1970 00:00:00 GMT" );
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-09-30 14:32:49 +00:00
|
|
|
// Set header so the called script knows that it's an XMLHttpRequest
|
2006-07-10 03:20:56 +00:00
|
|
|
xml.setRequestHeader("X-Requested-With", "XMLHttpRequest");
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
// Make sure the browser sends the right content length
|
|
|
|
if ( xml.overrideMimeType )
|
|
|
|
xml.setRequestHeader("Connection", "close");
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
// Wait for a response to come back
|
2006-11-03 11:30:57 +00:00
|
|
|
var onreadystatechange = function(isTimeout){
|
2006-08-17 04:18:32 +00:00
|
|
|
// The transfer is complete and the data is available, or the request timed out
|
2006-11-03 11:30:57 +00:00
|
|
|
if ( xml && (xml.readyState == 4 || isTimeout == "timeout") ) {
|
2006-08-22 07:32:25 +00:00
|
|
|
requestDone = true;
|
|
|
|
|
2006-11-03 11:30:57 +00:00
|
|
|
var status = jQuery.httpSuccess( xml ) && isTimeout != "timeout" ?
|
|
|
|
s.ifModified && jQuery.httpNotModified( xml, s.url ) ? "notmodified" : "success" : "error";
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-08-17 04:18:32 +00:00
|
|
|
// Make sure that the request was successful or notmodified
|
|
|
|
if ( status != "error" ) {
|
|
|
|
// Cache Last-Modified header, if ifModified mode.
|
2006-10-01 14:32:29 +00:00
|
|
|
var modRes;
|
|
|
|
try {
|
|
|
|
modRes = xml.getResponseHeader("Last-Modified");
|
|
|
|
} catch(e) {} // swallow exception thrown by FF if header is not available
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-11-03 11:30:57 +00:00
|
|
|
if ( s.ifModified && modRes )
|
|
|
|
jQuery.lastModified[s.url] = modRes;
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-11-20 20:37:28 +00:00
|
|
|
// process the data (runs the xml through httpData regardless of callback)
|
|
|
|
var data = jQuery.httpData( xml, s.dataType );
|
|
|
|
|
|
|
|
// If a local callback was specified, fire it and pass it the data
|
2006-11-03 11:30:57 +00:00
|
|
|
if ( s.success )
|
2006-11-20 20:37:28 +00:00
|
|
|
s.success( data, status );
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
// Fire the global callback
|
2006-11-03 11:30:57 +00:00
|
|
|
if( s.global )
|
2006-10-01 14:05:10 +00:00
|
|
|
jQuery.event.trigger( "ajaxSuccess" );
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
// Otherwise, the request was not successful
|
|
|
|
} else {
|
|
|
|
// If a local callback was specified, fire it
|
2006-11-03 11:30:57 +00:00
|
|
|
if ( s.error ) s.error( xml, status );
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
// Fire the global callback
|
2006-11-03 11:30:57 +00:00
|
|
|
if( s.global )
|
2006-10-01 14:05:10 +00:00
|
|
|
jQuery.event.trigger( "ajaxError" );
|
2006-07-10 03:20:56 +00:00
|
|
|
}
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
// The request was completed
|
2006-11-03 11:30:57 +00:00
|
|
|
if( s.global )
|
2006-10-01 14:05:10 +00:00
|
|
|
jQuery.event.trigger( "ajaxComplete" );
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
// Handle the global AJAX counter
|
2006-11-03 11:30:57 +00:00
|
|
|
if ( s.global && ! --jQuery.active )
|
2006-07-10 03:20:56 +00:00
|
|
|
jQuery.event.trigger( "ajaxStop" );
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
// Process result
|
2006-11-03 11:30:57 +00:00
|
|
|
if ( s.complete ) s.complete(xml, status);
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-17 04:57:07 +00:00
|
|
|
// Stop memory leaks
|
|
|
|
xml.onreadystatechange = function(){};
|
|
|
|
xml = null;
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-06-19 01:29:54 +00:00
|
|
|
}
|
2006-07-17 04:57:07 +00:00
|
|
|
};
|
2006-08-17 04:18:32 +00:00
|
|
|
xml.onreadystatechange = onreadystatechange;
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-08-17 04:18:32 +00:00
|
|
|
// Timeout checker
|
2006-11-03 11:30:57 +00:00
|
|
|
if(s.timeout > 0)
|
2006-08-17 04:18:32 +00:00
|
|
|
setTimeout(function(){
|
|
|
|
// Check to see if the request is still happening
|
|
|
|
if (xml) {
|
|
|
|
// Cancel the request
|
|
|
|
xml.abort();
|
|
|
|
|
2006-08-22 07:32:25 +00:00
|
|
|
if ( !requestDone ) onreadystatechange( "timeout" );
|
2006-08-17 04:18:32 +00:00
|
|
|
|
|
|
|
// Clear from memory
|
|
|
|
xml = null;
|
|
|
|
}
|
2006-11-03 11:30:57 +00:00
|
|
|
}, s.timeout);
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
// Send the data
|
2006-11-03 11:30:57 +00:00
|
|
|
xml.send(s.data);
|
2006-11-17 14:49:44 +00:00
|
|
|
|
|
|
|
// return XMLHttpRequest to allow aborting the request etc.
|
|
|
|
return xml;
|
2006-07-10 03:20:56 +00:00
|
|
|
},
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
// Counter for holding the number of active queries
|
|
|
|
active: 0,
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
// Determines if an XMLHttpRequest was successful or not
|
|
|
|
httpSuccess: function(r) {
|
|
|
|
try {
|
2006-08-22 07:32:25 +00:00
|
|
|
return !r.status && location.protocol == "file:" ||
|
|
|
|
( r.status >= 200 && r.status < 300 ) || r.status == 304 ||
|
|
|
|
jQuery.browser.safari && r.status == undefined;
|
2006-07-10 03:20:56 +00:00
|
|
|
} catch(e){}
|
2006-08-17 04:18:32 +00:00
|
|
|
|
|
|
|
return false;
|
|
|
|
},
|
|
|
|
|
|
|
|
// Determines if an XMLHttpRequest returns NotModified
|
|
|
|
httpNotModified: function(xml, url) {
|
|
|
|
try {
|
|
|
|
var xmlRes = xml.getResponseHeader("Last-Modified");
|
|
|
|
|
|
|
|
// Firefox always returns 200. check Last-Modified date
|
2006-08-22 07:32:25 +00:00
|
|
|
return xml.status == 304 || xmlRes == jQuery.lastModified[url] ||
|
|
|
|
jQuery.browser.safari && xml.status == undefined;
|
2006-08-17 04:18:32 +00:00
|
|
|
} catch(e){}
|
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
return false;
|
|
|
|
},
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-09-08 10:18:46 +00:00
|
|
|
/* Get the data out of an XMLHttpRequest.
|
|
|
|
* Return parsed XML if content-type header is "xml" and type is "xml" or omitted,
|
|
|
|
* otherwise return plain text.
|
|
|
|
* (String) data - The type of data that you're expecting back,
|
|
|
|
* (e.g. "xml", "html", "script")
|
|
|
|
*/
|
2006-07-10 03:20:56 +00:00
|
|
|
httpData: function(r,type) {
|
|
|
|
var ct = r.getResponseHeader("content-type");
|
2006-08-17 05:11:34 +00:00
|
|
|
var data = !type && ct && ct.indexOf("xml") >= 0;
|
|
|
|
data = type == "xml" || data ? r.responseXML : r.responseText;
|
2006-08-17 04:18:32 +00:00
|
|
|
|
2006-11-21 09:21:38 +00:00
|
|
|
// If the type is "script", eval it in global context
|
2006-11-20 20:37:28 +00:00
|
|
|
if ( type == "script" ) {
|
2006-12-02 13:43:02 +00:00
|
|
|
jQuery.globalEval( data );
|
2006-11-20 20:37:28 +00:00
|
|
|
}
|
2006-08-17 04:18:32 +00:00
|
|
|
|
2006-08-31 06:32:27 +00:00
|
|
|
// Get the JavaScript object, if JSON is used.
|
|
|
|
if ( type == "json" ) eval( "data = " + data );
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-10-13 13:57:55 +00:00
|
|
|
// evaluate scripts within html
|
2006-11-01 21:59:56 +00:00
|
|
|
if ( type == "html" ) jQuery("<div>").html(data).evalScripts();
|
2006-08-31 06:32:27 +00:00
|
|
|
|
2006-08-17 04:18:32 +00:00
|
|
|
return data;
|
2006-07-10 03:20:56 +00:00
|
|
|
},
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
// Serialize an array of form elements or a set of
|
|
|
|
// key/values into a query string
|
|
|
|
param: function(a) {
|
|
|
|
var s = [];
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
// If an array was passed in, assume that it is an array
|
|
|
|
// of form elements
|
2006-09-08 10:18:46 +00:00
|
|
|
if ( a.constructor == Array || a.jquery ) {
|
2006-07-10 03:20:56 +00:00
|
|
|
// Serialize the form elements
|
|
|
|
for ( var i = 0; i < a.length; i++ )
|
|
|
|
s.push( a[i].name + "=" + encodeURIComponent( a[i].value ) );
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
// Otherwise, assume that it's an object of key/value pairs
|
2006-08-13 01:29:27 +00:00
|
|
|
} else {
|
2006-07-10 03:20:56 +00:00
|
|
|
// Serialize the key/values
|
2006-11-16 10:30:14 +00:00
|
|
|
for ( var j in a ) {
|
2006-11-30 20:52:24 +00:00
|
|
|
// If the value is an array then the key names need to be repeated
|
|
|
|
if( a[j].constructor == Array ) {
|
2006-11-16 10:30:14 +00:00
|
|
|
for (var k = 0; k < a[j].length; k++) {
|
2006-11-30 20:52:24 +00:00
|
|
|
s.push( j + "=" + encodeURIComponent( a[j][k] ) );
|
2006-11-16 10:30:14 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
s.push( j + "=" + encodeURIComponent( a[j] ) );
|
|
|
|
}
|
2006-11-16 20:39:28 +00:00
|
|
|
}
|
2006-08-13 01:29:27 +00:00
|
|
|
}
|
2006-11-04 21:09:05 +00:00
|
|
|
|
2006-07-10 03:20:56 +00:00
|
|
|
// Return the resulting serialization
|
|
|
|
return s.join("&");
|
2006-11-21 09:55:34 +00:00
|
|
|
},
|
|
|
|
|
2006-12-02 13:43:02 +00:00
|
|
|
// evalulates a script in global context
|
|
|
|
// not reliable for safari
|
|
|
|
globalEval: function(data) {
|
2006-11-21 09:55:34 +00:00
|
|
|
if (window.execScript)
|
|
|
|
window.execScript( data );
|
2006-12-02 13:43:02 +00:00
|
|
|
else if(jQuery.browser.safari)
|
|
|
|
// safari doesn't provide a synchronous global eval
|
|
|
|
window.setTimeout( data, 0 );
|
2006-11-21 09:55:34 +00:00
|
|
|
else
|
|
|
|
eval.call( window, data );
|
2006-07-10 03:20:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
});
|