Completely removed pushStack - and all code related to .find(..., fn). The stack...
[jquery.git] / src / ajax / ajax.js
1 jQuery.fn.extend({
2
3         /**
4          * Load HTML from a remote file and inject it into the DOM, only if it's
5          * been modified by the server.
6          *
7          * @example $("#feeds").loadIfModified("feeds.html");
8          * @before <div id="feeds"></div>
9          * @result <div id="feeds"><b>45</b> feeds found.</div>
10          *
11          * @name loadIfModified
12          * @type jQuery
13          * @param String url The URL of the HTML file to load.
14          * @param Hash params (optional) A set of key/value pairs that will be sent to the server.
15          * @param Function callback (optional) A function to be executed whenever the data is loaded (parameters: responseText, status and response itself).
16          * @cat AJAX
17          */
18         loadIfModified: function( url, params, callback ) {
19                 this.load( url, params, callback, 1 );
20         },
21
22         /**
23          * Load HTML from a remote file and inject it into the DOM.
24          *
25          * Note: Avoid to use this to load scripts, instead use $.getScript.
26          * IE strips script tags when there aren't any other characters in front of it.
27          *
28          * @example $("#feeds").load("feeds.html");
29          * @before <div id="feeds"></div>
30          * @result <div id="feeds"><b>45</b> feeds found.</div>
31          *
32          * @example $("#feeds").load("feeds.html",
33          *   {limit: 25},
34          *   function() { alert("The last 25 entries in the feed have been loaded"); }
35          * );
36          * @desc Same as above, but with an additional parameter
37          * and a callback that is executed when the data was loaded.
38          *
39          * @name load
40          * @type jQuery
41          * @param String url The URL of the HTML file to load.
42          * @param Object params (optional) A set of key/value pairs that will be sent as data to the server.
43          * @param Function callback (optional) A function to be executed whenever the data is loaded (parameters: responseText, status and response itself).
44          * @cat AJAX
45          */
46         load: function( url, params, callback, ifModified ) {
47                 if ( url.constructor == Function )
48                         return this.bind("load", url);
49
50                 callback = callback || function(){};
51
52                 // Default to a GET request
53                 var type = "GET";
54
55                 // If the second parameter was provided
56                 if ( params ) {
57                         // If it's a function
58                         if ( params.constructor == Function ) {
59                                 // We assume that it's the callback
60                                 callback = params;
61                                 params = null;
62
63                         // Otherwise, build a param string
64                         } else {
65                                 params = jQuery.param( params );
66                                 type = "POST";
67                         }
68                 }
69
70                 var self = this;
71
72                 // Request the remote document
73                 jQuery.ajax({
74                         url: url,
75                         type: type,
76                         data: params,
77                         ifModified: ifModified,
78                         complete: function(res, status){
79                                 if ( status == "success" || !ifModified && status == "notmodified" ) {
80                                         // Inject the HTML into all the matched elements
81                                         self.html(res.responseText)
82                                           // Execute all the scripts inside of the newly-injected HTML
83                                           .evalScripts()
84                                           // Execute callback
85                                           .each( callback, [res.responseText, status, res] );
86                                 } else
87                                         callback.apply( self, [res.responseText, status, res] );
88                         }
89                 });
90                 return this;
91         },
92
93         /**
94          * Serializes a set of input elements into a string of data.
95          * This will serialize all given elements.
96          *
97          * A serialization similar to the form submit of a browser is
98          * provided by the form plugin. It also takes multiple-selects 
99          * into account, while this method recognizes only a single option.
100          *
101          * @example $("input[@type=text]").serialize();
102          * @before <input type='text' name='name' value='John'/>
103          * <input type='text' name='location' value='Boston'/>
104          * @after name=John&location=Boston
105          * @desc Serialize a selection of input elements to a string
106          *
107          * @name serialize
108          * @type String
109          * @cat AJAX
110          */
111         serialize: function() {
112                 return jQuery.param( this );
113         },
114
115         /**
116          * Evaluate all script tags inside this jQuery. If they have a src attribute,
117          * the script is loaded, otherwise it's content is evaluated.
118          *
119          * @name evalScripts
120          * @type jQuery
121          * @private
122          * @cat AJAX
123          */
124         evalScripts: function() {
125                 return this.find('script').each(function(){
126                         if ( this.src )
127                                 jQuery.getScript( this.src );
128                         else {
129                                 jQuery.globalEval( this.text || this.textContent || this.innerHTML || "" );
130                         }
131                 }).end();
132         }
133
134 });
135
136 // If IE is used, create a wrapper for the XMLHttpRequest object
137 if ( jQuery.browser.msie && typeof XMLHttpRequest == "undefined" )
138         XMLHttpRequest = function(){
139                 return new ActiveXObject("Microsoft.XMLHTTP");
140         };
141
142 // Attach a bunch of functions for handling common AJAX events
143
144 /**
145  * Attach a function to be executed whenever an AJAX request begins
146  * and there is none already active.
147  *
148  * @example $("#loading").ajaxStart(function(){
149  *   $(this).show();
150  * });
151  * @desc Show a loading message whenever an AJAX request starts
152  * (and none is already active).
153  *
154  * @name ajaxStart
155  * @type jQuery
156  * @param Function callback The function to execute.
157  * @cat AJAX
158  */
159
160 /**
161  * Attach a function to be executed whenever all AJAX requests have ended.
162  *
163  * @example $("#loading").ajaxStop(function(){
164  *   $(this).hide();
165  * });
166  * @desc Hide a loading message after all the AJAX requests have stopped.
167  *
168  * @name ajaxStop
169  * @type jQuery
170  * @param Function callback The function to execute.
171  * @cat AJAX
172  */
173
174 /**
175  * Attach a function to be executed whenever an AJAX request completes.
176  *
177  * The XMLHttpRequest and settings used for that request are passed
178  * as arguments to the callback.
179  *
180  * @example $("#msg").ajaxComplete(function(request, settings){
181  *   $(this).append("<li>Request Complete.</li>");
182  * });
183  * @desc Show a message when an AJAX request completes.
184  *
185  * @name ajaxComplete
186  * @type jQuery
187  * @param Function callback The function to execute.
188  * @cat AJAX
189  */
190
191 /**
192  * Attach a function to be executed whenever an AJAX request completes
193  * successfully.
194  *
195  * The XMLHttpRequest and settings used for that request are passed
196  * as arguments to the callback.
197  *
198  * @example $("#msg").ajaxSuccess(function(request, settings){
199  *   $(this).append("<li>Successful Request!</li>");
200  * });
201  * @desc Show a message when an AJAX request completes successfully.
202  *
203  * @name ajaxSuccess
204  * @type jQuery
205  * @param Function callback The function to execute.
206  * @cat AJAX
207  */
208
209 /**
210  * Attach a function to be executed whenever an AJAX request fails.
211  *
212  * The XMLHttpRequest and settings used for that request are passed
213  * as arguments to the callback. A third argument, an exception object,
214  * is passed if an exception occured while processing the request.
215  *
216  * @example $("#msg").ajaxError(function(request, settings){
217  *   $(this).append("<li>Error requesting page " + settings.url + "</li>");
218  * });
219  * @desc Show a message when an AJAX request fails.
220  *
221  * @name ajaxError
222  * @type jQuery
223  * @param Function callback The function to execute.
224  * @cat AJAX
225  */
226  
227 /**
228  * Attach a function to be executed before an AJAX request is send.
229  *
230  * The XMLHttpRequest and settings used for that request are passed
231  * as arguments to the callback.
232  *
233  * @example $("#msg").ajaxSend(function(request, settings){
234  *   $(this).append("<li>Starting request at " + settings.url + "</li>");
235  * });
236  * @desc Show a message before an AJAX request is send.
237  *
238  * @name ajaxSend
239  * @type jQuery
240  * @param Function callback The function to execute.
241  * @cat AJAX
242  */
243
244 new function(){
245         var e = "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(",");
246
247         for ( var i = 0; i < e.length; i++ ) new function(){
248                 var o = e[i];
249                 jQuery.fn[o] = function(f){
250                         return this.bind(o, f);
251                 };
252         };
253 };
254
255 jQuery.extend({
256
257         /**
258          * Load a remote page using an HTTP GET request.
259          *
260          * @example $.get("test.cgi");
261          *
262          * @example $.get("test.cgi", { name: "John", time: "2pm" } );
263          *
264          * @example $.get("test.cgi", function(data){
265          *   alert("Data Loaded: " + data);
266          * });
267          *
268          * @example $.get("test.cgi",
269          *   { name: "John", time: "2pm" },
270          *   function(data){
271          *     alert("Data Loaded: " + data);
272          *   }
273          * );
274          *
275          * @name $.get
276          * @type XMLHttpRequest
277          * @param String url The URL of the page to load.
278          * @param Hash params (optional) A set of key/value pairs that will be sent to the server.
279          * @param Function callback (optional) A function to be executed whenever the data is loaded.
280          * @cat AJAX
281          */
282         get: function( url, data, callback, type, ifModified ) {
283                 // shift arguments if data argument was ommited
284                 if ( data && data.constructor == Function ) {
285                         callback = data;
286                         data = null;
287                 }
288                 return jQuery.ajax({
289                         url: url,
290                         data: data,
291                         success: callback,
292                         dataType: type,
293                         ifModified: ifModified
294                 });
295         },
296
297         /**
298          * Load a remote page using an HTTP GET request, only if it hasn't
299          * been modified since it was last retrieved.
300          *
301          * @example $.getIfModified("test.html");
302          *
303          * @example $.getIfModified("test.html", { name: "John", time: "2pm" } );
304          *
305          * @example $.getIfModified("test.cgi", function(data){
306          *   alert("Data Loaded: " + data);
307          * });
308          *
309          * @example $.getifModified("test.cgi",
310          *   { name: "John", time: "2pm" },
311          *   function(data){
312          *     alert("Data Loaded: " + data);
313          *   }
314          * );
315          *
316          * @name $.getIfModified
317          * @type XMLHttpRequest
318          * @param String url The URL of the page to load.
319          * @param Hash params (optional) A set of key/value pairs that will be sent to the server.
320          * @param Function callback (optional) A function to be executed whenever the data is loaded.
321          * @cat AJAX
322          */
323         getIfModified: function( url, data, callback, type ) {
324                 return jQuery.get(url, data, callback, type, 1);
325         },
326
327         /**
328          * Loads, and executes, a remote JavaScript file using an HTTP GET request.
329          *
330          * Warning: Safari <= 2.0.x is unable to evalulate scripts in a global
331          * context synchronously. If you load functions via getScript, make sure
332          * to call them after a delay.
333          *
334          * @example $.getScript("test.js");
335          *
336          * @example $.getScript("test.js", function(){
337          *   alert("Script loaded and executed.");
338          * });
339          *
340          * @name $.getScript
341          * @type XMLHttpRequest
342          * @param String url The URL of the page to load.
343          * @param Function callback (optional) A function to be executed whenever the data is loaded.
344          * @cat AJAX
345          */
346         getScript: function( url, callback ) {
347                 return jQuery.get(url, null, callback, "script");
348         },
349
350         /**
351          * Load JSON data using an HTTP GET request.
352          *
353          * @example $.getJSON("test.js", function(json){
354          *   alert("JSON Data: " + json.users[3].name);
355          * });
356          *
357          * @example $.getJSON("test.js",
358          *   { name: "John", time: "2pm" },
359          *   function(json){
360          *     alert("JSON Data: " + json.users[3].name);
361          *   }
362          * );
363          *
364          * @name $.getJSON
365          * @type XMLHttpRequest
366          * @param String url The URL of the page to load.
367          * @param Hash params (optional) A set of key/value pairs that will be sent to the server.
368          * @param Function callback A function to be executed whenever the data is loaded.
369          * @cat AJAX
370          */
371         getJSON: function( url, data, callback ) {
372                 return jQuery.get(url, data, callback, "json");
373         },
374
375         /**
376          * Load a remote page using an HTTP POST request.
377          *
378          * @example $.post("test.cgi");
379          *
380          * @example $.post("test.cgi", { name: "John", time: "2pm" } );
381          *
382          * @example $.post("test.cgi", function(data){
383          *   alert("Data Loaded: " + data);
384          * });
385          *
386          * @example $.post("test.cgi",
387          *   { name: "John", time: "2pm" },
388          *   function(data){
389          *     alert("Data Loaded: " + data);
390          *   }
391          * );
392          *
393          * @name $.post
394          * @type XMLHttpRequest
395          * @param String url The URL of the page to load.
396          * @param Hash params (optional) A set of key/value pairs that will be sent to the server.
397          * @param Function callback (optional) A function to be executed whenever the data is loaded.
398          * @cat AJAX
399          */
400         post: function( url, data, callback, type ) {
401                 return jQuery.ajax({
402                         type: "POST",
403                         url: url,
404                         data: data,
405                         success: callback,
406                         dataType: type
407                 });
408         },
409
410         // timeout (ms)
411         //timeout: 0,
412
413         /**
414          * Set the timeout of all AJAX requests to a specific amount of time.
415          * This will make all future AJAX requests timeout after a specified amount
416          * of time.
417          *
418          * Set to null or 0 to disable timeouts (default).
419          *
420          * You can manually abort requests with the XMLHttpRequest's (returned by
421          * all ajax functions) abort() method.
422          *
423          * Deprecated. Use $.ajaxSetup instead.
424          *
425          * @example $.ajaxTimeout( 5000 );
426          * @desc Make all AJAX requests timeout after 5 seconds.
427          *
428          * @name $.ajaxTimeout
429          * @type undefined
430          * @param Number time How long before an AJAX request times out.
431          * @cat AJAX
432          */
433         ajaxTimeout: function(timeout) {
434                 jQuery.ajaxSettings.timeout = timeout;
435         },
436         
437         /**
438          * Setup global settings for AJAX requests.
439          *
440          * See $.ajax for a description of all available options.
441          *
442          * @example $.ajaxSetup( {
443          *   url: "/xmlhttp/",
444          *   global: false,
445          *   type: "POST"
446          * } );
447          * @desc Sets the defaults for AJAX requests to the url "/xmlhttp/",
448          * disables global handlers and uses POST instead of GET
449          *
450          * @name $.ajaxSetup
451          * @type undefined
452          * @param Object settings Key/value pairs for ajax options
453          * @cat AJAX
454          */
455         ajaxSetup: function(settings) {
456                 jQuery.extend(jQuery.ajaxSettings, settings);
457         },
458
459         ajaxSettings: {
460                 global: true,
461                 type: "GET",
462                 timeout: 0,
463                 contentType: "application/x-www-form-urlencoded",
464                 processData: true,
465                 async: true
466         },
467         
468         // Last-Modified header cache for next request
469         lastModified: {},
470
471         /**
472          * Load a remote page using an HTTP request.
473          *
474          * This is jQuery's low-level AJAX implementation. See $.get, $.post etc. for
475          * higher-level abstractions.
476          *
477          * $.ajax() returns the XMLHttpRequest that it creates. In most cases you won't
478          * need that object to manipulate directly, but it is available if you need to
479          * abort the request manually.
480          *
481          * Note: Make sure the server sends the right mimetype (eg. xml as
482          * "text/xml"). Sending the wrong mimetype will get you into serious
483          * trouble that jQuery can't solve.
484          *
485          * Supported datatypes are (see dataType option):
486          *
487          * "xml": Returns a XML document that can be processed via jQuery.
488          *
489          * "html": Returns HTML as plain text, included script tags are evaluated.
490          *
491          * "script": Evaluates the response as Javascript and returns it as plain text.
492          *
493          * "json": Evaluates the response as JSON and returns a Javascript Object
494          *
495          * $.ajax() takes one argument, an object of key/value pairs, that are
496          * used to initalize and handle the request. These are all the key/values that can
497          * be used:
498          *
499          * (String) url - The URL to request.
500          *
501          * (String) type - The type of request to make ("POST" or "GET"), default is "GET".
502          *
503          * (String) dataType - The type of data that you're expecting back from
504          * the server. No default: If the server sends xml, the responseXML, otherwise
505          * the responseText is passed to the success callback.
506          *
507          * (Boolean) ifModified - Allow the request to be successful only if the
508          * response has changed since the last request. This is done by checking the
509          * Last-Modified header. Default value is false, ignoring the header.
510          *
511          * (Number) timeout - Local timeout to override global timeout, eg. to give a
512          * single request a longer timeout while all others timeout after 1 second.
513          * See $.ajaxTimeout() for global timeouts.
514          *
515          * (Boolean) global - Whether to trigger global AJAX event handlers for
516          * this request, default is true. Set to false to prevent that global handlers
517          * like ajaxStart or ajaxStop are triggered.
518          *
519          * (Function) error - A function to be called if the request fails. The
520          * function gets passed tree arguments: The XMLHttpRequest object, a
521          * string describing the type of error that occurred and an optional
522          * exception object, if one occured.
523          *
524          * (Function) success - A function to be called if the request succeeds. The
525          * function gets passed one argument: The data returned from the server,
526          * formatted according to the 'dataType' parameter.
527          *
528          * (Function) complete - A function to be called when the request finishes. The
529          * function gets passed two arguments: The XMLHttpRequest object and a
530          * string describing the type of success of the request.
531          *
532          * (Object|String) data - Data to be sent to the server. Converted to a query
533          * string, if not already a string. Is appended to the url for GET-requests.
534          * See processData option to prevent this automatic processing.
535          *
536          * (String) contentType - When sending data to the server, use this content-type.
537          * Default is "application/x-www-form-urlencoded", which is fine for most cases.
538          *
539          * (Boolean) processData - By default, data passed in to the data option as an object
540          * other as string will be processed and transformed into a query string, fitting to
541          * the default content-type "application/x-www-form-urlencoded". If you want to send
542          * DOMDocuments, set this option to false.
543          *
544          * (Boolean) async - By default, all requests are send asynchronous (set to true).
545          * If you need synchronous requests, set this option to false.
546          *
547          * (Function) beforeSend - A pre-callback to set custom headers etc., the
548          * XMLHttpRequest is passed as the only argument.
549          *
550          * @example $.ajax({
551          *   type: "GET",
552          *   url: "test.js",
553          *   dataType: "script"
554          * })
555          * @desc Load and execute a JavaScript file.
556          *
557          * @example $.ajax({
558          *   type: "POST",
559          *   url: "some.php",
560          *   data: "name=John&location=Boston",
561          *   success: function(msg){
562          *     alert( "Data Saved: " + msg );
563          *   }
564          * });
565          * @desc Save some data to the server and notify the user once its complete.
566          *
567          * @example var html = $.ajax({
568          *  url: "some.php",
569          *  async: false
570          * }).responseText;
571          * @desc Loads data synchronously. Blocks the browser while the requests is active.
572          * It is better to block user interaction with others means when synchronization is
573          * necessary, instead to block the complete browser.
574          *
575          * @example var xmlDocument = [create xml document];
576          * $.ajax({
577          *   url: "page.php",
578          *   processData: false,
579          *   data: xmlDocument,
580          *   success: handleResponse
581          * });
582          * @desc Sends an xml document as data to the server. By setting the processData
583          * option to false, the automatic conversion of data to strings is prevented.
584          * 
585          * @name $.ajax
586          * @type XMLHttpRequest
587          * @param Hash prop A set of properties to initialize the request with.
588          * @cat AJAX
589          */
590         ajax: function( s ) {
591                 // TODO introduce global settings, allowing the client to modify them for all requests, not only timeout
592                 s = jQuery.extend({}, jQuery.ajaxSettings, s);
593
594                 // if data available
595                 if ( s.data ) {
596                         // convert data if not already a string
597                         if (s.processData && typeof s.data != 'string')
598                         s.data = jQuery.param(s.data);
599                         // append data to url for get requests
600                         if( s.type.toLowerCase() == "get" )
601                                 // "?" + data or "&" + data (in case there are already params)
602                                 s.url += ((s.url.indexOf("?") > -1) ? "&" : "?") + s.data;
603                 }
604
605                 // Watch for a new set of requests
606                 if ( s.global && ! jQuery.active++ )
607                         jQuery.event.trigger( "ajaxStart" );
608
609                 var requestDone = false;
610
611                 // Create the request object
612                 var xml = new XMLHttpRequest();
613
614                 // Open the socket
615                 xml.open(s.type, s.url, s.async);
616
617                 // Set the correct header, if data is being sent
618                 if ( s.data )
619                         xml.setRequestHeader("Content-Type", s.contentType);
620
621                 // Set the If-Modified-Since header, if ifModified mode.
622                 if ( s.ifModified )
623                         xml.setRequestHeader("If-Modified-Since",
624                                 jQuery.lastModified[s.url] || "Thu, 01 Jan 1970 00:00:00 GMT" );
625
626                 // Set header so the called script knows that it's an XMLHttpRequest
627                 xml.setRequestHeader("X-Requested-With", "XMLHttpRequest");
628
629                 // Make sure the browser sends the right content length
630                 if ( xml.overrideMimeType )
631                         xml.setRequestHeader("Connection", "close");
632                         
633                 // Allow custom headers/mimetypes
634                 if( s.beforeSend )
635                         s.beforeSend(xml);
636                 if (s.global)
637                     jQuery.event.trigger("ajaxSend", [xml, s]);
638
639                 // Wait for a response to come back
640                 var onreadystatechange = function(isTimeout){
641                         // The transfer is complete and the data is available, or the request timed out
642                         if ( xml && (xml.readyState == 4 || isTimeout == "timeout") ) {
643                                 requestDone = true;
644                                 var status;
645                                 try {
646                                         status = jQuery.httpSuccess( xml ) && isTimeout != "timeout" ?
647                                                 s.ifModified && jQuery.httpNotModified( xml, s.url ) ? "notmodified" : "success" : "error";
648                                         // Make sure that the request was successful or notmodified
649                                         if ( status != "error" ) {
650                                                 // Cache Last-Modified header, if ifModified mode.
651                                                 var modRes;
652                                                 try {
653                                                         modRes = xml.getResponseHeader("Last-Modified");
654                                                 } catch(e) {} // swallow exception thrown by FF if header is not available
655         
656                                                 if ( s.ifModified && modRes )
657                                                         jQuery.lastModified[s.url] = modRes;
658         
659                                                 // process the data (runs the xml through httpData regardless of callback)
660                                                 var data = jQuery.httpData( xml, s.dataType );
661         
662                                                 // If a local callback was specified, fire it and pass it the data
663                                                 if ( s.success )
664                                                         s.success( data, status );
665         
666                                                 // Fire the global callback
667                                                 if( s.global )
668                                                         jQuery.event.trigger( "ajaxSuccess", [xml, s] );
669                                         } else {
670                                                 jQuery.handleError(s, xml, status);
671                                         }
672                                 } catch(e) {
673                                         status = "error";
674                                         jQuery.handleError(s, xml, status, e);
675                                 }
676
677                                 // The request was completed
678                                 if( s.global )
679                                         jQuery.event.trigger( "ajaxComplete", [xml, s] );
680
681                                 // Handle the global AJAX counter
682                                 if ( s.global && ! --jQuery.active )
683                                         jQuery.event.trigger( "ajaxStop" );
684
685                                 // Process result
686                                 if ( s.complete ) s.complete(xml, status);
687
688                                 // Stop memory leaks
689                                 xml.onreadystatechange = function(){};
690                                 xml = null;
691                         }
692                 };
693                 xml.onreadystatechange = onreadystatechange;
694
695                 // Timeout checker
696                 if(s.timeout > 0)
697                         setTimeout(function(){
698                                 // Check to see if the request is still happening
699                                 if(xml) {
700                                         // Cancel the request
701                                         xml.abort();
702
703                                         if( !requestDone )
704                                                 onreadystatechange( "timeout" );
705                                 }
706                         }, s.timeout);
707                         
708                 // save non-leaking reference 
709                 var xml2 = xml;
710
711                 // Send the data
712                 try {
713                         xml2.send(s.data);
714                 } catch(e) {
715                         jQuery.handleError(s, xml, null, e);
716                 }
717                 
718                 // firefox 1.5 doesn't fire statechange for sync requests
719                 if(!s.async)
720                         onreadystatechange();
721                 
722                 // return XMLHttpRequest to allow aborting the request etc.
723                 return xml2;
724         },
725
726         handleError: function(s, xml, status, e) {
727                 // If a local callback was specified, fire it
728                 if ( s.error ) s.error( xml, status, e );
729
730                 // Fire the global callback
731                 if( s.global )
732                         jQuery.event.trigger( "ajaxError", [xml, s, e] );
733         },
734
735         // Counter for holding the number of active queries
736         active: 0,
737
738         // Determines if an XMLHttpRequest was successful or not
739         httpSuccess: function(r) {
740                 try {
741                         return !r.status && location.protocol == "file:" ||
742                                 ( r.status >= 200 && r.status < 300 ) || r.status == 304 ||
743                                 jQuery.browser.safari && r.status == undefined;
744                 } catch(e){}
745                 return false;
746         },
747
748         // Determines if an XMLHttpRequest returns NotModified
749         httpNotModified: function(xml, url) {
750                 try {
751                         var xmlRes = xml.getResponseHeader("Last-Modified");
752
753                         // Firefox always returns 200. check Last-Modified date
754                         return xml.status == 304 || xmlRes == jQuery.lastModified[url] ||
755                                 jQuery.browser.safari && xml.status == undefined;
756                 } catch(e){}
757                 return false;
758         },
759
760         /* Get the data out of an XMLHttpRequest.
761          * Return parsed XML if content-type header is "xml" and type is "xml" or omitted,
762          * otherwise return plain text.
763          * (String) data - The type of data that you're expecting back,
764          * (e.g. "xml", "html", "script")
765          */
766         httpData: function(r,type) {
767                 var ct = r.getResponseHeader("content-type");
768                 var data = !type && ct && ct.indexOf("xml") >= 0;
769                 data = type == "xml" || data ? r.responseXML : r.responseText;
770
771                 // If the type is "script", eval it in global context
772                 if ( type == "script" ) {
773                         jQuery.globalEval( data );
774                 }
775
776                 // Get the JavaScript object, if JSON is used.
777                 if ( type == "json" ) eval( "data = " + data );
778
779                 // evaluate scripts within html
780                 if ( type == "html" ) jQuery("<div>").html(data).evalScripts();
781
782                 return data;
783         },
784
785         // Serialize an array of form elements or a set of
786         // key/values into a query string
787         param: function(a) {
788                 var s = [];
789
790                 // If an array was passed in, assume that it is an array
791                 // of form elements
792                 if ( a.constructor == Array || a.jquery ) {
793                         // Serialize the form elements
794                         for ( var i = 0; i < a.length; i++ )
795                                 s.push( a[i].name + "=" + encodeURIComponent( a[i].value ) );
796
797                 // Otherwise, assume that it's an object of key/value pairs
798                 } else {
799                         // Serialize the key/values
800                         for ( var j in a ) {
801                                 // If the value is an array then the key names need to be repeated
802                                 if( a[j].constructor == Array ) {
803                                         for (var k = 0; k < a[j].length; k++) {
804                                                 s.push( j + "=" + encodeURIComponent( a[j][k] ) );
805                                         }
806                                 } else {
807                                         s.push( j + "=" + encodeURIComponent( a[j] ) );
808                                 }
809                         }
810                 }
811
812                 // Return the resulting serialization
813                 return s.join("&");
814         },
815         
816         // evalulates a script in global context
817         // not reliable for safari
818         globalEval: function(data) {
819                 if (window.execScript)
820                         window.execScript( data );
821                 else if(jQuery.browser.safari)
822                         // safari doesn't provide a synchronous global eval
823                         window.setTimeout( data, 0 );
824                 else
825                         eval.call( window, data );
826         }
827
828 });