annotate src/main/webapp/imageServer/resources/js/jquery-ui-1.10.4/tests/jquery-1.6.3.js @ 205:f719d73383db

Merge iiif_diva branch 964846688a95cc9b0af5ade832b8d34ae4a4bc21
author Robert Casties <casties@mpiwg-berlin.mpg.de>
date Mon, 08 Jul 2019 17:55:14 +0200
parents 764f47286679
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
7
jurzua
parents:
diff changeset
1 /*!
jurzua
parents:
diff changeset
2 * jQuery JavaScript Library v1.6.3
jurzua
parents:
diff changeset
3 * http://jquery.com/
jurzua
parents:
diff changeset
4 *
jurzua
parents:
diff changeset
5 * Copyright 2011, John Resig
jurzua
parents:
diff changeset
6 * Dual licensed under the MIT or GPL Version 2 licenses.
jurzua
parents:
diff changeset
7 * http://jquery.org/license
jurzua
parents:
diff changeset
8 *
jurzua
parents:
diff changeset
9 * Includes Sizzle.js
jurzua
parents:
diff changeset
10 * http://sizzlejs.com/
jurzua
parents:
diff changeset
11 * Copyright 2011, The Dojo Foundation
jurzua
parents:
diff changeset
12 * Released under the MIT, BSD, and GPL Licenses.
jurzua
parents:
diff changeset
13 *
jurzua
parents:
diff changeset
14 * Date: Wed Aug 31 10:35:15 2011 -0400
jurzua
parents:
diff changeset
15 */
jurzua
parents:
diff changeset
16 (function( window, undefined ) {
jurzua
parents:
diff changeset
17
jurzua
parents:
diff changeset
18 // Use the correct document accordingly with window argument (sandbox)
jurzua
parents:
diff changeset
19 var document = window.document,
jurzua
parents:
diff changeset
20 navigator = window.navigator,
jurzua
parents:
diff changeset
21 location = window.location;
jurzua
parents:
diff changeset
22 var jQuery = (function() {
jurzua
parents:
diff changeset
23
jurzua
parents:
diff changeset
24 // Define a local copy of jQuery
jurzua
parents:
diff changeset
25 var jQuery = function( selector, context ) {
jurzua
parents:
diff changeset
26 // The jQuery object is actually just the init constructor 'enhanced'
jurzua
parents:
diff changeset
27 return new jQuery.fn.init( selector, context, rootjQuery );
jurzua
parents:
diff changeset
28 },
jurzua
parents:
diff changeset
29
jurzua
parents:
diff changeset
30 // Map over jQuery in case of overwrite
jurzua
parents:
diff changeset
31 _jQuery = window.jQuery,
jurzua
parents:
diff changeset
32
jurzua
parents:
diff changeset
33 // Map over the $ in case of overwrite
jurzua
parents:
diff changeset
34 _$ = window.$,
jurzua
parents:
diff changeset
35
jurzua
parents:
diff changeset
36 // A central reference to the root jQuery(document)
jurzua
parents:
diff changeset
37 rootjQuery,
jurzua
parents:
diff changeset
38
jurzua
parents:
diff changeset
39 // A simple way to check for HTML strings or ID strings
jurzua
parents:
diff changeset
40 // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
jurzua
parents:
diff changeset
41 quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
jurzua
parents:
diff changeset
42
jurzua
parents:
diff changeset
43 // Check if a string has a non-whitespace character in it
jurzua
parents:
diff changeset
44 rnotwhite = /\S/,
jurzua
parents:
diff changeset
45
jurzua
parents:
diff changeset
46 // Used for trimming whitespace
jurzua
parents:
diff changeset
47 trimLeft = /^\s+/,
jurzua
parents:
diff changeset
48 trimRight = /\s+$/,
jurzua
parents:
diff changeset
49
jurzua
parents:
diff changeset
50 // Check for digits
jurzua
parents:
diff changeset
51 rdigit = /\d/,
jurzua
parents:
diff changeset
52
jurzua
parents:
diff changeset
53 // Match a standalone tag
jurzua
parents:
diff changeset
54 rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
jurzua
parents:
diff changeset
55
jurzua
parents:
diff changeset
56 // JSON RegExp
jurzua
parents:
diff changeset
57 rvalidchars = /^[\],:{}\s]*$/,
jurzua
parents:
diff changeset
58 rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
jurzua
parents:
diff changeset
59 rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
jurzua
parents:
diff changeset
60 rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
jurzua
parents:
diff changeset
61
jurzua
parents:
diff changeset
62 // Useragent RegExp
jurzua
parents:
diff changeset
63 rwebkit = /(webkit)[ \/]([\w.]+)/,
jurzua
parents:
diff changeset
64 ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
jurzua
parents:
diff changeset
65 rmsie = /(msie) ([\w.]+)/,
jurzua
parents:
diff changeset
66 rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
jurzua
parents:
diff changeset
67
jurzua
parents:
diff changeset
68 // Matches dashed string for camelizing
jurzua
parents:
diff changeset
69 rdashAlpha = /-([a-z]|[0-9])/ig,
jurzua
parents:
diff changeset
70 rmsPrefix = /^-ms-/,
jurzua
parents:
diff changeset
71
jurzua
parents:
diff changeset
72 // Used by jQuery.camelCase as callback to replace()
jurzua
parents:
diff changeset
73 fcamelCase = function( all, letter ) {
jurzua
parents:
diff changeset
74 return ( letter + "" ).toUpperCase();
jurzua
parents:
diff changeset
75 },
jurzua
parents:
diff changeset
76
jurzua
parents:
diff changeset
77 // Keep a UserAgent string for use with jQuery.browser
jurzua
parents:
diff changeset
78 userAgent = navigator.userAgent,
jurzua
parents:
diff changeset
79
jurzua
parents:
diff changeset
80 // For matching the engine and version of the browser
jurzua
parents:
diff changeset
81 browserMatch,
jurzua
parents:
diff changeset
82
jurzua
parents:
diff changeset
83 // The deferred used on DOM ready
jurzua
parents:
diff changeset
84 readyList,
jurzua
parents:
diff changeset
85
jurzua
parents:
diff changeset
86 // The ready event handler
jurzua
parents:
diff changeset
87 DOMContentLoaded,
jurzua
parents:
diff changeset
88
jurzua
parents:
diff changeset
89 // Save a reference to some core methods
jurzua
parents:
diff changeset
90 toString = Object.prototype.toString,
jurzua
parents:
diff changeset
91 hasOwn = Object.prototype.hasOwnProperty,
jurzua
parents:
diff changeset
92 push = Array.prototype.push,
jurzua
parents:
diff changeset
93 slice = Array.prototype.slice,
jurzua
parents:
diff changeset
94 trim = String.prototype.trim,
jurzua
parents:
diff changeset
95 indexOf = Array.prototype.indexOf,
jurzua
parents:
diff changeset
96
jurzua
parents:
diff changeset
97 // [[Class]] -> type pairs
jurzua
parents:
diff changeset
98 class2type = {};
jurzua
parents:
diff changeset
99
jurzua
parents:
diff changeset
100 jQuery.fn = jQuery.prototype = {
jurzua
parents:
diff changeset
101 constructor: jQuery,
jurzua
parents:
diff changeset
102 init: function( selector, context, rootjQuery ) {
jurzua
parents:
diff changeset
103 var match, elem, ret, doc;
jurzua
parents:
diff changeset
104
jurzua
parents:
diff changeset
105 // Handle $(""), $(null), or $(undefined)
jurzua
parents:
diff changeset
106 if ( !selector ) {
jurzua
parents:
diff changeset
107 return this;
jurzua
parents:
diff changeset
108 }
jurzua
parents:
diff changeset
109
jurzua
parents:
diff changeset
110 // Handle $(DOMElement)
jurzua
parents:
diff changeset
111 if ( selector.nodeType ) {
jurzua
parents:
diff changeset
112 this.context = this[0] = selector;
jurzua
parents:
diff changeset
113 this.length = 1;
jurzua
parents:
diff changeset
114 return this;
jurzua
parents:
diff changeset
115 }
jurzua
parents:
diff changeset
116
jurzua
parents:
diff changeset
117 // The body element only exists once, optimize finding it
jurzua
parents:
diff changeset
118 if ( selector === "body" && !context && document.body ) {
jurzua
parents:
diff changeset
119 this.context = document;
jurzua
parents:
diff changeset
120 this[0] = document.body;
jurzua
parents:
diff changeset
121 this.selector = selector;
jurzua
parents:
diff changeset
122 this.length = 1;
jurzua
parents:
diff changeset
123 return this;
jurzua
parents:
diff changeset
124 }
jurzua
parents:
diff changeset
125
jurzua
parents:
diff changeset
126 // Handle HTML strings
jurzua
parents:
diff changeset
127 if ( typeof selector === "string" ) {
jurzua
parents:
diff changeset
128 // Are we dealing with HTML string or an ID?
jurzua
parents:
diff changeset
129 if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
jurzua
parents:
diff changeset
130 // Assume that strings that start and end with <> are HTML and skip the regex check
jurzua
parents:
diff changeset
131 match = [ null, selector, null ];
jurzua
parents:
diff changeset
132
jurzua
parents:
diff changeset
133 } else {
jurzua
parents:
diff changeset
134 match = quickExpr.exec( selector );
jurzua
parents:
diff changeset
135 }
jurzua
parents:
diff changeset
136
jurzua
parents:
diff changeset
137 // Verify a match, and that no context was specified for #id
jurzua
parents:
diff changeset
138 if ( match && (match[1] || !context) ) {
jurzua
parents:
diff changeset
139
jurzua
parents:
diff changeset
140 // HANDLE: $(html) -> $(array)
jurzua
parents:
diff changeset
141 if ( match[1] ) {
jurzua
parents:
diff changeset
142 context = context instanceof jQuery ? context[0] : context;
jurzua
parents:
diff changeset
143 doc = (context ? context.ownerDocument || context : document);
jurzua
parents:
diff changeset
144
jurzua
parents:
diff changeset
145 // If a single string is passed in and it's a single tag
jurzua
parents:
diff changeset
146 // just do a createElement and skip the rest
jurzua
parents:
diff changeset
147 ret = rsingleTag.exec( selector );
jurzua
parents:
diff changeset
148
jurzua
parents:
diff changeset
149 if ( ret ) {
jurzua
parents:
diff changeset
150 if ( jQuery.isPlainObject( context ) ) {
jurzua
parents:
diff changeset
151 selector = [ document.createElement( ret[1] ) ];
jurzua
parents:
diff changeset
152 jQuery.fn.attr.call( selector, context, true );
jurzua
parents:
diff changeset
153
jurzua
parents:
diff changeset
154 } else {
jurzua
parents:
diff changeset
155 selector = [ doc.createElement( ret[1] ) ];
jurzua
parents:
diff changeset
156 }
jurzua
parents:
diff changeset
157
jurzua
parents:
diff changeset
158 } else {
jurzua
parents:
diff changeset
159 ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
jurzua
parents:
diff changeset
160 selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
jurzua
parents:
diff changeset
161 }
jurzua
parents:
diff changeset
162
jurzua
parents:
diff changeset
163 return jQuery.merge( this, selector );
jurzua
parents:
diff changeset
164
jurzua
parents:
diff changeset
165 // HANDLE: $("#id")
jurzua
parents:
diff changeset
166 } else {
jurzua
parents:
diff changeset
167 elem = document.getElementById( match[2] );
jurzua
parents:
diff changeset
168
jurzua
parents:
diff changeset
169 // Check parentNode to catch when Blackberry 4.6 returns
jurzua
parents:
diff changeset
170 // nodes that are no longer in the document #6963
jurzua
parents:
diff changeset
171 if ( elem && elem.parentNode ) {
jurzua
parents:
diff changeset
172 // Handle the case where IE and Opera return items
jurzua
parents:
diff changeset
173 // by name instead of ID
jurzua
parents:
diff changeset
174 if ( elem.id !== match[2] ) {
jurzua
parents:
diff changeset
175 return rootjQuery.find( selector );
jurzua
parents:
diff changeset
176 }
jurzua
parents:
diff changeset
177
jurzua
parents:
diff changeset
178 // Otherwise, we inject the element directly into the jQuery object
jurzua
parents:
diff changeset
179 this.length = 1;
jurzua
parents:
diff changeset
180 this[0] = elem;
jurzua
parents:
diff changeset
181 }
jurzua
parents:
diff changeset
182
jurzua
parents:
diff changeset
183 this.context = document;
jurzua
parents:
diff changeset
184 this.selector = selector;
jurzua
parents:
diff changeset
185 return this;
jurzua
parents:
diff changeset
186 }
jurzua
parents:
diff changeset
187
jurzua
parents:
diff changeset
188 // HANDLE: $(expr, $(...))
jurzua
parents:
diff changeset
189 } else if ( !context || context.jquery ) {
jurzua
parents:
diff changeset
190 return (context || rootjQuery).find( selector );
jurzua
parents:
diff changeset
191
jurzua
parents:
diff changeset
192 // HANDLE: $(expr, context)
jurzua
parents:
diff changeset
193 // (which is just equivalent to: $(context).find(expr)
jurzua
parents:
diff changeset
194 } else {
jurzua
parents:
diff changeset
195 return this.constructor( context ).find( selector );
jurzua
parents:
diff changeset
196 }
jurzua
parents:
diff changeset
197
jurzua
parents:
diff changeset
198 // HANDLE: $(function)
jurzua
parents:
diff changeset
199 // Shortcut for document ready
jurzua
parents:
diff changeset
200 } else if ( jQuery.isFunction( selector ) ) {
jurzua
parents:
diff changeset
201 return rootjQuery.ready( selector );
jurzua
parents:
diff changeset
202 }
jurzua
parents:
diff changeset
203
jurzua
parents:
diff changeset
204 if (selector.selector !== undefined) {
jurzua
parents:
diff changeset
205 this.selector = selector.selector;
jurzua
parents:
diff changeset
206 this.context = selector.context;
jurzua
parents:
diff changeset
207 }
jurzua
parents:
diff changeset
208
jurzua
parents:
diff changeset
209 return jQuery.makeArray( selector, this );
jurzua
parents:
diff changeset
210 },
jurzua
parents:
diff changeset
211
jurzua
parents:
diff changeset
212 // Start with an empty selector
jurzua
parents:
diff changeset
213 selector: "",
jurzua
parents:
diff changeset
214
jurzua
parents:
diff changeset
215 // The current version of jQuery being used
jurzua
parents:
diff changeset
216 jquery: "1.6.3",
jurzua
parents:
diff changeset
217
jurzua
parents:
diff changeset
218 // The default length of a jQuery object is 0
jurzua
parents:
diff changeset
219 length: 0,
jurzua
parents:
diff changeset
220
jurzua
parents:
diff changeset
221 // The number of elements contained in the matched element set
jurzua
parents:
diff changeset
222 size: function() {
jurzua
parents:
diff changeset
223 return this.length;
jurzua
parents:
diff changeset
224 },
jurzua
parents:
diff changeset
225
jurzua
parents:
diff changeset
226 toArray: function() {
jurzua
parents:
diff changeset
227 return slice.call( this, 0 );
jurzua
parents:
diff changeset
228 },
jurzua
parents:
diff changeset
229
jurzua
parents:
diff changeset
230 // Get the Nth element in the matched element set OR
jurzua
parents:
diff changeset
231 // Get the whole matched element set as a clean array
jurzua
parents:
diff changeset
232 get: function( num ) {
jurzua
parents:
diff changeset
233 return num == null ?
jurzua
parents:
diff changeset
234
jurzua
parents:
diff changeset
235 // Return a 'clean' array
jurzua
parents:
diff changeset
236 this.toArray() :
jurzua
parents:
diff changeset
237
jurzua
parents:
diff changeset
238 // Return just the object
jurzua
parents:
diff changeset
239 ( num < 0 ? this[ this.length + num ] : this[ num ] );
jurzua
parents:
diff changeset
240 },
jurzua
parents:
diff changeset
241
jurzua
parents:
diff changeset
242 // Take an array of elements and push it onto the stack
jurzua
parents:
diff changeset
243 // (returning the new matched element set)
jurzua
parents:
diff changeset
244 pushStack: function( elems, name, selector ) {
jurzua
parents:
diff changeset
245 // Build a new jQuery matched element set
jurzua
parents:
diff changeset
246 var ret = this.constructor();
jurzua
parents:
diff changeset
247
jurzua
parents:
diff changeset
248 if ( jQuery.isArray( elems ) ) {
jurzua
parents:
diff changeset
249 push.apply( ret, elems );
jurzua
parents:
diff changeset
250
jurzua
parents:
diff changeset
251 } else {
jurzua
parents:
diff changeset
252 jQuery.merge( ret, elems );
jurzua
parents:
diff changeset
253 }
jurzua
parents:
diff changeset
254
jurzua
parents:
diff changeset
255 // Add the old object onto the stack (as a reference)
jurzua
parents:
diff changeset
256 ret.prevObject = this;
jurzua
parents:
diff changeset
257
jurzua
parents:
diff changeset
258 ret.context = this.context;
jurzua
parents:
diff changeset
259
jurzua
parents:
diff changeset
260 if ( name === "find" ) {
jurzua
parents:
diff changeset
261 ret.selector = this.selector + (this.selector ? " " : "") + selector;
jurzua
parents:
diff changeset
262 } else if ( name ) {
jurzua
parents:
diff changeset
263 ret.selector = this.selector + "." + name + "(" + selector + ")";
jurzua
parents:
diff changeset
264 }
jurzua
parents:
diff changeset
265
jurzua
parents:
diff changeset
266 // Return the newly-formed element set
jurzua
parents:
diff changeset
267 return ret;
jurzua
parents:
diff changeset
268 },
jurzua
parents:
diff changeset
269
jurzua
parents:
diff changeset
270 // Execute a callback for every element in the matched set.
jurzua
parents:
diff changeset
271 // (You can seed the arguments with an array of args, but this is
jurzua
parents:
diff changeset
272 // only used internally.)
jurzua
parents:
diff changeset
273 each: function( callback, args ) {
jurzua
parents:
diff changeset
274 return jQuery.each( this, callback, args );
jurzua
parents:
diff changeset
275 },
jurzua
parents:
diff changeset
276
jurzua
parents:
diff changeset
277 ready: function( fn ) {
jurzua
parents:
diff changeset
278 // Attach the listeners
jurzua
parents:
diff changeset
279 jQuery.bindReady();
jurzua
parents:
diff changeset
280
jurzua
parents:
diff changeset
281 // Add the callback
jurzua
parents:
diff changeset
282 readyList.done( fn );
jurzua
parents:
diff changeset
283
jurzua
parents:
diff changeset
284 return this;
jurzua
parents:
diff changeset
285 },
jurzua
parents:
diff changeset
286
jurzua
parents:
diff changeset
287 eq: function( i ) {
jurzua
parents:
diff changeset
288 return i === -1 ?
jurzua
parents:
diff changeset
289 this.slice( i ) :
jurzua
parents:
diff changeset
290 this.slice( i, +i + 1 );
jurzua
parents:
diff changeset
291 },
jurzua
parents:
diff changeset
292
jurzua
parents:
diff changeset
293 first: function() {
jurzua
parents:
diff changeset
294 return this.eq( 0 );
jurzua
parents:
diff changeset
295 },
jurzua
parents:
diff changeset
296
jurzua
parents:
diff changeset
297 last: function() {
jurzua
parents:
diff changeset
298 return this.eq( -1 );
jurzua
parents:
diff changeset
299 },
jurzua
parents:
diff changeset
300
jurzua
parents:
diff changeset
301 slice: function() {
jurzua
parents:
diff changeset
302 return this.pushStack( slice.apply( this, arguments ),
jurzua
parents:
diff changeset
303 "slice", slice.call(arguments).join(",") );
jurzua
parents:
diff changeset
304 },
jurzua
parents:
diff changeset
305
jurzua
parents:
diff changeset
306 map: function( callback ) {
jurzua
parents:
diff changeset
307 return this.pushStack( jQuery.map(this, function( elem, i ) {
jurzua
parents:
diff changeset
308 return callback.call( elem, i, elem );
jurzua
parents:
diff changeset
309 }));
jurzua
parents:
diff changeset
310 },
jurzua
parents:
diff changeset
311
jurzua
parents:
diff changeset
312 end: function() {
jurzua
parents:
diff changeset
313 return this.prevObject || this.constructor(null);
jurzua
parents:
diff changeset
314 },
jurzua
parents:
diff changeset
315
jurzua
parents:
diff changeset
316 // For internal use only.
jurzua
parents:
diff changeset
317 // Behaves like an Array's method, not like a jQuery method.
jurzua
parents:
diff changeset
318 push: push,
jurzua
parents:
diff changeset
319 sort: [].sort,
jurzua
parents:
diff changeset
320 splice: [].splice
jurzua
parents:
diff changeset
321 };
jurzua
parents:
diff changeset
322
jurzua
parents:
diff changeset
323 // Give the init function the jQuery prototype for later instantiation
jurzua
parents:
diff changeset
324 jQuery.fn.init.prototype = jQuery.fn;
jurzua
parents:
diff changeset
325
jurzua
parents:
diff changeset
326 jQuery.extend = jQuery.fn.extend = function() {
jurzua
parents:
diff changeset
327 var options, name, src, copy, copyIsArray, clone,
jurzua
parents:
diff changeset
328 target = arguments[0] || {},
jurzua
parents:
diff changeset
329 i = 1,
jurzua
parents:
diff changeset
330 length = arguments.length,
jurzua
parents:
diff changeset
331 deep = false;
jurzua
parents:
diff changeset
332
jurzua
parents:
diff changeset
333 // Handle a deep copy situation
jurzua
parents:
diff changeset
334 if ( typeof target === "boolean" ) {
jurzua
parents:
diff changeset
335 deep = target;
jurzua
parents:
diff changeset
336 target = arguments[1] || {};
jurzua
parents:
diff changeset
337 // skip the boolean and the target
jurzua
parents:
diff changeset
338 i = 2;
jurzua
parents:
diff changeset
339 }
jurzua
parents:
diff changeset
340
jurzua
parents:
diff changeset
341 // Handle case when target is a string or something (possible in deep copy)
jurzua
parents:
diff changeset
342 if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
jurzua
parents:
diff changeset
343 target = {};
jurzua
parents:
diff changeset
344 }
jurzua
parents:
diff changeset
345
jurzua
parents:
diff changeset
346 // extend jQuery itself if only one argument is passed
jurzua
parents:
diff changeset
347 if ( length === i ) {
jurzua
parents:
diff changeset
348 target = this;
jurzua
parents:
diff changeset
349 --i;
jurzua
parents:
diff changeset
350 }
jurzua
parents:
diff changeset
351
jurzua
parents:
diff changeset
352 for ( ; i < length; i++ ) {
jurzua
parents:
diff changeset
353 // Only deal with non-null/undefined values
jurzua
parents:
diff changeset
354 if ( (options = arguments[ i ]) != null ) {
jurzua
parents:
diff changeset
355 // Extend the base object
jurzua
parents:
diff changeset
356 for ( name in options ) {
jurzua
parents:
diff changeset
357 src = target[ name ];
jurzua
parents:
diff changeset
358 copy = options[ name ];
jurzua
parents:
diff changeset
359
jurzua
parents:
diff changeset
360 // Prevent never-ending loop
jurzua
parents:
diff changeset
361 if ( target === copy ) {
jurzua
parents:
diff changeset
362 continue;
jurzua
parents:
diff changeset
363 }
jurzua
parents:
diff changeset
364
jurzua
parents:
diff changeset
365 // Recurse if we're merging plain objects or arrays
jurzua
parents:
diff changeset
366 if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
jurzua
parents:
diff changeset
367 if ( copyIsArray ) {
jurzua
parents:
diff changeset
368 copyIsArray = false;
jurzua
parents:
diff changeset
369 clone = src && jQuery.isArray(src) ? src : [];
jurzua
parents:
diff changeset
370
jurzua
parents:
diff changeset
371 } else {
jurzua
parents:
diff changeset
372 clone = src && jQuery.isPlainObject(src) ? src : {};
jurzua
parents:
diff changeset
373 }
jurzua
parents:
diff changeset
374
jurzua
parents:
diff changeset
375 // Never move original objects, clone them
jurzua
parents:
diff changeset
376 target[ name ] = jQuery.extend( deep, clone, copy );
jurzua
parents:
diff changeset
377
jurzua
parents:
diff changeset
378 // Don't bring in undefined values
jurzua
parents:
diff changeset
379 } else if ( copy !== undefined ) {
jurzua
parents:
diff changeset
380 target[ name ] = copy;
jurzua
parents:
diff changeset
381 }
jurzua
parents:
diff changeset
382 }
jurzua
parents:
diff changeset
383 }
jurzua
parents:
diff changeset
384 }
jurzua
parents:
diff changeset
385
jurzua
parents:
diff changeset
386 // Return the modified object
jurzua
parents:
diff changeset
387 return target;
jurzua
parents:
diff changeset
388 };
jurzua
parents:
diff changeset
389
jurzua
parents:
diff changeset
390 jQuery.extend({
jurzua
parents:
diff changeset
391 noConflict: function( deep ) {
jurzua
parents:
diff changeset
392 if ( window.$ === jQuery ) {
jurzua
parents:
diff changeset
393 window.$ = _$;
jurzua
parents:
diff changeset
394 }
jurzua
parents:
diff changeset
395
jurzua
parents:
diff changeset
396 if ( deep && window.jQuery === jQuery ) {
jurzua
parents:
diff changeset
397 window.jQuery = _jQuery;
jurzua
parents:
diff changeset
398 }
jurzua
parents:
diff changeset
399
jurzua
parents:
diff changeset
400 return jQuery;
jurzua
parents:
diff changeset
401 },
jurzua
parents:
diff changeset
402
jurzua
parents:
diff changeset
403 // Is the DOM ready to be used? Set to true once it occurs.
jurzua
parents:
diff changeset
404 isReady: false,
jurzua
parents:
diff changeset
405
jurzua
parents:
diff changeset
406 // A counter to track how many items to wait for before
jurzua
parents:
diff changeset
407 // the ready event fires. See #6781
jurzua
parents:
diff changeset
408 readyWait: 1,
jurzua
parents:
diff changeset
409
jurzua
parents:
diff changeset
410 // Hold (or release) the ready event
jurzua
parents:
diff changeset
411 holdReady: function( hold ) {
jurzua
parents:
diff changeset
412 if ( hold ) {
jurzua
parents:
diff changeset
413 jQuery.readyWait++;
jurzua
parents:
diff changeset
414 } else {
jurzua
parents:
diff changeset
415 jQuery.ready( true );
jurzua
parents:
diff changeset
416 }
jurzua
parents:
diff changeset
417 },
jurzua
parents:
diff changeset
418
jurzua
parents:
diff changeset
419 // Handle when the DOM is ready
jurzua
parents:
diff changeset
420 ready: function( wait ) {
jurzua
parents:
diff changeset
421 // Either a released hold or an DOMready/load event and not yet ready
jurzua
parents:
diff changeset
422 if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
jurzua
parents:
diff changeset
423 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
jurzua
parents:
diff changeset
424 if ( !document.body ) {
jurzua
parents:
diff changeset
425 return setTimeout( jQuery.ready, 1 );
jurzua
parents:
diff changeset
426 }
jurzua
parents:
diff changeset
427
jurzua
parents:
diff changeset
428 // Remember that the DOM is ready
jurzua
parents:
diff changeset
429 jQuery.isReady = true;
jurzua
parents:
diff changeset
430
jurzua
parents:
diff changeset
431 // If a normal DOM Ready event fired, decrement, and wait if need be
jurzua
parents:
diff changeset
432 if ( wait !== true && --jQuery.readyWait > 0 ) {
jurzua
parents:
diff changeset
433 return;
jurzua
parents:
diff changeset
434 }
jurzua
parents:
diff changeset
435
jurzua
parents:
diff changeset
436 // If there are functions bound, to execute
jurzua
parents:
diff changeset
437 readyList.resolveWith( document, [ jQuery ] );
jurzua
parents:
diff changeset
438
jurzua
parents:
diff changeset
439 // Trigger any bound ready events
jurzua
parents:
diff changeset
440 if ( jQuery.fn.trigger ) {
jurzua
parents:
diff changeset
441 jQuery( document ).trigger( "ready" ).unbind( "ready" );
jurzua
parents:
diff changeset
442 }
jurzua
parents:
diff changeset
443 }
jurzua
parents:
diff changeset
444 },
jurzua
parents:
diff changeset
445
jurzua
parents:
diff changeset
446 bindReady: function() {
jurzua
parents:
diff changeset
447 if ( readyList ) {
jurzua
parents:
diff changeset
448 return;
jurzua
parents:
diff changeset
449 }
jurzua
parents:
diff changeset
450
jurzua
parents:
diff changeset
451 readyList = jQuery._Deferred();
jurzua
parents:
diff changeset
452
jurzua
parents:
diff changeset
453 // Catch cases where $(document).ready() is called after the
jurzua
parents:
diff changeset
454 // browser event has already occurred.
jurzua
parents:
diff changeset
455 if ( document.readyState === "complete" ) {
jurzua
parents:
diff changeset
456 // Handle it asynchronously to allow scripts the opportunity to delay ready
jurzua
parents:
diff changeset
457 return setTimeout( jQuery.ready, 1 );
jurzua
parents:
diff changeset
458 }
jurzua
parents:
diff changeset
459
jurzua
parents:
diff changeset
460 // Mozilla, Opera and webkit nightlies currently support this event
jurzua
parents:
diff changeset
461 if ( document.addEventListener ) {
jurzua
parents:
diff changeset
462 // Use the handy event callback
jurzua
parents:
diff changeset
463 document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
jurzua
parents:
diff changeset
464
jurzua
parents:
diff changeset
465 // A fallback to window.onload, that will always work
jurzua
parents:
diff changeset
466 window.addEventListener( "load", jQuery.ready, false );
jurzua
parents:
diff changeset
467
jurzua
parents:
diff changeset
468 // If IE event model is used
jurzua
parents:
diff changeset
469 } else if ( document.attachEvent ) {
jurzua
parents:
diff changeset
470 // ensure firing before onload,
jurzua
parents:
diff changeset
471 // maybe late but safe also for iframes
jurzua
parents:
diff changeset
472 document.attachEvent( "onreadystatechange", DOMContentLoaded );
jurzua
parents:
diff changeset
473
jurzua
parents:
diff changeset
474 // A fallback to window.onload, that will always work
jurzua
parents:
diff changeset
475 window.attachEvent( "onload", jQuery.ready );
jurzua
parents:
diff changeset
476
jurzua
parents:
diff changeset
477 // If IE and not a frame
jurzua
parents:
diff changeset
478 // continually check to see if the document is ready
jurzua
parents:
diff changeset
479 var toplevel = false;
jurzua
parents:
diff changeset
480
jurzua
parents:
diff changeset
481 try {
jurzua
parents:
diff changeset
482 toplevel = window.frameElement == null;
jurzua
parents:
diff changeset
483 } catch(e) {}
jurzua
parents:
diff changeset
484
jurzua
parents:
diff changeset
485 if ( document.documentElement.doScroll && toplevel ) {
jurzua
parents:
diff changeset
486 doScrollCheck();
jurzua
parents:
diff changeset
487 }
jurzua
parents:
diff changeset
488 }
jurzua
parents:
diff changeset
489 },
jurzua
parents:
diff changeset
490
jurzua
parents:
diff changeset
491 // See test/unit/core.js for details concerning isFunction.
jurzua
parents:
diff changeset
492 // Since version 1.3, DOM methods and functions like alert
jurzua
parents:
diff changeset
493 // aren't supported. They return false on IE (#2968).
jurzua
parents:
diff changeset
494 isFunction: function( obj ) {
jurzua
parents:
diff changeset
495 return jQuery.type(obj) === "function";
jurzua
parents:
diff changeset
496 },
jurzua
parents:
diff changeset
497
jurzua
parents:
diff changeset
498 isArray: Array.isArray || function( obj ) {
jurzua
parents:
diff changeset
499 return jQuery.type(obj) === "array";
jurzua
parents:
diff changeset
500 },
jurzua
parents:
diff changeset
501
jurzua
parents:
diff changeset
502 // A crude way of determining if an object is a window
jurzua
parents:
diff changeset
503 isWindow: function( obj ) {
jurzua
parents:
diff changeset
504 return obj && typeof obj === "object" && "setInterval" in obj;
jurzua
parents:
diff changeset
505 },
jurzua
parents:
diff changeset
506
jurzua
parents:
diff changeset
507 isNaN: function( obj ) {
jurzua
parents:
diff changeset
508 return obj == null || !rdigit.test( obj ) || isNaN( obj );
jurzua
parents:
diff changeset
509 },
jurzua
parents:
diff changeset
510
jurzua
parents:
diff changeset
511 type: function( obj ) {
jurzua
parents:
diff changeset
512 return obj == null ?
jurzua
parents:
diff changeset
513 String( obj ) :
jurzua
parents:
diff changeset
514 class2type[ toString.call(obj) ] || "object";
jurzua
parents:
diff changeset
515 },
jurzua
parents:
diff changeset
516
jurzua
parents:
diff changeset
517 isPlainObject: function( obj ) {
jurzua
parents:
diff changeset
518 // Must be an Object.
jurzua
parents:
diff changeset
519 // Because of IE, we also have to check the presence of the constructor property.
jurzua
parents:
diff changeset
520 // Make sure that DOM nodes and window objects don't pass through, as well
jurzua
parents:
diff changeset
521 if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
jurzua
parents:
diff changeset
522 return false;
jurzua
parents:
diff changeset
523 }
jurzua
parents:
diff changeset
524
jurzua
parents:
diff changeset
525 try {
jurzua
parents:
diff changeset
526 // Not own constructor property must be Object
jurzua
parents:
diff changeset
527 if ( obj.constructor &&
jurzua
parents:
diff changeset
528 !hasOwn.call(obj, "constructor") &&
jurzua
parents:
diff changeset
529 !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
jurzua
parents:
diff changeset
530 return false;
jurzua
parents:
diff changeset
531 }
jurzua
parents:
diff changeset
532 } catch ( e ) {
jurzua
parents:
diff changeset
533 // IE8,9 Will throw exceptions on certain host objects #9897
jurzua
parents:
diff changeset
534 return false;
jurzua
parents:
diff changeset
535 }
jurzua
parents:
diff changeset
536
jurzua
parents:
diff changeset
537 // Own properties are enumerated firstly, so to speed up,
jurzua
parents:
diff changeset
538 // if last one is own, then all properties are own.
jurzua
parents:
diff changeset
539
jurzua
parents:
diff changeset
540 var key;
jurzua
parents:
diff changeset
541 for ( key in obj ) {}
jurzua
parents:
diff changeset
542
jurzua
parents:
diff changeset
543 return key === undefined || hasOwn.call( obj, key );
jurzua
parents:
diff changeset
544 },
jurzua
parents:
diff changeset
545
jurzua
parents:
diff changeset
546 isEmptyObject: function( obj ) {
jurzua
parents:
diff changeset
547 for ( var name in obj ) {
jurzua
parents:
diff changeset
548 return false;
jurzua
parents:
diff changeset
549 }
jurzua
parents:
diff changeset
550 return true;
jurzua
parents:
diff changeset
551 },
jurzua
parents:
diff changeset
552
jurzua
parents:
diff changeset
553 error: function( msg ) {
jurzua
parents:
diff changeset
554 throw msg;
jurzua
parents:
diff changeset
555 },
jurzua
parents:
diff changeset
556
jurzua
parents:
diff changeset
557 parseJSON: function( data ) {
jurzua
parents:
diff changeset
558 if ( typeof data !== "string" || !data ) {
jurzua
parents:
diff changeset
559 return null;
jurzua
parents:
diff changeset
560 }
jurzua
parents:
diff changeset
561
jurzua
parents:
diff changeset
562 // Make sure leading/trailing whitespace is removed (IE can't handle it)
jurzua
parents:
diff changeset
563 data = jQuery.trim( data );
jurzua
parents:
diff changeset
564
jurzua
parents:
diff changeset
565 // Attempt to parse using the native JSON parser first
jurzua
parents:
diff changeset
566 if ( window.JSON && window.JSON.parse ) {
jurzua
parents:
diff changeset
567 return window.JSON.parse( data );
jurzua
parents:
diff changeset
568 }
jurzua
parents:
diff changeset
569
jurzua
parents:
diff changeset
570 // Make sure the incoming data is actual JSON
jurzua
parents:
diff changeset
571 // Logic borrowed from http://json.org/json2.js
jurzua
parents:
diff changeset
572 if ( rvalidchars.test( data.replace( rvalidescape, "@" )
jurzua
parents:
diff changeset
573 .replace( rvalidtokens, "]" )
jurzua
parents:
diff changeset
574 .replace( rvalidbraces, "")) ) {
jurzua
parents:
diff changeset
575
jurzua
parents:
diff changeset
576 return (new Function( "return " + data ))();
jurzua
parents:
diff changeset
577
jurzua
parents:
diff changeset
578 }
jurzua
parents:
diff changeset
579 jQuery.error( "Invalid JSON: " + data );
jurzua
parents:
diff changeset
580 },
jurzua
parents:
diff changeset
581
jurzua
parents:
diff changeset
582 // Cross-browser xml parsing
jurzua
parents:
diff changeset
583 parseXML: function( data ) {
jurzua
parents:
diff changeset
584 var xml, tmp;
jurzua
parents:
diff changeset
585 try {
jurzua
parents:
diff changeset
586 if ( window.DOMParser ) { // Standard
jurzua
parents:
diff changeset
587 tmp = new DOMParser();
jurzua
parents:
diff changeset
588 xml = tmp.parseFromString( data , "text/xml" );
jurzua
parents:
diff changeset
589 } else { // IE
jurzua
parents:
diff changeset
590 xml = new ActiveXObject( "Microsoft.XMLDOM" );
jurzua
parents:
diff changeset
591 xml.async = "false";
jurzua
parents:
diff changeset
592 xml.loadXML( data );
jurzua
parents:
diff changeset
593 }
jurzua
parents:
diff changeset
594 } catch( e ) {
jurzua
parents:
diff changeset
595 xml = undefined;
jurzua
parents:
diff changeset
596 }
jurzua
parents:
diff changeset
597 if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
jurzua
parents:
diff changeset
598 jQuery.error( "Invalid XML: " + data );
jurzua
parents:
diff changeset
599 }
jurzua
parents:
diff changeset
600 return xml;
jurzua
parents:
diff changeset
601 },
jurzua
parents:
diff changeset
602
jurzua
parents:
diff changeset
603 noop: function() {},
jurzua
parents:
diff changeset
604
jurzua
parents:
diff changeset
605 // Evaluates a script in a global context
jurzua
parents:
diff changeset
606 // Workarounds based on findings by Jim Driscoll
jurzua
parents:
diff changeset
607 // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
jurzua
parents:
diff changeset
608 globalEval: function( data ) {
jurzua
parents:
diff changeset
609 if ( data && rnotwhite.test( data ) ) {
jurzua
parents:
diff changeset
610 // We use execScript on Internet Explorer
jurzua
parents:
diff changeset
611 // We use an anonymous function so that context is window
jurzua
parents:
diff changeset
612 // rather than jQuery in Firefox
jurzua
parents:
diff changeset
613 ( window.execScript || function( data ) {
jurzua
parents:
diff changeset
614 window[ "eval" ].call( window, data );
jurzua
parents:
diff changeset
615 } )( data );
jurzua
parents:
diff changeset
616 }
jurzua
parents:
diff changeset
617 },
jurzua
parents:
diff changeset
618
jurzua
parents:
diff changeset
619 // Convert dashed to camelCase; used by the css and data modules
jurzua
parents:
diff changeset
620 // Microsoft forgot to hump their vendor prefix (#9572)
jurzua
parents:
diff changeset
621 camelCase: function( string ) {
jurzua
parents:
diff changeset
622 return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
jurzua
parents:
diff changeset
623 },
jurzua
parents:
diff changeset
624
jurzua
parents:
diff changeset
625 nodeName: function( elem, name ) {
jurzua
parents:
diff changeset
626 return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
jurzua
parents:
diff changeset
627 },
jurzua
parents:
diff changeset
628
jurzua
parents:
diff changeset
629 // args is for internal usage only
jurzua
parents:
diff changeset
630 each: function( object, callback, args ) {
jurzua
parents:
diff changeset
631 var name, i = 0,
jurzua
parents:
diff changeset
632 length = object.length,
jurzua
parents:
diff changeset
633 isObj = length === undefined || jQuery.isFunction( object );
jurzua
parents:
diff changeset
634
jurzua
parents:
diff changeset
635 if ( args ) {
jurzua
parents:
diff changeset
636 if ( isObj ) {
jurzua
parents:
diff changeset
637 for ( name in object ) {
jurzua
parents:
diff changeset
638 if ( callback.apply( object[ name ], args ) === false ) {
jurzua
parents:
diff changeset
639 break;
jurzua
parents:
diff changeset
640 }
jurzua
parents:
diff changeset
641 }
jurzua
parents:
diff changeset
642 } else {
jurzua
parents:
diff changeset
643 for ( ; i < length; ) {
jurzua
parents:
diff changeset
644 if ( callback.apply( object[ i++ ], args ) === false ) {
jurzua
parents:
diff changeset
645 break;
jurzua
parents:
diff changeset
646 }
jurzua
parents:
diff changeset
647 }
jurzua
parents:
diff changeset
648 }
jurzua
parents:
diff changeset
649
jurzua
parents:
diff changeset
650 // A special, fast, case for the most common use of each
jurzua
parents:
diff changeset
651 } else {
jurzua
parents:
diff changeset
652 if ( isObj ) {
jurzua
parents:
diff changeset
653 for ( name in object ) {
jurzua
parents:
diff changeset
654 if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
jurzua
parents:
diff changeset
655 break;
jurzua
parents:
diff changeset
656 }
jurzua
parents:
diff changeset
657 }
jurzua
parents:
diff changeset
658 } else {
jurzua
parents:
diff changeset
659 for ( ; i < length; ) {
jurzua
parents:
diff changeset
660 if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
jurzua
parents:
diff changeset
661 break;
jurzua
parents:
diff changeset
662 }
jurzua
parents:
diff changeset
663 }
jurzua
parents:
diff changeset
664 }
jurzua
parents:
diff changeset
665 }
jurzua
parents:
diff changeset
666
jurzua
parents:
diff changeset
667 return object;
jurzua
parents:
diff changeset
668 },
jurzua
parents:
diff changeset
669
jurzua
parents:
diff changeset
670 // Use native String.trim function wherever possible
jurzua
parents:
diff changeset
671 trim: trim ?
jurzua
parents:
diff changeset
672 function( text ) {
jurzua
parents:
diff changeset
673 return text == null ?
jurzua
parents:
diff changeset
674 "" :
jurzua
parents:
diff changeset
675 trim.call( text );
jurzua
parents:
diff changeset
676 } :
jurzua
parents:
diff changeset
677
jurzua
parents:
diff changeset
678 // Otherwise use our own trimming functionality
jurzua
parents:
diff changeset
679 function( text ) {
jurzua
parents:
diff changeset
680 return text == null ?
jurzua
parents:
diff changeset
681 "" :
jurzua
parents:
diff changeset
682 text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
jurzua
parents:
diff changeset
683 },
jurzua
parents:
diff changeset
684
jurzua
parents:
diff changeset
685 // results is for internal usage only
jurzua
parents:
diff changeset
686 makeArray: function( array, results ) {
jurzua
parents:
diff changeset
687 var ret = results || [];
jurzua
parents:
diff changeset
688
jurzua
parents:
diff changeset
689 if ( array != null ) {
jurzua
parents:
diff changeset
690 // The window, strings (and functions) also have 'length'
jurzua
parents:
diff changeset
691 // The extra typeof function check is to prevent crashes
jurzua
parents:
diff changeset
692 // in Safari 2 (See: #3039)
jurzua
parents:
diff changeset
693 // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
jurzua
parents:
diff changeset
694 var type = jQuery.type( array );
jurzua
parents:
diff changeset
695
jurzua
parents:
diff changeset
696 if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
jurzua
parents:
diff changeset
697 push.call( ret, array );
jurzua
parents:
diff changeset
698 } else {
jurzua
parents:
diff changeset
699 jQuery.merge( ret, array );
jurzua
parents:
diff changeset
700 }
jurzua
parents:
diff changeset
701 }
jurzua
parents:
diff changeset
702
jurzua
parents:
diff changeset
703 return ret;
jurzua
parents:
diff changeset
704 },
jurzua
parents:
diff changeset
705
jurzua
parents:
diff changeset
706 inArray: function( elem, array ) {
jurzua
parents:
diff changeset
707 if ( !array ) {
jurzua
parents:
diff changeset
708 return -1;
jurzua
parents:
diff changeset
709 }
jurzua
parents:
diff changeset
710
jurzua
parents:
diff changeset
711 if ( indexOf ) {
jurzua
parents:
diff changeset
712 return indexOf.call( array, elem );
jurzua
parents:
diff changeset
713 }
jurzua
parents:
diff changeset
714
jurzua
parents:
diff changeset
715 for ( var i = 0, length = array.length; i < length; i++ ) {
jurzua
parents:
diff changeset
716 if ( array[ i ] === elem ) {
jurzua
parents:
diff changeset
717 return i;
jurzua
parents:
diff changeset
718 }
jurzua
parents:
diff changeset
719 }
jurzua
parents:
diff changeset
720
jurzua
parents:
diff changeset
721 return -1;
jurzua
parents:
diff changeset
722 },
jurzua
parents:
diff changeset
723
jurzua
parents:
diff changeset
724 merge: function( first, second ) {
jurzua
parents:
diff changeset
725 var i = first.length,
jurzua
parents:
diff changeset
726 j = 0;
jurzua
parents:
diff changeset
727
jurzua
parents:
diff changeset
728 if ( typeof second.length === "number" ) {
jurzua
parents:
diff changeset
729 for ( var l = second.length; j < l; j++ ) {
jurzua
parents:
diff changeset
730 first[ i++ ] = second[ j ];
jurzua
parents:
diff changeset
731 }
jurzua
parents:
diff changeset
732
jurzua
parents:
diff changeset
733 } else {
jurzua
parents:
diff changeset
734 while ( second[j] !== undefined ) {
jurzua
parents:
diff changeset
735 first[ i++ ] = second[ j++ ];
jurzua
parents:
diff changeset
736 }
jurzua
parents:
diff changeset
737 }
jurzua
parents:
diff changeset
738
jurzua
parents:
diff changeset
739 first.length = i;
jurzua
parents:
diff changeset
740
jurzua
parents:
diff changeset
741 return first;
jurzua
parents:
diff changeset
742 },
jurzua
parents:
diff changeset
743
jurzua
parents:
diff changeset
744 grep: function( elems, callback, inv ) {
jurzua
parents:
diff changeset
745 var ret = [], retVal;
jurzua
parents:
diff changeset
746 inv = !!inv;
jurzua
parents:
diff changeset
747
jurzua
parents:
diff changeset
748 // Go through the array, only saving the items
jurzua
parents:
diff changeset
749 // that pass the validator function
jurzua
parents:
diff changeset
750 for ( var i = 0, length = elems.length; i < length; i++ ) {
jurzua
parents:
diff changeset
751 retVal = !!callback( elems[ i ], i );
jurzua
parents:
diff changeset
752 if ( inv !== retVal ) {
jurzua
parents:
diff changeset
753 ret.push( elems[ i ] );
jurzua
parents:
diff changeset
754 }
jurzua
parents:
diff changeset
755 }
jurzua
parents:
diff changeset
756
jurzua
parents:
diff changeset
757 return ret;
jurzua
parents:
diff changeset
758 },
jurzua
parents:
diff changeset
759
jurzua
parents:
diff changeset
760 // arg is for internal usage only
jurzua
parents:
diff changeset
761 map: function( elems, callback, arg ) {
jurzua
parents:
diff changeset
762 var value, key, ret = [],
jurzua
parents:
diff changeset
763 i = 0,
jurzua
parents:
diff changeset
764 length = elems.length,
jurzua
parents:
diff changeset
765 // jquery objects are treated as arrays
jurzua
parents:
diff changeset
766 isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
jurzua
parents:
diff changeset
767
jurzua
parents:
diff changeset
768 // Go through the array, translating each of the items to their
jurzua
parents:
diff changeset
769 if ( isArray ) {
jurzua
parents:
diff changeset
770 for ( ; i < length; i++ ) {
jurzua
parents:
diff changeset
771 value = callback( elems[ i ], i, arg );
jurzua
parents:
diff changeset
772
jurzua
parents:
diff changeset
773 if ( value != null ) {
jurzua
parents:
diff changeset
774 ret[ ret.length ] = value;
jurzua
parents:
diff changeset
775 }
jurzua
parents:
diff changeset
776 }
jurzua
parents:
diff changeset
777
jurzua
parents:
diff changeset
778 // Go through every key on the object,
jurzua
parents:
diff changeset
779 } else {
jurzua
parents:
diff changeset
780 for ( key in elems ) {
jurzua
parents:
diff changeset
781 value = callback( elems[ key ], key, arg );
jurzua
parents:
diff changeset
782
jurzua
parents:
diff changeset
783 if ( value != null ) {
jurzua
parents:
diff changeset
784 ret[ ret.length ] = value;
jurzua
parents:
diff changeset
785 }
jurzua
parents:
diff changeset
786 }
jurzua
parents:
diff changeset
787 }
jurzua
parents:
diff changeset
788
jurzua
parents:
diff changeset
789 // Flatten any nested arrays
jurzua
parents:
diff changeset
790 return ret.concat.apply( [], ret );
jurzua
parents:
diff changeset
791 },
jurzua
parents:
diff changeset
792
jurzua
parents:
diff changeset
793 // A global GUID counter for objects
jurzua
parents:
diff changeset
794 guid: 1,
jurzua
parents:
diff changeset
795
jurzua
parents:
diff changeset
796 // Bind a function to a context, optionally partially applying any
jurzua
parents:
diff changeset
797 // arguments.
jurzua
parents:
diff changeset
798 proxy: function( fn, context ) {
jurzua
parents:
diff changeset
799 if ( typeof context === "string" ) {
jurzua
parents:
diff changeset
800 var tmp = fn[ context ];
jurzua
parents:
diff changeset
801 context = fn;
jurzua
parents:
diff changeset
802 fn = tmp;
jurzua
parents:
diff changeset
803 }
jurzua
parents:
diff changeset
804
jurzua
parents:
diff changeset
805 // Quick check to determine if target is callable, in the spec
jurzua
parents:
diff changeset
806 // this throws a TypeError, but we will just return undefined.
jurzua
parents:
diff changeset
807 if ( !jQuery.isFunction( fn ) ) {
jurzua
parents:
diff changeset
808 return undefined;
jurzua
parents:
diff changeset
809 }
jurzua
parents:
diff changeset
810
jurzua
parents:
diff changeset
811 // Simulated bind
jurzua
parents:
diff changeset
812 var args = slice.call( arguments, 2 ),
jurzua
parents:
diff changeset
813 proxy = function() {
jurzua
parents:
diff changeset
814 return fn.apply( context, args.concat( slice.call( arguments ) ) );
jurzua
parents:
diff changeset
815 };
jurzua
parents:
diff changeset
816
jurzua
parents:
diff changeset
817 // Set the guid of unique handler to the same of original handler, so it can be removed
jurzua
parents:
diff changeset
818 proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
jurzua
parents:
diff changeset
819
jurzua
parents:
diff changeset
820 return proxy;
jurzua
parents:
diff changeset
821 },
jurzua
parents:
diff changeset
822
jurzua
parents:
diff changeset
823 // Mutifunctional method to get and set values to a collection
jurzua
parents:
diff changeset
824 // The value/s can optionally be executed if it's a function
jurzua
parents:
diff changeset
825 access: function( elems, key, value, exec, fn, pass ) {
jurzua
parents:
diff changeset
826 var length = elems.length;
jurzua
parents:
diff changeset
827
jurzua
parents:
diff changeset
828 // Setting many attributes
jurzua
parents:
diff changeset
829 if ( typeof key === "object" ) {
jurzua
parents:
diff changeset
830 for ( var k in key ) {
jurzua
parents:
diff changeset
831 jQuery.access( elems, k, key[k], exec, fn, value );
jurzua
parents:
diff changeset
832 }
jurzua
parents:
diff changeset
833 return elems;
jurzua
parents:
diff changeset
834 }
jurzua
parents:
diff changeset
835
jurzua
parents:
diff changeset
836 // Setting one attribute
jurzua
parents:
diff changeset
837 if ( value !== undefined ) {
jurzua
parents:
diff changeset
838 // Optionally, function values get executed if exec is true
jurzua
parents:
diff changeset
839 exec = !pass && exec && jQuery.isFunction(value);
jurzua
parents:
diff changeset
840
jurzua
parents:
diff changeset
841 for ( var i = 0; i < length; i++ ) {
jurzua
parents:
diff changeset
842 fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
jurzua
parents:
diff changeset
843 }
jurzua
parents:
diff changeset
844
jurzua
parents:
diff changeset
845 return elems;
jurzua
parents:
diff changeset
846 }
jurzua
parents:
diff changeset
847
jurzua
parents:
diff changeset
848 // Getting an attribute
jurzua
parents:
diff changeset
849 return length ? fn( elems[0], key ) : undefined;
jurzua
parents:
diff changeset
850 },
jurzua
parents:
diff changeset
851
jurzua
parents:
diff changeset
852 now: function() {
jurzua
parents:
diff changeset
853 return (new Date()).getTime();
jurzua
parents:
diff changeset
854 },
jurzua
parents:
diff changeset
855
jurzua
parents:
diff changeset
856 // Use of jQuery.browser is frowned upon.
jurzua
parents:
diff changeset
857 // More details: http://docs.jquery.com/Utilities/jQuery.browser
jurzua
parents:
diff changeset
858 uaMatch: function( ua ) {
jurzua
parents:
diff changeset
859 ua = ua.toLowerCase();
jurzua
parents:
diff changeset
860
jurzua
parents:
diff changeset
861 var match = rwebkit.exec( ua ) ||
jurzua
parents:
diff changeset
862 ropera.exec( ua ) ||
jurzua
parents:
diff changeset
863 rmsie.exec( ua ) ||
jurzua
parents:
diff changeset
864 ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
jurzua
parents:
diff changeset
865 [];
jurzua
parents:
diff changeset
866
jurzua
parents:
diff changeset
867 return { browser: match[1] || "", version: match[2] || "0" };
jurzua
parents:
diff changeset
868 },
jurzua
parents:
diff changeset
869
jurzua
parents:
diff changeset
870 sub: function() {
jurzua
parents:
diff changeset
871 function jQuerySub( selector, context ) {
jurzua
parents:
diff changeset
872 return new jQuerySub.fn.init( selector, context );
jurzua
parents:
diff changeset
873 }
jurzua
parents:
diff changeset
874 jQuery.extend( true, jQuerySub, this );
jurzua
parents:
diff changeset
875 jQuerySub.superclass = this;
jurzua
parents:
diff changeset
876 jQuerySub.fn = jQuerySub.prototype = this();
jurzua
parents:
diff changeset
877 jQuerySub.fn.constructor = jQuerySub;
jurzua
parents:
diff changeset
878 jQuerySub.sub = this.sub;
jurzua
parents:
diff changeset
879 jQuerySub.fn.init = function init( selector, context ) {
jurzua
parents:
diff changeset
880 if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
jurzua
parents:
diff changeset
881 context = jQuerySub( context );
jurzua
parents:
diff changeset
882 }
jurzua
parents:
diff changeset
883
jurzua
parents:
diff changeset
884 return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
jurzua
parents:
diff changeset
885 };
jurzua
parents:
diff changeset
886 jQuerySub.fn.init.prototype = jQuerySub.fn;
jurzua
parents:
diff changeset
887 var rootjQuerySub = jQuerySub(document);
jurzua
parents:
diff changeset
888 return jQuerySub;
jurzua
parents:
diff changeset
889 },
jurzua
parents:
diff changeset
890
jurzua
parents:
diff changeset
891 browser: {}
jurzua
parents:
diff changeset
892 });
jurzua
parents:
diff changeset
893
jurzua
parents:
diff changeset
894 // Populate the class2type map
jurzua
parents:
diff changeset
895 jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
jurzua
parents:
diff changeset
896 class2type[ "[object " + name + "]" ] = name.toLowerCase();
jurzua
parents:
diff changeset
897 });
jurzua
parents:
diff changeset
898
jurzua
parents:
diff changeset
899 browserMatch = jQuery.uaMatch( userAgent );
jurzua
parents:
diff changeset
900 if ( browserMatch.browser ) {
jurzua
parents:
diff changeset
901 jQuery.browser[ browserMatch.browser ] = true;
jurzua
parents:
diff changeset
902 jQuery.browser.version = browserMatch.version;
jurzua
parents:
diff changeset
903 }
jurzua
parents:
diff changeset
904
jurzua
parents:
diff changeset
905 // Deprecated, use jQuery.browser.webkit instead
jurzua
parents:
diff changeset
906 if ( jQuery.browser.webkit ) {
jurzua
parents:
diff changeset
907 jQuery.browser.safari = true;
jurzua
parents:
diff changeset
908 }
jurzua
parents:
diff changeset
909
jurzua
parents:
diff changeset
910 // IE doesn't match non-breaking spaces with \s
jurzua
parents:
diff changeset
911 if ( rnotwhite.test( "\xA0" ) ) {
jurzua
parents:
diff changeset
912 trimLeft = /^[\s\xA0]+/;
jurzua
parents:
diff changeset
913 trimRight = /[\s\xA0]+$/;
jurzua
parents:
diff changeset
914 }
jurzua
parents:
diff changeset
915
jurzua
parents:
diff changeset
916 // All jQuery objects should point back to these
jurzua
parents:
diff changeset
917 rootjQuery = jQuery(document);
jurzua
parents:
diff changeset
918
jurzua
parents:
diff changeset
919 // Cleanup functions for the document ready method
jurzua
parents:
diff changeset
920 if ( document.addEventListener ) {
jurzua
parents:
diff changeset
921 DOMContentLoaded = function() {
jurzua
parents:
diff changeset
922 document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
jurzua
parents:
diff changeset
923 jQuery.ready();
jurzua
parents:
diff changeset
924 };
jurzua
parents:
diff changeset
925
jurzua
parents:
diff changeset
926 } else if ( document.attachEvent ) {
jurzua
parents:
diff changeset
927 DOMContentLoaded = function() {
jurzua
parents:
diff changeset
928 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
jurzua
parents:
diff changeset
929 if ( document.readyState === "complete" ) {
jurzua
parents:
diff changeset
930 document.detachEvent( "onreadystatechange", DOMContentLoaded );
jurzua
parents:
diff changeset
931 jQuery.ready();
jurzua
parents:
diff changeset
932 }
jurzua
parents:
diff changeset
933 };
jurzua
parents:
diff changeset
934 }
jurzua
parents:
diff changeset
935
jurzua
parents:
diff changeset
936 // The DOM ready check for Internet Explorer
jurzua
parents:
diff changeset
937 function doScrollCheck() {
jurzua
parents:
diff changeset
938 if ( jQuery.isReady ) {
jurzua
parents:
diff changeset
939 return;
jurzua
parents:
diff changeset
940 }
jurzua
parents:
diff changeset
941
jurzua
parents:
diff changeset
942 try {
jurzua
parents:
diff changeset
943 // If IE is used, use the trick by Diego Perini
jurzua
parents:
diff changeset
944 // http://javascript.nwbox.com/IEContentLoaded/
jurzua
parents:
diff changeset
945 document.documentElement.doScroll("left");
jurzua
parents:
diff changeset
946 } catch(e) {
jurzua
parents:
diff changeset
947 setTimeout( doScrollCheck, 1 );
jurzua
parents:
diff changeset
948 return;
jurzua
parents:
diff changeset
949 }
jurzua
parents:
diff changeset
950
jurzua
parents:
diff changeset
951 // and execute any waiting functions
jurzua
parents:
diff changeset
952 jQuery.ready();
jurzua
parents:
diff changeset
953 }
jurzua
parents:
diff changeset
954
jurzua
parents:
diff changeset
955 return jQuery;
jurzua
parents:
diff changeset
956
jurzua
parents:
diff changeset
957 })();
jurzua
parents:
diff changeset
958
jurzua
parents:
diff changeset
959
jurzua
parents:
diff changeset
960 var // Promise methods
jurzua
parents:
diff changeset
961 promiseMethods = "done fail isResolved isRejected promise then always pipe".split( " " ),
jurzua
parents:
diff changeset
962 // Static reference to slice
jurzua
parents:
diff changeset
963 sliceDeferred = [].slice;
jurzua
parents:
diff changeset
964
jurzua
parents:
diff changeset
965 jQuery.extend({
jurzua
parents:
diff changeset
966 // Create a simple deferred (one callbacks list)
jurzua
parents:
diff changeset
967 _Deferred: function() {
jurzua
parents:
diff changeset
968 var // callbacks list
jurzua
parents:
diff changeset
969 callbacks = [],
jurzua
parents:
diff changeset
970 // stored [ context , args ]
jurzua
parents:
diff changeset
971 fired,
jurzua
parents:
diff changeset
972 // to avoid firing when already doing so
jurzua
parents:
diff changeset
973 firing,
jurzua
parents:
diff changeset
974 // flag to know if the deferred has been cancelled
jurzua
parents:
diff changeset
975 cancelled,
jurzua
parents:
diff changeset
976 // the deferred itself
jurzua
parents:
diff changeset
977 deferred = {
jurzua
parents:
diff changeset
978
jurzua
parents:
diff changeset
979 // done( f1, f2, ...)
jurzua
parents:
diff changeset
980 done: function() {
jurzua
parents:
diff changeset
981 if ( !cancelled ) {
jurzua
parents:
diff changeset
982 var args = arguments,
jurzua
parents:
diff changeset
983 i,
jurzua
parents:
diff changeset
984 length,
jurzua
parents:
diff changeset
985 elem,
jurzua
parents:
diff changeset
986 type,
jurzua
parents:
diff changeset
987 _fired;
jurzua
parents:
diff changeset
988 if ( fired ) {
jurzua
parents:
diff changeset
989 _fired = fired;
jurzua
parents:
diff changeset
990 fired = 0;
jurzua
parents:
diff changeset
991 }
jurzua
parents:
diff changeset
992 for ( i = 0, length = args.length; i < length; i++ ) {
jurzua
parents:
diff changeset
993 elem = args[ i ];
jurzua
parents:
diff changeset
994 type = jQuery.type( elem );
jurzua
parents:
diff changeset
995 if ( type === "array" ) {
jurzua
parents:
diff changeset
996 deferred.done.apply( deferred, elem );
jurzua
parents:
diff changeset
997 } else if ( type === "function" ) {
jurzua
parents:
diff changeset
998 callbacks.push( elem );
jurzua
parents:
diff changeset
999 }
jurzua
parents:
diff changeset
1000 }
jurzua
parents:
diff changeset
1001 if ( _fired ) {
jurzua
parents:
diff changeset
1002 deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
jurzua
parents:
diff changeset
1003 }
jurzua
parents:
diff changeset
1004 }
jurzua
parents:
diff changeset
1005 return this;
jurzua
parents:
diff changeset
1006 },
jurzua
parents:
diff changeset
1007
jurzua
parents:
diff changeset
1008 // resolve with given context and args
jurzua
parents:
diff changeset
1009 resolveWith: function( context, args ) {
jurzua
parents:
diff changeset
1010 if ( !cancelled && !fired && !firing ) {
jurzua
parents:
diff changeset
1011 // make sure args are available (#8421)
jurzua
parents:
diff changeset
1012 args = args || [];
jurzua
parents:
diff changeset
1013 firing = 1;
jurzua
parents:
diff changeset
1014 try {
jurzua
parents:
diff changeset
1015 while( callbacks[ 0 ] ) {
jurzua
parents:
diff changeset
1016 callbacks.shift().apply( context, args );
jurzua
parents:
diff changeset
1017 }
jurzua
parents:
diff changeset
1018 }
jurzua
parents:
diff changeset
1019 finally {
jurzua
parents:
diff changeset
1020 fired = [ context, args ];
jurzua
parents:
diff changeset
1021 firing = 0;
jurzua
parents:
diff changeset
1022 }
jurzua
parents:
diff changeset
1023 }
jurzua
parents:
diff changeset
1024 return this;
jurzua
parents:
diff changeset
1025 },
jurzua
parents:
diff changeset
1026
jurzua
parents:
diff changeset
1027 // resolve with this as context and given arguments
jurzua
parents:
diff changeset
1028 resolve: function() {
jurzua
parents:
diff changeset
1029 deferred.resolveWith( this, arguments );
jurzua
parents:
diff changeset
1030 return this;
jurzua
parents:
diff changeset
1031 },
jurzua
parents:
diff changeset
1032
jurzua
parents:
diff changeset
1033 // Has this deferred been resolved?
jurzua
parents:
diff changeset
1034 isResolved: function() {
jurzua
parents:
diff changeset
1035 return !!( firing || fired );
jurzua
parents:
diff changeset
1036 },
jurzua
parents:
diff changeset
1037
jurzua
parents:
diff changeset
1038 // Cancel
jurzua
parents:
diff changeset
1039 cancel: function() {
jurzua
parents:
diff changeset
1040 cancelled = 1;
jurzua
parents:
diff changeset
1041 callbacks = [];
jurzua
parents:
diff changeset
1042 return this;
jurzua
parents:
diff changeset
1043 }
jurzua
parents:
diff changeset
1044 };
jurzua
parents:
diff changeset
1045
jurzua
parents:
diff changeset
1046 return deferred;
jurzua
parents:
diff changeset
1047 },
jurzua
parents:
diff changeset
1048
jurzua
parents:
diff changeset
1049 // Full fledged deferred (two callbacks list)
jurzua
parents:
diff changeset
1050 Deferred: function( func ) {
jurzua
parents:
diff changeset
1051 var deferred = jQuery._Deferred(),
jurzua
parents:
diff changeset
1052 failDeferred = jQuery._Deferred(),
jurzua
parents:
diff changeset
1053 promise;
jurzua
parents:
diff changeset
1054 // Add errorDeferred methods, then and promise
jurzua
parents:
diff changeset
1055 jQuery.extend( deferred, {
jurzua
parents:
diff changeset
1056 then: function( doneCallbacks, failCallbacks ) {
jurzua
parents:
diff changeset
1057 deferred.done( doneCallbacks ).fail( failCallbacks );
jurzua
parents:
diff changeset
1058 return this;
jurzua
parents:
diff changeset
1059 },
jurzua
parents:
diff changeset
1060 always: function() {
jurzua
parents:
diff changeset
1061 return deferred.done.apply( deferred, arguments ).fail.apply( this, arguments );
jurzua
parents:
diff changeset
1062 },
jurzua
parents:
diff changeset
1063 fail: failDeferred.done,
jurzua
parents:
diff changeset
1064 rejectWith: failDeferred.resolveWith,
jurzua
parents:
diff changeset
1065 reject: failDeferred.resolve,
jurzua
parents:
diff changeset
1066 isRejected: failDeferred.isResolved,
jurzua
parents:
diff changeset
1067 pipe: function( fnDone, fnFail ) {
jurzua
parents:
diff changeset
1068 return jQuery.Deferred(function( newDefer ) {
jurzua
parents:
diff changeset
1069 jQuery.each( {
jurzua
parents:
diff changeset
1070 done: [ fnDone, "resolve" ],
jurzua
parents:
diff changeset
1071 fail: [ fnFail, "reject" ]
jurzua
parents:
diff changeset
1072 }, function( handler, data ) {
jurzua
parents:
diff changeset
1073 var fn = data[ 0 ],
jurzua
parents:
diff changeset
1074 action = data[ 1 ],
jurzua
parents:
diff changeset
1075 returned;
jurzua
parents:
diff changeset
1076 if ( jQuery.isFunction( fn ) ) {
jurzua
parents:
diff changeset
1077 deferred[ handler ](function() {
jurzua
parents:
diff changeset
1078 returned = fn.apply( this, arguments );
jurzua
parents:
diff changeset
1079 if ( returned && jQuery.isFunction( returned.promise ) ) {
jurzua
parents:
diff changeset
1080 returned.promise().then( newDefer.resolve, newDefer.reject );
jurzua
parents:
diff changeset
1081 } else {
jurzua
parents:
diff changeset
1082 newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
jurzua
parents:
diff changeset
1083 }
jurzua
parents:
diff changeset
1084 });
jurzua
parents:
diff changeset
1085 } else {
jurzua
parents:
diff changeset
1086 deferred[ handler ]( newDefer[ action ] );
jurzua
parents:
diff changeset
1087 }
jurzua
parents:
diff changeset
1088 });
jurzua
parents:
diff changeset
1089 }).promise();
jurzua
parents:
diff changeset
1090 },
jurzua
parents:
diff changeset
1091 // Get a promise for this deferred
jurzua
parents:
diff changeset
1092 // If obj is provided, the promise aspect is added to the object
jurzua
parents:
diff changeset
1093 promise: function( obj ) {
jurzua
parents:
diff changeset
1094 if ( obj == null ) {
jurzua
parents:
diff changeset
1095 if ( promise ) {
jurzua
parents:
diff changeset
1096 return promise;
jurzua
parents:
diff changeset
1097 }
jurzua
parents:
diff changeset
1098 promise = obj = {};
jurzua
parents:
diff changeset
1099 }
jurzua
parents:
diff changeset
1100 var i = promiseMethods.length;
jurzua
parents:
diff changeset
1101 while( i-- ) {
jurzua
parents:
diff changeset
1102 obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ];
jurzua
parents:
diff changeset
1103 }
jurzua
parents:
diff changeset
1104 return obj;
jurzua
parents:
diff changeset
1105 }
jurzua
parents:
diff changeset
1106 });
jurzua
parents:
diff changeset
1107 // Make sure only one callback list will be used
jurzua
parents:
diff changeset
1108 deferred.done( failDeferred.cancel ).fail( deferred.cancel );
jurzua
parents:
diff changeset
1109 // Unexpose cancel
jurzua
parents:
diff changeset
1110 delete deferred.cancel;
jurzua
parents:
diff changeset
1111 // Call given func if any
jurzua
parents:
diff changeset
1112 if ( func ) {
jurzua
parents:
diff changeset
1113 func.call( deferred, deferred );
jurzua
parents:
diff changeset
1114 }
jurzua
parents:
diff changeset
1115 return deferred;
jurzua
parents:
diff changeset
1116 },
jurzua
parents:
diff changeset
1117
jurzua
parents:
diff changeset
1118 // Deferred helper
jurzua
parents:
diff changeset
1119 when: function( firstParam ) {
jurzua
parents:
diff changeset
1120 var args = arguments,
jurzua
parents:
diff changeset
1121 i = 0,
jurzua
parents:
diff changeset
1122 length = args.length,
jurzua
parents:
diff changeset
1123 count = length,
jurzua
parents:
diff changeset
1124 deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
jurzua
parents:
diff changeset
1125 firstParam :
jurzua
parents:
diff changeset
1126 jQuery.Deferred();
jurzua
parents:
diff changeset
1127 function resolveFunc( i ) {
jurzua
parents:
diff changeset
1128 return function( value ) {
jurzua
parents:
diff changeset
1129 args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
jurzua
parents:
diff changeset
1130 if ( !( --count ) ) {
jurzua
parents:
diff changeset
1131 // Strange bug in FF4:
jurzua
parents:
diff changeset
1132 // Values changed onto the arguments object sometimes end up as undefined values
jurzua
parents:
diff changeset
1133 // outside the $.when method. Cloning the object into a fresh array solves the issue
jurzua
parents:
diff changeset
1134 deferred.resolveWith( deferred, sliceDeferred.call( args, 0 ) );
jurzua
parents:
diff changeset
1135 }
jurzua
parents:
diff changeset
1136 };
jurzua
parents:
diff changeset
1137 }
jurzua
parents:
diff changeset
1138 if ( length > 1 ) {
jurzua
parents:
diff changeset
1139 for( ; i < length; i++ ) {
jurzua
parents:
diff changeset
1140 if ( args[ i ] && jQuery.isFunction( args[ i ].promise ) ) {
jurzua
parents:
diff changeset
1141 args[ i ].promise().then( resolveFunc(i), deferred.reject );
jurzua
parents:
diff changeset
1142 } else {
jurzua
parents:
diff changeset
1143 --count;
jurzua
parents:
diff changeset
1144 }
jurzua
parents:
diff changeset
1145 }
jurzua
parents:
diff changeset
1146 if ( !count ) {
jurzua
parents:
diff changeset
1147 deferred.resolveWith( deferred, args );
jurzua
parents:
diff changeset
1148 }
jurzua
parents:
diff changeset
1149 } else if ( deferred !== firstParam ) {
jurzua
parents:
diff changeset
1150 deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
jurzua
parents:
diff changeset
1151 }
jurzua
parents:
diff changeset
1152 return deferred.promise();
jurzua
parents:
diff changeset
1153 }
jurzua
parents:
diff changeset
1154 });
jurzua
parents:
diff changeset
1155
jurzua
parents:
diff changeset
1156
jurzua
parents:
diff changeset
1157
jurzua
parents:
diff changeset
1158 jQuery.support = (function() {
jurzua
parents:
diff changeset
1159
jurzua
parents:
diff changeset
1160 var div = document.createElement( "div" ),
jurzua
parents:
diff changeset
1161 documentElement = document.documentElement,
jurzua
parents:
diff changeset
1162 all,
jurzua
parents:
diff changeset
1163 a,
jurzua
parents:
diff changeset
1164 select,
jurzua
parents:
diff changeset
1165 opt,
jurzua
parents:
diff changeset
1166 input,
jurzua
parents:
diff changeset
1167 marginDiv,
jurzua
parents:
diff changeset
1168 support,
jurzua
parents:
diff changeset
1169 fragment,
jurzua
parents:
diff changeset
1170 body,
jurzua
parents:
diff changeset
1171 testElementParent,
jurzua
parents:
diff changeset
1172 testElement,
jurzua
parents:
diff changeset
1173 testElementStyle,
jurzua
parents:
diff changeset
1174 tds,
jurzua
parents:
diff changeset
1175 events,
jurzua
parents:
diff changeset
1176 eventName,
jurzua
parents:
diff changeset
1177 i,
jurzua
parents:
diff changeset
1178 isSupported;
jurzua
parents:
diff changeset
1179
jurzua
parents:
diff changeset
1180 // Preliminary tests
jurzua
parents:
diff changeset
1181 div.setAttribute("className", "t");
jurzua
parents:
diff changeset
1182 div.innerHTML = " <link><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type=checkbox>";
jurzua
parents:
diff changeset
1183
jurzua
parents:
diff changeset
1184
jurzua
parents:
diff changeset
1185 all = div.getElementsByTagName( "*" );
jurzua
parents:
diff changeset
1186 a = div.getElementsByTagName( "a" )[ 0 ];
jurzua
parents:
diff changeset
1187
jurzua
parents:
diff changeset
1188 // Can't get basic test support
jurzua
parents:
diff changeset
1189 if ( !all || !all.length || !a ) {
jurzua
parents:
diff changeset
1190 return {};
jurzua
parents:
diff changeset
1191 }
jurzua
parents:
diff changeset
1192
jurzua
parents:
diff changeset
1193 // First batch of supports tests
jurzua
parents:
diff changeset
1194 select = document.createElement( "select" );
jurzua
parents:
diff changeset
1195 opt = select.appendChild( document.createElement("option") );
jurzua
parents:
diff changeset
1196 input = div.getElementsByTagName( "input" )[ 0 ];
jurzua
parents:
diff changeset
1197
jurzua
parents:
diff changeset
1198 support = {
jurzua
parents:
diff changeset
1199 // IE strips leading whitespace when .innerHTML is used
jurzua
parents:
diff changeset
1200 leadingWhitespace: ( div.firstChild.nodeType === 3 ),
jurzua
parents:
diff changeset
1201
jurzua
parents:
diff changeset
1202 // Make sure that tbody elements aren't automatically inserted
jurzua
parents:
diff changeset
1203 // IE will insert them into empty tables
jurzua
parents:
diff changeset
1204 tbody: !div.getElementsByTagName( "tbody" ).length,
jurzua
parents:
diff changeset
1205
jurzua
parents:
diff changeset
1206 // Make sure that link elements get serialized correctly by innerHTML
jurzua
parents:
diff changeset
1207 // This requires a wrapper element in IE
jurzua
parents:
diff changeset
1208 htmlSerialize: !!div.getElementsByTagName( "link" ).length,
jurzua
parents:
diff changeset
1209
jurzua
parents:
diff changeset
1210 // Get the style information from getAttribute
jurzua
parents:
diff changeset
1211 // (IE uses .cssText instead)
jurzua
parents:
diff changeset
1212 style: /top/.test( a.getAttribute("style") ),
jurzua
parents:
diff changeset
1213
jurzua
parents:
diff changeset
1214 // Make sure that URLs aren't manipulated
jurzua
parents:
diff changeset
1215 // (IE normalizes it by default)
jurzua
parents:
diff changeset
1216 hrefNormalized: ( a.getAttribute( "href" ) === "/a" ),
jurzua
parents:
diff changeset
1217
jurzua
parents:
diff changeset
1218 // Make sure that element opacity exists
jurzua
parents:
diff changeset
1219 // (IE uses filter instead)
jurzua
parents:
diff changeset
1220 // Use a regex to work around a WebKit issue. See #5145
jurzua
parents:
diff changeset
1221 opacity: /^0.55$/.test( a.style.opacity ),
jurzua
parents:
diff changeset
1222
jurzua
parents:
diff changeset
1223 // Verify style float existence
jurzua
parents:
diff changeset
1224 // (IE uses styleFloat instead of cssFloat)
jurzua
parents:
diff changeset
1225 cssFloat: !!a.style.cssFloat,
jurzua
parents:
diff changeset
1226
jurzua
parents:
diff changeset
1227 // Make sure that if no value is specified for a checkbox
jurzua
parents:
diff changeset
1228 // that it defaults to "on".
jurzua
parents:
diff changeset
1229 // (WebKit defaults to "" instead)
jurzua
parents:
diff changeset
1230 checkOn: ( input.value === "on" ),
jurzua
parents:
diff changeset
1231
jurzua
parents:
diff changeset
1232 // Make sure that a selected-by-default option has a working selected property.
jurzua
parents:
diff changeset
1233 // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
jurzua
parents:
diff changeset
1234 optSelected: opt.selected,
jurzua
parents:
diff changeset
1235
jurzua
parents:
diff changeset
1236 // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
jurzua
parents:
diff changeset
1237 getSetAttribute: div.className !== "t",
jurzua
parents:
diff changeset
1238
jurzua
parents:
diff changeset
1239 // Will be defined later
jurzua
parents:
diff changeset
1240 submitBubbles: true,
jurzua
parents:
diff changeset
1241 changeBubbles: true,
jurzua
parents:
diff changeset
1242 focusinBubbles: false,
jurzua
parents:
diff changeset
1243 deleteExpando: true,
jurzua
parents:
diff changeset
1244 noCloneEvent: true,
jurzua
parents:
diff changeset
1245 inlineBlockNeedsLayout: false,
jurzua
parents:
diff changeset
1246 shrinkWrapBlocks: false,
jurzua
parents:
diff changeset
1247 reliableMarginRight: true
jurzua
parents:
diff changeset
1248 };
jurzua
parents:
diff changeset
1249
jurzua
parents:
diff changeset
1250 // Make sure checked status is properly cloned
jurzua
parents:
diff changeset
1251 input.checked = true;
jurzua
parents:
diff changeset
1252 support.noCloneChecked = input.cloneNode( true ).checked;
jurzua
parents:
diff changeset
1253
jurzua
parents:
diff changeset
1254 // Make sure that the options inside disabled selects aren't marked as disabled
jurzua
parents:
diff changeset
1255 // (WebKit marks them as disabled)
jurzua
parents:
diff changeset
1256 select.disabled = true;
jurzua
parents:
diff changeset
1257 support.optDisabled = !opt.disabled;
jurzua
parents:
diff changeset
1258
jurzua
parents:
diff changeset
1259 // Test to see if it's possible to delete an expando from an element
jurzua
parents:
diff changeset
1260 // Fails in Internet Explorer
jurzua
parents:
diff changeset
1261 try {
jurzua
parents:
diff changeset
1262 delete div.test;
jurzua
parents:
diff changeset
1263 } catch( e ) {
jurzua
parents:
diff changeset
1264 support.deleteExpando = false;
jurzua
parents:
diff changeset
1265 }
jurzua
parents:
diff changeset
1266
jurzua
parents:
diff changeset
1267 if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
jurzua
parents:
diff changeset
1268 div.attachEvent( "onclick", function() {
jurzua
parents:
diff changeset
1269 // Cloning a node shouldn't copy over any
jurzua
parents:
diff changeset
1270 // bound event handlers (IE does this)
jurzua
parents:
diff changeset
1271 support.noCloneEvent = false;
jurzua
parents:
diff changeset
1272 });
jurzua
parents:
diff changeset
1273 div.cloneNode( true ).fireEvent( "onclick" );
jurzua
parents:
diff changeset
1274 }
jurzua
parents:
diff changeset
1275
jurzua
parents:
diff changeset
1276 // Check if a radio maintains it's value
jurzua
parents:
diff changeset
1277 // after being appended to the DOM
jurzua
parents:
diff changeset
1278 input = document.createElement("input");
jurzua
parents:
diff changeset
1279 input.value = "t";
jurzua
parents:
diff changeset
1280 input.setAttribute("type", "radio");
jurzua
parents:
diff changeset
1281 support.radioValue = input.value === "t";
jurzua
parents:
diff changeset
1282
jurzua
parents:
diff changeset
1283 input.setAttribute("checked", "checked");
jurzua
parents:
diff changeset
1284 div.appendChild( input );
jurzua
parents:
diff changeset
1285 fragment = document.createDocumentFragment();
jurzua
parents:
diff changeset
1286 fragment.appendChild( div.firstChild );
jurzua
parents:
diff changeset
1287
jurzua
parents:
diff changeset
1288 // WebKit doesn't clone checked state correctly in fragments
jurzua
parents:
diff changeset
1289 support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
jurzua
parents:
diff changeset
1290
jurzua
parents:
diff changeset
1291 div.innerHTML = "";
jurzua
parents:
diff changeset
1292
jurzua
parents:
diff changeset
1293 // Figure out if the W3C box model works as expected
jurzua
parents:
diff changeset
1294 div.style.width = div.style.paddingLeft = "1px";
jurzua
parents:
diff changeset
1295
jurzua
parents:
diff changeset
1296 body = document.getElementsByTagName( "body" )[ 0 ];
jurzua
parents:
diff changeset
1297 // We use our own, invisible, body unless the body is already present
jurzua
parents:
diff changeset
1298 // in which case we use a div (#9239)
jurzua
parents:
diff changeset
1299 testElement = document.createElement( body ? "div" : "body" );
jurzua
parents:
diff changeset
1300 testElementStyle = {
jurzua
parents:
diff changeset
1301 visibility: "hidden",
jurzua
parents:
diff changeset
1302 width: 0,
jurzua
parents:
diff changeset
1303 height: 0,
jurzua
parents:
diff changeset
1304 border: 0,
jurzua
parents:
diff changeset
1305 margin: 0,
jurzua
parents:
diff changeset
1306 background: "none"
jurzua
parents:
diff changeset
1307 };
jurzua
parents:
diff changeset
1308 if ( body ) {
jurzua
parents:
diff changeset
1309 jQuery.extend( testElementStyle, {
jurzua
parents:
diff changeset
1310 position: "absolute",
jurzua
parents:
diff changeset
1311 left: "-1000px",
jurzua
parents:
diff changeset
1312 top: "-1000px"
jurzua
parents:
diff changeset
1313 });
jurzua
parents:
diff changeset
1314 }
jurzua
parents:
diff changeset
1315 for ( i in testElementStyle ) {
jurzua
parents:
diff changeset
1316 testElement.style[ i ] = testElementStyle[ i ];
jurzua
parents:
diff changeset
1317 }
jurzua
parents:
diff changeset
1318 testElement.appendChild( div );
jurzua
parents:
diff changeset
1319 testElementParent = body || documentElement;
jurzua
parents:
diff changeset
1320 testElementParent.insertBefore( testElement, testElementParent.firstChild );
jurzua
parents:
diff changeset
1321
jurzua
parents:
diff changeset
1322 // Check if a disconnected checkbox will retain its checked
jurzua
parents:
diff changeset
1323 // value of true after appended to the DOM (IE6/7)
jurzua
parents:
diff changeset
1324 support.appendChecked = input.checked;
jurzua
parents:
diff changeset
1325
jurzua
parents:
diff changeset
1326 support.boxModel = div.offsetWidth === 2;
jurzua
parents:
diff changeset
1327
jurzua
parents:
diff changeset
1328 if ( "zoom" in div.style ) {
jurzua
parents:
diff changeset
1329 // Check if natively block-level elements act like inline-block
jurzua
parents:
diff changeset
1330 // elements when setting their display to 'inline' and giving
jurzua
parents:
diff changeset
1331 // them layout
jurzua
parents:
diff changeset
1332 // (IE < 8 does this)
jurzua
parents:
diff changeset
1333 div.style.display = "inline";
jurzua
parents:
diff changeset
1334 div.style.zoom = 1;
jurzua
parents:
diff changeset
1335 support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 );
jurzua
parents:
diff changeset
1336
jurzua
parents:
diff changeset
1337 // Check if elements with layout shrink-wrap their children
jurzua
parents:
diff changeset
1338 // (IE 6 does this)
jurzua
parents:
diff changeset
1339 div.style.display = "";
jurzua
parents:
diff changeset
1340 div.innerHTML = "<div style='width:4px;'></div>";
jurzua
parents:
diff changeset
1341 support.shrinkWrapBlocks = ( div.offsetWidth !== 2 );
jurzua
parents:
diff changeset
1342 }
jurzua
parents:
diff changeset
1343
jurzua
parents:
diff changeset
1344 div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
jurzua
parents:
diff changeset
1345 tds = div.getElementsByTagName( "td" );
jurzua
parents:
diff changeset
1346
jurzua
parents:
diff changeset
1347 // Check if table cells still have offsetWidth/Height when they are set
jurzua
parents:
diff changeset
1348 // to display:none and there are still other visible table cells in a
jurzua
parents:
diff changeset
1349 // table row; if so, offsetWidth/Height are not reliable for use when
jurzua
parents:
diff changeset
1350 // determining if an element has been hidden directly using
jurzua
parents:
diff changeset
1351 // display:none (it is still safe to use offsets if a parent element is
jurzua
parents:
diff changeset
1352 // hidden; don safety goggles and see bug #4512 for more information).
jurzua
parents:
diff changeset
1353 // (only IE 8 fails this test)
jurzua
parents:
diff changeset
1354 isSupported = ( tds[ 0 ].offsetHeight === 0 );
jurzua
parents:
diff changeset
1355
jurzua
parents:
diff changeset
1356 tds[ 0 ].style.display = "";
jurzua
parents:
diff changeset
1357 tds[ 1 ].style.display = "none";
jurzua
parents:
diff changeset
1358
jurzua
parents:
diff changeset
1359 // Check if empty table cells still have offsetWidth/Height
jurzua
parents:
diff changeset
1360 // (IE < 8 fail this test)
jurzua
parents:
diff changeset
1361 support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
jurzua
parents:
diff changeset
1362 div.innerHTML = "";
jurzua
parents:
diff changeset
1363
jurzua
parents:
diff changeset
1364 // Check if div with explicit width and no margin-right incorrectly
jurzua
parents:
diff changeset
1365 // gets computed margin-right based on width of container. For more
jurzua
parents:
diff changeset
1366 // info see bug #3333
jurzua
parents:
diff changeset
1367 // Fails in WebKit before Feb 2011 nightlies
jurzua
parents:
diff changeset
1368 // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
jurzua
parents:
diff changeset
1369 if ( document.defaultView && document.defaultView.getComputedStyle ) {
jurzua
parents:
diff changeset
1370 marginDiv = document.createElement( "div" );
jurzua
parents:
diff changeset
1371 marginDiv.style.width = "0";
jurzua
parents:
diff changeset
1372 marginDiv.style.marginRight = "0";
jurzua
parents:
diff changeset
1373 div.appendChild( marginDiv );
jurzua
parents:
diff changeset
1374 support.reliableMarginRight =
jurzua
parents:
diff changeset
1375 ( parseInt( ( document.defaultView.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
jurzua
parents:
diff changeset
1376 }
jurzua
parents:
diff changeset
1377
jurzua
parents:
diff changeset
1378 // Remove the body element we added
jurzua
parents:
diff changeset
1379 testElement.innerHTML = "";
jurzua
parents:
diff changeset
1380 testElementParent.removeChild( testElement );
jurzua
parents:
diff changeset
1381
jurzua
parents:
diff changeset
1382 // Technique from Juriy Zaytsev
jurzua
parents:
diff changeset
1383 // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
jurzua
parents:
diff changeset
1384 // We only care about the case where non-standard event systems
jurzua
parents:
diff changeset
1385 // are used, namely in IE. Short-circuiting here helps us to
jurzua
parents:
diff changeset
1386 // avoid an eval call (in setAttribute) which can cause CSP
jurzua
parents:
diff changeset
1387 // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
jurzua
parents:
diff changeset
1388 if ( div.attachEvent ) {
jurzua
parents:
diff changeset
1389 for( i in {
jurzua
parents:
diff changeset
1390 submit: 1,
jurzua
parents:
diff changeset
1391 change: 1,
jurzua
parents:
diff changeset
1392 focusin: 1
jurzua
parents:
diff changeset
1393 } ) {
jurzua
parents:
diff changeset
1394 eventName = "on" + i;
jurzua
parents:
diff changeset
1395 isSupported = ( eventName in div );
jurzua
parents:
diff changeset
1396 if ( !isSupported ) {
jurzua
parents:
diff changeset
1397 div.setAttribute( eventName, "return;" );
jurzua
parents:
diff changeset
1398 isSupported = ( typeof div[ eventName ] === "function" );
jurzua
parents:
diff changeset
1399 }
jurzua
parents:
diff changeset
1400 support[ i + "Bubbles" ] = isSupported;
jurzua
parents:
diff changeset
1401 }
jurzua
parents:
diff changeset
1402 }
jurzua
parents:
diff changeset
1403
jurzua
parents:
diff changeset
1404 // Null connected elements to avoid leaks in IE
jurzua
parents:
diff changeset
1405 testElement = fragment = select = opt = body = marginDiv = div = input = null;
jurzua
parents:
diff changeset
1406
jurzua
parents:
diff changeset
1407 return support;
jurzua
parents:
diff changeset
1408 })();
jurzua
parents:
diff changeset
1409
jurzua
parents:
diff changeset
1410 // Keep track of boxModel
jurzua
parents:
diff changeset
1411 jQuery.boxModel = jQuery.support.boxModel;
jurzua
parents:
diff changeset
1412
jurzua
parents:
diff changeset
1413
jurzua
parents:
diff changeset
1414
jurzua
parents:
diff changeset
1415
jurzua
parents:
diff changeset
1416 var rbrace = /^(?:\{.*\}|\[.*\])$/,
jurzua
parents:
diff changeset
1417 rmultiDash = /([a-z])([A-Z])/g;
jurzua
parents:
diff changeset
1418
jurzua
parents:
diff changeset
1419 jQuery.extend({
jurzua
parents:
diff changeset
1420 cache: {},
jurzua
parents:
diff changeset
1421
jurzua
parents:
diff changeset
1422 // Please use with caution
jurzua
parents:
diff changeset
1423 uuid: 0,
jurzua
parents:
diff changeset
1424
jurzua
parents:
diff changeset
1425 // Unique for each copy of jQuery on the page
jurzua
parents:
diff changeset
1426 // Non-digits removed to match rinlinejQuery
jurzua
parents:
diff changeset
1427 expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
jurzua
parents:
diff changeset
1428
jurzua
parents:
diff changeset
1429 // The following elements throw uncatchable exceptions if you
jurzua
parents:
diff changeset
1430 // attempt to add expando properties to them.
jurzua
parents:
diff changeset
1431 noData: {
jurzua
parents:
diff changeset
1432 "embed": true,
jurzua
parents:
diff changeset
1433 // Ban all objects except for Flash (which handle expandos)
jurzua
parents:
diff changeset
1434 "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
jurzua
parents:
diff changeset
1435 "applet": true
jurzua
parents:
diff changeset
1436 },
jurzua
parents:
diff changeset
1437
jurzua
parents:
diff changeset
1438 hasData: function( elem ) {
jurzua
parents:
diff changeset
1439 elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
jurzua
parents:
diff changeset
1440
jurzua
parents:
diff changeset
1441 return !!elem && !isEmptyDataObject( elem );
jurzua
parents:
diff changeset
1442 },
jurzua
parents:
diff changeset
1443
jurzua
parents:
diff changeset
1444 data: function( elem, name, data, pvt /* Internal Use Only */ ) {
jurzua
parents:
diff changeset
1445 if ( !jQuery.acceptData( elem ) ) {
jurzua
parents:
diff changeset
1446 return;
jurzua
parents:
diff changeset
1447 }
jurzua
parents:
diff changeset
1448
jurzua
parents:
diff changeset
1449 var thisCache, ret,
jurzua
parents:
diff changeset
1450 internalKey = jQuery.expando,
jurzua
parents:
diff changeset
1451 getByName = typeof name === "string",
jurzua
parents:
diff changeset
1452
jurzua
parents:
diff changeset
1453 // We have to handle DOM nodes and JS objects differently because IE6-7
jurzua
parents:
diff changeset
1454 // can't GC object references properly across the DOM-JS boundary
jurzua
parents:
diff changeset
1455 isNode = elem.nodeType,
jurzua
parents:
diff changeset
1456
jurzua
parents:
diff changeset
1457 // Only DOM nodes need the global jQuery cache; JS object data is
jurzua
parents:
diff changeset
1458 // attached directly to the object so GC can occur automatically
jurzua
parents:
diff changeset
1459 cache = isNode ? jQuery.cache : elem,
jurzua
parents:
diff changeset
1460
jurzua
parents:
diff changeset
1461 // Only defining an ID for JS objects if its cache already exists allows
jurzua
parents:
diff changeset
1462 // the code to shortcut on the same path as a DOM node with no cache
jurzua
parents:
diff changeset
1463 id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando;
jurzua
parents:
diff changeset
1464
jurzua
parents:
diff changeset
1465 // Avoid doing any more work than we need to when trying to get data on an
jurzua
parents:
diff changeset
1466 // object that has no data at all
jurzua
parents:
diff changeset
1467 if ( (!id || (pvt && id && (cache[ id ] && !cache[ id ][ internalKey ]))) && getByName && data === undefined ) {
jurzua
parents:
diff changeset
1468 return;
jurzua
parents:
diff changeset
1469 }
jurzua
parents:
diff changeset
1470
jurzua
parents:
diff changeset
1471 if ( !id ) {
jurzua
parents:
diff changeset
1472 // Only DOM nodes need a new unique ID for each element since their data
jurzua
parents:
diff changeset
1473 // ends up in the global cache
jurzua
parents:
diff changeset
1474 if ( isNode ) {
jurzua
parents:
diff changeset
1475 elem[ jQuery.expando ] = id = ++jQuery.uuid;
jurzua
parents:
diff changeset
1476 } else {
jurzua
parents:
diff changeset
1477 id = jQuery.expando;
jurzua
parents:
diff changeset
1478 }
jurzua
parents:
diff changeset
1479 }
jurzua
parents:
diff changeset
1480
jurzua
parents:
diff changeset
1481 if ( !cache[ id ] ) {
jurzua
parents:
diff changeset
1482 cache[ id ] = {};
jurzua
parents:
diff changeset
1483
jurzua
parents:
diff changeset
1484 // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
jurzua
parents:
diff changeset
1485 // metadata on plain JS objects when the object is serialized using
jurzua
parents:
diff changeset
1486 // JSON.stringify
jurzua
parents:
diff changeset
1487 if ( !isNode ) {
jurzua
parents:
diff changeset
1488 cache[ id ].toJSON = jQuery.noop;
jurzua
parents:
diff changeset
1489 }
jurzua
parents:
diff changeset
1490 }
jurzua
parents:
diff changeset
1491
jurzua
parents:
diff changeset
1492 // An object can be passed to jQuery.data instead of a key/value pair; this gets
jurzua
parents:
diff changeset
1493 // shallow copied over onto the existing cache
jurzua
parents:
diff changeset
1494 if ( typeof name === "object" || typeof name === "function" ) {
jurzua
parents:
diff changeset
1495 if ( pvt ) {
jurzua
parents:
diff changeset
1496 cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
jurzua
parents:
diff changeset
1497 } else {
jurzua
parents:
diff changeset
1498 cache[ id ] = jQuery.extend(cache[ id ], name);
jurzua
parents:
diff changeset
1499 }
jurzua
parents:
diff changeset
1500 }
jurzua
parents:
diff changeset
1501
jurzua
parents:
diff changeset
1502 thisCache = cache[ id ];
jurzua
parents:
diff changeset
1503
jurzua
parents:
diff changeset
1504 // Internal jQuery data is stored in a separate object inside the object's data
jurzua
parents:
diff changeset
1505 // cache in order to avoid key collisions between internal data and user-defined
jurzua
parents:
diff changeset
1506 // data
jurzua
parents:
diff changeset
1507 if ( pvt ) {
jurzua
parents:
diff changeset
1508 if ( !thisCache[ internalKey ] ) {
jurzua
parents:
diff changeset
1509 thisCache[ internalKey ] = {};
jurzua
parents:
diff changeset
1510 }
jurzua
parents:
diff changeset
1511
jurzua
parents:
diff changeset
1512 thisCache = thisCache[ internalKey ];
jurzua
parents:
diff changeset
1513 }
jurzua
parents:
diff changeset
1514
jurzua
parents:
diff changeset
1515 if ( data !== undefined ) {
jurzua
parents:
diff changeset
1516 thisCache[ jQuery.camelCase( name ) ] = data;
jurzua
parents:
diff changeset
1517 }
jurzua
parents:
diff changeset
1518
jurzua
parents:
diff changeset
1519 // TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
jurzua
parents:
diff changeset
1520 // not attempt to inspect the internal events object using jQuery.data, as this
jurzua
parents:
diff changeset
1521 // internal data object is undocumented and subject to change.
jurzua
parents:
diff changeset
1522 if ( name === "events" && !thisCache[name] ) {
jurzua
parents:
diff changeset
1523 return thisCache[ internalKey ] && thisCache[ internalKey ].events;
jurzua
parents:
diff changeset
1524 }
jurzua
parents:
diff changeset
1525
jurzua
parents:
diff changeset
1526 // Check for both converted-to-camel and non-converted data property names
jurzua
parents:
diff changeset
1527 // If a data property was specified
jurzua
parents:
diff changeset
1528 if ( getByName ) {
jurzua
parents:
diff changeset
1529
jurzua
parents:
diff changeset
1530 // First Try to find as-is property data
jurzua
parents:
diff changeset
1531 ret = thisCache[ name ];
jurzua
parents:
diff changeset
1532
jurzua
parents:
diff changeset
1533 // Test for null|undefined property data
jurzua
parents:
diff changeset
1534 if ( ret == null ) {
jurzua
parents:
diff changeset
1535
jurzua
parents:
diff changeset
1536 // Try to find the camelCased property
jurzua
parents:
diff changeset
1537 ret = thisCache[ jQuery.camelCase( name ) ];
jurzua
parents:
diff changeset
1538 }
jurzua
parents:
diff changeset
1539 } else {
jurzua
parents:
diff changeset
1540 ret = thisCache;
jurzua
parents:
diff changeset
1541 }
jurzua
parents:
diff changeset
1542
jurzua
parents:
diff changeset
1543 return ret;
jurzua
parents:
diff changeset
1544 },
jurzua
parents:
diff changeset
1545
jurzua
parents:
diff changeset
1546 removeData: function( elem, name, pvt /* Internal Use Only */ ) {
jurzua
parents:
diff changeset
1547 if ( !jQuery.acceptData( elem ) ) {
jurzua
parents:
diff changeset
1548 return;
jurzua
parents:
diff changeset
1549 }
jurzua
parents:
diff changeset
1550
jurzua
parents:
diff changeset
1551 var thisCache,
jurzua
parents:
diff changeset
1552
jurzua
parents:
diff changeset
1553 // Reference to internal data cache key
jurzua
parents:
diff changeset
1554 internalKey = jQuery.expando,
jurzua
parents:
diff changeset
1555
jurzua
parents:
diff changeset
1556 isNode = elem.nodeType,
jurzua
parents:
diff changeset
1557
jurzua
parents:
diff changeset
1558 // See jQuery.data for more information
jurzua
parents:
diff changeset
1559 cache = isNode ? jQuery.cache : elem,
jurzua
parents:
diff changeset
1560
jurzua
parents:
diff changeset
1561 // See jQuery.data for more information
jurzua
parents:
diff changeset
1562 id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
jurzua
parents:
diff changeset
1563
jurzua
parents:
diff changeset
1564 // If there is already no cache entry for this object, there is no
jurzua
parents:
diff changeset
1565 // purpose in continuing
jurzua
parents:
diff changeset
1566 if ( !cache[ id ] ) {
jurzua
parents:
diff changeset
1567 return;
jurzua
parents:
diff changeset
1568 }
jurzua
parents:
diff changeset
1569
jurzua
parents:
diff changeset
1570 if ( name ) {
jurzua
parents:
diff changeset
1571
jurzua
parents:
diff changeset
1572 thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];
jurzua
parents:
diff changeset
1573
jurzua
parents:
diff changeset
1574 if ( thisCache ) {
jurzua
parents:
diff changeset
1575
jurzua
parents:
diff changeset
1576 // Support interoperable removal of hyphenated or camelcased keys
jurzua
parents:
diff changeset
1577 if ( !thisCache[ name ] ) {
jurzua
parents:
diff changeset
1578 name = jQuery.camelCase( name );
jurzua
parents:
diff changeset
1579 }
jurzua
parents:
diff changeset
1580
jurzua
parents:
diff changeset
1581 delete thisCache[ name ];
jurzua
parents:
diff changeset
1582
jurzua
parents:
diff changeset
1583 // If there is no data left in the cache, we want to continue
jurzua
parents:
diff changeset
1584 // and let the cache object itself get destroyed
jurzua
parents:
diff changeset
1585 if ( !isEmptyDataObject(thisCache) ) {
jurzua
parents:
diff changeset
1586 return;
jurzua
parents:
diff changeset
1587 }
jurzua
parents:
diff changeset
1588 }
jurzua
parents:
diff changeset
1589 }
jurzua
parents:
diff changeset
1590
jurzua
parents:
diff changeset
1591 // See jQuery.data for more information
jurzua
parents:
diff changeset
1592 if ( pvt ) {
jurzua
parents:
diff changeset
1593 delete cache[ id ][ internalKey ];
jurzua
parents:
diff changeset
1594
jurzua
parents:
diff changeset
1595 // Don't destroy the parent cache unless the internal data object
jurzua
parents:
diff changeset
1596 // had been the only thing left in it
jurzua
parents:
diff changeset
1597 if ( !isEmptyDataObject(cache[ id ]) ) {
jurzua
parents:
diff changeset
1598 return;
jurzua
parents:
diff changeset
1599 }
jurzua
parents:
diff changeset
1600 }
jurzua
parents:
diff changeset
1601
jurzua
parents:
diff changeset
1602 var internalCache = cache[ id ][ internalKey ];
jurzua
parents:
diff changeset
1603
jurzua
parents:
diff changeset
1604 // Browsers that fail expando deletion also refuse to delete expandos on
jurzua
parents:
diff changeset
1605 // the window, but it will allow it on all other JS objects; other browsers
jurzua
parents:
diff changeset
1606 // don't care
jurzua
parents:
diff changeset
1607 // Ensure that `cache` is not a window object #10080
jurzua
parents:
diff changeset
1608 if ( jQuery.support.deleteExpando || !cache.setInterval ) {
jurzua
parents:
diff changeset
1609 delete cache[ id ];
jurzua
parents:
diff changeset
1610 } else {
jurzua
parents:
diff changeset
1611 cache[ id ] = null;
jurzua
parents:
diff changeset
1612 }
jurzua
parents:
diff changeset
1613
jurzua
parents:
diff changeset
1614 // We destroyed the entire user cache at once because it's faster than
jurzua
parents:
diff changeset
1615 // iterating through each key, but we need to continue to persist internal
jurzua
parents:
diff changeset
1616 // data if it existed
jurzua
parents:
diff changeset
1617 if ( internalCache ) {
jurzua
parents:
diff changeset
1618 cache[ id ] = {};
jurzua
parents:
diff changeset
1619 // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
jurzua
parents:
diff changeset
1620 // metadata on plain JS objects when the object is serialized using
jurzua
parents:
diff changeset
1621 // JSON.stringify
jurzua
parents:
diff changeset
1622 if ( !isNode ) {
jurzua
parents:
diff changeset
1623 cache[ id ].toJSON = jQuery.noop;
jurzua
parents:
diff changeset
1624 }
jurzua
parents:
diff changeset
1625
jurzua
parents:
diff changeset
1626 cache[ id ][ internalKey ] = internalCache;
jurzua
parents:
diff changeset
1627
jurzua
parents:
diff changeset
1628 // Otherwise, we need to eliminate the expando on the node to avoid
jurzua
parents:
diff changeset
1629 // false lookups in the cache for entries that no longer exist
jurzua
parents:
diff changeset
1630 } else if ( isNode ) {
jurzua
parents:
diff changeset
1631 // IE does not allow us to delete expando properties from nodes,
jurzua
parents:
diff changeset
1632 // nor does it have a removeAttribute function on Document nodes;
jurzua
parents:
diff changeset
1633 // we must handle all of these cases
jurzua
parents:
diff changeset
1634 if ( jQuery.support.deleteExpando ) {
jurzua
parents:
diff changeset
1635 delete elem[ jQuery.expando ];
jurzua
parents:
diff changeset
1636 } else if ( elem.removeAttribute ) {
jurzua
parents:
diff changeset
1637 elem.removeAttribute( jQuery.expando );
jurzua
parents:
diff changeset
1638 } else {
jurzua
parents:
diff changeset
1639 elem[ jQuery.expando ] = null;
jurzua
parents:
diff changeset
1640 }
jurzua
parents:
diff changeset
1641 }
jurzua
parents:
diff changeset
1642 },
jurzua
parents:
diff changeset
1643
jurzua
parents:
diff changeset
1644 // For internal use only.
jurzua
parents:
diff changeset
1645 _data: function( elem, name, data ) {
jurzua
parents:
diff changeset
1646 return jQuery.data( elem, name, data, true );
jurzua
parents:
diff changeset
1647 },
jurzua
parents:
diff changeset
1648
jurzua
parents:
diff changeset
1649 // A method for determining if a DOM node can handle the data expando
jurzua
parents:
diff changeset
1650 acceptData: function( elem ) {
jurzua
parents:
diff changeset
1651 if ( elem.nodeName ) {
jurzua
parents:
diff changeset
1652 var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
jurzua
parents:
diff changeset
1653
jurzua
parents:
diff changeset
1654 if ( match ) {
jurzua
parents:
diff changeset
1655 return !(match === true || elem.getAttribute("classid") !== match);
jurzua
parents:
diff changeset
1656 }
jurzua
parents:
diff changeset
1657 }
jurzua
parents:
diff changeset
1658
jurzua
parents:
diff changeset
1659 return true;
jurzua
parents:
diff changeset
1660 }
jurzua
parents:
diff changeset
1661 });
jurzua
parents:
diff changeset
1662
jurzua
parents:
diff changeset
1663 jQuery.fn.extend({
jurzua
parents:
diff changeset
1664 data: function( key, value ) {
jurzua
parents:
diff changeset
1665 var data = null;
jurzua
parents:
diff changeset
1666
jurzua
parents:
diff changeset
1667 if ( typeof key === "undefined" ) {
jurzua
parents:
diff changeset
1668 if ( this.length ) {
jurzua
parents:
diff changeset
1669 data = jQuery.data( this[0] );
jurzua
parents:
diff changeset
1670
jurzua
parents:
diff changeset
1671 if ( this[0].nodeType === 1 ) {
jurzua
parents:
diff changeset
1672 var attr = this[0].attributes, name;
jurzua
parents:
diff changeset
1673 for ( var i = 0, l = attr.length; i < l; i++ ) {
jurzua
parents:
diff changeset
1674 name = attr[i].name;
jurzua
parents:
diff changeset
1675
jurzua
parents:
diff changeset
1676 if ( name.indexOf( "data-" ) === 0 ) {
jurzua
parents:
diff changeset
1677 name = jQuery.camelCase( name.substring(5) );
jurzua
parents:
diff changeset
1678
jurzua
parents:
diff changeset
1679 dataAttr( this[0], name, data[ name ] );
jurzua
parents:
diff changeset
1680 }
jurzua
parents:
diff changeset
1681 }
jurzua
parents:
diff changeset
1682 }
jurzua
parents:
diff changeset
1683 }
jurzua
parents:
diff changeset
1684
jurzua
parents:
diff changeset
1685 return data;
jurzua
parents:
diff changeset
1686
jurzua
parents:
diff changeset
1687 } else if ( typeof key === "object" ) {
jurzua
parents:
diff changeset
1688 return this.each(function() {
jurzua
parents:
diff changeset
1689 jQuery.data( this, key );
jurzua
parents:
diff changeset
1690 });
jurzua
parents:
diff changeset
1691 }
jurzua
parents:
diff changeset
1692
jurzua
parents:
diff changeset
1693 var parts = key.split(".");
jurzua
parents:
diff changeset
1694 parts[1] = parts[1] ? "." + parts[1] : "";
jurzua
parents:
diff changeset
1695
jurzua
parents:
diff changeset
1696 if ( value === undefined ) {
jurzua
parents:
diff changeset
1697 data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
jurzua
parents:
diff changeset
1698
jurzua
parents:
diff changeset
1699 // Try to fetch any internally stored data first
jurzua
parents:
diff changeset
1700 if ( data === undefined && this.length ) {
jurzua
parents:
diff changeset
1701 data = jQuery.data( this[0], key );
jurzua
parents:
diff changeset
1702 data = dataAttr( this[0], key, data );
jurzua
parents:
diff changeset
1703 }
jurzua
parents:
diff changeset
1704
jurzua
parents:
diff changeset
1705 return data === undefined && parts[1] ?
jurzua
parents:
diff changeset
1706 this.data( parts[0] ) :
jurzua
parents:
diff changeset
1707 data;
jurzua
parents:
diff changeset
1708
jurzua
parents:
diff changeset
1709 } else {
jurzua
parents:
diff changeset
1710 return this.each(function() {
jurzua
parents:
diff changeset
1711 var $this = jQuery( this ),
jurzua
parents:
diff changeset
1712 args = [ parts[0], value ];
jurzua
parents:
diff changeset
1713
jurzua
parents:
diff changeset
1714 $this.triggerHandler( "setData" + parts[1] + "!", args );
jurzua
parents:
diff changeset
1715 jQuery.data( this, key, value );
jurzua
parents:
diff changeset
1716 $this.triggerHandler( "changeData" + parts[1] + "!", args );
jurzua
parents:
diff changeset
1717 });
jurzua
parents:
diff changeset
1718 }
jurzua
parents:
diff changeset
1719 },
jurzua
parents:
diff changeset
1720
jurzua
parents:
diff changeset
1721 removeData: function( key ) {
jurzua
parents:
diff changeset
1722 return this.each(function() {
jurzua
parents:
diff changeset
1723 jQuery.removeData( this, key );
jurzua
parents:
diff changeset
1724 });
jurzua
parents:
diff changeset
1725 }
jurzua
parents:
diff changeset
1726 });
jurzua
parents:
diff changeset
1727
jurzua
parents:
diff changeset
1728 function dataAttr( elem, key, data ) {
jurzua
parents:
diff changeset
1729 // If nothing was found internally, try to fetch any
jurzua
parents:
diff changeset
1730 // data from the HTML5 data-* attribute
jurzua
parents:
diff changeset
1731 if ( data === undefined && elem.nodeType === 1 ) {
jurzua
parents:
diff changeset
1732 var name = "data-" + key.replace( rmultiDash, "$1-$2" ).toLowerCase();
jurzua
parents:
diff changeset
1733
jurzua
parents:
diff changeset
1734 data = elem.getAttribute( name );
jurzua
parents:
diff changeset
1735
jurzua
parents:
diff changeset
1736 if ( typeof data === "string" ) {
jurzua
parents:
diff changeset
1737 try {
jurzua
parents:
diff changeset
1738 data = data === "true" ? true :
jurzua
parents:
diff changeset
1739 data === "false" ? false :
jurzua
parents:
diff changeset
1740 data === "null" ? null :
jurzua
parents:
diff changeset
1741 !jQuery.isNaN( data ) ? parseFloat( data ) :
jurzua
parents:
diff changeset
1742 rbrace.test( data ) ? jQuery.parseJSON( data ) :
jurzua
parents:
diff changeset
1743 data;
jurzua
parents:
diff changeset
1744 } catch( e ) {}
jurzua
parents:
diff changeset
1745
jurzua
parents:
diff changeset
1746 // Make sure we set the data so it isn't changed later
jurzua
parents:
diff changeset
1747 jQuery.data( elem, key, data );
jurzua
parents:
diff changeset
1748
jurzua
parents:
diff changeset
1749 } else {
jurzua
parents:
diff changeset
1750 data = undefined;
jurzua
parents:
diff changeset
1751 }
jurzua
parents:
diff changeset
1752 }
jurzua
parents:
diff changeset
1753
jurzua
parents:
diff changeset
1754 return data;
jurzua
parents:
diff changeset
1755 }
jurzua
parents:
diff changeset
1756
jurzua
parents:
diff changeset
1757 // TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON
jurzua
parents:
diff changeset
1758 // property to be considered empty objects; this property always exists in
jurzua
parents:
diff changeset
1759 // order to make sure JSON.stringify does not expose internal metadata
jurzua
parents:
diff changeset
1760 function isEmptyDataObject( obj ) {
jurzua
parents:
diff changeset
1761 for ( var name in obj ) {
jurzua
parents:
diff changeset
1762 if ( name !== "toJSON" ) {
jurzua
parents:
diff changeset
1763 return false;
jurzua
parents:
diff changeset
1764 }
jurzua
parents:
diff changeset
1765 }
jurzua
parents:
diff changeset
1766
jurzua
parents:
diff changeset
1767 return true;
jurzua
parents:
diff changeset
1768 }
jurzua
parents:
diff changeset
1769
jurzua
parents:
diff changeset
1770
jurzua
parents:
diff changeset
1771
jurzua
parents:
diff changeset
1772
jurzua
parents:
diff changeset
1773 function handleQueueMarkDefer( elem, type, src ) {
jurzua
parents:
diff changeset
1774 var deferDataKey = type + "defer",
jurzua
parents:
diff changeset
1775 queueDataKey = type + "queue",
jurzua
parents:
diff changeset
1776 markDataKey = type + "mark",
jurzua
parents:
diff changeset
1777 defer = jQuery.data( elem, deferDataKey, undefined, true );
jurzua
parents:
diff changeset
1778 if ( defer &&
jurzua
parents:
diff changeset
1779 ( src === "queue" || !jQuery.data( elem, queueDataKey, undefined, true ) ) &&
jurzua
parents:
diff changeset
1780 ( src === "mark" || !jQuery.data( elem, markDataKey, undefined, true ) ) ) {
jurzua
parents:
diff changeset
1781 // Give room for hard-coded callbacks to fire first
jurzua
parents:
diff changeset
1782 // and eventually mark/queue something else on the element
jurzua
parents:
diff changeset
1783 setTimeout( function() {
jurzua
parents:
diff changeset
1784 if ( !jQuery.data( elem, queueDataKey, undefined, true ) &&
jurzua
parents:
diff changeset
1785 !jQuery.data( elem, markDataKey, undefined, true ) ) {
jurzua
parents:
diff changeset
1786 jQuery.removeData( elem, deferDataKey, true );
jurzua
parents:
diff changeset
1787 defer.resolve();
jurzua
parents:
diff changeset
1788 }
jurzua
parents:
diff changeset
1789 }, 0 );
jurzua
parents:
diff changeset
1790 }
jurzua
parents:
diff changeset
1791 }
jurzua
parents:
diff changeset
1792
jurzua
parents:
diff changeset
1793 jQuery.extend({
jurzua
parents:
diff changeset
1794
jurzua
parents:
diff changeset
1795 _mark: function( elem, type ) {
jurzua
parents:
diff changeset
1796 if ( elem ) {
jurzua
parents:
diff changeset
1797 type = (type || "fx") + "mark";
jurzua
parents:
diff changeset
1798 jQuery.data( elem, type, (jQuery.data(elem,type,undefined,true) || 0) + 1, true );
jurzua
parents:
diff changeset
1799 }
jurzua
parents:
diff changeset
1800 },
jurzua
parents:
diff changeset
1801
jurzua
parents:
diff changeset
1802 _unmark: function( force, elem, type ) {
jurzua
parents:
diff changeset
1803 if ( force !== true ) {
jurzua
parents:
diff changeset
1804 type = elem;
jurzua
parents:
diff changeset
1805 elem = force;
jurzua
parents:
diff changeset
1806 force = false;
jurzua
parents:
diff changeset
1807 }
jurzua
parents:
diff changeset
1808 if ( elem ) {
jurzua
parents:
diff changeset
1809 type = type || "fx";
jurzua
parents:
diff changeset
1810 var key = type + "mark",
jurzua
parents:
diff changeset
1811 count = force ? 0 : ( (jQuery.data( elem, key, undefined, true) || 1 ) - 1 );
jurzua
parents:
diff changeset
1812 if ( count ) {
jurzua
parents:
diff changeset
1813 jQuery.data( elem, key, count, true );
jurzua
parents:
diff changeset
1814 } else {
jurzua
parents:
diff changeset
1815 jQuery.removeData( elem, key, true );
jurzua
parents:
diff changeset
1816 handleQueueMarkDefer( elem, type, "mark" );
jurzua
parents:
diff changeset
1817 }
jurzua
parents:
diff changeset
1818 }
jurzua
parents:
diff changeset
1819 },
jurzua
parents:
diff changeset
1820
jurzua
parents:
diff changeset
1821 queue: function( elem, type, data ) {
jurzua
parents:
diff changeset
1822 if ( elem ) {
jurzua
parents:
diff changeset
1823 type = (type || "fx") + "queue";
jurzua
parents:
diff changeset
1824 var q = jQuery.data( elem, type, undefined, true );
jurzua
parents:
diff changeset
1825 // Speed up dequeue by getting out quickly if this is just a lookup
jurzua
parents:
diff changeset
1826 if ( data ) {
jurzua
parents:
diff changeset
1827 if ( !q || jQuery.isArray(data) ) {
jurzua
parents:
diff changeset
1828 q = jQuery.data( elem, type, jQuery.makeArray(data), true );
jurzua
parents:
diff changeset
1829 } else {
jurzua
parents:
diff changeset
1830 q.push( data );
jurzua
parents:
diff changeset
1831 }
jurzua
parents:
diff changeset
1832 }
jurzua
parents:
diff changeset
1833 return q || [];
jurzua
parents:
diff changeset
1834 }
jurzua
parents:
diff changeset
1835 },
jurzua
parents:
diff changeset
1836
jurzua
parents:
diff changeset
1837 dequeue: function( elem, type ) {
jurzua
parents:
diff changeset
1838 type = type || "fx";
jurzua
parents:
diff changeset
1839
jurzua
parents:
diff changeset
1840 var queue = jQuery.queue( elem, type ),
jurzua
parents:
diff changeset
1841 fn = queue.shift(),
jurzua
parents:
diff changeset
1842 defer;
jurzua
parents:
diff changeset
1843
jurzua
parents:
diff changeset
1844 // If the fx queue is dequeued, always remove the progress sentinel
jurzua
parents:
diff changeset
1845 if ( fn === "inprogress" ) {
jurzua
parents:
diff changeset
1846 fn = queue.shift();
jurzua
parents:
diff changeset
1847 }
jurzua
parents:
diff changeset
1848
jurzua
parents:
diff changeset
1849 if ( fn ) {
jurzua
parents:
diff changeset
1850 // Add a progress sentinel to prevent the fx queue from being
jurzua
parents:
diff changeset
1851 // automatically dequeued
jurzua
parents:
diff changeset
1852 if ( type === "fx" ) {
jurzua
parents:
diff changeset
1853 queue.unshift("inprogress");
jurzua
parents:
diff changeset
1854 }
jurzua
parents:
diff changeset
1855
jurzua
parents:
diff changeset
1856 fn.call(elem, function() {
jurzua
parents:
diff changeset
1857 jQuery.dequeue(elem, type);
jurzua
parents:
diff changeset
1858 });
jurzua
parents:
diff changeset
1859 }
jurzua
parents:
diff changeset
1860
jurzua
parents:
diff changeset
1861 if ( !queue.length ) {
jurzua
parents:
diff changeset
1862 jQuery.removeData( elem, type + "queue", true );
jurzua
parents:
diff changeset
1863 handleQueueMarkDefer( elem, type, "queue" );
jurzua
parents:
diff changeset
1864 }
jurzua
parents:
diff changeset
1865 }
jurzua
parents:
diff changeset
1866 });
jurzua
parents:
diff changeset
1867
jurzua
parents:
diff changeset
1868 jQuery.fn.extend({
jurzua
parents:
diff changeset
1869 queue: function( type, data ) {
jurzua
parents:
diff changeset
1870 if ( typeof type !== "string" ) {
jurzua
parents:
diff changeset
1871 data = type;
jurzua
parents:
diff changeset
1872 type = "fx";
jurzua
parents:
diff changeset
1873 }
jurzua
parents:
diff changeset
1874
jurzua
parents:
diff changeset
1875 if ( data === undefined ) {
jurzua
parents:
diff changeset
1876 return jQuery.queue( this[0], type );
jurzua
parents:
diff changeset
1877 }
jurzua
parents:
diff changeset
1878 return this.each(function() {
jurzua
parents:
diff changeset
1879 var queue = jQuery.queue( this, type, data );
jurzua
parents:
diff changeset
1880
jurzua
parents:
diff changeset
1881 if ( type === "fx" && queue[0] !== "inprogress" ) {
jurzua
parents:
diff changeset
1882 jQuery.dequeue( this, type );
jurzua
parents:
diff changeset
1883 }
jurzua
parents:
diff changeset
1884 });
jurzua
parents:
diff changeset
1885 },
jurzua
parents:
diff changeset
1886 dequeue: function( type ) {
jurzua
parents:
diff changeset
1887 return this.each(function() {
jurzua
parents:
diff changeset
1888 jQuery.dequeue( this, type );
jurzua
parents:
diff changeset
1889 });
jurzua
parents:
diff changeset
1890 },
jurzua
parents:
diff changeset
1891 // Based off of the plugin by Clint Helfers, with permission.
jurzua
parents:
diff changeset
1892 // http://blindsignals.com/index.php/2009/07/jquery-delay/
jurzua
parents:
diff changeset
1893 delay: function( time, type ) {
jurzua
parents:
diff changeset
1894 time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
jurzua
parents:
diff changeset
1895 type = type || "fx";
jurzua
parents:
diff changeset
1896
jurzua
parents:
diff changeset
1897 return this.queue( type, function() {
jurzua
parents:
diff changeset
1898 var elem = this;
jurzua
parents:
diff changeset
1899 setTimeout(function() {
jurzua
parents:
diff changeset
1900 jQuery.dequeue( elem, type );
jurzua
parents:
diff changeset
1901 }, time );
jurzua
parents:
diff changeset
1902 });
jurzua
parents:
diff changeset
1903 },
jurzua
parents:
diff changeset
1904 clearQueue: function( type ) {
jurzua
parents:
diff changeset
1905 return this.queue( type || "fx", [] );
jurzua
parents:
diff changeset
1906 },
jurzua
parents:
diff changeset
1907 // Get a promise resolved when queues of a certain type
jurzua
parents:
diff changeset
1908 // are emptied (fx is the type by default)
jurzua
parents:
diff changeset
1909 promise: function( type, object ) {
jurzua
parents:
diff changeset
1910 if ( typeof type !== "string" ) {
jurzua
parents:
diff changeset
1911 object = type;
jurzua
parents:
diff changeset
1912 type = undefined;
jurzua
parents:
diff changeset
1913 }
jurzua
parents:
diff changeset
1914 type = type || "fx";
jurzua
parents:
diff changeset
1915 var defer = jQuery.Deferred(),
jurzua
parents:
diff changeset
1916 elements = this,
jurzua
parents:
diff changeset
1917 i = elements.length,
jurzua
parents:
diff changeset
1918 count = 1,
jurzua
parents:
diff changeset
1919 deferDataKey = type + "defer",
jurzua
parents:
diff changeset
1920 queueDataKey = type + "queue",
jurzua
parents:
diff changeset
1921 markDataKey = type + "mark",
jurzua
parents:
diff changeset
1922 tmp;
jurzua
parents:
diff changeset
1923 function resolve() {
jurzua
parents:
diff changeset
1924 if ( !( --count ) ) {
jurzua
parents:
diff changeset
1925 defer.resolveWith( elements, [ elements ] );
jurzua
parents:
diff changeset
1926 }
jurzua
parents:
diff changeset
1927 }
jurzua
parents:
diff changeset
1928 while( i-- ) {
jurzua
parents:
diff changeset
1929 if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
jurzua
parents:
diff changeset
1930 ( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
jurzua
parents:
diff changeset
1931 jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
jurzua
parents:
diff changeset
1932 jQuery.data( elements[ i ], deferDataKey, jQuery._Deferred(), true ) )) {
jurzua
parents:
diff changeset
1933 count++;
jurzua
parents:
diff changeset
1934 tmp.done( resolve );
jurzua
parents:
diff changeset
1935 }
jurzua
parents:
diff changeset
1936 }
jurzua
parents:
diff changeset
1937 resolve();
jurzua
parents:
diff changeset
1938 return defer.promise();
jurzua
parents:
diff changeset
1939 }
jurzua
parents:
diff changeset
1940 });
jurzua
parents:
diff changeset
1941
jurzua
parents:
diff changeset
1942
jurzua
parents:
diff changeset
1943
jurzua
parents:
diff changeset
1944
jurzua
parents:
diff changeset
1945 var rclass = /[\n\t\r]/g,
jurzua
parents:
diff changeset
1946 rspace = /\s+/,
jurzua
parents:
diff changeset
1947 rreturn = /\r/g,
jurzua
parents:
diff changeset
1948 rtype = /^(?:button|input)$/i,
jurzua
parents:
diff changeset
1949 rfocusable = /^(?:button|input|object|select|textarea)$/i,
jurzua
parents:
diff changeset
1950 rclickable = /^a(?:rea)?$/i,
jurzua
parents:
diff changeset
1951 rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
jurzua
parents:
diff changeset
1952 nodeHook, boolHook;
jurzua
parents:
diff changeset
1953
jurzua
parents:
diff changeset
1954 jQuery.fn.extend({
jurzua
parents:
diff changeset
1955 attr: function( name, value ) {
jurzua
parents:
diff changeset
1956 return jQuery.access( this, name, value, true, jQuery.attr );
jurzua
parents:
diff changeset
1957 },
jurzua
parents:
diff changeset
1958
jurzua
parents:
diff changeset
1959 removeAttr: function( name ) {
jurzua
parents:
diff changeset
1960 return this.each(function() {
jurzua
parents:
diff changeset
1961 jQuery.removeAttr( this, name );
jurzua
parents:
diff changeset
1962 });
jurzua
parents:
diff changeset
1963 },
jurzua
parents:
diff changeset
1964
jurzua
parents:
diff changeset
1965 prop: function( name, value ) {
jurzua
parents:
diff changeset
1966 return jQuery.access( this, name, value, true, jQuery.prop );
jurzua
parents:
diff changeset
1967 },
jurzua
parents:
diff changeset
1968
jurzua
parents:
diff changeset
1969 removeProp: function( name ) {
jurzua
parents:
diff changeset
1970 name = jQuery.propFix[ name ] || name;
jurzua
parents:
diff changeset
1971 return this.each(function() {
jurzua
parents:
diff changeset
1972 // try/catch handles cases where IE balks (such as removing a property on window)
jurzua
parents:
diff changeset
1973 try {
jurzua
parents:
diff changeset
1974 this[ name ] = undefined;
jurzua
parents:
diff changeset
1975 delete this[ name ];
jurzua
parents:
diff changeset
1976 } catch( e ) {}
jurzua
parents:
diff changeset
1977 });
jurzua
parents:
diff changeset
1978 },
jurzua
parents:
diff changeset
1979
jurzua
parents:
diff changeset
1980 addClass: function( value ) {
jurzua
parents:
diff changeset
1981 var classNames, i, l, elem,
jurzua
parents:
diff changeset
1982 setClass, c, cl;
jurzua
parents:
diff changeset
1983
jurzua
parents:
diff changeset
1984 if ( jQuery.isFunction( value ) ) {
jurzua
parents:
diff changeset
1985 return this.each(function( j ) {
jurzua
parents:
diff changeset
1986 jQuery( this ).addClass( value.call(this, j, this.className) );
jurzua
parents:
diff changeset
1987 });
jurzua
parents:
diff changeset
1988 }
jurzua
parents:
diff changeset
1989
jurzua
parents:
diff changeset
1990 if ( value && typeof value === "string" ) {
jurzua
parents:
diff changeset
1991 classNames = value.split( rspace );
jurzua
parents:
diff changeset
1992
jurzua
parents:
diff changeset
1993 for ( i = 0, l = this.length; i < l; i++ ) {
jurzua
parents:
diff changeset
1994 elem = this[ i ];
jurzua
parents:
diff changeset
1995
jurzua
parents:
diff changeset
1996 if ( elem.nodeType === 1 ) {
jurzua
parents:
diff changeset
1997 if ( !elem.className && classNames.length === 1 ) {
jurzua
parents:
diff changeset
1998 elem.className = value;
jurzua
parents:
diff changeset
1999
jurzua
parents:
diff changeset
2000 } else {
jurzua
parents:
diff changeset
2001 setClass = " " + elem.className + " ";
jurzua
parents:
diff changeset
2002
jurzua
parents:
diff changeset
2003 for ( c = 0, cl = classNames.length; c < cl; c++ ) {
jurzua
parents:
diff changeset
2004 if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) {
jurzua
parents:
diff changeset
2005 setClass += classNames[ c ] + " ";
jurzua
parents:
diff changeset
2006 }
jurzua
parents:
diff changeset
2007 }
jurzua
parents:
diff changeset
2008 elem.className = jQuery.trim( setClass );
jurzua
parents:
diff changeset
2009 }
jurzua
parents:
diff changeset
2010 }
jurzua
parents:
diff changeset
2011 }
jurzua
parents:
diff changeset
2012 }
jurzua
parents:
diff changeset
2013
jurzua
parents:
diff changeset
2014 return this;
jurzua
parents:
diff changeset
2015 },
jurzua
parents:
diff changeset
2016
jurzua
parents:
diff changeset
2017 removeClass: function( value ) {
jurzua
parents:
diff changeset
2018 var classNames, i, l, elem, className, c, cl;
jurzua
parents:
diff changeset
2019
jurzua
parents:
diff changeset
2020 if ( jQuery.isFunction( value ) ) {
jurzua
parents:
diff changeset
2021 return this.each(function( j ) {
jurzua
parents:
diff changeset
2022 jQuery( this ).removeClass( value.call(this, j, this.className) );
jurzua
parents:
diff changeset
2023 });
jurzua
parents:
diff changeset
2024 }
jurzua
parents:
diff changeset
2025
jurzua
parents:
diff changeset
2026 if ( (value && typeof value === "string") || value === undefined ) {
jurzua
parents:
diff changeset
2027 classNames = (value || "").split( rspace );
jurzua
parents:
diff changeset
2028
jurzua
parents:
diff changeset
2029 for ( i = 0, l = this.length; i < l; i++ ) {
jurzua
parents:
diff changeset
2030 elem = this[ i ];
jurzua
parents:
diff changeset
2031
jurzua
parents:
diff changeset
2032 if ( elem.nodeType === 1 && elem.className ) {
jurzua
parents:
diff changeset
2033 if ( value ) {
jurzua
parents:
diff changeset
2034 className = (" " + elem.className + " ").replace( rclass, " " );
jurzua
parents:
diff changeset
2035 for ( c = 0, cl = classNames.length; c < cl; c++ ) {
jurzua
parents:
diff changeset
2036 className = className.replace(" " + classNames[ c ] + " ", " ");
jurzua
parents:
diff changeset
2037 }
jurzua
parents:
diff changeset
2038 elem.className = jQuery.trim( className );
jurzua
parents:
diff changeset
2039
jurzua
parents:
diff changeset
2040 } else {
jurzua
parents:
diff changeset
2041 elem.className = "";
jurzua
parents:
diff changeset
2042 }
jurzua
parents:
diff changeset
2043 }
jurzua
parents:
diff changeset
2044 }
jurzua
parents:
diff changeset
2045 }
jurzua
parents:
diff changeset
2046
jurzua
parents:
diff changeset
2047 return this;
jurzua
parents:
diff changeset
2048 },
jurzua
parents:
diff changeset
2049
jurzua
parents:
diff changeset
2050 toggleClass: function( value, stateVal ) {
jurzua
parents:
diff changeset
2051 var type = typeof value,
jurzua
parents:
diff changeset
2052 isBool = typeof stateVal === "boolean";
jurzua
parents:
diff changeset
2053
jurzua
parents:
diff changeset
2054 if ( jQuery.isFunction( value ) ) {
jurzua
parents:
diff changeset
2055 return this.each(function( i ) {
jurzua
parents:
diff changeset
2056 jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
jurzua
parents:
diff changeset
2057 });
jurzua
parents:
diff changeset
2058 }
jurzua
parents:
diff changeset
2059
jurzua
parents:
diff changeset
2060 return this.each(function() {
jurzua
parents:
diff changeset
2061 if ( type === "string" ) {
jurzua
parents:
diff changeset
2062 // toggle individual class names
jurzua
parents:
diff changeset
2063 var className,
jurzua
parents:
diff changeset
2064 i = 0,
jurzua
parents:
diff changeset
2065 self = jQuery( this ),
jurzua
parents:
diff changeset
2066 state = stateVal,
jurzua
parents:
diff changeset
2067 classNames = value.split( rspace );
jurzua
parents:
diff changeset
2068
jurzua
parents:
diff changeset
2069 while ( (className = classNames[ i++ ]) ) {
jurzua
parents:
diff changeset
2070 // check each className given, space seperated list
jurzua
parents:
diff changeset
2071 state = isBool ? state : !self.hasClass( className );
jurzua
parents:
diff changeset
2072 self[ state ? "addClass" : "removeClass" ]( className );
jurzua
parents:
diff changeset
2073 }
jurzua
parents:
diff changeset
2074
jurzua
parents:
diff changeset
2075 } else if ( type === "undefined" || type === "boolean" ) {
jurzua
parents:
diff changeset
2076 if ( this.className ) {
jurzua
parents:
diff changeset
2077 // store className if set
jurzua
parents:
diff changeset
2078 jQuery._data( this, "__className__", this.className );
jurzua
parents:
diff changeset
2079 }
jurzua
parents:
diff changeset
2080
jurzua
parents:
diff changeset
2081 // toggle whole className
jurzua
parents:
diff changeset
2082 this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
jurzua
parents:
diff changeset
2083 }
jurzua
parents:
diff changeset
2084 });
jurzua
parents:
diff changeset
2085 },
jurzua
parents:
diff changeset
2086
jurzua
parents:
diff changeset
2087 hasClass: function( selector ) {
jurzua
parents:
diff changeset
2088 var className = " " + selector + " ";
jurzua
parents:
diff changeset
2089 for ( var i = 0, l = this.length; i < l; i++ ) {
jurzua
parents:
diff changeset
2090 if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
jurzua
parents:
diff changeset
2091 return true;
jurzua
parents:
diff changeset
2092 }
jurzua
parents:
diff changeset
2093 }
jurzua
parents:
diff changeset
2094
jurzua
parents:
diff changeset
2095 return false;
jurzua
parents:
diff changeset
2096 },
jurzua
parents:
diff changeset
2097
jurzua
parents:
diff changeset
2098 val: function( value ) {
jurzua
parents:
diff changeset
2099 var hooks, ret,
jurzua
parents:
diff changeset
2100 elem = this[0];
jurzua
parents:
diff changeset
2101
jurzua
parents:
diff changeset
2102 if ( !arguments.length ) {
jurzua
parents:
diff changeset
2103 if ( elem ) {
jurzua
parents:
diff changeset
2104 hooks = jQuery.valHooks[ elem.nodeName.toLowerCase() ] || jQuery.valHooks[ elem.type ];
jurzua
parents:
diff changeset
2105
jurzua
parents:
diff changeset
2106 if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
jurzua
parents:
diff changeset
2107 return ret;
jurzua
parents:
diff changeset
2108 }
jurzua
parents:
diff changeset
2109
jurzua
parents:
diff changeset
2110 ret = elem.value;
jurzua
parents:
diff changeset
2111
jurzua
parents:
diff changeset
2112 return typeof ret === "string" ?
jurzua
parents:
diff changeset
2113 // handle most common string cases
jurzua
parents:
diff changeset
2114 ret.replace(rreturn, "") :
jurzua
parents:
diff changeset
2115 // handle cases where value is null/undef or number
jurzua
parents:
diff changeset
2116 ret == null ? "" : ret;
jurzua
parents:
diff changeset
2117 }
jurzua
parents:
diff changeset
2118
jurzua
parents:
diff changeset
2119 return undefined;
jurzua
parents:
diff changeset
2120 }
jurzua
parents:
diff changeset
2121
jurzua
parents:
diff changeset
2122 var isFunction = jQuery.isFunction( value );
jurzua
parents:
diff changeset
2123
jurzua
parents:
diff changeset
2124 return this.each(function( i ) {
jurzua
parents:
diff changeset
2125 var self = jQuery(this), val;
jurzua
parents:
diff changeset
2126
jurzua
parents:
diff changeset
2127 if ( this.nodeType !== 1 ) {
jurzua
parents:
diff changeset
2128 return;
jurzua
parents:
diff changeset
2129 }
jurzua
parents:
diff changeset
2130
jurzua
parents:
diff changeset
2131 if ( isFunction ) {
jurzua
parents:
diff changeset
2132 val = value.call( this, i, self.val() );
jurzua
parents:
diff changeset
2133 } else {
jurzua
parents:
diff changeset
2134 val = value;
jurzua
parents:
diff changeset
2135 }
jurzua
parents:
diff changeset
2136
jurzua
parents:
diff changeset
2137 // Treat null/undefined as ""; convert numbers to string
jurzua
parents:
diff changeset
2138 if ( val == null ) {
jurzua
parents:
diff changeset
2139 val = "";
jurzua
parents:
diff changeset
2140 } else if ( typeof val === "number" ) {
jurzua
parents:
diff changeset
2141 val += "";
jurzua
parents:
diff changeset
2142 } else if ( jQuery.isArray( val ) ) {
jurzua
parents:
diff changeset
2143 val = jQuery.map(val, function ( value ) {
jurzua
parents:
diff changeset
2144 return value == null ? "" : value + "";
jurzua
parents:
diff changeset
2145 });
jurzua
parents:
diff changeset
2146 }
jurzua
parents:
diff changeset
2147
jurzua
parents:
diff changeset
2148 hooks = jQuery.valHooks[ this.nodeName.toLowerCase() ] || jQuery.valHooks[ this.type ];
jurzua
parents:
diff changeset
2149
jurzua
parents:
diff changeset
2150 // If set returns undefined, fall back to normal setting
jurzua
parents:
diff changeset
2151 if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
jurzua
parents:
diff changeset
2152 this.value = val;
jurzua
parents:
diff changeset
2153 }
jurzua
parents:
diff changeset
2154 });
jurzua
parents:
diff changeset
2155 }
jurzua
parents:
diff changeset
2156 });
jurzua
parents:
diff changeset
2157
jurzua
parents:
diff changeset
2158 jQuery.extend({
jurzua
parents:
diff changeset
2159 valHooks: {
jurzua
parents:
diff changeset
2160 option: {
jurzua
parents:
diff changeset
2161 get: function( elem ) {
jurzua
parents:
diff changeset
2162 // attributes.value is undefined in Blackberry 4.7 but
jurzua
parents:
diff changeset
2163 // uses .value. See #6932
jurzua
parents:
diff changeset
2164 var val = elem.attributes.value;
jurzua
parents:
diff changeset
2165 return !val || val.specified ? elem.value : elem.text;
jurzua
parents:
diff changeset
2166 }
jurzua
parents:
diff changeset
2167 },
jurzua
parents:
diff changeset
2168 select: {
jurzua
parents:
diff changeset
2169 get: function( elem ) {
jurzua
parents:
diff changeset
2170 var value,
jurzua
parents:
diff changeset
2171 index = elem.selectedIndex,
jurzua
parents:
diff changeset
2172 values = [],
jurzua
parents:
diff changeset
2173 options = elem.options,
jurzua
parents:
diff changeset
2174 one = elem.type === "select-one";
jurzua
parents:
diff changeset
2175
jurzua
parents:
diff changeset
2176 // Nothing was selected
jurzua
parents:
diff changeset
2177 if ( index < 0 ) {
jurzua
parents:
diff changeset
2178 return null;
jurzua
parents:
diff changeset
2179 }
jurzua
parents:
diff changeset
2180
jurzua
parents:
diff changeset
2181 // Loop through all the selected options
jurzua
parents:
diff changeset
2182 for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
jurzua
parents:
diff changeset
2183 var option = options[ i ];
jurzua
parents:
diff changeset
2184
jurzua
parents:
diff changeset
2185 // Don't return options that are disabled or in a disabled optgroup
jurzua
parents:
diff changeset
2186 if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
jurzua
parents:
diff changeset
2187 (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
jurzua
parents:
diff changeset
2188
jurzua
parents:
diff changeset
2189 // Get the specific value for the option
jurzua
parents:
diff changeset
2190 value = jQuery( option ).val();
jurzua
parents:
diff changeset
2191
jurzua
parents:
diff changeset
2192 // We don't need an array for one selects
jurzua
parents:
diff changeset
2193 if ( one ) {
jurzua
parents:
diff changeset
2194 return value;
jurzua
parents:
diff changeset
2195 }
jurzua
parents:
diff changeset
2196
jurzua
parents:
diff changeset
2197 // Multi-Selects return an array
jurzua
parents:
diff changeset
2198 values.push( value );
jurzua
parents:
diff changeset
2199 }
jurzua
parents:
diff changeset
2200 }
jurzua
parents:
diff changeset
2201
jurzua
parents:
diff changeset
2202 // Fixes Bug #2551 -- select.val() broken in IE after form.reset()
jurzua
parents:
diff changeset
2203 if ( one && !values.length && options.length ) {
jurzua
parents:
diff changeset
2204 return jQuery( options[ index ] ).val();
jurzua
parents:
diff changeset
2205 }
jurzua
parents:
diff changeset
2206
jurzua
parents:
diff changeset
2207 return values;
jurzua
parents:
diff changeset
2208 },
jurzua
parents:
diff changeset
2209
jurzua
parents:
diff changeset
2210 set: function( elem, value ) {
jurzua
parents:
diff changeset
2211 var values = jQuery.makeArray( value );
jurzua
parents:
diff changeset
2212
jurzua
parents:
diff changeset
2213 jQuery(elem).find("option").each(function() {
jurzua
parents:
diff changeset
2214 this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
jurzua
parents:
diff changeset
2215 });
jurzua
parents:
diff changeset
2216
jurzua
parents:
diff changeset
2217 if ( !values.length ) {
jurzua
parents:
diff changeset
2218 elem.selectedIndex = -1;
jurzua
parents:
diff changeset
2219 }
jurzua
parents:
diff changeset
2220 return values;
jurzua
parents:
diff changeset
2221 }
jurzua
parents:
diff changeset
2222 }
jurzua
parents:
diff changeset
2223 },
jurzua
parents:
diff changeset
2224
jurzua
parents:
diff changeset
2225 attrFn: {
jurzua
parents:
diff changeset
2226 val: true,
jurzua
parents:
diff changeset
2227 css: true,
jurzua
parents:
diff changeset
2228 html: true,
jurzua
parents:
diff changeset
2229 text: true,
jurzua
parents:
diff changeset
2230 data: true,
jurzua
parents:
diff changeset
2231 width: true,
jurzua
parents:
diff changeset
2232 height: true,
jurzua
parents:
diff changeset
2233 offset: true
jurzua
parents:
diff changeset
2234 },
jurzua
parents:
diff changeset
2235
jurzua
parents:
diff changeset
2236 attrFix: {
jurzua
parents:
diff changeset
2237 // Always normalize to ensure hook usage
jurzua
parents:
diff changeset
2238 tabindex: "tabIndex"
jurzua
parents:
diff changeset
2239 },
jurzua
parents:
diff changeset
2240
jurzua
parents:
diff changeset
2241 attr: function( elem, name, value, pass ) {
jurzua
parents:
diff changeset
2242 var nType = elem.nodeType;
jurzua
parents:
diff changeset
2243
jurzua
parents:
diff changeset
2244 // don't get/set attributes on text, comment and attribute nodes
jurzua
parents:
diff changeset
2245 if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
jurzua
parents:
diff changeset
2246 return undefined;
jurzua
parents:
diff changeset
2247 }
jurzua
parents:
diff changeset
2248
jurzua
parents:
diff changeset
2249 if ( pass && name in jQuery.attrFn ) {
jurzua
parents:
diff changeset
2250 return jQuery( elem )[ name ]( value );
jurzua
parents:
diff changeset
2251 }
jurzua
parents:
diff changeset
2252
jurzua
parents:
diff changeset
2253 // Fallback to prop when attributes are not supported
jurzua
parents:
diff changeset
2254 if ( !("getAttribute" in elem) ) {
jurzua
parents:
diff changeset
2255 return jQuery.prop( elem, name, value );
jurzua
parents:
diff changeset
2256 }
jurzua
parents:
diff changeset
2257
jurzua
parents:
diff changeset
2258 var ret, hooks,
jurzua
parents:
diff changeset
2259 notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
jurzua
parents:
diff changeset
2260
jurzua
parents:
diff changeset
2261 // Normalize the name if needed
jurzua
parents:
diff changeset
2262 if ( notxml ) {
jurzua
parents:
diff changeset
2263 name = jQuery.attrFix[ name ] || name;
jurzua
parents:
diff changeset
2264
jurzua
parents:
diff changeset
2265 hooks = jQuery.attrHooks[ name ];
jurzua
parents:
diff changeset
2266
jurzua
parents:
diff changeset
2267 if ( !hooks ) {
jurzua
parents:
diff changeset
2268 // Use boolHook for boolean attributes
jurzua
parents:
diff changeset
2269 if ( rboolean.test( name ) ) {
jurzua
parents:
diff changeset
2270 hooks = boolHook;
jurzua
parents:
diff changeset
2271
jurzua
parents:
diff changeset
2272 // Use nodeHook if available( IE6/7 )
jurzua
parents:
diff changeset
2273 } else if ( nodeHook ) {
jurzua
parents:
diff changeset
2274 hooks = nodeHook;
jurzua
parents:
diff changeset
2275 }
jurzua
parents:
diff changeset
2276 }
jurzua
parents:
diff changeset
2277 }
jurzua
parents:
diff changeset
2278
jurzua
parents:
diff changeset
2279 if ( value !== undefined ) {
jurzua
parents:
diff changeset
2280
jurzua
parents:
diff changeset
2281 if ( value === null ) {
jurzua
parents:
diff changeset
2282 jQuery.removeAttr( elem, name );
jurzua
parents:
diff changeset
2283 return undefined;
jurzua
parents:
diff changeset
2284
jurzua
parents:
diff changeset
2285 } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
jurzua
parents:
diff changeset
2286 return ret;
jurzua
parents:
diff changeset
2287
jurzua
parents:
diff changeset
2288 } else {
jurzua
parents:
diff changeset
2289 elem.setAttribute( name, "" + value );
jurzua
parents:
diff changeset
2290 return value;
jurzua
parents:
diff changeset
2291 }
jurzua
parents:
diff changeset
2292
jurzua
parents:
diff changeset
2293 } else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
jurzua
parents:
diff changeset
2294 return ret;
jurzua
parents:
diff changeset
2295
jurzua
parents:
diff changeset
2296 } else {
jurzua
parents:
diff changeset
2297
jurzua
parents:
diff changeset
2298 ret = elem.getAttribute( name );
jurzua
parents:
diff changeset
2299
jurzua
parents:
diff changeset
2300 // Non-existent attributes return null, we normalize to undefined
jurzua
parents:
diff changeset
2301 return ret === null ?
jurzua
parents:
diff changeset
2302 undefined :
jurzua
parents:
diff changeset
2303 ret;
jurzua
parents:
diff changeset
2304 }
jurzua
parents:
diff changeset
2305 },
jurzua
parents:
diff changeset
2306
jurzua
parents:
diff changeset
2307 removeAttr: function( elem, name ) {
jurzua
parents:
diff changeset
2308 var propName;
jurzua
parents:
diff changeset
2309 if ( elem.nodeType === 1 ) {
jurzua
parents:
diff changeset
2310 name = jQuery.attrFix[ name ] || name;
jurzua
parents:
diff changeset
2311
jurzua
parents:
diff changeset
2312 jQuery.attr( elem, name, "" );
jurzua
parents:
diff changeset
2313 elem.removeAttribute( name );
jurzua
parents:
diff changeset
2314
jurzua
parents:
diff changeset
2315 // Set corresponding property to false for boolean attributes
jurzua
parents:
diff changeset
2316 if ( rboolean.test( name ) && (propName = jQuery.propFix[ name ] || name) in elem ) {
jurzua
parents:
diff changeset
2317 elem[ propName ] = false;
jurzua
parents:
diff changeset
2318 }
jurzua
parents:
diff changeset
2319 }
jurzua
parents:
diff changeset
2320 },
jurzua
parents:
diff changeset
2321
jurzua
parents:
diff changeset
2322 attrHooks: {
jurzua
parents:
diff changeset
2323 type: {
jurzua
parents:
diff changeset
2324 set: function( elem, value ) {
jurzua
parents:
diff changeset
2325 // We can't allow the type property to be changed (since it causes problems in IE)
jurzua
parents:
diff changeset
2326 if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
jurzua
parents:
diff changeset
2327 jQuery.error( "type property can't be changed" );
jurzua
parents:
diff changeset
2328 } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
jurzua
parents:
diff changeset
2329 // Setting the type on a radio button after the value resets the value in IE6-9
jurzua
parents:
diff changeset
2330 // Reset value to it's default in case type is set after value
jurzua
parents:
diff changeset
2331 // This is for element creation
jurzua
parents:
diff changeset
2332 var val = elem.value;
jurzua
parents:
diff changeset
2333 elem.setAttribute( "type", value );
jurzua
parents:
diff changeset
2334 if ( val ) {
jurzua
parents:
diff changeset
2335 elem.value = val;
jurzua
parents:
diff changeset
2336 }
jurzua
parents:
diff changeset
2337 return value;
jurzua
parents:
diff changeset
2338 }
jurzua
parents:
diff changeset
2339 }
jurzua
parents:
diff changeset
2340 },
jurzua
parents:
diff changeset
2341 // Use the value property for back compat
jurzua
parents:
diff changeset
2342 // Use the nodeHook for button elements in IE6/7 (#1954)
jurzua
parents:
diff changeset
2343 value: {
jurzua
parents:
diff changeset
2344 get: function( elem, name ) {
jurzua
parents:
diff changeset
2345 if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
jurzua
parents:
diff changeset
2346 return nodeHook.get( elem, name );
jurzua
parents:
diff changeset
2347 }
jurzua
parents:
diff changeset
2348 return name in elem ?
jurzua
parents:
diff changeset
2349 elem.value :
jurzua
parents:
diff changeset
2350 null;
jurzua
parents:
diff changeset
2351 },
jurzua
parents:
diff changeset
2352 set: function( elem, value, name ) {
jurzua
parents:
diff changeset
2353 if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
jurzua
parents:
diff changeset
2354 return nodeHook.set( elem, value, name );
jurzua
parents:
diff changeset
2355 }
jurzua
parents:
diff changeset
2356 // Does not return so that setAttribute is also used
jurzua
parents:
diff changeset
2357 elem.value = value;
jurzua
parents:
diff changeset
2358 }
jurzua
parents:
diff changeset
2359 }
jurzua
parents:
diff changeset
2360 },
jurzua
parents:
diff changeset
2361
jurzua
parents:
diff changeset
2362 propFix: {
jurzua
parents:
diff changeset
2363 tabindex: "tabIndex",
jurzua
parents:
diff changeset
2364 readonly: "readOnly",
jurzua
parents:
diff changeset
2365 "for": "htmlFor",
jurzua
parents:
diff changeset
2366 "class": "className",
jurzua
parents:
diff changeset
2367 maxlength: "maxLength",
jurzua
parents:
diff changeset
2368 cellspacing: "cellSpacing",
jurzua
parents:
diff changeset
2369 cellpadding: "cellPadding",
jurzua
parents:
diff changeset
2370 rowspan: "rowSpan",
jurzua
parents:
diff changeset
2371 colspan: "colSpan",
jurzua
parents:
diff changeset
2372 usemap: "useMap",
jurzua
parents:
diff changeset
2373 frameborder: "frameBorder",
jurzua
parents:
diff changeset
2374 contenteditable: "contentEditable"
jurzua
parents:
diff changeset
2375 },
jurzua
parents:
diff changeset
2376
jurzua
parents:
diff changeset
2377 prop: function( elem, name, value ) {
jurzua
parents:
diff changeset
2378 var nType = elem.nodeType;
jurzua
parents:
diff changeset
2379
jurzua
parents:
diff changeset
2380 // don't get/set properties on text, comment and attribute nodes
jurzua
parents:
diff changeset
2381 if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
jurzua
parents:
diff changeset
2382 return undefined;
jurzua
parents:
diff changeset
2383 }
jurzua
parents:
diff changeset
2384
jurzua
parents:
diff changeset
2385 var ret, hooks,
jurzua
parents:
diff changeset
2386 notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
jurzua
parents:
diff changeset
2387
jurzua
parents:
diff changeset
2388 if ( notxml ) {
jurzua
parents:
diff changeset
2389 // Fix name and attach hooks
jurzua
parents:
diff changeset
2390 name = jQuery.propFix[ name ] || name;
jurzua
parents:
diff changeset
2391 hooks = jQuery.propHooks[ name ];
jurzua
parents:
diff changeset
2392 }
jurzua
parents:
diff changeset
2393
jurzua
parents:
diff changeset
2394 if ( value !== undefined ) {
jurzua
parents:
diff changeset
2395 if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
jurzua
parents:
diff changeset
2396 return ret;
jurzua
parents:
diff changeset
2397
jurzua
parents:
diff changeset
2398 } else {
jurzua
parents:
diff changeset
2399 return (elem[ name ] = value);
jurzua
parents:
diff changeset
2400 }
jurzua
parents:
diff changeset
2401
jurzua
parents:
diff changeset
2402 } else {
jurzua
parents:
diff changeset
2403 if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
jurzua
parents:
diff changeset
2404 return ret;
jurzua
parents:
diff changeset
2405
jurzua
parents:
diff changeset
2406 } else {
jurzua
parents:
diff changeset
2407 return elem[ name ];
jurzua
parents:
diff changeset
2408 }
jurzua
parents:
diff changeset
2409 }
jurzua
parents:
diff changeset
2410 },
jurzua
parents:
diff changeset
2411
jurzua
parents:
diff changeset
2412 propHooks: {
jurzua
parents:
diff changeset
2413 tabIndex: {
jurzua
parents:
diff changeset
2414 get: function( elem ) {
jurzua
parents:
diff changeset
2415 // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
jurzua
parents:
diff changeset
2416 // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
jurzua
parents:
diff changeset
2417 var attributeNode = elem.getAttributeNode("tabindex");
jurzua
parents:
diff changeset
2418
jurzua
parents:
diff changeset
2419 return attributeNode && attributeNode.specified ?
jurzua
parents:
diff changeset
2420 parseInt( attributeNode.value, 10 ) :
jurzua
parents:
diff changeset
2421 rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
jurzua
parents:
diff changeset
2422 0 :
jurzua
parents:
diff changeset
2423 undefined;
jurzua
parents:
diff changeset
2424 }
jurzua
parents:
diff changeset
2425 }
jurzua
parents:
diff changeset
2426 }
jurzua
parents:
diff changeset
2427 });
jurzua
parents:
diff changeset
2428
jurzua
parents:
diff changeset
2429 // Add the tabindex propHook to attrHooks for back-compat
jurzua
parents:
diff changeset
2430 jQuery.attrHooks.tabIndex = jQuery.propHooks.tabIndex;
jurzua
parents:
diff changeset
2431
jurzua
parents:
diff changeset
2432 // Hook for boolean attributes
jurzua
parents:
diff changeset
2433 boolHook = {
jurzua
parents:
diff changeset
2434 get: function( elem, name ) {
jurzua
parents:
diff changeset
2435 // Align boolean attributes with corresponding properties
jurzua
parents:
diff changeset
2436 // Fall back to attribute presence where some booleans are not supported
jurzua
parents:
diff changeset
2437 var attrNode;
jurzua
parents:
diff changeset
2438 return jQuery.prop( elem, name ) === true || ( attrNode = elem.getAttributeNode( name ) ) && attrNode.nodeValue !== false ?
jurzua
parents:
diff changeset
2439 name.toLowerCase() :
jurzua
parents:
diff changeset
2440 undefined;
jurzua
parents:
diff changeset
2441 },
jurzua
parents:
diff changeset
2442 set: function( elem, value, name ) {
jurzua
parents:
diff changeset
2443 var propName;
jurzua
parents:
diff changeset
2444 if ( value === false ) {
jurzua
parents:
diff changeset
2445 // Remove boolean attributes when set to false
jurzua
parents:
diff changeset
2446 jQuery.removeAttr( elem, name );
jurzua
parents:
diff changeset
2447 } else {
jurzua
parents:
diff changeset
2448 // value is true since we know at this point it's type boolean and not false
jurzua
parents:
diff changeset
2449 // Set boolean attributes to the same name and set the DOM property
jurzua
parents:
diff changeset
2450 propName = jQuery.propFix[ name ] || name;
jurzua
parents:
diff changeset
2451 if ( propName in elem ) {
jurzua
parents:
diff changeset
2452 // Only set the IDL specifically if it already exists on the element
jurzua
parents:
diff changeset
2453 elem[ propName ] = true;
jurzua
parents:
diff changeset
2454 }
jurzua
parents:
diff changeset
2455
jurzua
parents:
diff changeset
2456 elem.setAttribute( name, name.toLowerCase() );
jurzua
parents:
diff changeset
2457 }
jurzua
parents:
diff changeset
2458 return name;
jurzua
parents:
diff changeset
2459 }
jurzua
parents:
diff changeset
2460 };
jurzua
parents:
diff changeset
2461
jurzua
parents:
diff changeset
2462 // IE6/7 do not support getting/setting some attributes with get/setAttribute
jurzua
parents:
diff changeset
2463 if ( !jQuery.support.getSetAttribute ) {
jurzua
parents:
diff changeset
2464
jurzua
parents:
diff changeset
2465 // Use this for any attribute in IE6/7
jurzua
parents:
diff changeset
2466 // This fixes almost every IE6/7 issue
jurzua
parents:
diff changeset
2467 nodeHook = jQuery.valHooks.button = {
jurzua
parents:
diff changeset
2468 get: function( elem, name ) {
jurzua
parents:
diff changeset
2469 var ret;
jurzua
parents:
diff changeset
2470 ret = elem.getAttributeNode( name );
jurzua
parents:
diff changeset
2471 // Return undefined if nodeValue is empty string
jurzua
parents:
diff changeset
2472 return ret && ret.nodeValue !== "" ?
jurzua
parents:
diff changeset
2473 ret.nodeValue :
jurzua
parents:
diff changeset
2474 undefined;
jurzua
parents:
diff changeset
2475 },
jurzua
parents:
diff changeset
2476 set: function( elem, value, name ) {
jurzua
parents:
diff changeset
2477 // Set the existing or create a new attribute node
jurzua
parents:
diff changeset
2478 var ret = elem.getAttributeNode( name );
jurzua
parents:
diff changeset
2479 if ( !ret ) {
jurzua
parents:
diff changeset
2480 ret = document.createAttribute( name );
jurzua
parents:
diff changeset
2481 elem.setAttributeNode( ret );
jurzua
parents:
diff changeset
2482 }
jurzua
parents:
diff changeset
2483 return (ret.nodeValue = value + "");
jurzua
parents:
diff changeset
2484 }
jurzua
parents:
diff changeset
2485 };
jurzua
parents:
diff changeset
2486
jurzua
parents:
diff changeset
2487 // Set width and height to auto instead of 0 on empty string( Bug #8150 )
jurzua
parents:
diff changeset
2488 // This is for removals
jurzua
parents:
diff changeset
2489 jQuery.each([ "width", "height" ], function( i, name ) {
jurzua
parents:
diff changeset
2490 jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
jurzua
parents:
diff changeset
2491 set: function( elem, value ) {
jurzua
parents:
diff changeset
2492 if ( value === "" ) {
jurzua
parents:
diff changeset
2493 elem.setAttribute( name, "auto" );
jurzua
parents:
diff changeset
2494 return value;
jurzua
parents:
diff changeset
2495 }
jurzua
parents:
diff changeset
2496 }
jurzua
parents:
diff changeset
2497 });
jurzua
parents:
diff changeset
2498 });
jurzua
parents:
diff changeset
2499 }
jurzua
parents:
diff changeset
2500
jurzua
parents:
diff changeset
2501
jurzua
parents:
diff changeset
2502 // Some attributes require a special call on IE
jurzua
parents:
diff changeset
2503 if ( !jQuery.support.hrefNormalized ) {
jurzua
parents:
diff changeset
2504 jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
jurzua
parents:
diff changeset
2505 jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
jurzua
parents:
diff changeset
2506 get: function( elem ) {
jurzua
parents:
diff changeset
2507 var ret = elem.getAttribute( name, 2 );
jurzua
parents:
diff changeset
2508 return ret === null ? undefined : ret;
jurzua
parents:
diff changeset
2509 }
jurzua
parents:
diff changeset
2510 });
jurzua
parents:
diff changeset
2511 });
jurzua
parents:
diff changeset
2512 }
jurzua
parents:
diff changeset
2513
jurzua
parents:
diff changeset
2514 if ( !jQuery.support.style ) {
jurzua
parents:
diff changeset
2515 jQuery.attrHooks.style = {
jurzua
parents:
diff changeset
2516 get: function( elem ) {
jurzua
parents:
diff changeset
2517 // Return undefined in the case of empty string
jurzua
parents:
diff changeset
2518 // Normalize to lowercase since IE uppercases css property names
jurzua
parents:
diff changeset
2519 return elem.style.cssText.toLowerCase() || undefined;
jurzua
parents:
diff changeset
2520 },
jurzua
parents:
diff changeset
2521 set: function( elem, value ) {
jurzua
parents:
diff changeset
2522 return (elem.style.cssText = "" + value);
jurzua
parents:
diff changeset
2523 }
jurzua
parents:
diff changeset
2524 };
jurzua
parents:
diff changeset
2525 }
jurzua
parents:
diff changeset
2526
jurzua
parents:
diff changeset
2527 // Safari mis-reports the default selected property of an option
jurzua
parents:
diff changeset
2528 // Accessing the parent's selectedIndex property fixes it
jurzua
parents:
diff changeset
2529 if ( !jQuery.support.optSelected ) {
jurzua
parents:
diff changeset
2530 jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
jurzua
parents:
diff changeset
2531 get: function( elem ) {
jurzua
parents:
diff changeset
2532 var parent = elem.parentNode;
jurzua
parents:
diff changeset
2533
jurzua
parents:
diff changeset
2534 if ( parent ) {
jurzua
parents:
diff changeset
2535 parent.selectedIndex;
jurzua
parents:
diff changeset
2536
jurzua
parents:
diff changeset
2537 // Make sure that it also works with optgroups, see #5701
jurzua
parents:
diff changeset
2538 if ( parent.parentNode ) {
jurzua
parents:
diff changeset
2539 parent.parentNode.selectedIndex;
jurzua
parents:
diff changeset
2540 }
jurzua
parents:
diff changeset
2541 }
jurzua
parents:
diff changeset
2542 return null;
jurzua
parents:
diff changeset
2543 }
jurzua
parents:
diff changeset
2544 });
jurzua
parents:
diff changeset
2545 }
jurzua
parents:
diff changeset
2546
jurzua
parents:
diff changeset
2547 // Radios and checkboxes getter/setter
jurzua
parents:
diff changeset
2548 if ( !jQuery.support.checkOn ) {
jurzua
parents:
diff changeset
2549 jQuery.each([ "radio", "checkbox" ], function() {
jurzua
parents:
diff changeset
2550 jQuery.valHooks[ this ] = {
jurzua
parents:
diff changeset
2551 get: function( elem ) {
jurzua
parents:
diff changeset
2552 // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
jurzua
parents:
diff changeset
2553 return elem.getAttribute("value") === null ? "on" : elem.value;
jurzua
parents:
diff changeset
2554 }
jurzua
parents:
diff changeset
2555 };
jurzua
parents:
diff changeset
2556 });
jurzua
parents:
diff changeset
2557 }
jurzua
parents:
diff changeset
2558 jQuery.each([ "radio", "checkbox" ], function() {
jurzua
parents:
diff changeset
2559 jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
jurzua
parents:
diff changeset
2560 set: function( elem, value ) {
jurzua
parents:
diff changeset
2561 if ( jQuery.isArray( value ) ) {
jurzua
parents:
diff changeset
2562 return (elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0);
jurzua
parents:
diff changeset
2563 }
jurzua
parents:
diff changeset
2564 }
jurzua
parents:
diff changeset
2565 });
jurzua
parents:
diff changeset
2566 });
jurzua
parents:
diff changeset
2567
jurzua
parents:
diff changeset
2568
jurzua
parents:
diff changeset
2569
jurzua
parents:
diff changeset
2570
jurzua
parents:
diff changeset
2571 var rnamespaces = /\.(.*)$/,
jurzua
parents:
diff changeset
2572 rformElems = /^(?:textarea|input|select)$/i,
jurzua
parents:
diff changeset
2573 rperiod = /\./g,
jurzua
parents:
diff changeset
2574 rspaces = / /g,
jurzua
parents:
diff changeset
2575 rescape = /[^\w\s.|`]/g,
jurzua
parents:
diff changeset
2576 fcleanup = function( nm ) {
jurzua
parents:
diff changeset
2577 return nm.replace(rescape, "\\$&");
jurzua
parents:
diff changeset
2578 };
jurzua
parents:
diff changeset
2579
jurzua
parents:
diff changeset
2580 /*
jurzua
parents:
diff changeset
2581 * A number of helper functions used for managing events.
jurzua
parents:
diff changeset
2582 * Many of the ideas behind this code originated from
jurzua
parents:
diff changeset
2583 * Dean Edwards' addEvent library.
jurzua
parents:
diff changeset
2584 */
jurzua
parents:
diff changeset
2585 jQuery.event = {
jurzua
parents:
diff changeset
2586
jurzua
parents:
diff changeset
2587 // Bind an event to an element
jurzua
parents:
diff changeset
2588 // Original by Dean Edwards
jurzua
parents:
diff changeset
2589 add: function( elem, types, handler, data ) {
jurzua
parents:
diff changeset
2590 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
jurzua
parents:
diff changeset
2591 return;
jurzua
parents:
diff changeset
2592 }
jurzua
parents:
diff changeset
2593
jurzua
parents:
diff changeset
2594 if ( handler === false ) {
jurzua
parents:
diff changeset
2595 handler = returnFalse;
jurzua
parents:
diff changeset
2596 } else if ( !handler ) {
jurzua
parents:
diff changeset
2597 // Fixes bug #7229. Fix recommended by jdalton
jurzua
parents:
diff changeset
2598 return;
jurzua
parents:
diff changeset
2599 }
jurzua
parents:
diff changeset
2600
jurzua
parents:
diff changeset
2601 var handleObjIn, handleObj;
jurzua
parents:
diff changeset
2602
jurzua
parents:
diff changeset
2603 if ( handler.handler ) {
jurzua
parents:
diff changeset
2604 handleObjIn = handler;
jurzua
parents:
diff changeset
2605 handler = handleObjIn.handler;
jurzua
parents:
diff changeset
2606 }
jurzua
parents:
diff changeset
2607
jurzua
parents:
diff changeset
2608 // Make sure that the function being executed has a unique ID
jurzua
parents:
diff changeset
2609 if ( !handler.guid ) {
jurzua
parents:
diff changeset
2610 handler.guid = jQuery.guid++;
jurzua
parents:
diff changeset
2611 }
jurzua
parents:
diff changeset
2612
jurzua
parents:
diff changeset
2613 // Init the element's event structure
jurzua
parents:
diff changeset
2614 var elemData = jQuery._data( elem );
jurzua
parents:
diff changeset
2615
jurzua
parents:
diff changeset
2616 // If no elemData is found then we must be trying to bind to one of the
jurzua
parents:
diff changeset
2617 // banned noData elements
jurzua
parents:
diff changeset
2618 if ( !elemData ) {
jurzua
parents:
diff changeset
2619 return;
jurzua
parents:
diff changeset
2620 }
jurzua
parents:
diff changeset
2621
jurzua
parents:
diff changeset
2622 var events = elemData.events,
jurzua
parents:
diff changeset
2623 eventHandle = elemData.handle;
jurzua
parents:
diff changeset
2624
jurzua
parents:
diff changeset
2625 if ( !events ) {
jurzua
parents:
diff changeset
2626 elemData.events = events = {};
jurzua
parents:
diff changeset
2627 }
jurzua
parents:
diff changeset
2628
jurzua
parents:
diff changeset
2629 if ( !eventHandle ) {
jurzua
parents:
diff changeset
2630 elemData.handle = eventHandle = function( e ) {
jurzua
parents:
diff changeset
2631 // Discard the second event of a jQuery.event.trigger() and
jurzua
parents:
diff changeset
2632 // when an event is called after a page has unloaded
jurzua
parents:
diff changeset
2633 return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
jurzua
parents:
diff changeset
2634 jQuery.event.handle.apply( eventHandle.elem, arguments ) :
jurzua
parents:
diff changeset
2635 undefined;
jurzua
parents:
diff changeset
2636 };
jurzua
parents:
diff changeset
2637 }
jurzua
parents:
diff changeset
2638
jurzua
parents:
diff changeset
2639 // Add elem as a property of the handle function
jurzua
parents:
diff changeset
2640 // This is to prevent a memory leak with non-native events in IE.
jurzua
parents:
diff changeset
2641 eventHandle.elem = elem;
jurzua
parents:
diff changeset
2642
jurzua
parents:
diff changeset
2643 // Handle multiple events separated by a space
jurzua
parents:
diff changeset
2644 // jQuery(...).bind("mouseover mouseout", fn);
jurzua
parents:
diff changeset
2645 types = types.split(" ");
jurzua
parents:
diff changeset
2646
jurzua
parents:
diff changeset
2647 var type, i = 0, namespaces;
jurzua
parents:
diff changeset
2648
jurzua
parents:
diff changeset
2649 while ( (type = types[ i++ ]) ) {
jurzua
parents:
diff changeset
2650 handleObj = handleObjIn ?
jurzua
parents:
diff changeset
2651 jQuery.extend({}, handleObjIn) :
jurzua
parents:
diff changeset
2652 { handler: handler, data: data };
jurzua
parents:
diff changeset
2653
jurzua
parents:
diff changeset
2654 // Namespaced event handlers
jurzua
parents:
diff changeset
2655 if ( type.indexOf(".") > -1 ) {
jurzua
parents:
diff changeset
2656 namespaces = type.split(".");
jurzua
parents:
diff changeset
2657 type = namespaces.shift();
jurzua
parents:
diff changeset
2658 handleObj.namespace = namespaces.slice(0).sort().join(".");
jurzua
parents:
diff changeset
2659
jurzua
parents:
diff changeset
2660 } else {
jurzua
parents:
diff changeset
2661 namespaces = [];
jurzua
parents:
diff changeset
2662 handleObj.namespace = "";
jurzua
parents:
diff changeset
2663 }
jurzua
parents:
diff changeset
2664
jurzua
parents:
diff changeset
2665 handleObj.type = type;
jurzua
parents:
diff changeset
2666 if ( !handleObj.guid ) {
jurzua
parents:
diff changeset
2667 handleObj.guid = handler.guid;
jurzua
parents:
diff changeset
2668 }
jurzua
parents:
diff changeset
2669
jurzua
parents:
diff changeset
2670 // Get the current list of functions bound to this event
jurzua
parents:
diff changeset
2671 var handlers = events[ type ],
jurzua
parents:
diff changeset
2672 special = jQuery.event.special[ type ] || {};
jurzua
parents:
diff changeset
2673
jurzua
parents:
diff changeset
2674 // Init the event handler queue
jurzua
parents:
diff changeset
2675 if ( !handlers ) {
jurzua
parents:
diff changeset
2676 handlers = events[ type ] = [];
jurzua
parents:
diff changeset
2677
jurzua
parents:
diff changeset
2678 // Check for a special event handler
jurzua
parents:
diff changeset
2679 // Only use addEventListener/attachEvent if the special
jurzua
parents:
diff changeset
2680 // events handler returns false
jurzua
parents:
diff changeset
2681 if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
jurzua
parents:
diff changeset
2682 // Bind the global event handler to the element
jurzua
parents:
diff changeset
2683 if ( elem.addEventListener ) {
jurzua
parents:
diff changeset
2684 elem.addEventListener( type, eventHandle, false );
jurzua
parents:
diff changeset
2685
jurzua
parents:
diff changeset
2686 } else if ( elem.attachEvent ) {
jurzua
parents:
diff changeset
2687 elem.attachEvent( "on" + type, eventHandle );
jurzua
parents:
diff changeset
2688 }
jurzua
parents:
diff changeset
2689 }
jurzua
parents:
diff changeset
2690 }
jurzua
parents:
diff changeset
2691
jurzua
parents:
diff changeset
2692 if ( special.add ) {
jurzua
parents:
diff changeset
2693 special.add.call( elem, handleObj );
jurzua
parents:
diff changeset
2694
jurzua
parents:
diff changeset
2695 if ( !handleObj.handler.guid ) {
jurzua
parents:
diff changeset
2696 handleObj.handler.guid = handler.guid;
jurzua
parents:
diff changeset
2697 }
jurzua
parents:
diff changeset
2698 }
jurzua
parents:
diff changeset
2699
jurzua
parents:
diff changeset
2700 // Add the function to the element's handler list
jurzua
parents:
diff changeset
2701 handlers.push( handleObj );
jurzua
parents:
diff changeset
2702
jurzua
parents:
diff changeset
2703 // Keep track of which events have been used, for event optimization
jurzua
parents:
diff changeset
2704 jQuery.event.global[ type ] = true;
jurzua
parents:
diff changeset
2705 }
jurzua
parents:
diff changeset
2706
jurzua
parents:
diff changeset
2707 // Nullify elem to prevent memory leaks in IE
jurzua
parents:
diff changeset
2708 elem = null;
jurzua
parents:
diff changeset
2709 },
jurzua
parents:
diff changeset
2710
jurzua
parents:
diff changeset
2711 global: {},
jurzua
parents:
diff changeset
2712
jurzua
parents:
diff changeset
2713 // Detach an event or set of events from an element
jurzua
parents:
diff changeset
2714 remove: function( elem, types, handler, pos ) {
jurzua
parents:
diff changeset
2715 // don't do events on text and comment nodes
jurzua
parents:
diff changeset
2716 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
jurzua
parents:
diff changeset
2717 return;
jurzua
parents:
diff changeset
2718 }
jurzua
parents:
diff changeset
2719
jurzua
parents:
diff changeset
2720 if ( handler === false ) {
jurzua
parents:
diff changeset
2721 handler = returnFalse;
jurzua
parents:
diff changeset
2722 }
jurzua
parents:
diff changeset
2723
jurzua
parents:
diff changeset
2724 var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
jurzua
parents:
diff changeset
2725 elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
jurzua
parents:
diff changeset
2726 events = elemData && elemData.events;
jurzua
parents:
diff changeset
2727
jurzua
parents:
diff changeset
2728 if ( !elemData || !events ) {
jurzua
parents:
diff changeset
2729 return;
jurzua
parents:
diff changeset
2730 }
jurzua
parents:
diff changeset
2731
jurzua
parents:
diff changeset
2732 // types is actually an event object here
jurzua
parents:
diff changeset
2733 if ( types && types.type ) {
jurzua
parents:
diff changeset
2734 handler = types.handler;
jurzua
parents:
diff changeset
2735 types = types.type;
jurzua
parents:
diff changeset
2736 }
jurzua
parents:
diff changeset
2737
jurzua
parents:
diff changeset
2738 // Unbind all events for the element
jurzua
parents:
diff changeset
2739 if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
jurzua
parents:
diff changeset
2740 types = types || "";
jurzua
parents:
diff changeset
2741
jurzua
parents:
diff changeset
2742 for ( type in events ) {
jurzua
parents:
diff changeset
2743 jQuery.event.remove( elem, type + types );
jurzua
parents:
diff changeset
2744 }
jurzua
parents:
diff changeset
2745
jurzua
parents:
diff changeset
2746 return;
jurzua
parents:
diff changeset
2747 }
jurzua
parents:
diff changeset
2748
jurzua
parents:
diff changeset
2749 // Handle multiple events separated by a space
jurzua
parents:
diff changeset
2750 // jQuery(...).unbind("mouseover mouseout", fn);
jurzua
parents:
diff changeset
2751 types = types.split(" ");
jurzua
parents:
diff changeset
2752
jurzua
parents:
diff changeset
2753 while ( (type = types[ i++ ]) ) {
jurzua
parents:
diff changeset
2754 origType = type;
jurzua
parents:
diff changeset
2755 handleObj = null;
jurzua
parents:
diff changeset
2756 all = type.indexOf(".") < 0;
jurzua
parents:
diff changeset
2757 namespaces = [];
jurzua
parents:
diff changeset
2758
jurzua
parents:
diff changeset
2759 if ( !all ) {
jurzua
parents:
diff changeset
2760 // Namespaced event handlers
jurzua
parents:
diff changeset
2761 namespaces = type.split(".");
jurzua
parents:
diff changeset
2762 type = namespaces.shift();
jurzua
parents:
diff changeset
2763
jurzua
parents:
diff changeset
2764 namespace = new RegExp("(^|\\.)" +
jurzua
parents:
diff changeset
2765 jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
jurzua
parents:
diff changeset
2766 }
jurzua
parents:
diff changeset
2767
jurzua
parents:
diff changeset
2768 eventType = events[ type ];
jurzua
parents:
diff changeset
2769
jurzua
parents:
diff changeset
2770 if ( !eventType ) {
jurzua
parents:
diff changeset
2771 continue;
jurzua
parents:
diff changeset
2772 }
jurzua
parents:
diff changeset
2773
jurzua
parents:
diff changeset
2774 if ( !handler ) {
jurzua
parents:
diff changeset
2775 for ( j = 0; j < eventType.length; j++ ) {
jurzua
parents:
diff changeset
2776 handleObj = eventType[ j ];
jurzua
parents:
diff changeset
2777
jurzua
parents:
diff changeset
2778 if ( all || namespace.test( handleObj.namespace ) ) {
jurzua
parents:
diff changeset
2779 jQuery.event.remove( elem, origType, handleObj.handler, j );
jurzua
parents:
diff changeset
2780 eventType.splice( j--, 1 );
jurzua
parents:
diff changeset
2781 }
jurzua
parents:
diff changeset
2782 }
jurzua
parents:
diff changeset
2783
jurzua
parents:
diff changeset
2784 continue;
jurzua
parents:
diff changeset
2785 }
jurzua
parents:
diff changeset
2786
jurzua
parents:
diff changeset
2787 special = jQuery.event.special[ type ] || {};
jurzua
parents:
diff changeset
2788
jurzua
parents:
diff changeset
2789 for ( j = pos || 0; j < eventType.length; j++ ) {
jurzua
parents:
diff changeset
2790 handleObj = eventType[ j ];
jurzua
parents:
diff changeset
2791
jurzua
parents:
diff changeset
2792 if ( handler.guid === handleObj.guid ) {
jurzua
parents:
diff changeset
2793 // remove the given handler for the given type
jurzua
parents:
diff changeset
2794 if ( all || namespace.test( handleObj.namespace ) ) {
jurzua
parents:
diff changeset
2795 if ( pos == null ) {
jurzua
parents:
diff changeset
2796 eventType.splice( j--, 1 );
jurzua
parents:
diff changeset
2797 }
jurzua
parents:
diff changeset
2798
jurzua
parents:
diff changeset
2799 if ( special.remove ) {
jurzua
parents:
diff changeset
2800 special.remove.call( elem, handleObj );
jurzua
parents:
diff changeset
2801 }
jurzua
parents:
diff changeset
2802 }
jurzua
parents:
diff changeset
2803
jurzua
parents:
diff changeset
2804 if ( pos != null ) {
jurzua
parents:
diff changeset
2805 break;
jurzua
parents:
diff changeset
2806 }
jurzua
parents:
diff changeset
2807 }
jurzua
parents:
diff changeset
2808 }
jurzua
parents:
diff changeset
2809
jurzua
parents:
diff changeset
2810 // remove generic event handler if no more handlers exist
jurzua
parents:
diff changeset
2811 if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
jurzua
parents:
diff changeset
2812 if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
jurzua
parents:
diff changeset
2813 jQuery.removeEvent( elem, type, elemData.handle );
jurzua
parents:
diff changeset
2814 }
jurzua
parents:
diff changeset
2815
jurzua
parents:
diff changeset
2816 ret = null;
jurzua
parents:
diff changeset
2817 delete events[ type ];
jurzua
parents:
diff changeset
2818 }
jurzua
parents:
diff changeset
2819 }
jurzua
parents:
diff changeset
2820
jurzua
parents:
diff changeset
2821 // Remove the expando if it's no longer used
jurzua
parents:
diff changeset
2822 if ( jQuery.isEmptyObject( events ) ) {
jurzua
parents:
diff changeset
2823 var handle = elemData.handle;
jurzua
parents:
diff changeset
2824 if ( handle ) {
jurzua
parents:
diff changeset
2825 handle.elem = null;
jurzua
parents:
diff changeset
2826 }
jurzua
parents:
diff changeset
2827
jurzua
parents:
diff changeset
2828 delete elemData.events;
jurzua
parents:
diff changeset
2829 delete elemData.handle;
jurzua
parents:
diff changeset
2830
jurzua
parents:
diff changeset
2831 if ( jQuery.isEmptyObject( elemData ) ) {
jurzua
parents:
diff changeset
2832 jQuery.removeData( elem, undefined, true );
jurzua
parents:
diff changeset
2833 }
jurzua
parents:
diff changeset
2834 }
jurzua
parents:
diff changeset
2835 },
jurzua
parents:
diff changeset
2836
jurzua
parents:
diff changeset
2837 // Events that are safe to short-circuit if no handlers are attached.
jurzua
parents:
diff changeset
2838 // Native DOM events should not be added, they may have inline handlers.
jurzua
parents:
diff changeset
2839 customEvent: {
jurzua
parents:
diff changeset
2840 "getData": true,
jurzua
parents:
diff changeset
2841 "setData": true,
jurzua
parents:
diff changeset
2842 "changeData": true
jurzua
parents:
diff changeset
2843 },
jurzua
parents:
diff changeset
2844
jurzua
parents:
diff changeset
2845 trigger: function( event, data, elem, onlyHandlers ) {
jurzua
parents:
diff changeset
2846 // Event object or event type
jurzua
parents:
diff changeset
2847 var type = event.type || event,
jurzua
parents:
diff changeset
2848 namespaces = [],
jurzua
parents:
diff changeset
2849 exclusive;
jurzua
parents:
diff changeset
2850
jurzua
parents:
diff changeset
2851 if ( type.indexOf("!") >= 0 ) {
jurzua
parents:
diff changeset
2852 // Exclusive events trigger only for the exact event (no namespaces)
jurzua
parents:
diff changeset
2853 type = type.slice(0, -1);
jurzua
parents:
diff changeset
2854 exclusive = true;
jurzua
parents:
diff changeset
2855 }
jurzua
parents:
diff changeset
2856
jurzua
parents:
diff changeset
2857 if ( type.indexOf(".") >= 0 ) {
jurzua
parents:
diff changeset
2858 // Namespaced trigger; create a regexp to match event type in handle()
jurzua
parents:
diff changeset
2859 namespaces = type.split(".");
jurzua
parents:
diff changeset
2860 type = namespaces.shift();
jurzua
parents:
diff changeset
2861 namespaces.sort();
jurzua
parents:
diff changeset
2862 }
jurzua
parents:
diff changeset
2863
jurzua
parents:
diff changeset
2864 if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
jurzua
parents:
diff changeset
2865 // No jQuery handlers for this event type, and it can't have inline handlers
jurzua
parents:
diff changeset
2866 return;
jurzua
parents:
diff changeset
2867 }
jurzua
parents:
diff changeset
2868
jurzua
parents:
diff changeset
2869 // Caller can pass in an Event, Object, or just an event type string
jurzua
parents:
diff changeset
2870 event = typeof event === "object" ?
jurzua
parents:
diff changeset
2871 // jQuery.Event object
jurzua
parents:
diff changeset
2872 event[ jQuery.expando ] ? event :
jurzua
parents:
diff changeset
2873 // Object literal
jurzua
parents:
diff changeset
2874 new jQuery.Event( type, event ) :
jurzua
parents:
diff changeset
2875 // Just the event type (string)
jurzua
parents:
diff changeset
2876 new jQuery.Event( type );
jurzua
parents:
diff changeset
2877
jurzua
parents:
diff changeset
2878 event.type = type;
jurzua
parents:
diff changeset
2879 event.exclusive = exclusive;
jurzua
parents:
diff changeset
2880 event.namespace = namespaces.join(".");
jurzua
parents:
diff changeset
2881 event.namespace_re = new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)");
jurzua
parents:
diff changeset
2882
jurzua
parents:
diff changeset
2883 // triggerHandler() and global events don't bubble or run the default action
jurzua
parents:
diff changeset
2884 if ( onlyHandlers || !elem ) {
jurzua
parents:
diff changeset
2885 event.preventDefault();
jurzua
parents:
diff changeset
2886 event.stopPropagation();
jurzua
parents:
diff changeset
2887 }
jurzua
parents:
diff changeset
2888
jurzua
parents:
diff changeset
2889 // Handle a global trigger
jurzua
parents:
diff changeset
2890 if ( !elem ) {
jurzua
parents:
diff changeset
2891 // TODO: Stop taunting the data cache; remove global events and always attach to document
jurzua
parents:
diff changeset
2892 jQuery.each( jQuery.cache, function() {
jurzua
parents:
diff changeset
2893 // internalKey variable is just used to make it easier to find
jurzua
parents:
diff changeset
2894 // and potentially change this stuff later; currently it just
jurzua
parents:
diff changeset
2895 // points to jQuery.expando
jurzua
parents:
diff changeset
2896 var internalKey = jQuery.expando,
jurzua
parents:
diff changeset
2897 internalCache = this[ internalKey ];
jurzua
parents:
diff changeset
2898 if ( internalCache && internalCache.events && internalCache.events[ type ] ) {
jurzua
parents:
diff changeset
2899 jQuery.event.trigger( event, data, internalCache.handle.elem );
jurzua
parents:
diff changeset
2900 }
jurzua
parents:
diff changeset
2901 });
jurzua
parents:
diff changeset
2902 return;
jurzua
parents:
diff changeset
2903 }
jurzua
parents:
diff changeset
2904
jurzua
parents:
diff changeset
2905 // Don't do events on text and comment nodes
jurzua
parents:
diff changeset
2906 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
jurzua
parents:
diff changeset
2907 return;
jurzua
parents:
diff changeset
2908 }
jurzua
parents:
diff changeset
2909
jurzua
parents:
diff changeset
2910 // Clean up the event in case it is being reused
jurzua
parents:
diff changeset
2911 event.result = undefined;
jurzua
parents:
diff changeset
2912 event.target = elem;
jurzua
parents:
diff changeset
2913
jurzua
parents:
diff changeset
2914 // Clone any incoming data and prepend the event, creating the handler arg list
jurzua
parents:
diff changeset
2915 data = data != null ? jQuery.makeArray( data ) : [];
jurzua
parents:
diff changeset
2916 data.unshift( event );
jurzua
parents:
diff changeset
2917
jurzua
parents:
diff changeset
2918 var cur = elem,
jurzua
parents:
diff changeset
2919 // IE doesn't like method names with a colon (#3533, #8272)
jurzua
parents:
diff changeset
2920 ontype = type.indexOf(":") < 0 ? "on" + type : "";
jurzua
parents:
diff changeset
2921
jurzua
parents:
diff changeset
2922 // Fire event on the current element, then bubble up the DOM tree
jurzua
parents:
diff changeset
2923 do {
jurzua
parents:
diff changeset
2924 var handle = jQuery._data( cur, "handle" );
jurzua
parents:
diff changeset
2925
jurzua
parents:
diff changeset
2926 event.currentTarget = cur;
jurzua
parents:
diff changeset
2927 if ( handle ) {
jurzua
parents:
diff changeset
2928 handle.apply( cur, data );
jurzua
parents:
diff changeset
2929 }
jurzua
parents:
diff changeset
2930
jurzua
parents:
diff changeset
2931 // Trigger an inline bound script
jurzua
parents:
diff changeset
2932 if ( ontype && jQuery.acceptData( cur ) && cur[ ontype ] && cur[ ontype ].apply( cur, data ) === false ) {
jurzua
parents:
diff changeset
2933 event.result = false;
jurzua
parents:
diff changeset
2934 event.preventDefault();
jurzua
parents:
diff changeset
2935 }
jurzua
parents:
diff changeset
2936
jurzua
parents:
diff changeset
2937 // Bubble up to document, then to window
jurzua
parents:
diff changeset
2938 cur = cur.parentNode || cur.ownerDocument || cur === event.target.ownerDocument && window;
jurzua
parents:
diff changeset
2939 } while ( cur && !event.isPropagationStopped() );
jurzua
parents:
diff changeset
2940
jurzua
parents:
diff changeset
2941 // If nobody prevented the default action, do it now
jurzua
parents:
diff changeset
2942 if ( !event.isDefaultPrevented() ) {
jurzua
parents:
diff changeset
2943 var old,
jurzua
parents:
diff changeset
2944 special = jQuery.event.special[ type ] || {};
jurzua
parents:
diff changeset
2945
jurzua
parents:
diff changeset
2946 if ( (!special._default || special._default.call( elem.ownerDocument, event ) === false) &&
jurzua
parents:
diff changeset
2947 !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
jurzua
parents:
diff changeset
2948
jurzua
parents:
diff changeset
2949 // Call a native DOM method on the target with the same name name as the event.
jurzua
parents:
diff changeset
2950 // Can't use an .isFunction)() check here because IE6/7 fails that test.
jurzua
parents:
diff changeset
2951 // IE<9 dies on focus to hidden element (#1486), may want to revisit a try/catch.
jurzua
parents:
diff changeset
2952 try {
jurzua
parents:
diff changeset
2953 if ( ontype && elem[ type ] ) {
jurzua
parents:
diff changeset
2954 // Don't re-trigger an onFOO event when we call its FOO() method
jurzua
parents:
diff changeset
2955 old = elem[ ontype ];
jurzua
parents:
diff changeset
2956
jurzua
parents:
diff changeset
2957 if ( old ) {
jurzua
parents:
diff changeset
2958 elem[ ontype ] = null;
jurzua
parents:
diff changeset
2959 }
jurzua
parents:
diff changeset
2960
jurzua
parents:
diff changeset
2961 jQuery.event.triggered = type;
jurzua
parents:
diff changeset
2962 elem[ type ]();
jurzua
parents:
diff changeset
2963 }
jurzua
parents:
diff changeset
2964 } catch ( ieError ) {}
jurzua
parents:
diff changeset
2965
jurzua
parents:
diff changeset
2966 if ( old ) {
jurzua
parents:
diff changeset
2967 elem[ ontype ] = old;
jurzua
parents:
diff changeset
2968 }
jurzua
parents:
diff changeset
2969
jurzua
parents:
diff changeset
2970 jQuery.event.triggered = undefined;
jurzua
parents:
diff changeset
2971 }
jurzua
parents:
diff changeset
2972 }
jurzua
parents:
diff changeset
2973
jurzua
parents:
diff changeset
2974 return event.result;
jurzua
parents:
diff changeset
2975 },
jurzua
parents:
diff changeset
2976
jurzua
parents:
diff changeset
2977 handle: function( event ) {
jurzua
parents:
diff changeset
2978 event = jQuery.event.fix( event || window.event );
jurzua
parents:
diff changeset
2979 // Snapshot the handlers list since a called handler may add/remove events.
jurzua
parents:
diff changeset
2980 var handlers = ((jQuery._data( this, "events" ) || {})[ event.type ] || []).slice(0),
jurzua
parents:
diff changeset
2981 run_all = !event.exclusive && !event.namespace,
jurzua
parents:
diff changeset
2982 args = Array.prototype.slice.call( arguments, 0 );
jurzua
parents:
diff changeset
2983
jurzua
parents:
diff changeset
2984 // Use the fix-ed Event rather than the (read-only) native event
jurzua
parents:
diff changeset
2985 args[0] = event;
jurzua
parents:
diff changeset
2986 event.currentTarget = this;
jurzua
parents:
diff changeset
2987
jurzua
parents:
diff changeset
2988 for ( var j = 0, l = handlers.length; j < l; j++ ) {
jurzua
parents:
diff changeset
2989 var handleObj = handlers[ j ];
jurzua
parents:
diff changeset
2990
jurzua
parents:
diff changeset
2991 // Triggered event must 1) be non-exclusive and have no namespace, or
jurzua
parents:
diff changeset
2992 // 2) have namespace(s) a subset or equal to those in the bound event.
jurzua
parents:
diff changeset
2993 if ( run_all || event.namespace_re.test( handleObj.namespace ) ) {
jurzua
parents:
diff changeset
2994 // Pass in a reference to the handler function itself
jurzua
parents:
diff changeset
2995 // So that we can later remove it
jurzua
parents:
diff changeset
2996 event.handler = handleObj.handler;
jurzua
parents:
diff changeset
2997 event.data = handleObj.data;
jurzua
parents:
diff changeset
2998 event.handleObj = handleObj;
jurzua
parents:
diff changeset
2999
jurzua
parents:
diff changeset
3000 var ret = handleObj.handler.apply( this, args );
jurzua
parents:
diff changeset
3001
jurzua
parents:
diff changeset
3002 if ( ret !== undefined ) {
jurzua
parents:
diff changeset
3003 event.result = ret;
jurzua
parents:
diff changeset
3004 if ( ret === false ) {
jurzua
parents:
diff changeset
3005 event.preventDefault();
jurzua
parents:
diff changeset
3006 event.stopPropagation();
jurzua
parents:
diff changeset
3007 }
jurzua
parents:
diff changeset
3008 }
jurzua
parents:
diff changeset
3009
jurzua
parents:
diff changeset
3010 if ( event.isImmediatePropagationStopped() ) {
jurzua
parents:
diff changeset
3011 break;
jurzua
parents:
diff changeset
3012 }
jurzua
parents:
diff changeset
3013 }
jurzua
parents:
diff changeset
3014 }
jurzua
parents:
diff changeset
3015 return event.result;
jurzua
parents:
diff changeset
3016 },
jurzua
parents:
diff changeset
3017
jurzua
parents:
diff changeset
3018 props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
jurzua
parents:
diff changeset
3019
jurzua
parents:
diff changeset
3020 fix: function( event ) {
jurzua
parents:
diff changeset
3021 if ( event[ jQuery.expando ] ) {
jurzua
parents:
diff changeset
3022 return event;
jurzua
parents:
diff changeset
3023 }
jurzua
parents:
diff changeset
3024
jurzua
parents:
diff changeset
3025 // store a copy of the original event object
jurzua
parents:
diff changeset
3026 // and "clone" to set read-only properties
jurzua
parents:
diff changeset
3027 var originalEvent = event;
jurzua
parents:
diff changeset
3028 event = jQuery.Event( originalEvent );
jurzua
parents:
diff changeset
3029
jurzua
parents:
diff changeset
3030 for ( var i = this.props.length, prop; i; ) {
jurzua
parents:
diff changeset
3031 prop = this.props[ --i ];
jurzua
parents:
diff changeset
3032 event[ prop ] = originalEvent[ prop ];
jurzua
parents:
diff changeset
3033 }
jurzua
parents:
diff changeset
3034
jurzua
parents:
diff changeset
3035 // Fix target property, if necessary
jurzua
parents:
diff changeset
3036 if ( !event.target ) {
jurzua
parents:
diff changeset
3037 // Fixes #1925 where srcElement might not be defined either
jurzua
parents:
diff changeset
3038 event.target = event.srcElement || document;
jurzua
parents:
diff changeset
3039 }
jurzua
parents:
diff changeset
3040
jurzua
parents:
diff changeset
3041 // check if target is a textnode (safari)
jurzua
parents:
diff changeset
3042 if ( event.target.nodeType === 3 ) {
jurzua
parents:
diff changeset
3043 event.target = event.target.parentNode;
jurzua
parents:
diff changeset
3044 }
jurzua
parents:
diff changeset
3045
jurzua
parents:
diff changeset
3046 // Add relatedTarget, if necessary
jurzua
parents:
diff changeset
3047 if ( !event.relatedTarget && event.fromElement ) {
jurzua
parents:
diff changeset
3048 event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
jurzua
parents:
diff changeset
3049 }
jurzua
parents:
diff changeset
3050
jurzua
parents:
diff changeset
3051 // Calculate pageX/Y if missing and clientX/Y available
jurzua
parents:
diff changeset
3052 if ( event.pageX == null && event.clientX != null ) {
jurzua
parents:
diff changeset
3053 var eventDocument = event.target.ownerDocument || document,
jurzua
parents:
diff changeset
3054 doc = eventDocument.documentElement,
jurzua
parents:
diff changeset
3055 body = eventDocument.body;
jurzua
parents:
diff changeset
3056
jurzua
parents:
diff changeset
3057 event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
jurzua
parents:
diff changeset
3058 event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
jurzua
parents:
diff changeset
3059 }
jurzua
parents:
diff changeset
3060
jurzua
parents:
diff changeset
3061 // Add which for key events
jurzua
parents:
diff changeset
3062 if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
jurzua
parents:
diff changeset
3063 event.which = event.charCode != null ? event.charCode : event.keyCode;
jurzua
parents:
diff changeset
3064 }
jurzua
parents:
diff changeset
3065
jurzua
parents:
diff changeset
3066 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
jurzua
parents:
diff changeset
3067 if ( !event.metaKey && event.ctrlKey ) {
jurzua
parents:
diff changeset
3068 event.metaKey = event.ctrlKey;
jurzua
parents:
diff changeset
3069 }
jurzua
parents:
diff changeset
3070
jurzua
parents:
diff changeset
3071 // Add which for click: 1 === left; 2 === middle; 3 === right
jurzua
parents:
diff changeset
3072 // Note: button is not normalized, so don't use it
jurzua
parents:
diff changeset
3073 if ( !event.which && event.button !== undefined ) {
jurzua
parents:
diff changeset
3074 event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
jurzua
parents:
diff changeset
3075 }
jurzua
parents:
diff changeset
3076
jurzua
parents:
diff changeset
3077 return event;
jurzua
parents:
diff changeset
3078 },
jurzua
parents:
diff changeset
3079
jurzua
parents:
diff changeset
3080 // Deprecated, use jQuery.guid instead
jurzua
parents:
diff changeset
3081 guid: 1E8,
jurzua
parents:
diff changeset
3082
jurzua
parents:
diff changeset
3083 // Deprecated, use jQuery.proxy instead
jurzua
parents:
diff changeset
3084 proxy: jQuery.proxy,
jurzua
parents:
diff changeset
3085
jurzua
parents:
diff changeset
3086 special: {
jurzua
parents:
diff changeset
3087 ready: {
jurzua
parents:
diff changeset
3088 // Make sure the ready event is setup
jurzua
parents:
diff changeset
3089 setup: jQuery.bindReady,
jurzua
parents:
diff changeset
3090 teardown: jQuery.noop
jurzua
parents:
diff changeset
3091 },
jurzua
parents:
diff changeset
3092
jurzua
parents:
diff changeset
3093 live: {
jurzua
parents:
diff changeset
3094 add: function( handleObj ) {
jurzua
parents:
diff changeset
3095 jQuery.event.add( this,
jurzua
parents:
diff changeset
3096 liveConvert( handleObj.origType, handleObj.selector ),
jurzua
parents:
diff changeset
3097 jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
jurzua
parents:
diff changeset
3098 },
jurzua
parents:
diff changeset
3099
jurzua
parents:
diff changeset
3100 remove: function( handleObj ) {
jurzua
parents:
diff changeset
3101 jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
jurzua
parents:
diff changeset
3102 }
jurzua
parents:
diff changeset
3103 },
jurzua
parents:
diff changeset
3104
jurzua
parents:
diff changeset
3105 beforeunload: {
jurzua
parents:
diff changeset
3106 setup: function( data, namespaces, eventHandle ) {
jurzua
parents:
diff changeset
3107 // We only want to do this special case on windows
jurzua
parents:
diff changeset
3108 if ( jQuery.isWindow( this ) ) {
jurzua
parents:
diff changeset
3109 this.onbeforeunload = eventHandle;
jurzua
parents:
diff changeset
3110 }
jurzua
parents:
diff changeset
3111 },
jurzua
parents:
diff changeset
3112
jurzua
parents:
diff changeset
3113 teardown: function( namespaces, eventHandle ) {
jurzua
parents:
diff changeset
3114 if ( this.onbeforeunload === eventHandle ) {
jurzua
parents:
diff changeset
3115 this.onbeforeunload = null;
jurzua
parents:
diff changeset
3116 }
jurzua
parents:
diff changeset
3117 }
jurzua
parents:
diff changeset
3118 }
jurzua
parents:
diff changeset
3119 }
jurzua
parents:
diff changeset
3120 };
jurzua
parents:
diff changeset
3121
jurzua
parents:
diff changeset
3122 jQuery.removeEvent = document.removeEventListener ?
jurzua
parents:
diff changeset
3123 function( elem, type, handle ) {
jurzua
parents:
diff changeset
3124 if ( elem.removeEventListener ) {
jurzua
parents:
diff changeset
3125 elem.removeEventListener( type, handle, false );
jurzua
parents:
diff changeset
3126 }
jurzua
parents:
diff changeset
3127 } :
jurzua
parents:
diff changeset
3128 function( elem, type, handle ) {
jurzua
parents:
diff changeset
3129 if ( elem.detachEvent ) {
jurzua
parents:
diff changeset
3130 elem.detachEvent( "on" + type, handle );
jurzua
parents:
diff changeset
3131 }
jurzua
parents:
diff changeset
3132 };
jurzua
parents:
diff changeset
3133
jurzua
parents:
diff changeset
3134 jQuery.Event = function( src, props ) {
jurzua
parents:
diff changeset
3135 // Allow instantiation without the 'new' keyword
jurzua
parents:
diff changeset
3136 if ( !this.preventDefault ) {
jurzua
parents:
diff changeset
3137 return new jQuery.Event( src, props );
jurzua
parents:
diff changeset
3138 }
jurzua
parents:
diff changeset
3139
jurzua
parents:
diff changeset
3140 // Event object
jurzua
parents:
diff changeset
3141 if ( src && src.type ) {
jurzua
parents:
diff changeset
3142 this.originalEvent = src;
jurzua
parents:
diff changeset
3143 this.type = src.type;
jurzua
parents:
diff changeset
3144
jurzua
parents:
diff changeset
3145 // Events bubbling up the document may have been marked as prevented
jurzua
parents:
diff changeset
3146 // by a handler lower down the tree; reflect the correct value.
jurzua
parents:
diff changeset
3147 this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false ||
jurzua
parents:
diff changeset
3148 src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;
jurzua
parents:
diff changeset
3149
jurzua
parents:
diff changeset
3150 // Event type
jurzua
parents:
diff changeset
3151 } else {
jurzua
parents:
diff changeset
3152 this.type = src;
jurzua
parents:
diff changeset
3153 }
jurzua
parents:
diff changeset
3154
jurzua
parents:
diff changeset
3155 // Put explicitly provided properties onto the event object
jurzua
parents:
diff changeset
3156 if ( props ) {
jurzua
parents:
diff changeset
3157 jQuery.extend( this, props );
jurzua
parents:
diff changeset
3158 }
jurzua
parents:
diff changeset
3159
jurzua
parents:
diff changeset
3160 // timeStamp is buggy for some events on Firefox(#3843)
jurzua
parents:
diff changeset
3161 // So we won't rely on the native value
jurzua
parents:
diff changeset
3162 this.timeStamp = jQuery.now();
jurzua
parents:
diff changeset
3163
jurzua
parents:
diff changeset
3164 // Mark it as fixed
jurzua
parents:
diff changeset
3165 this[ jQuery.expando ] = true;
jurzua
parents:
diff changeset
3166 };
jurzua
parents:
diff changeset
3167
jurzua
parents:
diff changeset
3168 function returnFalse() {
jurzua
parents:
diff changeset
3169 return false;
jurzua
parents:
diff changeset
3170 }
jurzua
parents:
diff changeset
3171 function returnTrue() {
jurzua
parents:
diff changeset
3172 return true;
jurzua
parents:
diff changeset
3173 }
jurzua
parents:
diff changeset
3174
jurzua
parents:
diff changeset
3175 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
jurzua
parents:
diff changeset
3176 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
jurzua
parents:
diff changeset
3177 jQuery.Event.prototype = {
jurzua
parents:
diff changeset
3178 preventDefault: function() {
jurzua
parents:
diff changeset
3179 this.isDefaultPrevented = returnTrue;
jurzua
parents:
diff changeset
3180
jurzua
parents:
diff changeset
3181 var e = this.originalEvent;
jurzua
parents:
diff changeset
3182 if ( !e ) {
jurzua
parents:
diff changeset
3183 return;
jurzua
parents:
diff changeset
3184 }
jurzua
parents:
diff changeset
3185
jurzua
parents:
diff changeset
3186 // if preventDefault exists run it on the original event
jurzua
parents:
diff changeset
3187 if ( e.preventDefault ) {
jurzua
parents:
diff changeset
3188 e.preventDefault();
jurzua
parents:
diff changeset
3189
jurzua
parents:
diff changeset
3190 // otherwise set the returnValue property of the original event to false (IE)
jurzua
parents:
diff changeset
3191 } else {
jurzua
parents:
diff changeset
3192 e.returnValue = false;
jurzua
parents:
diff changeset
3193 }
jurzua
parents:
diff changeset
3194 },
jurzua
parents:
diff changeset
3195 stopPropagation: function() {
jurzua
parents:
diff changeset
3196 this.isPropagationStopped = returnTrue;
jurzua
parents:
diff changeset
3197
jurzua
parents:
diff changeset
3198 var e = this.originalEvent;
jurzua
parents:
diff changeset
3199 if ( !e ) {
jurzua
parents:
diff changeset
3200 return;
jurzua
parents:
diff changeset
3201 }
jurzua
parents:
diff changeset
3202 // if stopPropagation exists run it on the original event
jurzua
parents:
diff changeset
3203 if ( e.stopPropagation ) {
jurzua
parents:
diff changeset
3204 e.stopPropagation();
jurzua
parents:
diff changeset
3205 }
jurzua
parents:
diff changeset
3206 // otherwise set the cancelBubble property of the original event to true (IE)
jurzua
parents:
diff changeset
3207 e.cancelBubble = true;
jurzua
parents:
diff changeset
3208 },
jurzua
parents:
diff changeset
3209 stopImmediatePropagation: function() {
jurzua
parents:
diff changeset
3210 this.isImmediatePropagationStopped = returnTrue;
jurzua
parents:
diff changeset
3211 this.stopPropagation();
jurzua
parents:
diff changeset
3212 },
jurzua
parents:
diff changeset
3213 isDefaultPrevented: returnFalse,
jurzua
parents:
diff changeset
3214 isPropagationStopped: returnFalse,
jurzua
parents:
diff changeset
3215 isImmediatePropagationStopped: returnFalse
jurzua
parents:
diff changeset
3216 };
jurzua
parents:
diff changeset
3217
jurzua
parents:
diff changeset
3218 // Checks if an event happened on an element within another element
jurzua
parents:
diff changeset
3219 // Used in jQuery.event.special.mouseenter and mouseleave handlers
jurzua
parents:
diff changeset
3220 var withinElement = function( event ) {
jurzua
parents:
diff changeset
3221
jurzua
parents:
diff changeset
3222 // Check if mouse(over|out) are still within the same parent element
jurzua
parents:
diff changeset
3223 var related = event.relatedTarget,
jurzua
parents:
diff changeset
3224 inside = false,
jurzua
parents:
diff changeset
3225 eventType = event.type;
jurzua
parents:
diff changeset
3226
jurzua
parents:
diff changeset
3227 event.type = event.data;
jurzua
parents:
diff changeset
3228
jurzua
parents:
diff changeset
3229 if ( related !== this ) {
jurzua
parents:
diff changeset
3230
jurzua
parents:
diff changeset
3231 if ( related ) {
jurzua
parents:
diff changeset
3232 inside = jQuery.contains( this, related );
jurzua
parents:
diff changeset
3233 }
jurzua
parents:
diff changeset
3234
jurzua
parents:
diff changeset
3235 if ( !inside ) {
jurzua
parents:
diff changeset
3236
jurzua
parents:
diff changeset
3237 jQuery.event.handle.apply( this, arguments );
jurzua
parents:
diff changeset
3238
jurzua
parents:
diff changeset
3239 event.type = eventType;
jurzua
parents:
diff changeset
3240 }
jurzua
parents:
diff changeset
3241 }
jurzua
parents:
diff changeset
3242 },
jurzua
parents:
diff changeset
3243
jurzua
parents:
diff changeset
3244 // In case of event delegation, we only need to rename the event.type,
jurzua
parents:
diff changeset
3245 // liveHandler will take care of the rest.
jurzua
parents:
diff changeset
3246 delegate = function( event ) {
jurzua
parents:
diff changeset
3247 event.type = event.data;
jurzua
parents:
diff changeset
3248 jQuery.event.handle.apply( this, arguments );
jurzua
parents:
diff changeset
3249 };
jurzua
parents:
diff changeset
3250
jurzua
parents:
diff changeset
3251 // Create mouseenter and mouseleave events
jurzua
parents:
diff changeset
3252 jQuery.each({
jurzua
parents:
diff changeset
3253 mouseenter: "mouseover",
jurzua
parents:
diff changeset
3254 mouseleave: "mouseout"
jurzua
parents:
diff changeset
3255 }, function( orig, fix ) {
jurzua
parents:
diff changeset
3256 jQuery.event.special[ orig ] = {
jurzua
parents:
diff changeset
3257 setup: function( data ) {
jurzua
parents:
diff changeset
3258 jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
jurzua
parents:
diff changeset
3259 },
jurzua
parents:
diff changeset
3260 teardown: function( data ) {
jurzua
parents:
diff changeset
3261 jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
jurzua
parents:
diff changeset
3262 }
jurzua
parents:
diff changeset
3263 };
jurzua
parents:
diff changeset
3264 });
jurzua
parents:
diff changeset
3265
jurzua
parents:
diff changeset
3266 // submit delegation
jurzua
parents:
diff changeset
3267 if ( !jQuery.support.submitBubbles ) {
jurzua
parents:
diff changeset
3268
jurzua
parents:
diff changeset
3269 jQuery.event.special.submit = {
jurzua
parents:
diff changeset
3270 setup: function( data, namespaces ) {
jurzua
parents:
diff changeset
3271 if ( !jQuery.nodeName( this, "form" ) ) {
jurzua
parents:
diff changeset
3272 jQuery.event.add(this, "click.specialSubmit", function( e ) {
jurzua
parents:
diff changeset
3273 var elem = e.target,
jurzua
parents:
diff changeset
3274 type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
jurzua
parents:
diff changeset
3275
jurzua
parents:
diff changeset
3276 if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
jurzua
parents:
diff changeset
3277 trigger( "submit", this, arguments );
jurzua
parents:
diff changeset
3278 }
jurzua
parents:
diff changeset
3279 });
jurzua
parents:
diff changeset
3280
jurzua
parents:
diff changeset
3281 jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
jurzua
parents:
diff changeset
3282 var elem = e.target,
jurzua
parents:
diff changeset
3283 type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
jurzua
parents:
diff changeset
3284
jurzua
parents:
diff changeset
3285 if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
jurzua
parents:
diff changeset
3286 trigger( "submit", this, arguments );
jurzua
parents:
diff changeset
3287 }
jurzua
parents:
diff changeset
3288 });
jurzua
parents:
diff changeset
3289
jurzua
parents:
diff changeset
3290 } else {
jurzua
parents:
diff changeset
3291 return false;
jurzua
parents:
diff changeset
3292 }
jurzua
parents:
diff changeset
3293 },
jurzua
parents:
diff changeset
3294
jurzua
parents:
diff changeset
3295 teardown: function( namespaces ) {
jurzua
parents:
diff changeset
3296 jQuery.event.remove( this, ".specialSubmit" );
jurzua
parents:
diff changeset
3297 }
jurzua
parents:
diff changeset
3298 };
jurzua
parents:
diff changeset
3299
jurzua
parents:
diff changeset
3300 }
jurzua
parents:
diff changeset
3301
jurzua
parents:
diff changeset
3302 // change delegation, happens here so we have bind.
jurzua
parents:
diff changeset
3303 if ( !jQuery.support.changeBubbles ) {
jurzua
parents:
diff changeset
3304
jurzua
parents:
diff changeset
3305 var changeFilters,
jurzua
parents:
diff changeset
3306
jurzua
parents:
diff changeset
3307 getVal = function( elem ) {
jurzua
parents:
diff changeset
3308 var type = jQuery.nodeName( elem, "input" ) ? elem.type : "",
jurzua
parents:
diff changeset
3309 val = elem.value;
jurzua
parents:
diff changeset
3310
jurzua
parents:
diff changeset
3311 if ( type === "radio" || type === "checkbox" ) {
jurzua
parents:
diff changeset
3312 val = elem.checked;
jurzua
parents:
diff changeset
3313
jurzua
parents:
diff changeset
3314 } else if ( type === "select-multiple" ) {
jurzua
parents:
diff changeset
3315 val = elem.selectedIndex > -1 ?
jurzua
parents:
diff changeset
3316 jQuery.map( elem.options, function( elem ) {
jurzua
parents:
diff changeset
3317 return elem.selected;
jurzua
parents:
diff changeset
3318 }).join("-") :
jurzua
parents:
diff changeset
3319 "";
jurzua
parents:
diff changeset
3320
jurzua
parents:
diff changeset
3321 } else if ( jQuery.nodeName( elem, "select" ) ) {
jurzua
parents:
diff changeset
3322 val = elem.selectedIndex;
jurzua
parents:
diff changeset
3323 }
jurzua
parents:
diff changeset
3324
jurzua
parents:
diff changeset
3325 return val;
jurzua
parents:
diff changeset
3326 },
jurzua
parents:
diff changeset
3327
jurzua
parents:
diff changeset
3328 testChange = function testChange( e ) {
jurzua
parents:
diff changeset
3329 var elem = e.target, data, val;
jurzua
parents:
diff changeset
3330
jurzua
parents:
diff changeset
3331 if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) {
jurzua
parents:
diff changeset
3332 return;
jurzua
parents:
diff changeset
3333 }
jurzua
parents:
diff changeset
3334
jurzua
parents:
diff changeset
3335 data = jQuery._data( elem, "_change_data" );
jurzua
parents:
diff changeset
3336 val = getVal(elem);
jurzua
parents:
diff changeset
3337
jurzua
parents:
diff changeset
3338 // the current data will be also retrieved by beforeactivate
jurzua
parents:
diff changeset
3339 if ( e.type !== "focusout" || elem.type !== "radio" ) {
jurzua
parents:
diff changeset
3340 jQuery._data( elem, "_change_data", val );
jurzua
parents:
diff changeset
3341 }
jurzua
parents:
diff changeset
3342
jurzua
parents:
diff changeset
3343 if ( data === undefined || val === data ) {
jurzua
parents:
diff changeset
3344 return;
jurzua
parents:
diff changeset
3345 }
jurzua
parents:
diff changeset
3346
jurzua
parents:
diff changeset
3347 if ( data != null || val ) {
jurzua
parents:
diff changeset
3348 e.type = "change";
jurzua
parents:
diff changeset
3349 e.liveFired = undefined;
jurzua
parents:
diff changeset
3350 jQuery.event.trigger( e, arguments[1], elem );
jurzua
parents:
diff changeset
3351 }
jurzua
parents:
diff changeset
3352 };
jurzua
parents:
diff changeset
3353
jurzua
parents:
diff changeset
3354 jQuery.event.special.change = {
jurzua
parents:
diff changeset
3355 filters: {
jurzua
parents:
diff changeset
3356 focusout: testChange,
jurzua
parents:
diff changeset
3357
jurzua
parents:
diff changeset
3358 beforedeactivate: testChange,
jurzua
parents:
diff changeset
3359
jurzua
parents:
diff changeset
3360 click: function( e ) {
jurzua
parents:
diff changeset
3361 var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
jurzua
parents:
diff changeset
3362
jurzua
parents:
diff changeset
3363 if ( type === "radio" || type === "checkbox" || jQuery.nodeName( elem, "select" ) ) {
jurzua
parents:
diff changeset
3364 testChange.call( this, e );
jurzua
parents:
diff changeset
3365 }
jurzua
parents:
diff changeset
3366 },
jurzua
parents:
diff changeset
3367
jurzua
parents:
diff changeset
3368 // Change has to be called before submit
jurzua
parents:
diff changeset
3369 // Keydown will be called before keypress, which is used in submit-event delegation
jurzua
parents:
diff changeset
3370 keydown: function( e ) {
jurzua
parents:
diff changeset
3371 var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
jurzua
parents:
diff changeset
3372
jurzua
parents:
diff changeset
3373 if ( (e.keyCode === 13 && !jQuery.nodeName( elem, "textarea" ) ) ||
jurzua
parents:
diff changeset
3374 (e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
jurzua
parents:
diff changeset
3375 type === "select-multiple" ) {
jurzua
parents:
diff changeset
3376 testChange.call( this, e );
jurzua
parents:
diff changeset
3377 }
jurzua
parents:
diff changeset
3378 },
jurzua
parents:
diff changeset
3379
jurzua
parents:
diff changeset
3380 // Beforeactivate happens also before the previous element is blurred
jurzua
parents:
diff changeset
3381 // with this event you can't trigger a change event, but you can store
jurzua
parents:
diff changeset
3382 // information
jurzua
parents:
diff changeset
3383 beforeactivate: function( e ) {
jurzua
parents:
diff changeset
3384 var elem = e.target;
jurzua
parents:
diff changeset
3385 jQuery._data( elem, "_change_data", getVal(elem) );
jurzua
parents:
diff changeset
3386 }
jurzua
parents:
diff changeset
3387 },
jurzua
parents:
diff changeset
3388
jurzua
parents:
diff changeset
3389 setup: function( data, namespaces ) {
jurzua
parents:
diff changeset
3390 if ( this.type === "file" ) {
jurzua
parents:
diff changeset
3391 return false;
jurzua
parents:
diff changeset
3392 }
jurzua
parents:
diff changeset
3393
jurzua
parents:
diff changeset
3394 for ( var type in changeFilters ) {
jurzua
parents:
diff changeset
3395 jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
jurzua
parents:
diff changeset
3396 }
jurzua
parents:
diff changeset
3397
jurzua
parents:
diff changeset
3398 return rformElems.test( this.nodeName );
jurzua
parents:
diff changeset
3399 },
jurzua
parents:
diff changeset
3400
jurzua
parents:
diff changeset
3401 teardown: function( namespaces ) {
jurzua
parents:
diff changeset
3402 jQuery.event.remove( this, ".specialChange" );
jurzua
parents:
diff changeset
3403
jurzua
parents:
diff changeset
3404 return rformElems.test( this.nodeName );
jurzua
parents:
diff changeset
3405 }
jurzua
parents:
diff changeset
3406 };
jurzua
parents:
diff changeset
3407
jurzua
parents:
diff changeset
3408 changeFilters = jQuery.event.special.change.filters;
jurzua
parents:
diff changeset
3409
jurzua
parents:
diff changeset
3410 // Handle when the input is .focus()'d
jurzua
parents:
diff changeset
3411 changeFilters.focus = changeFilters.beforeactivate;
jurzua
parents:
diff changeset
3412 }
jurzua
parents:
diff changeset
3413
jurzua
parents:
diff changeset
3414 function trigger( type, elem, args ) {
jurzua
parents:
diff changeset
3415 // Piggyback on a donor event to simulate a different one.
jurzua
parents:
diff changeset
3416 // Fake originalEvent to avoid donor's stopPropagation, but if the
jurzua
parents:
diff changeset
3417 // simulated event prevents default then we do the same on the donor.
jurzua
parents:
diff changeset
3418 // Don't pass args or remember liveFired; they apply to the donor event.
jurzua
parents:
diff changeset
3419 var event = jQuery.extend( {}, args[ 0 ] );
jurzua
parents:
diff changeset
3420 event.type = type;
jurzua
parents:
diff changeset
3421 event.originalEvent = {};
jurzua
parents:
diff changeset
3422 event.liveFired = undefined;
jurzua
parents:
diff changeset
3423 jQuery.event.handle.call( elem, event );
jurzua
parents:
diff changeset
3424 if ( event.isDefaultPrevented() ) {
jurzua
parents:
diff changeset
3425 args[ 0 ].preventDefault();
jurzua
parents:
diff changeset
3426 }
jurzua
parents:
diff changeset
3427 }
jurzua
parents:
diff changeset
3428
jurzua
parents:
diff changeset
3429 // Create "bubbling" focus and blur events
jurzua
parents:
diff changeset
3430 if ( !jQuery.support.focusinBubbles ) {
jurzua
parents:
diff changeset
3431 jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
jurzua
parents:
diff changeset
3432
jurzua
parents:
diff changeset
3433 // Attach a single capturing handler while someone wants focusin/focusout
jurzua
parents:
diff changeset
3434 var attaches = 0;
jurzua
parents:
diff changeset
3435
jurzua
parents:
diff changeset
3436 jQuery.event.special[ fix ] = {
jurzua
parents:
diff changeset
3437 setup: function() {
jurzua
parents:
diff changeset
3438 if ( attaches++ === 0 ) {
jurzua
parents:
diff changeset
3439 document.addEventListener( orig, handler, true );
jurzua
parents:
diff changeset
3440 }
jurzua
parents:
diff changeset
3441 },
jurzua
parents:
diff changeset
3442 teardown: function() {
jurzua
parents:
diff changeset
3443 if ( --attaches === 0 ) {
jurzua
parents:
diff changeset
3444 document.removeEventListener( orig, handler, true );
jurzua
parents:
diff changeset
3445 }
jurzua
parents:
diff changeset
3446 }
jurzua
parents:
diff changeset
3447 };
jurzua
parents:
diff changeset
3448
jurzua
parents:
diff changeset
3449 function handler( donor ) {
jurzua
parents:
diff changeset
3450 // Donor event is always a native one; fix it and switch its type.
jurzua
parents:
diff changeset
3451 // Let focusin/out handler cancel the donor focus/blur event.
jurzua
parents:
diff changeset
3452 var e = jQuery.event.fix( donor );
jurzua
parents:
diff changeset
3453 e.type = fix;
jurzua
parents:
diff changeset
3454 e.originalEvent = {};
jurzua
parents:
diff changeset
3455 jQuery.event.trigger( e, null, e.target );
jurzua
parents:
diff changeset
3456 if ( e.isDefaultPrevented() ) {
jurzua
parents:
diff changeset
3457 donor.preventDefault();
jurzua
parents:
diff changeset
3458 }
jurzua
parents:
diff changeset
3459 }
jurzua
parents:
diff changeset
3460 });
jurzua
parents:
diff changeset
3461 }
jurzua
parents:
diff changeset
3462
jurzua
parents:
diff changeset
3463 jQuery.each(["bind", "one"], function( i, name ) {
jurzua
parents:
diff changeset
3464 jQuery.fn[ name ] = function( type, data, fn ) {
jurzua
parents:
diff changeset
3465 var handler;
jurzua
parents:
diff changeset
3466
jurzua
parents:
diff changeset
3467 // Handle object literals
jurzua
parents:
diff changeset
3468 if ( typeof type === "object" ) {
jurzua
parents:
diff changeset
3469 for ( var key in type ) {
jurzua
parents:
diff changeset
3470 this[ name ](key, data, type[key], fn);
jurzua
parents:
diff changeset
3471 }
jurzua
parents:
diff changeset
3472 return this;
jurzua
parents:
diff changeset
3473 }
jurzua
parents:
diff changeset
3474
jurzua
parents:
diff changeset
3475 if ( arguments.length === 2 || data === false ) {
jurzua
parents:
diff changeset
3476 fn = data;
jurzua
parents:
diff changeset
3477 data = undefined;
jurzua
parents:
diff changeset
3478 }
jurzua
parents:
diff changeset
3479
jurzua
parents:
diff changeset
3480 if ( name === "one" ) {
jurzua
parents:
diff changeset
3481 handler = function( event ) {
jurzua
parents:
diff changeset
3482 jQuery( this ).unbind( event, handler );
jurzua
parents:
diff changeset
3483 return fn.apply( this, arguments );
jurzua
parents:
diff changeset
3484 };
jurzua
parents:
diff changeset
3485 handler.guid = fn.guid || jQuery.guid++;
jurzua
parents:
diff changeset
3486 } else {
jurzua
parents:
diff changeset
3487 handler = fn;
jurzua
parents:
diff changeset
3488 }
jurzua
parents:
diff changeset
3489
jurzua
parents:
diff changeset
3490 if ( type === "unload" && name !== "one" ) {
jurzua
parents:
diff changeset
3491 this.one( type, data, fn );
jurzua
parents:
diff changeset
3492
jurzua
parents:
diff changeset
3493 } else {
jurzua
parents:
diff changeset
3494 for ( var i = 0, l = this.length; i < l; i++ ) {
jurzua
parents:
diff changeset
3495 jQuery.event.add( this[i], type, handler, data );
jurzua
parents:
diff changeset
3496 }
jurzua
parents:
diff changeset
3497 }
jurzua
parents:
diff changeset
3498
jurzua
parents:
diff changeset
3499 return this;
jurzua
parents:
diff changeset
3500 };
jurzua
parents:
diff changeset
3501 });
jurzua
parents:
diff changeset
3502
jurzua
parents:
diff changeset
3503 jQuery.fn.extend({
jurzua
parents:
diff changeset
3504 unbind: function( type, fn ) {
jurzua
parents:
diff changeset
3505 // Handle object literals
jurzua
parents:
diff changeset
3506 if ( typeof type === "object" && !type.preventDefault ) {
jurzua
parents:
diff changeset
3507 for ( var key in type ) {
jurzua
parents:
diff changeset
3508 this.unbind(key, type[key]);
jurzua
parents:
diff changeset
3509 }
jurzua
parents:
diff changeset
3510
jurzua
parents:
diff changeset
3511 } else {
jurzua
parents:
diff changeset
3512 for ( var i = 0, l = this.length; i < l; i++ ) {
jurzua
parents:
diff changeset
3513 jQuery.event.remove( this[i], type, fn );
jurzua
parents:
diff changeset
3514 }
jurzua
parents:
diff changeset
3515 }
jurzua
parents:
diff changeset
3516
jurzua
parents:
diff changeset
3517 return this;
jurzua
parents:
diff changeset
3518 },
jurzua
parents:
diff changeset
3519
jurzua
parents:
diff changeset
3520 delegate: function( selector, types, data, fn ) {
jurzua
parents:
diff changeset
3521 return this.live( types, data, fn, selector );
jurzua
parents:
diff changeset
3522 },
jurzua
parents:
diff changeset
3523
jurzua
parents:
diff changeset
3524 undelegate: function( selector, types, fn ) {
jurzua
parents:
diff changeset
3525 if ( arguments.length === 0 ) {
jurzua
parents:
diff changeset
3526 return this.unbind( "live" );
jurzua
parents:
diff changeset
3527
jurzua
parents:
diff changeset
3528 } else {
jurzua
parents:
diff changeset
3529 return this.die( types, null, fn, selector );
jurzua
parents:
diff changeset
3530 }
jurzua
parents:
diff changeset
3531 },
jurzua
parents:
diff changeset
3532
jurzua
parents:
diff changeset
3533 trigger: function( type, data ) {
jurzua
parents:
diff changeset
3534 return this.each(function() {
jurzua
parents:
diff changeset
3535 jQuery.event.trigger( type, data, this );
jurzua
parents:
diff changeset
3536 });
jurzua
parents:
diff changeset
3537 },
jurzua
parents:
diff changeset
3538
jurzua
parents:
diff changeset
3539 triggerHandler: function( type, data ) {
jurzua
parents:
diff changeset
3540 if ( this[0] ) {
jurzua
parents:
diff changeset
3541 return jQuery.event.trigger( type, data, this[0], true );
jurzua
parents:
diff changeset
3542 }
jurzua
parents:
diff changeset
3543 },
jurzua
parents:
diff changeset
3544
jurzua
parents:
diff changeset
3545 toggle: function( fn ) {
jurzua
parents:
diff changeset
3546 // Save reference to arguments for access in closure
jurzua
parents:
diff changeset
3547 var args = arguments,
jurzua
parents:
diff changeset
3548 guid = fn.guid || jQuery.guid++,
jurzua
parents:
diff changeset
3549 i = 0,
jurzua
parents:
diff changeset
3550 toggler = function( event ) {
jurzua
parents:
diff changeset
3551 // Figure out which function to execute
jurzua
parents:
diff changeset
3552 var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
jurzua
parents:
diff changeset
3553 jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
jurzua
parents:
diff changeset
3554
jurzua
parents:
diff changeset
3555 // Make sure that clicks stop
jurzua
parents:
diff changeset
3556 event.preventDefault();
jurzua
parents:
diff changeset
3557
jurzua
parents:
diff changeset
3558 // and execute the function
jurzua
parents:
diff changeset
3559 return args[ lastToggle ].apply( this, arguments ) || false;
jurzua
parents:
diff changeset
3560 };
jurzua
parents:
diff changeset
3561
jurzua
parents:
diff changeset
3562 // link all the functions, so any of them can unbind this click handler
jurzua
parents:
diff changeset
3563 toggler.guid = guid;
jurzua
parents:
diff changeset
3564 while ( i < args.length ) {
jurzua
parents:
diff changeset
3565 args[ i++ ].guid = guid;
jurzua
parents:
diff changeset
3566 }
jurzua
parents:
diff changeset
3567
jurzua
parents:
diff changeset
3568 return this.click( toggler );
jurzua
parents:
diff changeset
3569 },
jurzua
parents:
diff changeset
3570
jurzua
parents:
diff changeset
3571 hover: function( fnOver, fnOut ) {
jurzua
parents:
diff changeset
3572 return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
jurzua
parents:
diff changeset
3573 }
jurzua
parents:
diff changeset
3574 });
jurzua
parents:
diff changeset
3575
jurzua
parents:
diff changeset
3576 var liveMap = {
jurzua
parents:
diff changeset
3577 focus: "focusin",
jurzua
parents:
diff changeset
3578 blur: "focusout",
jurzua
parents:
diff changeset
3579 mouseenter: "mouseover",
jurzua
parents:
diff changeset
3580 mouseleave: "mouseout"
jurzua
parents:
diff changeset
3581 };
jurzua
parents:
diff changeset
3582
jurzua
parents:
diff changeset
3583 jQuery.each(["live", "die"], function( i, name ) {
jurzua
parents:
diff changeset
3584 jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
jurzua
parents:
diff changeset
3585 var type, i = 0, match, namespaces, preType,
jurzua
parents:
diff changeset
3586 selector = origSelector || this.selector,
jurzua
parents:
diff changeset
3587 context = origSelector ? this : jQuery( this.context );
jurzua
parents:
diff changeset
3588
jurzua
parents:
diff changeset
3589 if ( typeof types === "object" && !types.preventDefault ) {
jurzua
parents:
diff changeset
3590 for ( var key in types ) {
jurzua
parents:
diff changeset
3591 context[ name ]( key, data, types[key], selector );
jurzua
parents:
diff changeset
3592 }
jurzua
parents:
diff changeset
3593
jurzua
parents:
diff changeset
3594 return this;
jurzua
parents:
diff changeset
3595 }
jurzua
parents:
diff changeset
3596
jurzua
parents:
diff changeset
3597 if ( name === "die" && !types &&
jurzua
parents:
diff changeset
3598 origSelector && origSelector.charAt(0) === "." ) {
jurzua
parents:
diff changeset
3599
jurzua
parents:
diff changeset
3600 context.unbind( origSelector );
jurzua
parents:
diff changeset
3601
jurzua
parents:
diff changeset
3602 return this;
jurzua
parents:
diff changeset
3603 }
jurzua
parents:
diff changeset
3604
jurzua
parents:
diff changeset
3605 if ( data === false || jQuery.isFunction( data ) ) {
jurzua
parents:
diff changeset
3606 fn = data || returnFalse;
jurzua
parents:
diff changeset
3607 data = undefined;
jurzua
parents:
diff changeset
3608 }
jurzua
parents:
diff changeset
3609
jurzua
parents:
diff changeset
3610 types = (types || "").split(" ");
jurzua
parents:
diff changeset
3611
jurzua
parents:
diff changeset
3612 while ( (type = types[ i++ ]) != null ) {
jurzua
parents:
diff changeset
3613 match = rnamespaces.exec( type );
jurzua
parents:
diff changeset
3614 namespaces = "";
jurzua
parents:
diff changeset
3615
jurzua
parents:
diff changeset
3616 if ( match ) {
jurzua
parents:
diff changeset
3617 namespaces = match[0];
jurzua
parents:
diff changeset
3618 type = type.replace( rnamespaces, "" );
jurzua
parents:
diff changeset
3619 }
jurzua
parents:
diff changeset
3620
jurzua
parents:
diff changeset
3621 if ( type === "hover" ) {
jurzua
parents:
diff changeset
3622 types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
jurzua
parents:
diff changeset
3623 continue;
jurzua
parents:
diff changeset
3624 }
jurzua
parents:
diff changeset
3625
jurzua
parents:
diff changeset
3626 preType = type;
jurzua
parents:
diff changeset
3627
jurzua
parents:
diff changeset
3628 if ( liveMap[ type ] ) {
jurzua
parents:
diff changeset
3629 types.push( liveMap[ type ] + namespaces );
jurzua
parents:
diff changeset
3630 type = type + namespaces;
jurzua
parents:
diff changeset
3631
jurzua
parents:
diff changeset
3632 } else {
jurzua
parents:
diff changeset
3633 type = (liveMap[ type ] || type) + namespaces;
jurzua
parents:
diff changeset
3634 }
jurzua
parents:
diff changeset
3635
jurzua
parents:
diff changeset
3636 if ( name === "live" ) {
jurzua
parents:
diff changeset
3637 // bind live handler
jurzua
parents:
diff changeset
3638 for ( var j = 0, l = context.length; j < l; j++ ) {
jurzua
parents:
diff changeset
3639 jQuery.event.add( context[j], "live." + liveConvert( type, selector ),
jurzua
parents:
diff changeset
3640 { data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
jurzua
parents:
diff changeset
3641 }
jurzua
parents:
diff changeset
3642
jurzua
parents:
diff changeset
3643 } else {
jurzua
parents:
diff changeset
3644 // unbind live handler
jurzua
parents:
diff changeset
3645 context.unbind( "live." + liveConvert( type, selector ), fn );
jurzua
parents:
diff changeset
3646 }
jurzua
parents:
diff changeset
3647 }
jurzua
parents:
diff changeset
3648
jurzua
parents:
diff changeset
3649 return this;
jurzua
parents:
diff changeset
3650 };
jurzua
parents:
diff changeset
3651 });
jurzua
parents:
diff changeset
3652
jurzua
parents:
diff changeset
3653 function liveHandler( event ) {
jurzua
parents:
diff changeset
3654 var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret,
jurzua
parents:
diff changeset
3655 elems = [],
jurzua
parents:
diff changeset
3656 selectors = [],
jurzua
parents:
diff changeset
3657 events = jQuery._data( this, "events" );
jurzua
parents:
diff changeset
3658
jurzua
parents:
diff changeset
3659 // Make sure we avoid non-left-click bubbling in Firefox (#3861) and disabled elements in IE (#6911)
jurzua
parents:
diff changeset
3660 if ( event.liveFired === this || !events || !events.live || event.target.disabled || event.button && event.type === "click" ) {
jurzua
parents:
diff changeset
3661 return;
jurzua
parents:
diff changeset
3662 }
jurzua
parents:
diff changeset
3663
jurzua
parents:
diff changeset
3664 if ( event.namespace ) {
jurzua
parents:
diff changeset
3665 namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
jurzua
parents:
diff changeset
3666 }
jurzua
parents:
diff changeset
3667
jurzua
parents:
diff changeset
3668 event.liveFired = this;
jurzua
parents:
diff changeset
3669
jurzua
parents:
diff changeset
3670 var live = events.live.slice(0);
jurzua
parents:
diff changeset
3671
jurzua
parents:
diff changeset
3672 for ( j = 0; j < live.length; j++ ) {
jurzua
parents:
diff changeset
3673 handleObj = live[j];
jurzua
parents:
diff changeset
3674
jurzua
parents:
diff changeset
3675 if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
jurzua
parents:
diff changeset
3676 selectors.push( handleObj.selector );
jurzua
parents:
diff changeset
3677
jurzua
parents:
diff changeset
3678 } else {
jurzua
parents:
diff changeset
3679 live.splice( j--, 1 );
jurzua
parents:
diff changeset
3680 }
jurzua
parents:
diff changeset
3681 }
jurzua
parents:
diff changeset
3682
jurzua
parents:
diff changeset
3683 match = jQuery( event.target ).closest( selectors, event.currentTarget );
jurzua
parents:
diff changeset
3684
jurzua
parents:
diff changeset
3685 for ( i = 0, l = match.length; i < l; i++ ) {
jurzua
parents:
diff changeset
3686 close = match[i];
jurzua
parents:
diff changeset
3687
jurzua
parents:
diff changeset
3688 for ( j = 0; j < live.length; j++ ) {
jurzua
parents:
diff changeset
3689 handleObj = live[j];
jurzua
parents:
diff changeset
3690
jurzua
parents:
diff changeset
3691 if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) && !close.elem.disabled ) {
jurzua
parents:
diff changeset
3692 elem = close.elem;
jurzua
parents:
diff changeset
3693 related = null;
jurzua
parents:
diff changeset
3694
jurzua
parents:
diff changeset
3695 // Those two events require additional checking
jurzua
parents:
diff changeset
3696 if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) {
jurzua
parents:
diff changeset
3697 event.type = handleObj.preType;
jurzua
parents:
diff changeset
3698 related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
jurzua
parents:
diff changeset
3699
jurzua
parents:
diff changeset
3700 // Make sure not to accidentally match a child element with the same selector
jurzua
parents:
diff changeset
3701 if ( related && jQuery.contains( elem, related ) ) {
jurzua
parents:
diff changeset
3702 related = elem;
jurzua
parents:
diff changeset
3703 }
jurzua
parents:
diff changeset
3704 }
jurzua
parents:
diff changeset
3705
jurzua
parents:
diff changeset
3706 if ( !related || related !== elem ) {
jurzua
parents:
diff changeset
3707 elems.push({ elem: elem, handleObj: handleObj, level: close.level });
jurzua
parents:
diff changeset
3708 }
jurzua
parents:
diff changeset
3709 }
jurzua
parents:
diff changeset
3710 }
jurzua
parents:
diff changeset
3711 }
jurzua
parents:
diff changeset
3712
jurzua
parents:
diff changeset
3713 for ( i = 0, l = elems.length; i < l; i++ ) {
jurzua
parents:
diff changeset
3714 match = elems[i];
jurzua
parents:
diff changeset
3715
jurzua
parents:
diff changeset
3716 if ( maxLevel && match.level > maxLevel ) {
jurzua
parents:
diff changeset
3717 break;
jurzua
parents:
diff changeset
3718 }
jurzua
parents:
diff changeset
3719
jurzua
parents:
diff changeset
3720 event.currentTarget = match.elem;
jurzua
parents:
diff changeset
3721 event.data = match.handleObj.data;
jurzua
parents:
diff changeset
3722 event.handleObj = match.handleObj;
jurzua
parents:
diff changeset
3723
jurzua
parents:
diff changeset
3724 ret = match.handleObj.origHandler.apply( match.elem, arguments );
jurzua
parents:
diff changeset
3725
jurzua
parents:
diff changeset
3726 if ( ret === false || event.isPropagationStopped() ) {
jurzua
parents:
diff changeset
3727 maxLevel = match.level;
jurzua
parents:
diff changeset
3728
jurzua
parents:
diff changeset
3729 if ( ret === false ) {
jurzua
parents:
diff changeset
3730 stop = false;
jurzua
parents:
diff changeset
3731 }
jurzua
parents:
diff changeset
3732 if ( event.isImmediatePropagationStopped() ) {
jurzua
parents:
diff changeset
3733 break;
jurzua
parents:
diff changeset
3734 }
jurzua
parents:
diff changeset
3735 }
jurzua
parents:
diff changeset
3736 }
jurzua
parents:
diff changeset
3737
jurzua
parents:
diff changeset
3738 return stop;
jurzua
parents:
diff changeset
3739 }
jurzua
parents:
diff changeset
3740
jurzua
parents:
diff changeset
3741 function liveConvert( type, selector ) {
jurzua
parents:
diff changeset
3742 return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspaces, "&");
jurzua
parents:
diff changeset
3743 }
jurzua
parents:
diff changeset
3744
jurzua
parents:
diff changeset
3745 jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
jurzua
parents:
diff changeset
3746 "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
jurzua
parents:
diff changeset
3747 "change select submit keydown keypress keyup error").split(" "), function( i, name ) {
jurzua
parents:
diff changeset
3748
jurzua
parents:
diff changeset
3749 // Handle event binding
jurzua
parents:
diff changeset
3750 jQuery.fn[ name ] = function( data, fn ) {
jurzua
parents:
diff changeset
3751 if ( fn == null ) {
jurzua
parents:
diff changeset
3752 fn = data;
jurzua
parents:
diff changeset
3753 data = null;
jurzua
parents:
diff changeset
3754 }
jurzua
parents:
diff changeset
3755
jurzua
parents:
diff changeset
3756 return arguments.length > 0 ?
jurzua
parents:
diff changeset
3757 this.bind( name, data, fn ) :
jurzua
parents:
diff changeset
3758 this.trigger( name );
jurzua
parents:
diff changeset
3759 };
jurzua
parents:
diff changeset
3760
jurzua
parents:
diff changeset
3761 if ( jQuery.attrFn ) {
jurzua
parents:
diff changeset
3762 jQuery.attrFn[ name ] = true;
jurzua
parents:
diff changeset
3763 }
jurzua
parents:
diff changeset
3764 });
jurzua
parents:
diff changeset
3765
jurzua
parents:
diff changeset
3766
jurzua
parents:
diff changeset
3767
jurzua
parents:
diff changeset
3768 /*!
jurzua
parents:
diff changeset
3769 * Sizzle CSS Selector Engine
jurzua
parents:
diff changeset
3770 * Copyright 2011, The Dojo Foundation
jurzua
parents:
diff changeset
3771 * Released under the MIT, BSD, and GPL Licenses.
jurzua
parents:
diff changeset
3772 * More information: http://sizzlejs.com/
jurzua
parents:
diff changeset
3773 */
jurzua
parents:
diff changeset
3774 (function(){
jurzua
parents:
diff changeset
3775
jurzua
parents:
diff changeset
3776 var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
jurzua
parents:
diff changeset
3777 done = 0,
jurzua
parents:
diff changeset
3778 toString = Object.prototype.toString,
jurzua
parents:
diff changeset
3779 hasDuplicate = false,
jurzua
parents:
diff changeset
3780 baseHasDuplicate = true,
jurzua
parents:
diff changeset
3781 rBackslash = /\\/g,
jurzua
parents:
diff changeset
3782 rNonWord = /\W/;
jurzua
parents:
diff changeset
3783
jurzua
parents:
diff changeset
3784 // Here we check if the JavaScript engine is using some sort of
jurzua
parents:
diff changeset
3785 // optimization where it does not always call our comparision
jurzua
parents:
diff changeset
3786 // function. If that is the case, discard the hasDuplicate value.
jurzua
parents:
diff changeset
3787 // Thus far that includes Google Chrome.
jurzua
parents:
diff changeset
3788 [0, 0].sort(function() {
jurzua
parents:
diff changeset
3789 baseHasDuplicate = false;
jurzua
parents:
diff changeset
3790 return 0;
jurzua
parents:
diff changeset
3791 });
jurzua
parents:
diff changeset
3792
jurzua
parents:
diff changeset
3793 var Sizzle = function( selector, context, results, seed ) {
jurzua
parents:
diff changeset
3794 results = results || [];
jurzua
parents:
diff changeset
3795 context = context || document;
jurzua
parents:
diff changeset
3796
jurzua
parents:
diff changeset
3797 var origContext = context;
jurzua
parents:
diff changeset
3798
jurzua
parents:
diff changeset
3799 if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
jurzua
parents:
diff changeset
3800 return [];
jurzua
parents:
diff changeset
3801 }
jurzua
parents:
diff changeset
3802
jurzua
parents:
diff changeset
3803 if ( !selector || typeof selector !== "string" ) {
jurzua
parents:
diff changeset
3804 return results;
jurzua
parents:
diff changeset
3805 }
jurzua
parents:
diff changeset
3806
jurzua
parents:
diff changeset
3807 var m, set, checkSet, extra, ret, cur, pop, i,
jurzua
parents:
diff changeset
3808 prune = true,
jurzua
parents:
diff changeset
3809 contextXML = Sizzle.isXML( context ),
jurzua
parents:
diff changeset
3810 parts = [],
jurzua
parents:
diff changeset
3811 soFar = selector;
jurzua
parents:
diff changeset
3812
jurzua
parents:
diff changeset
3813 // Reset the position of the chunker regexp (start from head)
jurzua
parents:
diff changeset
3814 do {
jurzua
parents:
diff changeset
3815 chunker.exec( "" );
jurzua
parents:
diff changeset
3816 m = chunker.exec( soFar );
jurzua
parents:
diff changeset
3817
jurzua
parents:
diff changeset
3818 if ( m ) {
jurzua
parents:
diff changeset
3819 soFar = m[3];
jurzua
parents:
diff changeset
3820
jurzua
parents:
diff changeset
3821 parts.push( m[1] );
jurzua
parents:
diff changeset
3822
jurzua
parents:
diff changeset
3823 if ( m[2] ) {
jurzua
parents:
diff changeset
3824 extra = m[3];
jurzua
parents:
diff changeset
3825 break;
jurzua
parents:
diff changeset
3826 }
jurzua
parents:
diff changeset
3827 }
jurzua
parents:
diff changeset
3828 } while ( m );
jurzua
parents:
diff changeset
3829
jurzua
parents:
diff changeset
3830 if ( parts.length > 1 && origPOS.exec( selector ) ) {
jurzua
parents:
diff changeset
3831
jurzua
parents:
diff changeset
3832 if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
jurzua
parents:
diff changeset
3833 set = posProcess( parts[0] + parts[1], context );
jurzua
parents:
diff changeset
3834
jurzua
parents:
diff changeset
3835 } else {
jurzua
parents:
diff changeset
3836 set = Expr.relative[ parts[0] ] ?
jurzua
parents:
diff changeset
3837 [ context ] :
jurzua
parents:
diff changeset
3838 Sizzle( parts.shift(), context );
jurzua
parents:
diff changeset
3839
jurzua
parents:
diff changeset
3840 while ( parts.length ) {
jurzua
parents:
diff changeset
3841 selector = parts.shift();
jurzua
parents:
diff changeset
3842
jurzua
parents:
diff changeset
3843 if ( Expr.relative[ selector ] ) {
jurzua
parents:
diff changeset
3844 selector += parts.shift();
jurzua
parents:
diff changeset
3845 }
jurzua
parents:
diff changeset
3846
jurzua
parents:
diff changeset
3847 set = posProcess( selector, set );
jurzua
parents:
diff changeset
3848 }
jurzua
parents:
diff changeset
3849 }
jurzua
parents:
diff changeset
3850
jurzua
parents:
diff changeset
3851 } else {
jurzua
parents:
diff changeset
3852 // Take a shortcut and set the context if the root selector is an ID
jurzua
parents:
diff changeset
3853 // (but not if it'll be faster if the inner selector is an ID)
jurzua
parents:
diff changeset
3854 if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
jurzua
parents:
diff changeset
3855 Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
jurzua
parents:
diff changeset
3856
jurzua
parents:
diff changeset
3857 ret = Sizzle.find( parts.shift(), context, contextXML );
jurzua
parents:
diff changeset
3858 context = ret.expr ?
jurzua
parents:
diff changeset
3859 Sizzle.filter( ret.expr, ret.set )[0] :
jurzua
parents:
diff changeset
3860 ret.set[0];
jurzua
parents:
diff changeset
3861 }
jurzua
parents:
diff changeset
3862
jurzua
parents:
diff changeset
3863 if ( context ) {
jurzua
parents:
diff changeset
3864 ret = seed ?
jurzua
parents:
diff changeset
3865 { expr: parts.pop(), set: makeArray(seed) } :
jurzua
parents:
diff changeset
3866 Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
jurzua
parents:
diff changeset
3867
jurzua
parents:
diff changeset
3868 set = ret.expr ?
jurzua
parents:
diff changeset
3869 Sizzle.filter( ret.expr, ret.set ) :
jurzua
parents:
diff changeset
3870 ret.set;
jurzua
parents:
diff changeset
3871
jurzua
parents:
diff changeset
3872 if ( parts.length > 0 ) {
jurzua
parents:
diff changeset
3873 checkSet = makeArray( set );
jurzua
parents:
diff changeset
3874
jurzua
parents:
diff changeset
3875 } else {
jurzua
parents:
diff changeset
3876 prune = false;
jurzua
parents:
diff changeset
3877 }
jurzua
parents:
diff changeset
3878
jurzua
parents:
diff changeset
3879 while ( parts.length ) {
jurzua
parents:
diff changeset
3880 cur = parts.pop();
jurzua
parents:
diff changeset
3881 pop = cur;
jurzua
parents:
diff changeset
3882
jurzua
parents:
diff changeset
3883 if ( !Expr.relative[ cur ] ) {
jurzua
parents:
diff changeset
3884 cur = "";
jurzua
parents:
diff changeset
3885 } else {
jurzua
parents:
diff changeset
3886 pop = parts.pop();
jurzua
parents:
diff changeset
3887 }
jurzua
parents:
diff changeset
3888
jurzua
parents:
diff changeset
3889 if ( pop == null ) {
jurzua
parents:
diff changeset
3890 pop = context;
jurzua
parents:
diff changeset
3891 }
jurzua
parents:
diff changeset
3892
jurzua
parents:
diff changeset
3893 Expr.relative[ cur ]( checkSet, pop, contextXML );
jurzua
parents:
diff changeset
3894 }
jurzua
parents:
diff changeset
3895
jurzua
parents:
diff changeset
3896 } else {
jurzua
parents:
diff changeset
3897 checkSet = parts = [];
jurzua
parents:
diff changeset
3898 }
jurzua
parents:
diff changeset
3899 }
jurzua
parents:
diff changeset
3900
jurzua
parents:
diff changeset
3901 if ( !checkSet ) {
jurzua
parents:
diff changeset
3902 checkSet = set;
jurzua
parents:
diff changeset
3903 }
jurzua
parents:
diff changeset
3904
jurzua
parents:
diff changeset
3905 if ( !checkSet ) {
jurzua
parents:
diff changeset
3906 Sizzle.error( cur || selector );
jurzua
parents:
diff changeset
3907 }
jurzua
parents:
diff changeset
3908
jurzua
parents:
diff changeset
3909 if ( toString.call(checkSet) === "[object Array]" ) {
jurzua
parents:
diff changeset
3910 if ( !prune ) {
jurzua
parents:
diff changeset
3911 results.push.apply( results, checkSet );
jurzua
parents:
diff changeset
3912
jurzua
parents:
diff changeset
3913 } else if ( context && context.nodeType === 1 ) {
jurzua
parents:
diff changeset
3914 for ( i = 0; checkSet[i] != null; i++ ) {
jurzua
parents:
diff changeset
3915 if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
jurzua
parents:
diff changeset
3916 results.push( set[i] );
jurzua
parents:
diff changeset
3917 }
jurzua
parents:
diff changeset
3918 }
jurzua
parents:
diff changeset
3919
jurzua
parents:
diff changeset
3920 } else {
jurzua
parents:
diff changeset
3921 for ( i = 0; checkSet[i] != null; i++ ) {
jurzua
parents:
diff changeset
3922 if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
jurzua
parents:
diff changeset
3923 results.push( set[i] );
jurzua
parents:
diff changeset
3924 }
jurzua
parents:
diff changeset
3925 }
jurzua
parents:
diff changeset
3926 }
jurzua
parents:
diff changeset
3927
jurzua
parents:
diff changeset
3928 } else {
jurzua
parents:
diff changeset
3929 makeArray( checkSet, results );
jurzua
parents:
diff changeset
3930 }
jurzua
parents:
diff changeset
3931
jurzua
parents:
diff changeset
3932 if ( extra ) {
jurzua
parents:
diff changeset
3933 Sizzle( extra, origContext, results, seed );
jurzua
parents:
diff changeset
3934 Sizzle.uniqueSort( results );
jurzua
parents:
diff changeset
3935 }
jurzua
parents:
diff changeset
3936
jurzua
parents:
diff changeset
3937 return results;
jurzua
parents:
diff changeset
3938 };
jurzua
parents:
diff changeset
3939
jurzua
parents:
diff changeset
3940 Sizzle.uniqueSort = function( results ) {
jurzua
parents:
diff changeset
3941 if ( sortOrder ) {
jurzua
parents:
diff changeset
3942 hasDuplicate = baseHasDuplicate;
jurzua
parents:
diff changeset
3943 results.sort( sortOrder );
jurzua
parents:
diff changeset
3944
jurzua
parents:
diff changeset
3945 if ( hasDuplicate ) {
jurzua
parents:
diff changeset
3946 for ( var i = 1; i < results.length; i++ ) {
jurzua
parents:
diff changeset
3947 if ( results[i] === results[ i - 1 ] ) {
jurzua
parents:
diff changeset
3948 results.splice( i--, 1 );
jurzua
parents:
diff changeset
3949 }
jurzua
parents:
diff changeset
3950 }
jurzua
parents:
diff changeset
3951 }
jurzua
parents:
diff changeset
3952 }
jurzua
parents:
diff changeset
3953
jurzua
parents:
diff changeset
3954 return results;
jurzua
parents:
diff changeset
3955 };
jurzua
parents:
diff changeset
3956
jurzua
parents:
diff changeset
3957 Sizzle.matches = function( expr, set ) {
jurzua
parents:
diff changeset
3958 return Sizzle( expr, null, null, set );
jurzua
parents:
diff changeset
3959 };
jurzua
parents:
diff changeset
3960
jurzua
parents:
diff changeset
3961 Sizzle.matchesSelector = function( node, expr ) {
jurzua
parents:
diff changeset
3962 return Sizzle( expr, null, null, [node] ).length > 0;
jurzua
parents:
diff changeset
3963 };
jurzua
parents:
diff changeset
3964
jurzua
parents:
diff changeset
3965 Sizzle.find = function( expr, context, isXML ) {
jurzua
parents:
diff changeset
3966 var set;
jurzua
parents:
diff changeset
3967
jurzua
parents:
diff changeset
3968 if ( !expr ) {
jurzua
parents:
diff changeset
3969 return [];
jurzua
parents:
diff changeset
3970 }
jurzua
parents:
diff changeset
3971
jurzua
parents:
diff changeset
3972 for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
jurzua
parents:
diff changeset
3973 var match,
jurzua
parents:
diff changeset
3974 type = Expr.order[i];
jurzua
parents:
diff changeset
3975
jurzua
parents:
diff changeset
3976 if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
jurzua
parents:
diff changeset
3977 var left = match[1];
jurzua
parents:
diff changeset
3978 match.splice( 1, 1 );
jurzua
parents:
diff changeset
3979
jurzua
parents:
diff changeset
3980 if ( left.substr( left.length - 1 ) !== "\\" ) {
jurzua
parents:
diff changeset
3981 match[1] = (match[1] || "").replace( rBackslash, "" );
jurzua
parents:
diff changeset
3982 set = Expr.find[ type ]( match, context, isXML );
jurzua
parents:
diff changeset
3983
jurzua
parents:
diff changeset
3984 if ( set != null ) {
jurzua
parents:
diff changeset
3985 expr = expr.replace( Expr.match[ type ], "" );
jurzua
parents:
diff changeset
3986 break;
jurzua
parents:
diff changeset
3987 }
jurzua
parents:
diff changeset
3988 }
jurzua
parents:
diff changeset
3989 }
jurzua
parents:
diff changeset
3990 }
jurzua
parents:
diff changeset
3991
jurzua
parents:
diff changeset
3992 if ( !set ) {
jurzua
parents:
diff changeset
3993 set = typeof context.getElementsByTagName !== "undefined" ?
jurzua
parents:
diff changeset
3994 context.getElementsByTagName( "*" ) :
jurzua
parents:
diff changeset
3995 [];
jurzua
parents:
diff changeset
3996 }
jurzua
parents:
diff changeset
3997
jurzua
parents:
diff changeset
3998 return { set: set, expr: expr };
jurzua
parents:
diff changeset
3999 };
jurzua
parents:
diff changeset
4000
jurzua
parents:
diff changeset
4001 Sizzle.filter = function( expr, set, inplace, not ) {
jurzua
parents:
diff changeset
4002 var match, anyFound,
jurzua
parents:
diff changeset
4003 old = expr,
jurzua
parents:
diff changeset
4004 result = [],
jurzua
parents:
diff changeset
4005 curLoop = set,
jurzua
parents:
diff changeset
4006 isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
jurzua
parents:
diff changeset
4007
jurzua
parents:
diff changeset
4008 while ( expr && set.length ) {
jurzua
parents:
diff changeset
4009 for ( var type in Expr.filter ) {
jurzua
parents:
diff changeset
4010 if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
jurzua
parents:
diff changeset
4011 var found, item,
jurzua
parents:
diff changeset
4012 filter = Expr.filter[ type ],
jurzua
parents:
diff changeset
4013 left = match[1];
jurzua
parents:
diff changeset
4014
jurzua
parents:
diff changeset
4015 anyFound = false;
jurzua
parents:
diff changeset
4016
jurzua
parents:
diff changeset
4017 match.splice(1,1);
jurzua
parents:
diff changeset
4018
jurzua
parents:
diff changeset
4019 if ( left.substr( left.length - 1 ) === "\\" ) {
jurzua
parents:
diff changeset
4020 continue;
jurzua
parents:
diff changeset
4021 }
jurzua
parents:
diff changeset
4022
jurzua
parents:
diff changeset
4023 if ( curLoop === result ) {
jurzua
parents:
diff changeset
4024 result = [];
jurzua
parents:
diff changeset
4025 }
jurzua
parents:
diff changeset
4026
jurzua
parents:
diff changeset
4027 if ( Expr.preFilter[ type ] ) {
jurzua
parents:
diff changeset
4028 match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
jurzua
parents:
diff changeset
4029
jurzua
parents:
diff changeset
4030 if ( !match ) {
jurzua
parents:
diff changeset
4031 anyFound = found = true;
jurzua
parents:
diff changeset
4032
jurzua
parents:
diff changeset
4033 } else if ( match === true ) {
jurzua
parents:
diff changeset
4034 continue;
jurzua
parents:
diff changeset
4035 }
jurzua
parents:
diff changeset
4036 }
jurzua
parents:
diff changeset
4037
jurzua
parents:
diff changeset
4038 if ( match ) {
jurzua
parents:
diff changeset
4039 for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
jurzua
parents:
diff changeset
4040 if ( item ) {
jurzua
parents:
diff changeset
4041 found = filter( item, match, i, curLoop );
jurzua
parents:
diff changeset
4042 var pass = not ^ !!found;
jurzua
parents:
diff changeset
4043
jurzua
parents:
diff changeset
4044 if ( inplace && found != null ) {
jurzua
parents:
diff changeset
4045 if ( pass ) {
jurzua
parents:
diff changeset
4046 anyFound = true;
jurzua
parents:
diff changeset
4047
jurzua
parents:
diff changeset
4048 } else {
jurzua
parents:
diff changeset
4049 curLoop[i] = false;
jurzua
parents:
diff changeset
4050 }
jurzua
parents:
diff changeset
4051
jurzua
parents:
diff changeset
4052 } else if ( pass ) {
jurzua
parents:
diff changeset
4053 result.push( item );
jurzua
parents:
diff changeset
4054 anyFound = true;
jurzua
parents:
diff changeset
4055 }
jurzua
parents:
diff changeset
4056 }
jurzua
parents:
diff changeset
4057 }
jurzua
parents:
diff changeset
4058 }
jurzua
parents:
diff changeset
4059
jurzua
parents:
diff changeset
4060 if ( found !== undefined ) {
jurzua
parents:
diff changeset
4061 if ( !inplace ) {
jurzua
parents:
diff changeset
4062 curLoop = result;
jurzua
parents:
diff changeset
4063 }
jurzua
parents:
diff changeset
4064
jurzua
parents:
diff changeset
4065 expr = expr.replace( Expr.match[ type ], "" );
jurzua
parents:
diff changeset
4066
jurzua
parents:
diff changeset
4067 if ( !anyFound ) {
jurzua
parents:
diff changeset
4068 return [];
jurzua
parents:
diff changeset
4069 }
jurzua
parents:
diff changeset
4070
jurzua
parents:
diff changeset
4071 break;
jurzua
parents:
diff changeset
4072 }
jurzua
parents:
diff changeset
4073 }
jurzua
parents:
diff changeset
4074 }
jurzua
parents:
diff changeset
4075
jurzua
parents:
diff changeset
4076 // Improper expression
jurzua
parents:
diff changeset
4077 if ( expr === old ) {
jurzua
parents:
diff changeset
4078 if ( anyFound == null ) {
jurzua
parents:
diff changeset
4079 Sizzle.error( expr );
jurzua
parents:
diff changeset
4080
jurzua
parents:
diff changeset
4081 } else {
jurzua
parents:
diff changeset
4082 break;
jurzua
parents:
diff changeset
4083 }
jurzua
parents:
diff changeset
4084 }
jurzua
parents:
diff changeset
4085
jurzua
parents:
diff changeset
4086 old = expr;
jurzua
parents:
diff changeset
4087 }
jurzua
parents:
diff changeset
4088
jurzua
parents:
diff changeset
4089 return curLoop;
jurzua
parents:
diff changeset
4090 };
jurzua
parents:
diff changeset
4091
jurzua
parents:
diff changeset
4092 Sizzle.error = function( msg ) {
jurzua
parents:
diff changeset
4093 throw "Syntax error, unrecognized expression: " + msg;
jurzua
parents:
diff changeset
4094 };
jurzua
parents:
diff changeset
4095
jurzua
parents:
diff changeset
4096 var Expr = Sizzle.selectors = {
jurzua
parents:
diff changeset
4097 order: [ "ID", "NAME", "TAG" ],
jurzua
parents:
diff changeset
4098
jurzua
parents:
diff changeset
4099 match: {
jurzua
parents:
diff changeset
4100 ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
jurzua
parents:
diff changeset
4101 CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
jurzua
parents:
diff changeset
4102 NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
jurzua
parents:
diff changeset
4103 ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
jurzua
parents:
diff changeset
4104 TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
jurzua
parents:
diff changeset
4105 CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
jurzua
parents:
diff changeset
4106 POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
jurzua
parents:
diff changeset
4107 PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
jurzua
parents:
diff changeset
4108 },
jurzua
parents:
diff changeset
4109
jurzua
parents:
diff changeset
4110 leftMatch: {},
jurzua
parents:
diff changeset
4111
jurzua
parents:
diff changeset
4112 attrMap: {
jurzua
parents:
diff changeset
4113 "class": "className",
jurzua
parents:
diff changeset
4114 "for": "htmlFor"
jurzua
parents:
diff changeset
4115 },
jurzua
parents:
diff changeset
4116
jurzua
parents:
diff changeset
4117 attrHandle: {
jurzua
parents:
diff changeset
4118 href: function( elem ) {
jurzua
parents:
diff changeset
4119 return elem.getAttribute( "href" );
jurzua
parents:
diff changeset
4120 },
jurzua
parents:
diff changeset
4121 type: function( elem ) {
jurzua
parents:
diff changeset
4122 return elem.getAttribute( "type" );
jurzua
parents:
diff changeset
4123 }
jurzua
parents:
diff changeset
4124 },
jurzua
parents:
diff changeset
4125
jurzua
parents:
diff changeset
4126 relative: {
jurzua
parents:
diff changeset
4127 "+": function(checkSet, part){
jurzua
parents:
diff changeset
4128 var isPartStr = typeof part === "string",
jurzua
parents:
diff changeset
4129 isTag = isPartStr && !rNonWord.test( part ),
jurzua
parents:
diff changeset
4130 isPartStrNotTag = isPartStr && !isTag;
jurzua
parents:
diff changeset
4131
jurzua
parents:
diff changeset
4132 if ( isTag ) {
jurzua
parents:
diff changeset
4133 part = part.toLowerCase();
jurzua
parents:
diff changeset
4134 }
jurzua
parents:
diff changeset
4135
jurzua
parents:
diff changeset
4136 for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
jurzua
parents:
diff changeset
4137 if ( (elem = checkSet[i]) ) {
jurzua
parents:
diff changeset
4138 while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
jurzua
parents:
diff changeset
4139
jurzua
parents:
diff changeset
4140 checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
jurzua
parents:
diff changeset
4141 elem || false :
jurzua
parents:
diff changeset
4142 elem === part;
jurzua
parents:
diff changeset
4143 }
jurzua
parents:
diff changeset
4144 }
jurzua
parents:
diff changeset
4145
jurzua
parents:
diff changeset
4146 if ( isPartStrNotTag ) {
jurzua
parents:
diff changeset
4147 Sizzle.filter( part, checkSet, true );
jurzua
parents:
diff changeset
4148 }
jurzua
parents:
diff changeset
4149 },
jurzua
parents:
diff changeset
4150
jurzua
parents:
diff changeset
4151 ">": function( checkSet, part ) {
jurzua
parents:
diff changeset
4152 var elem,
jurzua
parents:
diff changeset
4153 isPartStr = typeof part === "string",
jurzua
parents:
diff changeset
4154 i = 0,
jurzua
parents:
diff changeset
4155 l = checkSet.length;
jurzua
parents:
diff changeset
4156
jurzua
parents:
diff changeset
4157 if ( isPartStr && !rNonWord.test( part ) ) {
jurzua
parents:
diff changeset
4158 part = part.toLowerCase();
jurzua
parents:
diff changeset
4159
jurzua
parents:
diff changeset
4160 for ( ; i < l; i++ ) {
jurzua
parents:
diff changeset
4161 elem = checkSet[i];
jurzua
parents:
diff changeset
4162
jurzua
parents:
diff changeset
4163 if ( elem ) {
jurzua
parents:
diff changeset
4164 var parent = elem.parentNode;
jurzua
parents:
diff changeset
4165 checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
jurzua
parents:
diff changeset
4166 }
jurzua
parents:
diff changeset
4167 }
jurzua
parents:
diff changeset
4168
jurzua
parents:
diff changeset
4169 } else {
jurzua
parents:
diff changeset
4170 for ( ; i < l; i++ ) {
jurzua
parents:
diff changeset
4171 elem = checkSet[i];
jurzua
parents:
diff changeset
4172
jurzua
parents:
diff changeset
4173 if ( elem ) {
jurzua
parents:
diff changeset
4174 checkSet[i] = isPartStr ?
jurzua
parents:
diff changeset
4175 elem.parentNode :
jurzua
parents:
diff changeset
4176 elem.parentNode === part;
jurzua
parents:
diff changeset
4177 }
jurzua
parents:
diff changeset
4178 }
jurzua
parents:
diff changeset
4179
jurzua
parents:
diff changeset
4180 if ( isPartStr ) {
jurzua
parents:
diff changeset
4181 Sizzle.filter( part, checkSet, true );
jurzua
parents:
diff changeset
4182 }
jurzua
parents:
diff changeset
4183 }
jurzua
parents:
diff changeset
4184 },
jurzua
parents:
diff changeset
4185
jurzua
parents:
diff changeset
4186 "": function(checkSet, part, isXML){
jurzua
parents:
diff changeset
4187 var nodeCheck,
jurzua
parents:
diff changeset
4188 doneName = done++,
jurzua
parents:
diff changeset
4189 checkFn = dirCheck;
jurzua
parents:
diff changeset
4190
jurzua
parents:
diff changeset
4191 if ( typeof part === "string" && !rNonWord.test( part ) ) {
jurzua
parents:
diff changeset
4192 part = part.toLowerCase();
jurzua
parents:
diff changeset
4193 nodeCheck = part;
jurzua
parents:
diff changeset
4194 checkFn = dirNodeCheck;
jurzua
parents:
diff changeset
4195 }
jurzua
parents:
diff changeset
4196
jurzua
parents:
diff changeset
4197 checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
jurzua
parents:
diff changeset
4198 },
jurzua
parents:
diff changeset
4199
jurzua
parents:
diff changeset
4200 "~": function( checkSet, part, isXML ) {
jurzua
parents:
diff changeset
4201 var nodeCheck,
jurzua
parents:
diff changeset
4202 doneName = done++,
jurzua
parents:
diff changeset
4203 checkFn = dirCheck;
jurzua
parents:
diff changeset
4204
jurzua
parents:
diff changeset
4205 if ( typeof part === "string" && !rNonWord.test( part ) ) {
jurzua
parents:
diff changeset
4206 part = part.toLowerCase();
jurzua
parents:
diff changeset
4207 nodeCheck = part;
jurzua
parents:
diff changeset
4208 checkFn = dirNodeCheck;
jurzua
parents:
diff changeset
4209 }
jurzua
parents:
diff changeset
4210
jurzua
parents:
diff changeset
4211 checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
jurzua
parents:
diff changeset
4212 }
jurzua
parents:
diff changeset
4213 },
jurzua
parents:
diff changeset
4214
jurzua
parents:
diff changeset
4215 find: {
jurzua
parents:
diff changeset
4216 ID: function( match, context, isXML ) {
jurzua
parents:
diff changeset
4217 if ( typeof context.getElementById !== "undefined" && !isXML ) {
jurzua
parents:
diff changeset
4218 var m = context.getElementById(match[1]);
jurzua
parents:
diff changeset
4219 // Check parentNode to catch when Blackberry 4.6 returns
jurzua
parents:
diff changeset
4220 // nodes that are no longer in the document #6963
jurzua
parents:
diff changeset
4221 return m && m.parentNode ? [m] : [];
jurzua
parents:
diff changeset
4222 }
jurzua
parents:
diff changeset
4223 },
jurzua
parents:
diff changeset
4224
jurzua
parents:
diff changeset
4225 NAME: function( match, context ) {
jurzua
parents:
diff changeset
4226 if ( typeof context.getElementsByName !== "undefined" ) {
jurzua
parents:
diff changeset
4227 var ret = [],
jurzua
parents:
diff changeset
4228 results = context.getElementsByName( match[1] );
jurzua
parents:
diff changeset
4229
jurzua
parents:
diff changeset
4230 for ( var i = 0, l = results.length; i < l; i++ ) {
jurzua
parents:
diff changeset
4231 if ( results[i].getAttribute("name") === match[1] ) {
jurzua
parents:
diff changeset
4232 ret.push( results[i] );
jurzua
parents:
diff changeset
4233 }
jurzua
parents:
diff changeset
4234 }
jurzua
parents:
diff changeset
4235
jurzua
parents:
diff changeset
4236 return ret.length === 0 ? null : ret;
jurzua
parents:
diff changeset
4237 }
jurzua
parents:
diff changeset
4238 },
jurzua
parents:
diff changeset
4239
jurzua
parents:
diff changeset
4240 TAG: function( match, context ) {
jurzua
parents:
diff changeset
4241 if ( typeof context.getElementsByTagName !== "undefined" ) {
jurzua
parents:
diff changeset
4242 return context.getElementsByTagName( match[1] );
jurzua
parents:
diff changeset
4243 }
jurzua
parents:
diff changeset
4244 }
jurzua
parents:
diff changeset
4245 },
jurzua
parents:
diff changeset
4246 preFilter: {
jurzua
parents:
diff changeset
4247 CLASS: function( match, curLoop, inplace, result, not, isXML ) {
jurzua
parents:
diff changeset
4248 match = " " + match[1].replace( rBackslash, "" ) + " ";
jurzua
parents:
diff changeset
4249
jurzua
parents:
diff changeset
4250 if ( isXML ) {
jurzua
parents:
diff changeset
4251 return match;
jurzua
parents:
diff changeset
4252 }
jurzua
parents:
diff changeset
4253
jurzua
parents:
diff changeset
4254 for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
jurzua
parents:
diff changeset
4255 if ( elem ) {
jurzua
parents:
diff changeset
4256 if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
jurzua
parents:
diff changeset
4257 if ( !inplace ) {
jurzua
parents:
diff changeset
4258 result.push( elem );
jurzua
parents:
diff changeset
4259 }
jurzua
parents:
diff changeset
4260
jurzua
parents:
diff changeset
4261 } else if ( inplace ) {
jurzua
parents:
diff changeset
4262 curLoop[i] = false;
jurzua
parents:
diff changeset
4263 }
jurzua
parents:
diff changeset
4264 }
jurzua
parents:
diff changeset
4265 }
jurzua
parents:
diff changeset
4266
jurzua
parents:
diff changeset
4267 return false;
jurzua
parents:
diff changeset
4268 },
jurzua
parents:
diff changeset
4269
jurzua
parents:
diff changeset
4270 ID: function( match ) {
jurzua
parents:
diff changeset
4271 return match[1].replace( rBackslash, "" );
jurzua
parents:
diff changeset
4272 },
jurzua
parents:
diff changeset
4273
jurzua
parents:
diff changeset
4274 TAG: function( match, curLoop ) {
jurzua
parents:
diff changeset
4275 return match[1].replace( rBackslash, "" ).toLowerCase();
jurzua
parents:
diff changeset
4276 },
jurzua
parents:
diff changeset
4277
jurzua
parents:
diff changeset
4278 CHILD: function( match ) {
jurzua
parents:
diff changeset
4279 if ( match[1] === "nth" ) {
jurzua
parents:
diff changeset
4280 if ( !match[2] ) {
jurzua
parents:
diff changeset
4281 Sizzle.error( match[0] );
jurzua
parents:
diff changeset
4282 }
jurzua
parents:
diff changeset
4283
jurzua
parents:
diff changeset
4284 match[2] = match[2].replace(/^\+|\s*/g, '');
jurzua
parents:
diff changeset
4285
jurzua
parents:
diff changeset
4286 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
jurzua
parents:
diff changeset
4287 var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(
jurzua
parents:
diff changeset
4288 match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
jurzua
parents:
diff changeset
4289 !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
jurzua
parents:
diff changeset
4290
jurzua
parents:
diff changeset
4291 // calculate the numbers (first)n+(last) including if they are negative
jurzua
parents:
diff changeset
4292 match[2] = (test[1] + (test[2] || 1)) - 0;
jurzua
parents:
diff changeset
4293 match[3] = test[3] - 0;
jurzua
parents:
diff changeset
4294 }
jurzua
parents:
diff changeset
4295 else if ( match[2] ) {
jurzua
parents:
diff changeset
4296 Sizzle.error( match[0] );
jurzua
parents:
diff changeset
4297 }
jurzua
parents:
diff changeset
4298
jurzua
parents:
diff changeset
4299 // TODO: Move to normal caching system
jurzua
parents:
diff changeset
4300 match[0] = done++;
jurzua
parents:
diff changeset
4301
jurzua
parents:
diff changeset
4302 return match;
jurzua
parents:
diff changeset
4303 },
jurzua
parents:
diff changeset
4304
jurzua
parents:
diff changeset
4305 ATTR: function( match, curLoop, inplace, result, not, isXML ) {
jurzua
parents:
diff changeset
4306 var name = match[1] = match[1].replace( rBackslash, "" );
jurzua
parents:
diff changeset
4307
jurzua
parents:
diff changeset
4308 if ( !isXML && Expr.attrMap[name] ) {
jurzua
parents:
diff changeset
4309 match[1] = Expr.attrMap[name];
jurzua
parents:
diff changeset
4310 }
jurzua
parents:
diff changeset
4311
jurzua
parents:
diff changeset
4312 // Handle if an un-quoted value was used
jurzua
parents:
diff changeset
4313 match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" );
jurzua
parents:
diff changeset
4314
jurzua
parents:
diff changeset
4315 if ( match[2] === "~=" ) {
jurzua
parents:
diff changeset
4316 match[4] = " " + match[4] + " ";
jurzua
parents:
diff changeset
4317 }
jurzua
parents:
diff changeset
4318
jurzua
parents:
diff changeset
4319 return match;
jurzua
parents:
diff changeset
4320 },
jurzua
parents:
diff changeset
4321
jurzua
parents:
diff changeset
4322 PSEUDO: function( match, curLoop, inplace, result, not ) {
jurzua
parents:
diff changeset
4323 if ( match[1] === "not" ) {
jurzua
parents:
diff changeset
4324 // If we're dealing with a complex expression, or a simple one
jurzua
parents:
diff changeset
4325 if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
jurzua
parents:
diff changeset
4326 match[3] = Sizzle(match[3], null, null, curLoop);
jurzua
parents:
diff changeset
4327
jurzua
parents:
diff changeset
4328 } else {
jurzua
parents:
diff changeset
4329 var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
jurzua
parents:
diff changeset
4330
jurzua
parents:
diff changeset
4331 if ( !inplace ) {
jurzua
parents:
diff changeset
4332 result.push.apply( result, ret );
jurzua
parents:
diff changeset
4333 }
jurzua
parents:
diff changeset
4334
jurzua
parents:
diff changeset
4335 return false;
jurzua
parents:
diff changeset
4336 }
jurzua
parents:
diff changeset
4337
jurzua
parents:
diff changeset
4338 } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
jurzua
parents:
diff changeset
4339 return true;
jurzua
parents:
diff changeset
4340 }
jurzua
parents:
diff changeset
4341
jurzua
parents:
diff changeset
4342 return match;
jurzua
parents:
diff changeset
4343 },
jurzua
parents:
diff changeset
4344
jurzua
parents:
diff changeset
4345 POS: function( match ) {
jurzua
parents:
diff changeset
4346 match.unshift( true );
jurzua
parents:
diff changeset
4347
jurzua
parents:
diff changeset
4348 return match;
jurzua
parents:
diff changeset
4349 }
jurzua
parents:
diff changeset
4350 },
jurzua
parents:
diff changeset
4351
jurzua
parents:
diff changeset
4352 filters: {
jurzua
parents:
diff changeset
4353 enabled: function( elem ) {
jurzua
parents:
diff changeset
4354 return elem.disabled === false && elem.type !== "hidden";
jurzua
parents:
diff changeset
4355 },
jurzua
parents:
diff changeset
4356
jurzua
parents:
diff changeset
4357 disabled: function( elem ) {
jurzua
parents:
diff changeset
4358 return elem.disabled === true;
jurzua
parents:
diff changeset
4359 },
jurzua
parents:
diff changeset
4360
jurzua
parents:
diff changeset
4361 checked: function( elem ) {
jurzua
parents:
diff changeset
4362 return elem.checked === true;
jurzua
parents:
diff changeset
4363 },
jurzua
parents:
diff changeset
4364
jurzua
parents:
diff changeset
4365 selected: function( elem ) {
jurzua
parents:
diff changeset
4366 // Accessing this property makes selected-by-default
jurzua
parents:
diff changeset
4367 // options in Safari work properly
jurzua
parents:
diff changeset
4368 if ( elem.parentNode ) {
jurzua
parents:
diff changeset
4369 elem.parentNode.selectedIndex;
jurzua
parents:
diff changeset
4370 }
jurzua
parents:
diff changeset
4371
jurzua
parents:
diff changeset
4372 return elem.selected === true;
jurzua
parents:
diff changeset
4373 },
jurzua
parents:
diff changeset
4374
jurzua
parents:
diff changeset
4375 parent: function( elem ) {
jurzua
parents:
diff changeset
4376 return !!elem.firstChild;
jurzua
parents:
diff changeset
4377 },
jurzua
parents:
diff changeset
4378
jurzua
parents:
diff changeset
4379 empty: function( elem ) {
jurzua
parents:
diff changeset
4380 return !elem.firstChild;
jurzua
parents:
diff changeset
4381 },
jurzua
parents:
diff changeset
4382
jurzua
parents:
diff changeset
4383 has: function( elem, i, match ) {
jurzua
parents:
diff changeset
4384 return !!Sizzle( match[3], elem ).length;
jurzua
parents:
diff changeset
4385 },
jurzua
parents:
diff changeset
4386
jurzua
parents:
diff changeset
4387 header: function( elem ) {
jurzua
parents:
diff changeset
4388 return (/h\d/i).test( elem.nodeName );
jurzua
parents:
diff changeset
4389 },
jurzua
parents:
diff changeset
4390
jurzua
parents:
diff changeset
4391 text: function( elem ) {
jurzua
parents:
diff changeset
4392 var attr = elem.getAttribute( "type" ), type = elem.type;
jurzua
parents:
diff changeset
4393 // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
jurzua
parents:
diff changeset
4394 // use getAttribute instead to test this case
jurzua
parents:
diff changeset
4395 return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null );
jurzua
parents:
diff changeset
4396 },
jurzua
parents:
diff changeset
4397
jurzua
parents:
diff changeset
4398 radio: function( elem ) {
jurzua
parents:
diff changeset
4399 return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type;
jurzua
parents:
diff changeset
4400 },
jurzua
parents:
diff changeset
4401
jurzua
parents:
diff changeset
4402 checkbox: function( elem ) {
jurzua
parents:
diff changeset
4403 return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type;
jurzua
parents:
diff changeset
4404 },
jurzua
parents:
diff changeset
4405
jurzua
parents:
diff changeset
4406 file: function( elem ) {
jurzua
parents:
diff changeset
4407 return elem.nodeName.toLowerCase() === "input" && "file" === elem.type;
jurzua
parents:
diff changeset
4408 },
jurzua
parents:
diff changeset
4409
jurzua
parents:
diff changeset
4410 password: function( elem ) {
jurzua
parents:
diff changeset
4411 return elem.nodeName.toLowerCase() === "input" && "password" === elem.type;
jurzua
parents:
diff changeset
4412 },
jurzua
parents:
diff changeset
4413
jurzua
parents:
diff changeset
4414 submit: function( elem ) {
jurzua
parents:
diff changeset
4415 var name = elem.nodeName.toLowerCase();
jurzua
parents:
diff changeset
4416 return (name === "input" || name === "button") && "submit" === elem.type;
jurzua
parents:
diff changeset
4417 },
jurzua
parents:
diff changeset
4418
jurzua
parents:
diff changeset
4419 image: function( elem ) {
jurzua
parents:
diff changeset
4420 return elem.nodeName.toLowerCase() === "input" && "image" === elem.type;
jurzua
parents:
diff changeset
4421 },
jurzua
parents:
diff changeset
4422
jurzua
parents:
diff changeset
4423 reset: function( elem ) {
jurzua
parents:
diff changeset
4424 var name = elem.nodeName.toLowerCase();
jurzua
parents:
diff changeset
4425 return (name === "input" || name === "button") && "reset" === elem.type;
jurzua
parents:
diff changeset
4426 },
jurzua
parents:
diff changeset
4427
jurzua
parents:
diff changeset
4428 button: function( elem ) {
jurzua
parents:
diff changeset
4429 var name = elem.nodeName.toLowerCase();
jurzua
parents:
diff changeset
4430 return name === "input" && "button" === elem.type || name === "button";
jurzua
parents:
diff changeset
4431 },
jurzua
parents:
diff changeset
4432
jurzua
parents:
diff changeset
4433 input: function( elem ) {
jurzua
parents:
diff changeset
4434 return (/input|select|textarea|button/i).test( elem.nodeName );
jurzua
parents:
diff changeset
4435 },
jurzua
parents:
diff changeset
4436
jurzua
parents:
diff changeset
4437 focus: function( elem ) {
jurzua
parents:
diff changeset
4438 return elem === elem.ownerDocument.activeElement;
jurzua
parents:
diff changeset
4439 }
jurzua
parents:
diff changeset
4440 },
jurzua
parents:
diff changeset
4441 setFilters: {
jurzua
parents:
diff changeset
4442 first: function( elem, i ) {
jurzua
parents:
diff changeset
4443 return i === 0;
jurzua
parents:
diff changeset
4444 },
jurzua
parents:
diff changeset
4445
jurzua
parents:
diff changeset
4446 last: function( elem, i, match, array ) {
jurzua
parents:
diff changeset
4447 return i === array.length - 1;
jurzua
parents:
diff changeset
4448 },
jurzua
parents:
diff changeset
4449
jurzua
parents:
diff changeset
4450 even: function( elem, i ) {
jurzua
parents:
diff changeset
4451 return i % 2 === 0;
jurzua
parents:
diff changeset
4452 },
jurzua
parents:
diff changeset
4453
jurzua
parents:
diff changeset
4454 odd: function( elem, i ) {
jurzua
parents:
diff changeset
4455 return i % 2 === 1;
jurzua
parents:
diff changeset
4456 },
jurzua
parents:
diff changeset
4457
jurzua
parents:
diff changeset
4458 lt: function( elem, i, match ) {
jurzua
parents:
diff changeset
4459 return i < match[3] - 0;
jurzua
parents:
diff changeset
4460 },
jurzua
parents:
diff changeset
4461
jurzua
parents:
diff changeset
4462 gt: function( elem, i, match ) {
jurzua
parents:
diff changeset
4463 return i > match[3] - 0;
jurzua
parents:
diff changeset
4464 },
jurzua
parents:
diff changeset
4465
jurzua
parents:
diff changeset
4466 nth: function( elem, i, match ) {
jurzua
parents:
diff changeset
4467 return match[3] - 0 === i;
jurzua
parents:
diff changeset
4468 },
jurzua
parents:
diff changeset
4469
jurzua
parents:
diff changeset
4470 eq: function( elem, i, match ) {
jurzua
parents:
diff changeset
4471 return match[3] - 0 === i;
jurzua
parents:
diff changeset
4472 }
jurzua
parents:
diff changeset
4473 },
jurzua
parents:
diff changeset
4474 filter: {
jurzua
parents:
diff changeset
4475 PSEUDO: function( elem, match, i, array ) {
jurzua
parents:
diff changeset
4476 var name = match[1],
jurzua
parents:
diff changeset
4477 filter = Expr.filters[ name ];
jurzua
parents:
diff changeset
4478
jurzua
parents:
diff changeset
4479 if ( filter ) {
jurzua
parents:
diff changeset
4480 return filter( elem, i, match, array );
jurzua
parents:
diff changeset
4481
jurzua
parents:
diff changeset
4482 } else if ( name === "contains" ) {
jurzua
parents:
diff changeset
4483 return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0;
jurzua
parents:
diff changeset
4484
jurzua
parents:
diff changeset
4485 } else if ( name === "not" ) {
jurzua
parents:
diff changeset
4486 var not = match[3];
jurzua
parents:
diff changeset
4487
jurzua
parents:
diff changeset
4488 for ( var j = 0, l = not.length; j < l; j++ ) {
jurzua
parents:
diff changeset
4489 if ( not[j] === elem ) {
jurzua
parents:
diff changeset
4490 return false;
jurzua
parents:
diff changeset
4491 }
jurzua
parents:
diff changeset
4492 }
jurzua
parents:
diff changeset
4493
jurzua
parents:
diff changeset
4494 return true;
jurzua
parents:
diff changeset
4495
jurzua
parents:
diff changeset
4496 } else {
jurzua
parents:
diff changeset
4497 Sizzle.error( name );
jurzua
parents:
diff changeset
4498 }
jurzua
parents:
diff changeset
4499 },
jurzua
parents:
diff changeset
4500
jurzua
parents:
diff changeset
4501 CHILD: function( elem, match ) {
jurzua
parents:
diff changeset
4502 var type = match[1],
jurzua
parents:
diff changeset
4503 node = elem;
jurzua
parents:
diff changeset
4504
jurzua
parents:
diff changeset
4505 switch ( type ) {
jurzua
parents:
diff changeset
4506 case "only":
jurzua
parents:
diff changeset
4507 case "first":
jurzua
parents:
diff changeset
4508 while ( (node = node.previousSibling) ) {
jurzua
parents:
diff changeset
4509 if ( node.nodeType === 1 ) {
jurzua
parents:
diff changeset
4510 return false;
jurzua
parents:
diff changeset
4511 }
jurzua
parents:
diff changeset
4512 }
jurzua
parents:
diff changeset
4513
jurzua
parents:
diff changeset
4514 if ( type === "first" ) {
jurzua
parents:
diff changeset
4515 return true;
jurzua
parents:
diff changeset
4516 }
jurzua
parents:
diff changeset
4517
jurzua
parents:
diff changeset
4518 node = elem;
jurzua
parents:
diff changeset
4519
jurzua
parents:
diff changeset
4520 case "last":
jurzua
parents:
diff changeset
4521 while ( (node = node.nextSibling) ) {
jurzua
parents:
diff changeset
4522 if ( node.nodeType === 1 ) {
jurzua
parents:
diff changeset
4523 return false;
jurzua
parents:
diff changeset
4524 }
jurzua
parents:
diff changeset
4525 }
jurzua
parents:
diff changeset
4526
jurzua
parents:
diff changeset
4527 return true;
jurzua
parents:
diff changeset
4528
jurzua
parents:
diff changeset
4529 case "nth":
jurzua
parents:
diff changeset
4530 var first = match[2],
jurzua
parents:
diff changeset
4531 last = match[3];
jurzua
parents:
diff changeset
4532
jurzua
parents:
diff changeset
4533 if ( first === 1 && last === 0 ) {
jurzua
parents:
diff changeset
4534 return true;
jurzua
parents:
diff changeset
4535 }
jurzua
parents:
diff changeset
4536
jurzua
parents:
diff changeset
4537 var doneName = match[0],
jurzua
parents:
diff changeset
4538 parent = elem.parentNode;
jurzua
parents:
diff changeset
4539
jurzua
parents:
diff changeset
4540 if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
jurzua
parents:
diff changeset
4541 var count = 0;
jurzua
parents:
diff changeset
4542
jurzua
parents:
diff changeset
4543 for ( node = parent.firstChild; node; node = node.nextSibling ) {
jurzua
parents:
diff changeset
4544 if ( node.nodeType === 1 ) {
jurzua
parents:
diff changeset
4545 node.nodeIndex = ++count;
jurzua
parents:
diff changeset
4546 }
jurzua
parents:
diff changeset
4547 }
jurzua
parents:
diff changeset
4548
jurzua
parents:
diff changeset
4549 parent.sizcache = doneName;
jurzua
parents:
diff changeset
4550 }
jurzua
parents:
diff changeset
4551
jurzua
parents:
diff changeset
4552 var diff = elem.nodeIndex - last;
jurzua
parents:
diff changeset
4553
jurzua
parents:
diff changeset
4554 if ( first === 0 ) {
jurzua
parents:
diff changeset
4555 return diff === 0;
jurzua
parents:
diff changeset
4556
jurzua
parents:
diff changeset
4557 } else {
jurzua
parents:
diff changeset
4558 return ( diff % first === 0 && diff / first >= 0 );
jurzua
parents:
diff changeset
4559 }
jurzua
parents:
diff changeset
4560 }
jurzua
parents:
diff changeset
4561 },
jurzua
parents:
diff changeset
4562
jurzua
parents:
diff changeset
4563 ID: function( elem, match ) {
jurzua
parents:
diff changeset
4564 return elem.nodeType === 1 && elem.getAttribute("id") === match;
jurzua
parents:
diff changeset
4565 },
jurzua
parents:
diff changeset
4566
jurzua
parents:
diff changeset
4567 TAG: function( elem, match ) {
jurzua
parents:
diff changeset
4568 return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
jurzua
parents:
diff changeset
4569 },
jurzua
parents:
diff changeset
4570
jurzua
parents:
diff changeset
4571 CLASS: function( elem, match ) {
jurzua
parents:
diff changeset
4572 return (" " + (elem.className || elem.getAttribute("class")) + " ")
jurzua
parents:
diff changeset
4573 .indexOf( match ) > -1;
jurzua
parents:
diff changeset
4574 },
jurzua
parents:
diff changeset
4575
jurzua
parents:
diff changeset
4576 ATTR: function( elem, match ) {
jurzua
parents:
diff changeset
4577 var name = match[1],
jurzua
parents:
diff changeset
4578 result = Expr.attrHandle[ name ] ?
jurzua
parents:
diff changeset
4579 Expr.attrHandle[ name ]( elem ) :
jurzua
parents:
diff changeset
4580 elem[ name ] != null ?
jurzua
parents:
diff changeset
4581 elem[ name ] :
jurzua
parents:
diff changeset
4582 elem.getAttribute( name ),
jurzua
parents:
diff changeset
4583 value = result + "",
jurzua
parents:
diff changeset
4584 type = match[2],
jurzua
parents:
diff changeset
4585 check = match[4];
jurzua
parents:
diff changeset
4586
jurzua
parents:
diff changeset
4587 return result == null ?
jurzua
parents:
diff changeset
4588 type === "!=" :
jurzua
parents:
diff changeset
4589 type === "=" ?
jurzua
parents:
diff changeset
4590 value === check :
jurzua
parents:
diff changeset
4591 type === "*=" ?
jurzua
parents:
diff changeset
4592 value.indexOf(check) >= 0 :
jurzua
parents:
diff changeset
4593 type === "~=" ?
jurzua
parents:
diff changeset
4594 (" " + value + " ").indexOf(check) >= 0 :
jurzua
parents:
diff changeset
4595 !check ?
jurzua
parents:
diff changeset
4596 value && result !== false :
jurzua
parents:
diff changeset
4597 type === "!=" ?
jurzua
parents:
diff changeset
4598 value !== check :
jurzua
parents:
diff changeset
4599 type === "^=" ?
jurzua
parents:
diff changeset
4600 value.indexOf(check) === 0 :
jurzua
parents:
diff changeset
4601 type === "$=" ?
jurzua
parents:
diff changeset
4602 value.substr(value.length - check.length) === check :
jurzua
parents:
diff changeset
4603 type === "|=" ?
jurzua
parents:
diff changeset
4604 value === check || value.substr(0, check.length + 1) === check + "-" :
jurzua
parents:
diff changeset
4605 false;
jurzua
parents:
diff changeset
4606 },
jurzua
parents:
diff changeset
4607
jurzua
parents:
diff changeset
4608 POS: function( elem, match, i, array ) {
jurzua
parents:
diff changeset
4609 var name = match[2],
jurzua
parents:
diff changeset
4610 filter = Expr.setFilters[ name ];
jurzua
parents:
diff changeset
4611
jurzua
parents:
diff changeset
4612 if ( filter ) {
jurzua
parents:
diff changeset
4613 return filter( elem, i, match, array );
jurzua
parents:
diff changeset
4614 }
jurzua
parents:
diff changeset
4615 }
jurzua
parents:
diff changeset
4616 }
jurzua
parents:
diff changeset
4617 };
jurzua
parents:
diff changeset
4618
jurzua
parents:
diff changeset
4619 var origPOS = Expr.match.POS,
jurzua
parents:
diff changeset
4620 fescape = function(all, num){
jurzua
parents:
diff changeset
4621 return "\\" + (num - 0 + 1);
jurzua
parents:
diff changeset
4622 };
jurzua
parents:
diff changeset
4623
jurzua
parents:
diff changeset
4624 for ( var type in Expr.match ) {
jurzua
parents:
diff changeset
4625 Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
jurzua
parents:
diff changeset
4626 Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
jurzua
parents:
diff changeset
4627 }
jurzua
parents:
diff changeset
4628
jurzua
parents:
diff changeset
4629 var makeArray = function( array, results ) {
jurzua
parents:
diff changeset
4630 array = Array.prototype.slice.call( array, 0 );
jurzua
parents:
diff changeset
4631
jurzua
parents:
diff changeset
4632 if ( results ) {
jurzua
parents:
diff changeset
4633 results.push.apply( results, array );
jurzua
parents:
diff changeset
4634 return results;
jurzua
parents:
diff changeset
4635 }
jurzua
parents:
diff changeset
4636
jurzua
parents:
diff changeset
4637 return array;
jurzua
parents:
diff changeset
4638 };
jurzua
parents:
diff changeset
4639
jurzua
parents:
diff changeset
4640 // Perform a simple check to determine if the browser is capable of
jurzua
parents:
diff changeset
4641 // converting a NodeList to an array using builtin methods.
jurzua
parents:
diff changeset
4642 // Also verifies that the returned array holds DOM nodes
jurzua
parents:
diff changeset
4643 // (which is not the case in the Blackberry browser)
jurzua
parents:
diff changeset
4644 try {
jurzua
parents:
diff changeset
4645 Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
jurzua
parents:
diff changeset
4646
jurzua
parents:
diff changeset
4647 // Provide a fallback method if it does not work
jurzua
parents:
diff changeset
4648 } catch( e ) {
jurzua
parents:
diff changeset
4649 makeArray = function( array, results ) {
jurzua
parents:
diff changeset
4650 var i = 0,
jurzua
parents:
diff changeset
4651 ret = results || [];
jurzua
parents:
diff changeset
4652
jurzua
parents:
diff changeset
4653 if ( toString.call(array) === "[object Array]" ) {
jurzua
parents:
diff changeset
4654 Array.prototype.push.apply( ret, array );
jurzua
parents:
diff changeset
4655
jurzua
parents:
diff changeset
4656 } else {
jurzua
parents:
diff changeset
4657 if ( typeof array.length === "number" ) {
jurzua
parents:
diff changeset
4658 for ( var l = array.length; i < l; i++ ) {
jurzua
parents:
diff changeset
4659 ret.push( array[i] );
jurzua
parents:
diff changeset
4660 }
jurzua
parents:
diff changeset
4661
jurzua
parents:
diff changeset
4662 } else {
jurzua
parents:
diff changeset
4663 for ( ; array[i]; i++ ) {
jurzua
parents:
diff changeset
4664 ret.push( array[i] );
jurzua
parents:
diff changeset
4665 }
jurzua
parents:
diff changeset
4666 }
jurzua
parents:
diff changeset
4667 }
jurzua
parents:
diff changeset
4668
jurzua
parents:
diff changeset
4669 return ret;
jurzua
parents:
diff changeset
4670 };
jurzua
parents:
diff changeset
4671 }
jurzua
parents:
diff changeset
4672
jurzua
parents:
diff changeset
4673 var sortOrder, siblingCheck;
jurzua
parents:
diff changeset
4674
jurzua
parents:
diff changeset
4675 if ( document.documentElement.compareDocumentPosition ) {
jurzua
parents:
diff changeset
4676 sortOrder = function( a, b ) {
jurzua
parents:
diff changeset
4677 if ( a === b ) {
jurzua
parents:
diff changeset
4678 hasDuplicate = true;
jurzua
parents:
diff changeset
4679 return 0;
jurzua
parents:
diff changeset
4680 }
jurzua
parents:
diff changeset
4681
jurzua
parents:
diff changeset
4682 if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
jurzua
parents:
diff changeset
4683 return a.compareDocumentPosition ? -1 : 1;
jurzua
parents:
diff changeset
4684 }
jurzua
parents:
diff changeset
4685
jurzua
parents:
diff changeset
4686 return a.compareDocumentPosition(b) & 4 ? -1 : 1;
jurzua
parents:
diff changeset
4687 };
jurzua
parents:
diff changeset
4688
jurzua
parents:
diff changeset
4689 } else {
jurzua
parents:
diff changeset
4690 sortOrder = function( a, b ) {
jurzua
parents:
diff changeset
4691 // The nodes are identical, we can exit early
jurzua
parents:
diff changeset
4692 if ( a === b ) {
jurzua
parents:
diff changeset
4693 hasDuplicate = true;
jurzua
parents:
diff changeset
4694 return 0;
jurzua
parents:
diff changeset
4695
jurzua
parents:
diff changeset
4696 // Fallback to using sourceIndex (in IE) if it's available on both nodes
jurzua
parents:
diff changeset
4697 } else if ( a.sourceIndex && b.sourceIndex ) {
jurzua
parents:
diff changeset
4698 return a.sourceIndex - b.sourceIndex;
jurzua
parents:
diff changeset
4699 }
jurzua
parents:
diff changeset
4700
jurzua
parents:
diff changeset
4701 var al, bl,
jurzua
parents:
diff changeset
4702 ap = [],
jurzua
parents:
diff changeset
4703 bp = [],
jurzua
parents:
diff changeset
4704 aup = a.parentNode,
jurzua
parents:
diff changeset
4705 bup = b.parentNode,
jurzua
parents:
diff changeset
4706 cur = aup;
jurzua
parents:
diff changeset
4707
jurzua
parents:
diff changeset
4708 // If the nodes are siblings (or identical) we can do a quick check
jurzua
parents:
diff changeset
4709 if ( aup === bup ) {
jurzua
parents:
diff changeset
4710 return siblingCheck( a, b );
jurzua
parents:
diff changeset
4711
jurzua
parents:
diff changeset
4712 // If no parents were found then the nodes are disconnected
jurzua
parents:
diff changeset
4713 } else if ( !aup ) {
jurzua
parents:
diff changeset
4714 return -1;
jurzua
parents:
diff changeset
4715
jurzua
parents:
diff changeset
4716 } else if ( !bup ) {
jurzua
parents:
diff changeset
4717 return 1;
jurzua
parents:
diff changeset
4718 }
jurzua
parents:
diff changeset
4719
jurzua
parents:
diff changeset
4720 // Otherwise they're somewhere else in the tree so we need
jurzua
parents:
diff changeset
4721 // to build up a full list of the parentNodes for comparison
jurzua
parents:
diff changeset
4722 while ( cur ) {
jurzua
parents:
diff changeset
4723 ap.unshift( cur );
jurzua
parents:
diff changeset
4724 cur = cur.parentNode;
jurzua
parents:
diff changeset
4725 }
jurzua
parents:
diff changeset
4726
jurzua
parents:
diff changeset
4727 cur = bup;
jurzua
parents:
diff changeset
4728
jurzua
parents:
diff changeset
4729 while ( cur ) {
jurzua
parents:
diff changeset
4730 bp.unshift( cur );
jurzua
parents:
diff changeset
4731 cur = cur.parentNode;
jurzua
parents:
diff changeset
4732 }
jurzua
parents:
diff changeset
4733
jurzua
parents:
diff changeset
4734 al = ap.length;
jurzua
parents:
diff changeset
4735 bl = bp.length;
jurzua
parents:
diff changeset
4736
jurzua
parents:
diff changeset
4737 // Start walking down the tree looking for a discrepancy
jurzua
parents:
diff changeset
4738 for ( var i = 0; i < al && i < bl; i++ ) {
jurzua
parents:
diff changeset
4739 if ( ap[i] !== bp[i] ) {
jurzua
parents:
diff changeset
4740 return siblingCheck( ap[i], bp[i] );
jurzua
parents:
diff changeset
4741 }
jurzua
parents:
diff changeset
4742 }
jurzua
parents:
diff changeset
4743
jurzua
parents:
diff changeset
4744 // We ended someplace up the tree so do a sibling check
jurzua
parents:
diff changeset
4745 return i === al ?
jurzua
parents:
diff changeset
4746 siblingCheck( a, bp[i], -1 ) :
jurzua
parents:
diff changeset
4747 siblingCheck( ap[i], b, 1 );
jurzua
parents:
diff changeset
4748 };
jurzua
parents:
diff changeset
4749
jurzua
parents:
diff changeset
4750 siblingCheck = function( a, b, ret ) {
jurzua
parents:
diff changeset
4751 if ( a === b ) {
jurzua
parents:
diff changeset
4752 return ret;
jurzua
parents:
diff changeset
4753 }
jurzua
parents:
diff changeset
4754
jurzua
parents:
diff changeset
4755 var cur = a.nextSibling;
jurzua
parents:
diff changeset
4756
jurzua
parents:
diff changeset
4757 while ( cur ) {
jurzua
parents:
diff changeset
4758 if ( cur === b ) {
jurzua
parents:
diff changeset
4759 return -1;
jurzua
parents:
diff changeset
4760 }
jurzua
parents:
diff changeset
4761
jurzua
parents:
diff changeset
4762 cur = cur.nextSibling;
jurzua
parents:
diff changeset
4763 }
jurzua
parents:
diff changeset
4764
jurzua
parents:
diff changeset
4765 return 1;
jurzua
parents:
diff changeset
4766 };
jurzua
parents:
diff changeset
4767 }
jurzua
parents:
diff changeset
4768
jurzua
parents:
diff changeset
4769 // Utility function for retreiving the text value of an array of DOM nodes
jurzua
parents:
diff changeset
4770 Sizzle.getText = function( elems ) {
jurzua
parents:
diff changeset
4771 var ret = "", elem;
jurzua
parents:
diff changeset
4772
jurzua
parents:
diff changeset
4773 for ( var i = 0; elems[i]; i++ ) {
jurzua
parents:
diff changeset
4774 elem = elems[i];
jurzua
parents:
diff changeset
4775
jurzua
parents:
diff changeset
4776 // Get the text from text nodes and CDATA nodes
jurzua
parents:
diff changeset
4777 if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
jurzua
parents:
diff changeset
4778 ret += elem.nodeValue;
jurzua
parents:
diff changeset
4779
jurzua
parents:
diff changeset
4780 // Traverse everything else, except comment nodes
jurzua
parents:
diff changeset
4781 } else if ( elem.nodeType !== 8 ) {
jurzua
parents:
diff changeset
4782 ret += Sizzle.getText( elem.childNodes );
jurzua
parents:
diff changeset
4783 }
jurzua
parents:
diff changeset
4784 }
jurzua
parents:
diff changeset
4785
jurzua
parents:
diff changeset
4786 return ret;
jurzua
parents:
diff changeset
4787 };
jurzua
parents:
diff changeset
4788
jurzua
parents:
diff changeset
4789 // Check to see if the browser returns elements by name when
jurzua
parents:
diff changeset
4790 // querying by getElementById (and provide a workaround)
jurzua
parents:
diff changeset
4791 (function(){
jurzua
parents:
diff changeset
4792 // We're going to inject a fake input element with a specified name
jurzua
parents:
diff changeset
4793 var form = document.createElement("div"),
jurzua
parents:
diff changeset
4794 id = "script" + (new Date()).getTime(),
jurzua
parents:
diff changeset
4795 root = document.documentElement;
jurzua
parents:
diff changeset
4796
jurzua
parents:
diff changeset
4797 form.innerHTML = "<a name='" + id + "'/>";
jurzua
parents:
diff changeset
4798
jurzua
parents:
diff changeset
4799 // Inject it into the root element, check its status, and remove it quickly
jurzua
parents:
diff changeset
4800 root.insertBefore( form, root.firstChild );
jurzua
parents:
diff changeset
4801
jurzua
parents:
diff changeset
4802 // The workaround has to do additional checks after a getElementById
jurzua
parents:
diff changeset
4803 // Which slows things down for other browsers (hence the branching)
jurzua
parents:
diff changeset
4804 if ( document.getElementById( id ) ) {
jurzua
parents:
diff changeset
4805 Expr.find.ID = function( match, context, isXML ) {
jurzua
parents:
diff changeset
4806 if ( typeof context.getElementById !== "undefined" && !isXML ) {
jurzua
parents:
diff changeset
4807 var m = context.getElementById(match[1]);
jurzua
parents:
diff changeset
4808
jurzua
parents:
diff changeset
4809 return m ?
jurzua
parents:
diff changeset
4810 m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
jurzua
parents:
diff changeset
4811 [m] :
jurzua
parents:
diff changeset
4812 undefined :
jurzua
parents:
diff changeset
4813 [];
jurzua
parents:
diff changeset
4814 }
jurzua
parents:
diff changeset
4815 };
jurzua
parents:
diff changeset
4816
jurzua
parents:
diff changeset
4817 Expr.filter.ID = function( elem, match ) {
jurzua
parents:
diff changeset
4818 var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
jurzua
parents:
diff changeset
4819
jurzua
parents:
diff changeset
4820 return elem.nodeType === 1 && node && node.nodeValue === match;
jurzua
parents:
diff changeset
4821 };
jurzua
parents:
diff changeset
4822 }
jurzua
parents:
diff changeset
4823
jurzua
parents:
diff changeset
4824 root.removeChild( form );
jurzua
parents:
diff changeset
4825
jurzua
parents:
diff changeset
4826 // release memory in IE
jurzua
parents:
diff changeset
4827 root = form = null;
jurzua
parents:
diff changeset
4828 })();
jurzua
parents:
diff changeset
4829
jurzua
parents:
diff changeset
4830 (function(){
jurzua
parents:
diff changeset
4831 // Check to see if the browser returns only elements
jurzua
parents:
diff changeset
4832 // when doing getElementsByTagName("*")
jurzua
parents:
diff changeset
4833
jurzua
parents:
diff changeset
4834 // Create a fake element
jurzua
parents:
diff changeset
4835 var div = document.createElement("div");
jurzua
parents:
diff changeset
4836 div.appendChild( document.createComment("") );
jurzua
parents:
diff changeset
4837
jurzua
parents:
diff changeset
4838 // Make sure no comments are found
jurzua
parents:
diff changeset
4839 if ( div.getElementsByTagName("*").length > 0 ) {
jurzua
parents:
diff changeset
4840 Expr.find.TAG = function( match, context ) {
jurzua
parents:
diff changeset
4841 var results = context.getElementsByTagName( match[1] );
jurzua
parents:
diff changeset
4842
jurzua
parents:
diff changeset
4843 // Filter out possible comments
jurzua
parents:
diff changeset
4844 if ( match[1] === "*" ) {
jurzua
parents:
diff changeset
4845 var tmp = [];
jurzua
parents:
diff changeset
4846
jurzua
parents:
diff changeset
4847 for ( var i = 0; results[i]; i++ ) {
jurzua
parents:
diff changeset
4848 if ( results[i].nodeType === 1 ) {
jurzua
parents:
diff changeset
4849 tmp.push( results[i] );
jurzua
parents:
diff changeset
4850 }
jurzua
parents:
diff changeset
4851 }
jurzua
parents:
diff changeset
4852
jurzua
parents:
diff changeset
4853 results = tmp;
jurzua
parents:
diff changeset
4854 }
jurzua
parents:
diff changeset
4855
jurzua
parents:
diff changeset
4856 return results;
jurzua
parents:
diff changeset
4857 };
jurzua
parents:
diff changeset
4858 }
jurzua
parents:
diff changeset
4859
jurzua
parents:
diff changeset
4860 // Check to see if an attribute returns normalized href attributes
jurzua
parents:
diff changeset
4861 div.innerHTML = "<a href='#'></a>";
jurzua
parents:
diff changeset
4862
jurzua
parents:
diff changeset
4863 if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
jurzua
parents:
diff changeset
4864 div.firstChild.getAttribute("href") !== "#" ) {
jurzua
parents:
diff changeset
4865
jurzua
parents:
diff changeset
4866 Expr.attrHandle.href = function( elem ) {
jurzua
parents:
diff changeset
4867 return elem.getAttribute( "href", 2 );
jurzua
parents:
diff changeset
4868 };
jurzua
parents:
diff changeset
4869 }
jurzua
parents:
diff changeset
4870
jurzua
parents:
diff changeset
4871 // release memory in IE
jurzua
parents:
diff changeset
4872 div = null;
jurzua
parents:
diff changeset
4873 })();
jurzua
parents:
diff changeset
4874
jurzua
parents:
diff changeset
4875 if ( document.querySelectorAll ) {
jurzua
parents:
diff changeset
4876 (function(){
jurzua
parents:
diff changeset
4877 var oldSizzle = Sizzle,
jurzua
parents:
diff changeset
4878 div = document.createElement("div"),
jurzua
parents:
diff changeset
4879 id = "__sizzle__";
jurzua
parents:
diff changeset
4880
jurzua
parents:
diff changeset
4881 div.innerHTML = "<p class='TEST'></p>";
jurzua
parents:
diff changeset
4882
jurzua
parents:
diff changeset
4883 // Safari can't handle uppercase or unicode characters when
jurzua
parents:
diff changeset
4884 // in quirks mode.
jurzua
parents:
diff changeset
4885 if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
jurzua
parents:
diff changeset
4886 return;
jurzua
parents:
diff changeset
4887 }
jurzua
parents:
diff changeset
4888
jurzua
parents:
diff changeset
4889 Sizzle = function( query, context, extra, seed ) {
jurzua
parents:
diff changeset
4890 context = context || document;
jurzua
parents:
diff changeset
4891
jurzua
parents:
diff changeset
4892 // Only use querySelectorAll on non-XML documents
jurzua
parents:
diff changeset
4893 // (ID selectors don't work in non-HTML documents)
jurzua
parents:
diff changeset
4894 if ( !seed && !Sizzle.isXML(context) ) {
jurzua
parents:
diff changeset
4895 // See if we find a selector to speed up
jurzua
parents:
diff changeset
4896 var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );
jurzua
parents:
diff changeset
4897
jurzua
parents:
diff changeset
4898 if ( match && (context.nodeType === 1 || context.nodeType === 9) ) {
jurzua
parents:
diff changeset
4899 // Speed-up: Sizzle("TAG")
jurzua
parents:
diff changeset
4900 if ( match[1] ) {
jurzua
parents:
diff changeset
4901 return makeArray( context.getElementsByTagName( query ), extra );
jurzua
parents:
diff changeset
4902
jurzua
parents:
diff changeset
4903 // Speed-up: Sizzle(".CLASS")
jurzua
parents:
diff changeset
4904 } else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
jurzua
parents:
diff changeset
4905 return makeArray( context.getElementsByClassName( match[2] ), extra );
jurzua
parents:
diff changeset
4906 }
jurzua
parents:
diff changeset
4907 }
jurzua
parents:
diff changeset
4908
jurzua
parents:
diff changeset
4909 if ( context.nodeType === 9 ) {
jurzua
parents:
diff changeset
4910 // Speed-up: Sizzle("body")
jurzua
parents:
diff changeset
4911 // The body element only exists once, optimize finding it
jurzua
parents:
diff changeset
4912 if ( query === "body" && context.body ) {
jurzua
parents:
diff changeset
4913 return makeArray( [ context.body ], extra );
jurzua
parents:
diff changeset
4914
jurzua
parents:
diff changeset
4915 // Speed-up: Sizzle("#ID")
jurzua
parents:
diff changeset
4916 } else if ( match && match[3] ) {
jurzua
parents:
diff changeset
4917 var elem = context.getElementById( match[3] );
jurzua
parents:
diff changeset
4918
jurzua
parents:
diff changeset
4919 // Check parentNode to catch when Blackberry 4.6 returns
jurzua
parents:
diff changeset
4920 // nodes that are no longer in the document #6963
jurzua
parents:
diff changeset
4921 if ( elem && elem.parentNode ) {
jurzua
parents:
diff changeset
4922 // Handle the case where IE and Opera return items
jurzua
parents:
diff changeset
4923 // by name instead of ID
jurzua
parents:
diff changeset
4924 if ( elem.id === match[3] ) {
jurzua
parents:
diff changeset
4925 return makeArray( [ elem ], extra );
jurzua
parents:
diff changeset
4926 }
jurzua
parents:
diff changeset
4927
jurzua
parents:
diff changeset
4928 } else {
jurzua
parents:
diff changeset
4929 return makeArray( [], extra );
jurzua
parents:
diff changeset
4930 }
jurzua
parents:
diff changeset
4931 }
jurzua
parents:
diff changeset
4932
jurzua
parents:
diff changeset
4933 try {
jurzua
parents:
diff changeset
4934 return makeArray( context.querySelectorAll(query), extra );
jurzua
parents:
diff changeset
4935 } catch(qsaError) {}
jurzua
parents:
diff changeset
4936
jurzua
parents:
diff changeset
4937 // qSA works strangely on Element-rooted queries
jurzua
parents:
diff changeset
4938 // We can work around this by specifying an extra ID on the root
jurzua
parents:
diff changeset
4939 // and working up from there (Thanks to Andrew Dupont for the technique)
jurzua
parents:
diff changeset
4940 // IE 8 doesn't work on object elements
jurzua
parents:
diff changeset
4941 } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
jurzua
parents:
diff changeset
4942 var oldContext = context,
jurzua
parents:
diff changeset
4943 old = context.getAttribute( "id" ),
jurzua
parents:
diff changeset
4944 nid = old || id,
jurzua
parents:
diff changeset
4945 hasParent = context.parentNode,
jurzua
parents:
diff changeset
4946 relativeHierarchySelector = /^\s*[+~]/.test( query );
jurzua
parents:
diff changeset
4947
jurzua
parents:
diff changeset
4948 if ( !old ) {
jurzua
parents:
diff changeset
4949 context.setAttribute( "id", nid );
jurzua
parents:
diff changeset
4950 } else {
jurzua
parents:
diff changeset
4951 nid = nid.replace( /'/g, "\\$&" );
jurzua
parents:
diff changeset
4952 }
jurzua
parents:
diff changeset
4953 if ( relativeHierarchySelector && hasParent ) {
jurzua
parents:
diff changeset
4954 context = context.parentNode;
jurzua
parents:
diff changeset
4955 }
jurzua
parents:
diff changeset
4956
jurzua
parents:
diff changeset
4957 try {
jurzua
parents:
diff changeset
4958 if ( !relativeHierarchySelector || hasParent ) {
jurzua
parents:
diff changeset
4959 return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
jurzua
parents:
diff changeset
4960 }
jurzua
parents:
diff changeset
4961
jurzua
parents:
diff changeset
4962 } catch(pseudoError) {
jurzua
parents:
diff changeset
4963 } finally {
jurzua
parents:
diff changeset
4964 if ( !old ) {
jurzua
parents:
diff changeset
4965 oldContext.removeAttribute( "id" );
jurzua
parents:
diff changeset
4966 }
jurzua
parents:
diff changeset
4967 }
jurzua
parents:
diff changeset
4968 }
jurzua
parents:
diff changeset
4969 }
jurzua
parents:
diff changeset
4970
jurzua
parents:
diff changeset
4971 return oldSizzle(query, context, extra, seed);
jurzua
parents:
diff changeset
4972 };
jurzua
parents:
diff changeset
4973
jurzua
parents:
diff changeset
4974 for ( var prop in oldSizzle ) {
jurzua
parents:
diff changeset
4975 Sizzle[ prop ] = oldSizzle[ prop ];
jurzua
parents:
diff changeset
4976 }
jurzua
parents:
diff changeset
4977
jurzua
parents:
diff changeset
4978 // release memory in IE
jurzua
parents:
diff changeset
4979 div = null;
jurzua
parents:
diff changeset
4980 })();
jurzua
parents:
diff changeset
4981 }
jurzua
parents:
diff changeset
4982
jurzua
parents:
diff changeset
4983 (function(){
jurzua
parents:
diff changeset
4984 var html = document.documentElement,
jurzua
parents:
diff changeset
4985 matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector;
jurzua
parents:
diff changeset
4986
jurzua
parents:
diff changeset
4987 if ( matches ) {
jurzua
parents:
diff changeset
4988 // Check to see if it's possible to do matchesSelector
jurzua
parents:
diff changeset
4989 // on a disconnected node (IE 9 fails this)
jurzua
parents:
diff changeset
4990 var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ),
jurzua
parents:
diff changeset
4991 pseudoWorks = false;
jurzua
parents:
diff changeset
4992
jurzua
parents:
diff changeset
4993 try {
jurzua
parents:
diff changeset
4994 // This should fail with an exception
jurzua
parents:
diff changeset
4995 // Gecko does not error, returns false instead
jurzua
parents:
diff changeset
4996 matches.call( document.documentElement, "[test!='']:sizzle" );
jurzua
parents:
diff changeset
4997
jurzua
parents:
diff changeset
4998 } catch( pseudoError ) {
jurzua
parents:
diff changeset
4999 pseudoWorks = true;
jurzua
parents:
diff changeset
5000 }
jurzua
parents:
diff changeset
5001
jurzua
parents:
diff changeset
5002 Sizzle.matchesSelector = function( node, expr ) {
jurzua
parents:
diff changeset
5003 // Make sure that attribute selectors are quoted
jurzua
parents:
diff changeset
5004 expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
jurzua
parents:
diff changeset
5005
jurzua
parents:
diff changeset
5006 if ( !Sizzle.isXML( node ) ) {
jurzua
parents:
diff changeset
5007 try {
jurzua
parents:
diff changeset
5008 if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
jurzua
parents:
diff changeset
5009 var ret = matches.call( node, expr );
jurzua
parents:
diff changeset
5010
jurzua
parents:
diff changeset
5011 // IE 9's matchesSelector returns false on disconnected nodes
jurzua
parents:
diff changeset
5012 if ( ret || !disconnectedMatch ||
jurzua
parents:
diff changeset
5013 // As well, disconnected nodes are said to be in a document
jurzua
parents:
diff changeset
5014 // fragment in IE 9, so check for that
jurzua
parents:
diff changeset
5015 node.document && node.document.nodeType !== 11 ) {
jurzua
parents:
diff changeset
5016 return ret;
jurzua
parents:
diff changeset
5017 }
jurzua
parents:
diff changeset
5018 }
jurzua
parents:
diff changeset
5019 } catch(e) {}
jurzua
parents:
diff changeset
5020 }
jurzua
parents:
diff changeset
5021
jurzua
parents:
diff changeset
5022 return Sizzle(expr, null, null, [node]).length > 0;
jurzua
parents:
diff changeset
5023 };
jurzua
parents:
diff changeset
5024 }
jurzua
parents:
diff changeset
5025 })();
jurzua
parents:
diff changeset
5026
jurzua
parents:
diff changeset
5027 (function(){
jurzua
parents:
diff changeset
5028 var div = document.createElement("div");
jurzua
parents:
diff changeset
5029
jurzua
parents:
diff changeset
5030 div.innerHTML = "<div class='test e'></div><div class='test'></div>";
jurzua
parents:
diff changeset
5031
jurzua
parents:
diff changeset
5032 // Opera can't find a second classname (in 9.6)
jurzua
parents:
diff changeset
5033 // Also, make sure that getElementsByClassName actually exists
jurzua
parents:
diff changeset
5034 if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
jurzua
parents:
diff changeset
5035 return;
jurzua
parents:
diff changeset
5036 }
jurzua
parents:
diff changeset
5037
jurzua
parents:
diff changeset
5038 // Safari caches class attributes, doesn't catch changes (in 3.2)
jurzua
parents:
diff changeset
5039 div.lastChild.className = "e";
jurzua
parents:
diff changeset
5040
jurzua
parents:
diff changeset
5041 if ( div.getElementsByClassName("e").length === 1 ) {
jurzua
parents:
diff changeset
5042 return;
jurzua
parents:
diff changeset
5043 }
jurzua
parents:
diff changeset
5044
jurzua
parents:
diff changeset
5045 Expr.order.splice(1, 0, "CLASS");
jurzua
parents:
diff changeset
5046 Expr.find.CLASS = function( match, context, isXML ) {
jurzua
parents:
diff changeset
5047 if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
jurzua
parents:
diff changeset
5048 return context.getElementsByClassName(match[1]);
jurzua
parents:
diff changeset
5049 }
jurzua
parents:
diff changeset
5050 };
jurzua
parents:
diff changeset
5051
jurzua
parents:
diff changeset
5052 // release memory in IE
jurzua
parents:
diff changeset
5053 div = null;
jurzua
parents:
diff changeset
5054 })();
jurzua
parents:
diff changeset
5055
jurzua
parents:
diff changeset
5056 function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
jurzua
parents:
diff changeset
5057 for ( var i = 0, l = checkSet.length; i < l; i++ ) {
jurzua
parents:
diff changeset
5058 var elem = checkSet[i];
jurzua
parents:
diff changeset
5059
jurzua
parents:
diff changeset
5060 if ( elem ) {
jurzua
parents:
diff changeset
5061 var match = false;
jurzua
parents:
diff changeset
5062
jurzua
parents:
diff changeset
5063 elem = elem[dir];
jurzua
parents:
diff changeset
5064
jurzua
parents:
diff changeset
5065 while ( elem ) {
jurzua
parents:
diff changeset
5066 if ( elem.sizcache === doneName ) {
jurzua
parents:
diff changeset
5067 match = checkSet[elem.sizset];
jurzua
parents:
diff changeset
5068 break;
jurzua
parents:
diff changeset
5069 }
jurzua
parents:
diff changeset
5070
jurzua
parents:
diff changeset
5071 if ( elem.nodeType === 1 && !isXML ){
jurzua
parents:
diff changeset
5072 elem.sizcache = doneName;
jurzua
parents:
diff changeset
5073 elem.sizset = i;
jurzua
parents:
diff changeset
5074 }
jurzua
parents:
diff changeset
5075
jurzua
parents:
diff changeset
5076 if ( elem.nodeName.toLowerCase() === cur ) {
jurzua
parents:
diff changeset
5077 match = elem;
jurzua
parents:
diff changeset
5078 break;
jurzua
parents:
diff changeset
5079 }
jurzua
parents:
diff changeset
5080
jurzua
parents:
diff changeset
5081 elem = elem[dir];
jurzua
parents:
diff changeset
5082 }
jurzua
parents:
diff changeset
5083
jurzua
parents:
diff changeset
5084 checkSet[i] = match;
jurzua
parents:
diff changeset
5085 }
jurzua
parents:
diff changeset
5086 }
jurzua
parents:
diff changeset
5087 }
jurzua
parents:
diff changeset
5088
jurzua
parents:
diff changeset
5089 function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
jurzua
parents:
diff changeset
5090 for ( var i = 0, l = checkSet.length; i < l; i++ ) {
jurzua
parents:
diff changeset
5091 var elem = checkSet[i];
jurzua
parents:
diff changeset
5092
jurzua
parents:
diff changeset
5093 if ( elem ) {
jurzua
parents:
diff changeset
5094 var match = false;
jurzua
parents:
diff changeset
5095
jurzua
parents:
diff changeset
5096 elem = elem[dir];
jurzua
parents:
diff changeset
5097
jurzua
parents:
diff changeset
5098 while ( elem ) {
jurzua
parents:
diff changeset
5099 if ( elem.sizcache === doneName ) {
jurzua
parents:
diff changeset
5100 match = checkSet[elem.sizset];
jurzua
parents:
diff changeset
5101 break;
jurzua
parents:
diff changeset
5102 }
jurzua
parents:
diff changeset
5103
jurzua
parents:
diff changeset
5104 if ( elem.nodeType === 1 ) {
jurzua
parents:
diff changeset
5105 if ( !isXML ) {
jurzua
parents:
diff changeset
5106 elem.sizcache = doneName;
jurzua
parents:
diff changeset
5107 elem.sizset = i;
jurzua
parents:
diff changeset
5108 }
jurzua
parents:
diff changeset
5109
jurzua
parents:
diff changeset
5110 if ( typeof cur !== "string" ) {
jurzua
parents:
diff changeset
5111 if ( elem === cur ) {
jurzua
parents:
diff changeset
5112 match = true;
jurzua
parents:
diff changeset
5113 break;
jurzua
parents:
diff changeset
5114 }
jurzua
parents:
diff changeset
5115
jurzua
parents:
diff changeset
5116 } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
jurzua
parents:
diff changeset
5117 match = elem;
jurzua
parents:
diff changeset
5118 break;
jurzua
parents:
diff changeset
5119 }
jurzua
parents:
diff changeset
5120 }
jurzua
parents:
diff changeset
5121
jurzua
parents:
diff changeset
5122 elem = elem[dir];
jurzua
parents:
diff changeset
5123 }
jurzua
parents:
diff changeset
5124
jurzua
parents:
diff changeset
5125 checkSet[i] = match;
jurzua
parents:
diff changeset
5126 }
jurzua
parents:
diff changeset
5127 }
jurzua
parents:
diff changeset
5128 }
jurzua
parents:
diff changeset
5129
jurzua
parents:
diff changeset
5130 if ( document.documentElement.contains ) {
jurzua
parents:
diff changeset
5131 Sizzle.contains = function( a, b ) {
jurzua
parents:
diff changeset
5132 return a !== b && (a.contains ? a.contains(b) : true);
jurzua
parents:
diff changeset
5133 };
jurzua
parents:
diff changeset
5134
jurzua
parents:
diff changeset
5135 } else if ( document.documentElement.compareDocumentPosition ) {
jurzua
parents:
diff changeset
5136 Sizzle.contains = function( a, b ) {
jurzua
parents:
diff changeset
5137 return !!(a.compareDocumentPosition(b) & 16);
jurzua
parents:
diff changeset
5138 };
jurzua
parents:
diff changeset
5139
jurzua
parents:
diff changeset
5140 } else {
jurzua
parents:
diff changeset
5141 Sizzle.contains = function() {
jurzua
parents:
diff changeset
5142 return false;
jurzua
parents:
diff changeset
5143 };
jurzua
parents:
diff changeset
5144 }
jurzua
parents:
diff changeset
5145
jurzua
parents:
diff changeset
5146 Sizzle.isXML = function( elem ) {
jurzua
parents:
diff changeset
5147 // documentElement is verified for cases where it doesn't yet exist
jurzua
parents:
diff changeset
5148 // (such as loading iframes in IE - #4833)
jurzua
parents:
diff changeset
5149 var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
jurzua
parents:
diff changeset
5150
jurzua
parents:
diff changeset
5151 return documentElement ? documentElement.nodeName !== "HTML" : false;
jurzua
parents:
diff changeset
5152 };
jurzua
parents:
diff changeset
5153
jurzua
parents:
diff changeset
5154 var posProcess = function( selector, context ) {
jurzua
parents:
diff changeset
5155 var match,
jurzua
parents:
diff changeset
5156 tmpSet = [],
jurzua
parents:
diff changeset
5157 later = "",
jurzua
parents:
diff changeset
5158 root = context.nodeType ? [context] : context;
jurzua
parents:
diff changeset
5159
jurzua
parents:
diff changeset
5160 // Position selectors must be done after the filter
jurzua
parents:
diff changeset
5161 // And so must :not(positional) so we move all PSEUDOs to the end
jurzua
parents:
diff changeset
5162 while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
jurzua
parents:
diff changeset
5163 later += match[0];
jurzua
parents:
diff changeset
5164 selector = selector.replace( Expr.match.PSEUDO, "" );
jurzua
parents:
diff changeset
5165 }
jurzua
parents:
diff changeset
5166
jurzua
parents:
diff changeset
5167 selector = Expr.relative[selector] ? selector + "*" : selector;
jurzua
parents:
diff changeset
5168
jurzua
parents:
diff changeset
5169 for ( var i = 0, l = root.length; i < l; i++ ) {
jurzua
parents:
diff changeset
5170 Sizzle( selector, root[i], tmpSet );
jurzua
parents:
diff changeset
5171 }
jurzua
parents:
diff changeset
5172
jurzua
parents:
diff changeset
5173 return Sizzle.filter( later, tmpSet );
jurzua
parents:
diff changeset
5174 };
jurzua
parents:
diff changeset
5175
jurzua
parents:
diff changeset
5176 // EXPOSE
jurzua
parents:
diff changeset
5177 jQuery.find = Sizzle;
jurzua
parents:
diff changeset
5178 jQuery.expr = Sizzle.selectors;
jurzua
parents:
diff changeset
5179 jQuery.expr[":"] = jQuery.expr.filters;
jurzua
parents:
diff changeset
5180 jQuery.unique = Sizzle.uniqueSort;
jurzua
parents:
diff changeset
5181 jQuery.text = Sizzle.getText;
jurzua
parents:
diff changeset
5182 jQuery.isXMLDoc = Sizzle.isXML;
jurzua
parents:
diff changeset
5183 jQuery.contains = Sizzle.contains;
jurzua
parents:
diff changeset
5184
jurzua
parents:
diff changeset
5185
jurzua
parents:
diff changeset
5186 })();
jurzua
parents:
diff changeset
5187
jurzua
parents:
diff changeset
5188
jurzua
parents:
diff changeset
5189 var runtil = /Until$/,
jurzua
parents:
diff changeset
5190 rparentsprev = /^(?:parents|prevUntil|prevAll)/,
jurzua
parents:
diff changeset
5191 // Note: This RegExp should be improved, or likely pulled from Sizzle
jurzua
parents:
diff changeset
5192 rmultiselector = /,/,
jurzua
parents:
diff changeset
5193 isSimple = /^.[^:#\[\.,]*$/,
jurzua
parents:
diff changeset
5194 slice = Array.prototype.slice,
jurzua
parents:
diff changeset
5195 POS = jQuery.expr.match.POS,
jurzua
parents:
diff changeset
5196 // methods guaranteed to produce a unique set when starting from a unique set
jurzua
parents:
diff changeset
5197 guaranteedUnique = {
jurzua
parents:
diff changeset
5198 children: true,
jurzua
parents:
diff changeset
5199 contents: true,
jurzua
parents:
diff changeset
5200 next: true,
jurzua
parents:
diff changeset
5201 prev: true
jurzua
parents:
diff changeset
5202 };
jurzua
parents:
diff changeset
5203
jurzua
parents:
diff changeset
5204 jQuery.fn.extend({
jurzua
parents:
diff changeset
5205 find: function( selector ) {
jurzua
parents:
diff changeset
5206 var self = this,
jurzua
parents:
diff changeset
5207 i, l;
jurzua
parents:
diff changeset
5208
jurzua
parents:
diff changeset
5209 if ( typeof selector !== "string" ) {
jurzua
parents:
diff changeset
5210 return jQuery( selector ).filter(function() {
jurzua
parents:
diff changeset
5211 for ( i = 0, l = self.length; i < l; i++ ) {
jurzua
parents:
diff changeset
5212 if ( jQuery.contains( self[ i ], this ) ) {
jurzua
parents:
diff changeset
5213 return true;
jurzua
parents:
diff changeset
5214 }
jurzua
parents:
diff changeset
5215 }
jurzua
parents:
diff changeset
5216 });
jurzua
parents:
diff changeset
5217 }
jurzua
parents:
diff changeset
5218
jurzua
parents:
diff changeset
5219 var ret = this.pushStack( "", "find", selector ),
jurzua
parents:
diff changeset
5220 length, n, r;
jurzua
parents:
diff changeset
5221
jurzua
parents:
diff changeset
5222 for ( i = 0, l = this.length; i < l; i++ ) {
jurzua
parents:
diff changeset
5223 length = ret.length;
jurzua
parents:
diff changeset
5224 jQuery.find( selector, this[i], ret );
jurzua
parents:
diff changeset
5225
jurzua
parents:
diff changeset
5226 if ( i > 0 ) {
jurzua
parents:
diff changeset
5227 // Make sure that the results are unique
jurzua
parents:
diff changeset
5228 for ( n = length; n < ret.length; n++ ) {
jurzua
parents:
diff changeset
5229 for ( r = 0; r < length; r++ ) {
jurzua
parents:
diff changeset
5230 if ( ret[r] === ret[n] ) {
jurzua
parents:
diff changeset
5231 ret.splice(n--, 1);
jurzua
parents:
diff changeset
5232 break;
jurzua
parents:
diff changeset
5233 }
jurzua
parents:
diff changeset
5234 }
jurzua
parents:
diff changeset
5235 }
jurzua
parents:
diff changeset
5236 }
jurzua
parents:
diff changeset
5237 }
jurzua
parents:
diff changeset
5238
jurzua
parents:
diff changeset
5239 return ret;
jurzua
parents:
diff changeset
5240 },
jurzua
parents:
diff changeset
5241
jurzua
parents:
diff changeset
5242 has: function( target ) {
jurzua
parents:
diff changeset
5243 var targets = jQuery( target );
jurzua
parents:
diff changeset
5244 return this.filter(function() {
jurzua
parents:
diff changeset
5245 for ( var i = 0, l = targets.length; i < l; i++ ) {
jurzua
parents:
diff changeset
5246 if ( jQuery.contains( this, targets[i] ) ) {
jurzua
parents:
diff changeset
5247 return true;
jurzua
parents:
diff changeset
5248 }
jurzua
parents:
diff changeset
5249 }
jurzua
parents:
diff changeset
5250 });
jurzua
parents:
diff changeset
5251 },
jurzua
parents:
diff changeset
5252
jurzua
parents:
diff changeset
5253 not: function( selector ) {
jurzua
parents:
diff changeset
5254 return this.pushStack( winnow(this, selector, false), "not", selector);
jurzua
parents:
diff changeset
5255 },
jurzua
parents:
diff changeset
5256
jurzua
parents:
diff changeset
5257 filter: function( selector ) {
jurzua
parents:
diff changeset
5258 return this.pushStack( winnow(this, selector, true), "filter", selector );
jurzua
parents:
diff changeset
5259 },
jurzua
parents:
diff changeset
5260
jurzua
parents:
diff changeset
5261 is: function( selector ) {
jurzua
parents:
diff changeset
5262 return !!selector && ( typeof selector === "string" ?
jurzua
parents:
diff changeset
5263 jQuery.filter( selector, this ).length > 0 :
jurzua
parents:
diff changeset
5264 this.filter( selector ).length > 0 );
jurzua
parents:
diff changeset
5265 },
jurzua
parents:
diff changeset
5266
jurzua
parents:
diff changeset
5267 closest: function( selectors, context ) {
jurzua
parents:
diff changeset
5268 var ret = [], i, l, cur = this[0];
jurzua
parents:
diff changeset
5269
jurzua
parents:
diff changeset
5270 // Array
jurzua
parents:
diff changeset
5271 if ( jQuery.isArray( selectors ) ) {
jurzua
parents:
diff changeset
5272 var match, selector,
jurzua
parents:
diff changeset
5273 matches = {},
jurzua
parents:
diff changeset
5274 level = 1;
jurzua
parents:
diff changeset
5275
jurzua
parents:
diff changeset
5276 if ( cur && selectors.length ) {
jurzua
parents:
diff changeset
5277 for ( i = 0, l = selectors.length; i < l; i++ ) {
jurzua
parents:
diff changeset
5278 selector = selectors[i];
jurzua
parents:
diff changeset
5279
jurzua
parents:
diff changeset
5280 if ( !matches[ selector ] ) {
jurzua
parents:
diff changeset
5281 matches[ selector ] = POS.test( selector ) ?
jurzua
parents:
diff changeset
5282 jQuery( selector, context || this.context ) :
jurzua
parents:
diff changeset
5283 selector;
jurzua
parents:
diff changeset
5284 }
jurzua
parents:
diff changeset
5285 }
jurzua
parents:
diff changeset
5286
jurzua
parents:
diff changeset
5287 while ( cur && cur.ownerDocument && cur !== context ) {
jurzua
parents:
diff changeset
5288 for ( selector in matches ) {
jurzua
parents:
diff changeset
5289 match = matches[ selector ];
jurzua
parents:
diff changeset
5290
jurzua
parents:
diff changeset
5291 if ( match.jquery ? match.index( cur ) > -1 : jQuery( cur ).is( match ) ) {
jurzua
parents:
diff changeset
5292 ret.push({ selector: selector, elem: cur, level: level });
jurzua
parents:
diff changeset
5293 }
jurzua
parents:
diff changeset
5294 }
jurzua
parents:
diff changeset
5295
jurzua
parents:
diff changeset
5296 cur = cur.parentNode;
jurzua
parents:
diff changeset
5297 level++;
jurzua
parents:
diff changeset
5298 }
jurzua
parents:
diff changeset
5299 }
jurzua
parents:
diff changeset
5300
jurzua
parents:
diff changeset
5301 return ret;
jurzua
parents:
diff changeset
5302 }
jurzua
parents:
diff changeset
5303
jurzua
parents:
diff changeset
5304 // String
jurzua
parents:
diff changeset
5305 var pos = POS.test( selectors ) || typeof selectors !== "string" ?
jurzua
parents:
diff changeset
5306 jQuery( selectors, context || this.context ) :
jurzua
parents:
diff changeset
5307 0;
jurzua
parents:
diff changeset
5308
jurzua
parents:
diff changeset
5309 for ( i = 0, l = this.length; i < l; i++ ) {
jurzua
parents:
diff changeset
5310 cur = this[i];
jurzua
parents:
diff changeset
5311
jurzua
parents:
diff changeset
5312 while ( cur ) {
jurzua
parents:
diff changeset
5313 if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
jurzua
parents:
diff changeset
5314 ret.push( cur );
jurzua
parents:
diff changeset
5315 break;
jurzua
parents:
diff changeset
5316
jurzua
parents:
diff changeset
5317 } else {
jurzua
parents:
diff changeset
5318 cur = cur.parentNode;
jurzua
parents:
diff changeset
5319 if ( !cur || !cur.ownerDocument || cur === context || cur.nodeType === 11 ) {
jurzua
parents:
diff changeset
5320 break;
jurzua
parents:
diff changeset
5321 }
jurzua
parents:
diff changeset
5322 }
jurzua
parents:
diff changeset
5323 }
jurzua
parents:
diff changeset
5324 }
jurzua
parents:
diff changeset
5325
jurzua
parents:
diff changeset
5326 ret = ret.length > 1 ? jQuery.unique( ret ) : ret;
jurzua
parents:
diff changeset
5327
jurzua
parents:
diff changeset
5328 return this.pushStack( ret, "closest", selectors );
jurzua
parents:
diff changeset
5329 },
jurzua
parents:
diff changeset
5330
jurzua
parents:
diff changeset
5331 // Determine the position of an element within
jurzua
parents:
diff changeset
5332 // the matched set of elements
jurzua
parents:
diff changeset
5333 index: function( elem ) {
jurzua
parents:
diff changeset
5334
jurzua
parents:
diff changeset
5335 // No argument, return index in parent
jurzua
parents:
diff changeset
5336 if ( !elem ) {
jurzua
parents:
diff changeset
5337 return ( this[0] && this[0].parentNode ) ? this.prevAll().length : -1;
jurzua
parents:
diff changeset
5338 }
jurzua
parents:
diff changeset
5339
jurzua
parents:
diff changeset
5340 // index in selector
jurzua
parents:
diff changeset
5341 if ( typeof elem === "string" ) {
jurzua
parents:
diff changeset
5342 return jQuery.inArray( this[0], jQuery( elem ) );
jurzua
parents:
diff changeset
5343 }
jurzua
parents:
diff changeset
5344
jurzua
parents:
diff changeset
5345 // Locate the position of the desired element
jurzua
parents:
diff changeset
5346 return jQuery.inArray(
jurzua
parents:
diff changeset
5347 // If it receives a jQuery object, the first element is used
jurzua
parents:
diff changeset
5348 elem.jquery ? elem[0] : elem, this );
jurzua
parents:
diff changeset
5349 },
jurzua
parents:
diff changeset
5350
jurzua
parents:
diff changeset
5351 add: function( selector, context ) {
jurzua
parents:
diff changeset
5352 var set = typeof selector === "string" ?
jurzua
parents:
diff changeset
5353 jQuery( selector, context ) :
jurzua
parents:
diff changeset
5354 jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
jurzua
parents:
diff changeset
5355 all = jQuery.merge( this.get(), set );
jurzua
parents:
diff changeset
5356
jurzua
parents:
diff changeset
5357 return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
jurzua
parents:
diff changeset
5358 all :
jurzua
parents:
diff changeset
5359 jQuery.unique( all ) );
jurzua
parents:
diff changeset
5360 },
jurzua
parents:
diff changeset
5361
jurzua
parents:
diff changeset
5362 andSelf: function() {
jurzua
parents:
diff changeset
5363 return this.add( this.prevObject );
jurzua
parents:
diff changeset
5364 }
jurzua
parents:
diff changeset
5365 });
jurzua
parents:
diff changeset
5366
jurzua
parents:
diff changeset
5367 // A painfully simple check to see if an element is disconnected
jurzua
parents:
diff changeset
5368 // from a document (should be improved, where feasible).
jurzua
parents:
diff changeset
5369 function isDisconnected( node ) {
jurzua
parents:
diff changeset
5370 return !node || !node.parentNode || node.parentNode.nodeType === 11;
jurzua
parents:
diff changeset
5371 }
jurzua
parents:
diff changeset
5372
jurzua
parents:
diff changeset
5373 jQuery.each({
jurzua
parents:
diff changeset
5374 parent: function( elem ) {
jurzua
parents:
diff changeset
5375 var parent = elem.parentNode;
jurzua
parents:
diff changeset
5376 return parent && parent.nodeType !== 11 ? parent : null;
jurzua
parents:
diff changeset
5377 },
jurzua
parents:
diff changeset
5378 parents: function( elem ) {
jurzua
parents:
diff changeset
5379 return jQuery.dir( elem, "parentNode" );
jurzua
parents:
diff changeset
5380 },
jurzua
parents:
diff changeset
5381 parentsUntil: function( elem, i, until ) {
jurzua
parents:
diff changeset
5382 return jQuery.dir( elem, "parentNode", until );
jurzua
parents:
diff changeset
5383 },
jurzua
parents:
diff changeset
5384 next: function( elem ) {
jurzua
parents:
diff changeset
5385 return jQuery.nth( elem, 2, "nextSibling" );
jurzua
parents:
diff changeset
5386 },
jurzua
parents:
diff changeset
5387 prev: function( elem ) {
jurzua
parents:
diff changeset
5388 return jQuery.nth( elem, 2, "previousSibling" );
jurzua
parents:
diff changeset
5389 },
jurzua
parents:
diff changeset
5390 nextAll: function( elem ) {
jurzua
parents:
diff changeset
5391 return jQuery.dir( elem, "nextSibling" );
jurzua
parents:
diff changeset
5392 },
jurzua
parents:
diff changeset
5393 prevAll: function( elem ) {
jurzua
parents:
diff changeset
5394 return jQuery.dir( elem, "previousSibling" );
jurzua
parents:
diff changeset
5395 },
jurzua
parents:
diff changeset
5396 nextUntil: function( elem, i, until ) {
jurzua
parents:
diff changeset
5397 return jQuery.dir( elem, "nextSibling", until );
jurzua
parents:
diff changeset
5398 },
jurzua
parents:
diff changeset
5399 prevUntil: function( elem, i, until ) {
jurzua
parents:
diff changeset
5400 return jQuery.dir( elem, "previousSibling", until );
jurzua
parents:
diff changeset
5401 },
jurzua
parents:
diff changeset
5402 siblings: function( elem ) {
jurzua
parents:
diff changeset
5403 return jQuery.sibling( elem.parentNode.firstChild, elem );
jurzua
parents:
diff changeset
5404 },
jurzua
parents:
diff changeset
5405 children: function( elem ) {
jurzua
parents:
diff changeset
5406 return jQuery.sibling( elem.firstChild );
jurzua
parents:
diff changeset
5407 },
jurzua
parents:
diff changeset
5408 contents: function( elem ) {
jurzua
parents:
diff changeset
5409 return jQuery.nodeName( elem, "iframe" ) ?
jurzua
parents:
diff changeset
5410 elem.contentDocument || elem.contentWindow.document :
jurzua
parents:
diff changeset
5411 jQuery.makeArray( elem.childNodes );
jurzua
parents:
diff changeset
5412 }
jurzua
parents:
diff changeset
5413 }, function( name, fn ) {
jurzua
parents:
diff changeset
5414 jQuery.fn[ name ] = function( until, selector ) {
jurzua
parents:
diff changeset
5415 var ret = jQuery.map( this, fn, until ),
jurzua
parents:
diff changeset
5416 // The variable 'args' was introduced in
jurzua
parents:
diff changeset
5417 // https://github.com/jquery/jquery/commit/52a0238
jurzua
parents:
diff changeset
5418 // to work around a bug in Chrome 10 (Dev) and should be removed when the bug is fixed.
jurzua
parents:
diff changeset
5419 // http://code.google.com/p/v8/issues/detail?id=1050
jurzua
parents:
diff changeset
5420 args = slice.call(arguments);
jurzua
parents:
diff changeset
5421
jurzua
parents:
diff changeset
5422 if ( !runtil.test( name ) ) {
jurzua
parents:
diff changeset
5423 selector = until;
jurzua
parents:
diff changeset
5424 }
jurzua
parents:
diff changeset
5425
jurzua
parents:
diff changeset
5426 if ( selector && typeof selector === "string" ) {
jurzua
parents:
diff changeset
5427 ret = jQuery.filter( selector, ret );
jurzua
parents:
diff changeset
5428 }
jurzua
parents:
diff changeset
5429
jurzua
parents:
diff changeset
5430 ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
jurzua
parents:
diff changeset
5431
jurzua
parents:
diff changeset
5432 if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
jurzua
parents:
diff changeset
5433 ret = ret.reverse();
jurzua
parents:
diff changeset
5434 }
jurzua
parents:
diff changeset
5435
jurzua
parents:
diff changeset
5436 return this.pushStack( ret, name, args.join(",") );
jurzua
parents:
diff changeset
5437 };
jurzua
parents:
diff changeset
5438 });
jurzua
parents:
diff changeset
5439
jurzua
parents:
diff changeset
5440 jQuery.extend({
jurzua
parents:
diff changeset
5441 filter: function( expr, elems, not ) {
jurzua
parents:
diff changeset
5442 if ( not ) {
jurzua
parents:
diff changeset
5443 expr = ":not(" + expr + ")";
jurzua
parents:
diff changeset
5444 }
jurzua
parents:
diff changeset
5445
jurzua
parents:
diff changeset
5446 return elems.length === 1 ?
jurzua
parents:
diff changeset
5447 jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
jurzua
parents:
diff changeset
5448 jQuery.find.matches(expr, elems);
jurzua
parents:
diff changeset
5449 },
jurzua
parents:
diff changeset
5450
jurzua
parents:
diff changeset
5451 dir: function( elem, dir, until ) {
jurzua
parents:
diff changeset
5452 var matched = [],
jurzua
parents:
diff changeset
5453 cur = elem[ dir ];
jurzua
parents:
diff changeset
5454
jurzua
parents:
diff changeset
5455 while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
jurzua
parents:
diff changeset
5456 if ( cur.nodeType === 1 ) {
jurzua
parents:
diff changeset
5457 matched.push( cur );
jurzua
parents:
diff changeset
5458 }
jurzua
parents:
diff changeset
5459 cur = cur[dir];
jurzua
parents:
diff changeset
5460 }
jurzua
parents:
diff changeset
5461 return matched;
jurzua
parents:
diff changeset
5462 },
jurzua
parents:
diff changeset
5463
jurzua
parents:
diff changeset
5464 nth: function( cur, result, dir, elem ) {
jurzua
parents:
diff changeset
5465 result = result || 1;
jurzua
parents:
diff changeset
5466 var num = 0;
jurzua
parents:
diff changeset
5467
jurzua
parents:
diff changeset
5468 for ( ; cur; cur = cur[dir] ) {
jurzua
parents:
diff changeset
5469 if ( cur.nodeType === 1 && ++num === result ) {
jurzua
parents:
diff changeset
5470 break;
jurzua
parents:
diff changeset
5471 }
jurzua
parents:
diff changeset
5472 }
jurzua
parents:
diff changeset
5473
jurzua
parents:
diff changeset
5474 return cur;
jurzua
parents:
diff changeset
5475 },
jurzua
parents:
diff changeset
5476
jurzua
parents:
diff changeset
5477 sibling: function( n, elem ) {
jurzua
parents:
diff changeset
5478 var r = [];
jurzua
parents:
diff changeset
5479
jurzua
parents:
diff changeset
5480 for ( ; n; n = n.nextSibling ) {
jurzua
parents:
diff changeset
5481 if ( n.nodeType === 1 && n !== elem ) {
jurzua
parents:
diff changeset
5482 r.push( n );
jurzua
parents:
diff changeset
5483 }
jurzua
parents:
diff changeset
5484 }
jurzua
parents:
diff changeset
5485
jurzua
parents:
diff changeset
5486 return r;
jurzua
parents:
diff changeset
5487 }
jurzua
parents:
diff changeset
5488 });
jurzua
parents:
diff changeset
5489
jurzua
parents:
diff changeset
5490 // Implement the identical functionality for filter and not
jurzua
parents:
diff changeset
5491 function winnow( elements, qualifier, keep ) {
jurzua
parents:
diff changeset
5492
jurzua
parents:
diff changeset
5493 // Can't pass null or undefined to indexOf in Firefox 4
jurzua
parents:
diff changeset
5494 // Set to 0 to skip string check
jurzua
parents:
diff changeset
5495 qualifier = qualifier || 0;
jurzua
parents:
diff changeset
5496
jurzua
parents:
diff changeset
5497 if ( jQuery.isFunction( qualifier ) ) {
jurzua
parents:
diff changeset
5498 return jQuery.grep(elements, function( elem, i ) {
jurzua
parents:
diff changeset
5499 var retVal = !!qualifier.call( elem, i, elem );
jurzua
parents:
diff changeset
5500 return retVal === keep;
jurzua
parents:
diff changeset
5501 });
jurzua
parents:
diff changeset
5502
jurzua
parents:
diff changeset
5503 } else if ( qualifier.nodeType ) {
jurzua
parents:
diff changeset
5504 return jQuery.grep(elements, function( elem, i ) {
jurzua
parents:
diff changeset
5505 return (elem === qualifier) === keep;
jurzua
parents:
diff changeset
5506 });
jurzua
parents:
diff changeset
5507
jurzua
parents:
diff changeset
5508 } else if ( typeof qualifier === "string" ) {
jurzua
parents:
diff changeset
5509 var filtered = jQuery.grep(elements, function( elem ) {
jurzua
parents:
diff changeset
5510 return elem.nodeType === 1;
jurzua
parents:
diff changeset
5511 });
jurzua
parents:
diff changeset
5512
jurzua
parents:
diff changeset
5513 if ( isSimple.test( qualifier ) ) {
jurzua
parents:
diff changeset
5514 return jQuery.filter(qualifier, filtered, !keep);
jurzua
parents:
diff changeset
5515 } else {
jurzua
parents:
diff changeset
5516 qualifier = jQuery.filter( qualifier, filtered );
jurzua
parents:
diff changeset
5517 }
jurzua
parents:
diff changeset
5518 }
jurzua
parents:
diff changeset
5519
jurzua
parents:
diff changeset
5520 return jQuery.grep(elements, function( elem, i ) {
jurzua
parents:
diff changeset
5521 return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
jurzua
parents:
diff changeset
5522 });
jurzua
parents:
diff changeset
5523 }
jurzua
parents:
diff changeset
5524
jurzua
parents:
diff changeset
5525
jurzua
parents:
diff changeset
5526
jurzua
parents:
diff changeset
5527
jurzua
parents:
diff changeset
5528 var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
jurzua
parents:
diff changeset
5529 rleadingWhitespace = /^\s+/,
jurzua
parents:
diff changeset
5530 rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
jurzua
parents:
diff changeset
5531 rtagName = /<([\w:]+)/,
jurzua
parents:
diff changeset
5532 rtbody = /<tbody/i,
jurzua
parents:
diff changeset
5533 rhtml = /<|&#?\w+;/,
jurzua
parents:
diff changeset
5534 rnocache = /<(?:script|object|embed|option|style)/i,
jurzua
parents:
diff changeset
5535 // checked="checked" or checked
jurzua
parents:
diff changeset
5536 rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
jurzua
parents:
diff changeset
5537 rscriptType = /\/(java|ecma)script/i,
jurzua
parents:
diff changeset
5538 rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)/,
jurzua
parents:
diff changeset
5539 wrapMap = {
jurzua
parents:
diff changeset
5540 option: [ 1, "<select multiple='multiple'>", "</select>" ],
jurzua
parents:
diff changeset
5541 legend: [ 1, "<fieldset>", "</fieldset>" ],
jurzua
parents:
diff changeset
5542 thead: [ 1, "<table>", "</table>" ],
jurzua
parents:
diff changeset
5543 tr: [ 2, "<table><tbody>", "</tbody></table>" ],
jurzua
parents:
diff changeset
5544 td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
jurzua
parents:
diff changeset
5545 col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
jurzua
parents:
diff changeset
5546 area: [ 1, "<map>", "</map>" ],
jurzua
parents:
diff changeset
5547 _default: [ 0, "", "" ]
jurzua
parents:
diff changeset
5548 };
jurzua
parents:
diff changeset
5549
jurzua
parents:
diff changeset
5550 wrapMap.optgroup = wrapMap.option;
jurzua
parents:
diff changeset
5551 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
jurzua
parents:
diff changeset
5552 wrapMap.th = wrapMap.td;
jurzua
parents:
diff changeset
5553
jurzua
parents:
diff changeset
5554 // IE can't serialize <link> and <script> tags normally
jurzua
parents:
diff changeset
5555 if ( !jQuery.support.htmlSerialize ) {
jurzua
parents:
diff changeset
5556 wrapMap._default = [ 1, "div<div>", "</div>" ];
jurzua
parents:
diff changeset
5557 }
jurzua
parents:
diff changeset
5558
jurzua
parents:
diff changeset
5559 jQuery.fn.extend({
jurzua
parents:
diff changeset
5560 text: function( text ) {
jurzua
parents:
diff changeset
5561 if ( jQuery.isFunction(text) ) {
jurzua
parents:
diff changeset
5562 return this.each(function(i) {
jurzua
parents:
diff changeset
5563 var self = jQuery( this );
jurzua
parents:
diff changeset
5564
jurzua
parents:
diff changeset
5565 self.text( text.call(this, i, self.text()) );
jurzua
parents:
diff changeset
5566 });
jurzua
parents:
diff changeset
5567 }
jurzua
parents:
diff changeset
5568
jurzua
parents:
diff changeset
5569 if ( typeof text !== "object" && text !== undefined ) {
jurzua
parents:
diff changeset
5570 return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
jurzua
parents:
diff changeset
5571 }
jurzua
parents:
diff changeset
5572
jurzua
parents:
diff changeset
5573 return jQuery.text( this );
jurzua
parents:
diff changeset
5574 },
jurzua
parents:
diff changeset
5575
jurzua
parents:
diff changeset
5576 wrapAll: function( html ) {
jurzua
parents:
diff changeset
5577 if ( jQuery.isFunction( html ) ) {
jurzua
parents:
diff changeset
5578 return this.each(function(i) {
jurzua
parents:
diff changeset
5579 jQuery(this).wrapAll( html.call(this, i) );
jurzua
parents:
diff changeset
5580 });
jurzua
parents:
diff changeset
5581 }
jurzua
parents:
diff changeset
5582
jurzua
parents:
diff changeset
5583 if ( this[0] ) {
jurzua
parents:
diff changeset
5584 // The elements to wrap the target around
jurzua
parents:
diff changeset
5585 var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
jurzua
parents:
diff changeset
5586
jurzua
parents:
diff changeset
5587 if ( this[0].parentNode ) {
jurzua
parents:
diff changeset
5588 wrap.insertBefore( this[0] );
jurzua
parents:
diff changeset
5589 }
jurzua
parents:
diff changeset
5590
jurzua
parents:
diff changeset
5591 wrap.map(function() {
jurzua
parents:
diff changeset
5592 var elem = this;
jurzua
parents:
diff changeset
5593
jurzua
parents:
diff changeset
5594 while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
jurzua
parents:
diff changeset
5595 elem = elem.firstChild;
jurzua
parents:
diff changeset
5596 }
jurzua
parents:
diff changeset
5597
jurzua
parents:
diff changeset
5598 return elem;
jurzua
parents:
diff changeset
5599 }).append( this );
jurzua
parents:
diff changeset
5600 }
jurzua
parents:
diff changeset
5601
jurzua
parents:
diff changeset
5602 return this;
jurzua
parents:
diff changeset
5603 },
jurzua
parents:
diff changeset
5604
jurzua
parents:
diff changeset
5605 wrapInner: function( html ) {
jurzua
parents:
diff changeset
5606 if ( jQuery.isFunction( html ) ) {
jurzua
parents:
diff changeset
5607 return this.each(function(i) {
jurzua
parents:
diff changeset
5608 jQuery(this).wrapInner( html.call(this, i) );
jurzua
parents:
diff changeset
5609 });
jurzua
parents:
diff changeset
5610 }
jurzua
parents:
diff changeset
5611
jurzua
parents:
diff changeset
5612 return this.each(function() {
jurzua
parents:
diff changeset
5613 var self = jQuery( this ),
jurzua
parents:
diff changeset
5614 contents = self.contents();
jurzua
parents:
diff changeset
5615
jurzua
parents:
diff changeset
5616 if ( contents.length ) {
jurzua
parents:
diff changeset
5617 contents.wrapAll( html );
jurzua
parents:
diff changeset
5618
jurzua
parents:
diff changeset
5619 } else {
jurzua
parents:
diff changeset
5620 self.append( html );
jurzua
parents:
diff changeset
5621 }
jurzua
parents:
diff changeset
5622 });
jurzua
parents:
diff changeset
5623 },
jurzua
parents:
diff changeset
5624
jurzua
parents:
diff changeset
5625 wrap: function( html ) {
jurzua
parents:
diff changeset
5626 return this.each(function() {
jurzua
parents:
diff changeset
5627 jQuery( this ).wrapAll( html );
jurzua
parents:
diff changeset
5628 });
jurzua
parents:
diff changeset
5629 },
jurzua
parents:
diff changeset
5630
jurzua
parents:
diff changeset
5631 unwrap: function() {
jurzua
parents:
diff changeset
5632 return this.parent().each(function() {
jurzua
parents:
diff changeset
5633 if ( !jQuery.nodeName( this, "body" ) ) {
jurzua
parents:
diff changeset
5634 jQuery( this ).replaceWith( this.childNodes );
jurzua
parents:
diff changeset
5635 }
jurzua
parents:
diff changeset
5636 }).end();
jurzua
parents:
diff changeset
5637 },
jurzua
parents:
diff changeset
5638
jurzua
parents:
diff changeset
5639 append: function() {
jurzua
parents:
diff changeset
5640 return this.domManip(arguments, true, function( elem ) {
jurzua
parents:
diff changeset
5641 if ( this.nodeType === 1 ) {
jurzua
parents:
diff changeset
5642 this.appendChild( elem );
jurzua
parents:
diff changeset
5643 }
jurzua
parents:
diff changeset
5644 });
jurzua
parents:
diff changeset
5645 },
jurzua
parents:
diff changeset
5646
jurzua
parents:
diff changeset
5647 prepend: function() {
jurzua
parents:
diff changeset
5648 return this.domManip(arguments, true, function( elem ) {
jurzua
parents:
diff changeset
5649 if ( this.nodeType === 1 ) {
jurzua
parents:
diff changeset
5650 this.insertBefore( elem, this.firstChild );
jurzua
parents:
diff changeset
5651 }
jurzua
parents:
diff changeset
5652 });
jurzua
parents:
diff changeset
5653 },
jurzua
parents:
diff changeset
5654
jurzua
parents:
diff changeset
5655 before: function() {
jurzua
parents:
diff changeset
5656 if ( this[0] && this[0].parentNode ) {
jurzua
parents:
diff changeset
5657 return this.domManip(arguments, false, function( elem ) {
jurzua
parents:
diff changeset
5658 this.parentNode.insertBefore( elem, this );
jurzua
parents:
diff changeset
5659 });
jurzua
parents:
diff changeset
5660 } else if ( arguments.length ) {
jurzua
parents:
diff changeset
5661 var set = jQuery(arguments[0]);
jurzua
parents:
diff changeset
5662 set.push.apply( set, this.toArray() );
jurzua
parents:
diff changeset
5663 return this.pushStack( set, "before", arguments );
jurzua
parents:
diff changeset
5664 }
jurzua
parents:
diff changeset
5665 },
jurzua
parents:
diff changeset
5666
jurzua
parents:
diff changeset
5667 after: function() {
jurzua
parents:
diff changeset
5668 if ( this[0] && this[0].parentNode ) {
jurzua
parents:
diff changeset
5669 return this.domManip(arguments, false, function( elem ) {
jurzua
parents:
diff changeset
5670 this.parentNode.insertBefore( elem, this.nextSibling );
jurzua
parents:
diff changeset
5671 });
jurzua
parents:
diff changeset
5672 } else if ( arguments.length ) {
jurzua
parents:
diff changeset
5673 var set = this.pushStack( this, "after", arguments );
jurzua
parents:
diff changeset
5674 set.push.apply( set, jQuery(arguments[0]).toArray() );
jurzua
parents:
diff changeset
5675 return set;
jurzua
parents:
diff changeset
5676 }
jurzua
parents:
diff changeset
5677 },
jurzua
parents:
diff changeset
5678
jurzua
parents:
diff changeset
5679 // keepData is for internal use only--do not document
jurzua
parents:
diff changeset
5680 remove: function( selector, keepData ) {
jurzua
parents:
diff changeset
5681 for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
jurzua
parents:
diff changeset
5682 if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
jurzua
parents:
diff changeset
5683 if ( !keepData && elem.nodeType === 1 ) {
jurzua
parents:
diff changeset
5684 jQuery.cleanData( elem.getElementsByTagName("*") );
jurzua
parents:
diff changeset
5685 jQuery.cleanData( [ elem ] );
jurzua
parents:
diff changeset
5686 }
jurzua
parents:
diff changeset
5687
jurzua
parents:
diff changeset
5688 if ( elem.parentNode ) {
jurzua
parents:
diff changeset
5689 elem.parentNode.removeChild( elem );
jurzua
parents:
diff changeset
5690 }
jurzua
parents:
diff changeset
5691 }
jurzua
parents:
diff changeset
5692 }
jurzua
parents:
diff changeset
5693
jurzua
parents:
diff changeset
5694 return this;
jurzua
parents:
diff changeset
5695 },
jurzua
parents:
diff changeset
5696
jurzua
parents:
diff changeset
5697 empty: function() {
jurzua
parents:
diff changeset
5698 for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
jurzua
parents:
diff changeset
5699 // Remove element nodes and prevent memory leaks
jurzua
parents:
diff changeset
5700 if ( elem.nodeType === 1 ) {
jurzua
parents:
diff changeset
5701 jQuery.cleanData( elem.getElementsByTagName("*") );
jurzua
parents:
diff changeset
5702 }
jurzua
parents:
diff changeset
5703
jurzua
parents:
diff changeset
5704 // Remove any remaining nodes
jurzua
parents:
diff changeset
5705 while ( elem.firstChild ) {
jurzua
parents:
diff changeset
5706 elem.removeChild( elem.firstChild );
jurzua
parents:
diff changeset
5707 }
jurzua
parents:
diff changeset
5708 }
jurzua
parents:
diff changeset
5709
jurzua
parents:
diff changeset
5710 return this;
jurzua
parents:
diff changeset
5711 },
jurzua
parents:
diff changeset
5712
jurzua
parents:
diff changeset
5713 clone: function( dataAndEvents, deepDataAndEvents ) {
jurzua
parents:
diff changeset
5714 dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
jurzua
parents:
diff changeset
5715 deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
jurzua
parents:
diff changeset
5716
jurzua
parents:
diff changeset
5717 return this.map( function () {
jurzua
parents:
diff changeset
5718 return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
jurzua
parents:
diff changeset
5719 });
jurzua
parents:
diff changeset
5720 },
jurzua
parents:
diff changeset
5721
jurzua
parents:
diff changeset
5722 html: function( value ) {
jurzua
parents:
diff changeset
5723 if ( value === undefined ) {
jurzua
parents:
diff changeset
5724 return this[0] && this[0].nodeType === 1 ?
jurzua
parents:
diff changeset
5725 this[0].innerHTML.replace(rinlinejQuery, "") :
jurzua
parents:
diff changeset
5726 null;
jurzua
parents:
diff changeset
5727
jurzua
parents:
diff changeset
5728 // See if we can take a shortcut and just use innerHTML
jurzua
parents:
diff changeset
5729 } else if ( typeof value === "string" && !rnocache.test( value ) &&
jurzua
parents:
diff changeset
5730 (jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
jurzua
parents:
diff changeset
5731 !wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
jurzua
parents:
diff changeset
5732
jurzua
parents:
diff changeset
5733 value = value.replace(rxhtmlTag, "<$1></$2>");
jurzua
parents:
diff changeset
5734
jurzua
parents:
diff changeset
5735 try {
jurzua
parents:
diff changeset
5736 for ( var i = 0, l = this.length; i < l; i++ ) {
jurzua
parents:
diff changeset
5737 // Remove element nodes and prevent memory leaks
jurzua
parents:
diff changeset
5738 if ( this[i].nodeType === 1 ) {
jurzua
parents:
diff changeset
5739 jQuery.cleanData( this[i].getElementsByTagName("*") );
jurzua
parents:
diff changeset
5740 this[i].innerHTML = value;
jurzua
parents:
diff changeset
5741 }
jurzua
parents:
diff changeset
5742 }
jurzua
parents:
diff changeset
5743
jurzua
parents:
diff changeset
5744 // If using innerHTML throws an exception, use the fallback method
jurzua
parents:
diff changeset
5745 } catch(e) {
jurzua
parents:
diff changeset
5746 this.empty().append( value );
jurzua
parents:
diff changeset
5747 }
jurzua
parents:
diff changeset
5748
jurzua
parents:
diff changeset
5749 } else if ( jQuery.isFunction( value ) ) {
jurzua
parents:
diff changeset
5750 this.each(function(i){
jurzua
parents:
diff changeset
5751 var self = jQuery( this );
jurzua
parents:
diff changeset
5752
jurzua
parents:
diff changeset
5753 self.html( value.call(this, i, self.html()) );
jurzua
parents:
diff changeset
5754 });
jurzua
parents:
diff changeset
5755
jurzua
parents:
diff changeset
5756 } else {
jurzua
parents:
diff changeset
5757 this.empty().append( value );
jurzua
parents:
diff changeset
5758 }
jurzua
parents:
diff changeset
5759
jurzua
parents:
diff changeset
5760 return this;
jurzua
parents:
diff changeset
5761 },
jurzua
parents:
diff changeset
5762
jurzua
parents:
diff changeset
5763 replaceWith: function( value ) {
jurzua
parents:
diff changeset
5764 if ( this[0] && this[0].parentNode ) {
jurzua
parents:
diff changeset
5765 // Make sure that the elements are removed from the DOM before they are inserted
jurzua
parents:
diff changeset
5766 // this can help fix replacing a parent with child elements
jurzua
parents:
diff changeset
5767 if ( jQuery.isFunction( value ) ) {
jurzua
parents:
diff changeset
5768 return this.each(function(i) {
jurzua
parents:
diff changeset
5769 var self = jQuery(this), old = self.html();
jurzua
parents:
diff changeset
5770 self.replaceWith( value.call( this, i, old ) );
jurzua
parents:
diff changeset
5771 });
jurzua
parents:
diff changeset
5772 }
jurzua
parents:
diff changeset
5773
jurzua
parents:
diff changeset
5774 if ( typeof value !== "string" ) {
jurzua
parents:
diff changeset
5775 value = jQuery( value ).detach();
jurzua
parents:
diff changeset
5776 }
jurzua
parents:
diff changeset
5777
jurzua
parents:
diff changeset
5778 return this.each(function() {
jurzua
parents:
diff changeset
5779 var next = this.nextSibling,
jurzua
parents:
diff changeset
5780 parent = this.parentNode;
jurzua
parents:
diff changeset
5781
jurzua
parents:
diff changeset
5782 jQuery( this ).remove();
jurzua
parents:
diff changeset
5783
jurzua
parents:
diff changeset
5784 if ( next ) {
jurzua
parents:
diff changeset
5785 jQuery(next).before( value );
jurzua
parents:
diff changeset
5786 } else {
jurzua
parents:
diff changeset
5787 jQuery(parent).append( value );
jurzua
parents:
diff changeset
5788 }
jurzua
parents:
diff changeset
5789 });
jurzua
parents:
diff changeset
5790 } else {
jurzua
parents:
diff changeset
5791 return this.length ?
jurzua
parents:
diff changeset
5792 this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) :
jurzua
parents:
diff changeset
5793 this;
jurzua
parents:
diff changeset
5794 }
jurzua
parents:
diff changeset
5795 },
jurzua
parents:
diff changeset
5796
jurzua
parents:
diff changeset
5797 detach: function( selector ) {
jurzua
parents:
diff changeset
5798 return this.remove( selector, true );
jurzua
parents:
diff changeset
5799 },
jurzua
parents:
diff changeset
5800
jurzua
parents:
diff changeset
5801 domManip: function( args, table, callback ) {
jurzua
parents:
diff changeset
5802 var results, first, fragment, parent,
jurzua
parents:
diff changeset
5803 value = args[0],
jurzua
parents:
diff changeset
5804 scripts = [];
jurzua
parents:
diff changeset
5805
jurzua
parents:
diff changeset
5806 // We can't cloneNode fragments that contain checked, in WebKit
jurzua
parents:
diff changeset
5807 if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
jurzua
parents:
diff changeset
5808 return this.each(function() {
jurzua
parents:
diff changeset
5809 jQuery(this).domManip( args, table, callback, true );
jurzua
parents:
diff changeset
5810 });
jurzua
parents:
diff changeset
5811 }
jurzua
parents:
diff changeset
5812
jurzua
parents:
diff changeset
5813 if ( jQuery.isFunction(value) ) {
jurzua
parents:
diff changeset
5814 return this.each(function(i) {
jurzua
parents:
diff changeset
5815 var self = jQuery(this);
jurzua
parents:
diff changeset
5816 args[0] = value.call(this, i, table ? self.html() : undefined);
jurzua
parents:
diff changeset
5817 self.domManip( args, table, callback );
jurzua
parents:
diff changeset
5818 });
jurzua
parents:
diff changeset
5819 }
jurzua
parents:
diff changeset
5820
jurzua
parents:
diff changeset
5821 if ( this[0] ) {
jurzua
parents:
diff changeset
5822 parent = value && value.parentNode;
jurzua
parents:
diff changeset
5823
jurzua
parents:
diff changeset
5824 // If we're in a fragment, just use that instead of building a new one
jurzua
parents:
diff changeset
5825 if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
jurzua
parents:
diff changeset
5826 results = { fragment: parent };
jurzua
parents:
diff changeset
5827
jurzua
parents:
diff changeset
5828 } else {
jurzua
parents:
diff changeset
5829 results = jQuery.buildFragment( args, this, scripts );
jurzua
parents:
diff changeset
5830 }
jurzua
parents:
diff changeset
5831
jurzua
parents:
diff changeset
5832 fragment = results.fragment;
jurzua
parents:
diff changeset
5833
jurzua
parents:
diff changeset
5834 if ( fragment.childNodes.length === 1 ) {
jurzua
parents:
diff changeset
5835 first = fragment = fragment.firstChild;
jurzua
parents:
diff changeset
5836 } else {
jurzua
parents:
diff changeset
5837 first = fragment.firstChild;
jurzua
parents:
diff changeset
5838 }
jurzua
parents:
diff changeset
5839
jurzua
parents:
diff changeset
5840 if ( first ) {
jurzua
parents:
diff changeset
5841 table = table && jQuery.nodeName( first, "tr" );
jurzua
parents:
diff changeset
5842
jurzua
parents:
diff changeset
5843 for ( var i = 0, l = this.length, lastIndex = l - 1; i < l; i++ ) {
jurzua
parents:
diff changeset
5844 callback.call(
jurzua
parents:
diff changeset
5845 table ?
jurzua
parents:
diff changeset
5846 root(this[i], first) :
jurzua
parents:
diff changeset
5847 this[i],
jurzua
parents:
diff changeset
5848 // Make sure that we do not leak memory by inadvertently discarding
jurzua
parents:
diff changeset
5849 // the original fragment (which might have attached data) instead of
jurzua
parents:
diff changeset
5850 // using it; in addition, use the original fragment object for the last
jurzua
parents:
diff changeset
5851 // item instead of first because it can end up being emptied incorrectly
jurzua
parents:
diff changeset
5852 // in certain situations (Bug #8070).
jurzua
parents:
diff changeset
5853 // Fragments from the fragment cache must always be cloned and never used
jurzua
parents:
diff changeset
5854 // in place.
jurzua
parents:
diff changeset
5855 results.cacheable || (l > 1 && i < lastIndex) ?
jurzua
parents:
diff changeset
5856 jQuery.clone( fragment, true, true ) :
jurzua
parents:
diff changeset
5857 fragment
jurzua
parents:
diff changeset
5858 );
jurzua
parents:
diff changeset
5859 }
jurzua
parents:
diff changeset
5860 }
jurzua
parents:
diff changeset
5861
jurzua
parents:
diff changeset
5862 if ( scripts.length ) {
jurzua
parents:
diff changeset
5863 jQuery.each( scripts, evalScript );
jurzua
parents:
diff changeset
5864 }
jurzua
parents:
diff changeset
5865 }
jurzua
parents:
diff changeset
5866
jurzua
parents:
diff changeset
5867 return this;
jurzua
parents:
diff changeset
5868 }
jurzua
parents:
diff changeset
5869 });
jurzua
parents:
diff changeset
5870
jurzua
parents:
diff changeset
5871 function root( elem, cur ) {
jurzua
parents:
diff changeset
5872 return jQuery.nodeName(elem, "table") ?
jurzua
parents:
diff changeset
5873 (elem.getElementsByTagName("tbody")[0] ||
jurzua
parents:
diff changeset
5874 elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
jurzua
parents:
diff changeset
5875 elem;
jurzua
parents:
diff changeset
5876 }
jurzua
parents:
diff changeset
5877
jurzua
parents:
diff changeset
5878 function cloneCopyEvent( src, dest ) {
jurzua
parents:
diff changeset
5879
jurzua
parents:
diff changeset
5880 if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
jurzua
parents:
diff changeset
5881 return;
jurzua
parents:
diff changeset
5882 }
jurzua
parents:
diff changeset
5883
jurzua
parents:
diff changeset
5884 var internalKey = jQuery.expando,
jurzua
parents:
diff changeset
5885 oldData = jQuery.data( src ),
jurzua
parents:
diff changeset
5886 curData = jQuery.data( dest, oldData );
jurzua
parents:
diff changeset
5887
jurzua
parents:
diff changeset
5888 // Switch to use the internal data object, if it exists, for the next
jurzua
parents:
diff changeset
5889 // stage of data copying
jurzua
parents:
diff changeset
5890 if ( (oldData = oldData[ internalKey ]) ) {
jurzua
parents:
diff changeset
5891 var events = oldData.events;
jurzua
parents:
diff changeset
5892 curData = curData[ internalKey ] = jQuery.extend({}, oldData);
jurzua
parents:
diff changeset
5893
jurzua
parents:
diff changeset
5894 if ( events ) {
jurzua
parents:
diff changeset
5895 delete curData.handle;
jurzua
parents:
diff changeset
5896 curData.events = {};
jurzua
parents:
diff changeset
5897
jurzua
parents:
diff changeset
5898 for ( var type in events ) {
jurzua
parents:
diff changeset
5899 for ( var i = 0, l = events[ type ].length; i < l; i++ ) {
jurzua
parents:
diff changeset
5900 jQuery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data );
jurzua
parents:
diff changeset
5901 }
jurzua
parents:
diff changeset
5902 }
jurzua
parents:
diff changeset
5903 }
jurzua
parents:
diff changeset
5904 }
jurzua
parents:
diff changeset
5905 }
jurzua
parents:
diff changeset
5906
jurzua
parents:
diff changeset
5907 function cloneFixAttributes( src, dest ) {
jurzua
parents:
diff changeset
5908 var nodeName;
jurzua
parents:
diff changeset
5909
jurzua
parents:
diff changeset
5910 // We do not need to do anything for non-Elements
jurzua
parents:
diff changeset
5911 if ( dest.nodeType !== 1 ) {
jurzua
parents:
diff changeset
5912 return;
jurzua
parents:
diff changeset
5913 }
jurzua
parents:
diff changeset
5914
jurzua
parents:
diff changeset
5915 // clearAttributes removes the attributes, which we don't want,
jurzua
parents:
diff changeset
5916 // but also removes the attachEvent events, which we *do* want
jurzua
parents:
diff changeset
5917 if ( dest.clearAttributes ) {
jurzua
parents:
diff changeset
5918 dest.clearAttributes();
jurzua
parents:
diff changeset
5919 }
jurzua
parents:
diff changeset
5920
jurzua
parents:
diff changeset
5921 // mergeAttributes, in contrast, only merges back on the
jurzua
parents:
diff changeset
5922 // original attributes, not the events
jurzua
parents:
diff changeset
5923 if ( dest.mergeAttributes ) {
jurzua
parents:
diff changeset
5924 dest.mergeAttributes( src );
jurzua
parents:
diff changeset
5925 }
jurzua
parents:
diff changeset
5926
jurzua
parents:
diff changeset
5927 nodeName = dest.nodeName.toLowerCase();
jurzua
parents:
diff changeset
5928
jurzua
parents:
diff changeset
5929 // IE6-8 fail to clone children inside object elements that use
jurzua
parents:
diff changeset
5930 // the proprietary classid attribute value (rather than the type
jurzua
parents:
diff changeset
5931 // attribute) to identify the type of content to display
jurzua
parents:
diff changeset
5932 if ( nodeName === "object" ) {
jurzua
parents:
diff changeset
5933 dest.outerHTML = src.outerHTML;
jurzua
parents:
diff changeset
5934
jurzua
parents:
diff changeset
5935 } else if ( nodeName === "input" && (src.type === "checkbox" || src.type === "radio") ) {
jurzua
parents:
diff changeset
5936 // IE6-8 fails to persist the checked state of a cloned checkbox
jurzua
parents:
diff changeset
5937 // or radio button. Worse, IE6-7 fail to give the cloned element
jurzua
parents:
diff changeset
5938 // a checked appearance if the defaultChecked value isn't also set
jurzua
parents:
diff changeset
5939 if ( src.checked ) {
jurzua
parents:
diff changeset
5940 dest.defaultChecked = dest.checked = src.checked;
jurzua
parents:
diff changeset
5941 }
jurzua
parents:
diff changeset
5942
jurzua
parents:
diff changeset
5943 // IE6-7 get confused and end up setting the value of a cloned
jurzua
parents:
diff changeset
5944 // checkbox/radio button to an empty string instead of "on"
jurzua
parents:
diff changeset
5945 if ( dest.value !== src.value ) {
jurzua
parents:
diff changeset
5946 dest.value = src.value;
jurzua
parents:
diff changeset
5947 }
jurzua
parents:
diff changeset
5948
jurzua
parents:
diff changeset
5949 // IE6-8 fails to return the selected option to the default selected
jurzua
parents:
diff changeset
5950 // state when cloning options
jurzua
parents:
diff changeset
5951 } else if ( nodeName === "option" ) {
jurzua
parents:
diff changeset
5952 dest.selected = src.defaultSelected;
jurzua
parents:
diff changeset
5953
jurzua
parents:
diff changeset
5954 // IE6-8 fails to set the defaultValue to the correct value when
jurzua
parents:
diff changeset
5955 // cloning other types of input fields
jurzua
parents:
diff changeset
5956 } else if ( nodeName === "input" || nodeName === "textarea" ) {
jurzua
parents:
diff changeset
5957 dest.defaultValue = src.defaultValue;
jurzua
parents:
diff changeset
5958 }
jurzua
parents:
diff changeset
5959
jurzua
parents:
diff changeset
5960 // Event data gets referenced instead of copied if the expando
jurzua
parents:
diff changeset
5961 // gets copied too
jurzua
parents:
diff changeset
5962 dest.removeAttribute( jQuery.expando );
jurzua
parents:
diff changeset
5963 }
jurzua
parents:
diff changeset
5964
jurzua
parents:
diff changeset
5965 jQuery.buildFragment = function( args, nodes, scripts ) {
jurzua
parents:
diff changeset
5966 var fragment, cacheable, cacheresults, doc;
jurzua
parents:
diff changeset
5967
jurzua
parents:
diff changeset
5968 // nodes may contain either an explicit document object,
jurzua
parents:
diff changeset
5969 // a jQuery collection or context object.
jurzua
parents:
diff changeset
5970 // If nodes[0] contains a valid object to assign to doc
jurzua
parents:
diff changeset
5971 if ( nodes && nodes[0] ) {
jurzua
parents:
diff changeset
5972 doc = nodes[0].ownerDocument || nodes[0];
jurzua
parents:
diff changeset
5973 }
jurzua
parents:
diff changeset
5974
jurzua
parents:
diff changeset
5975 // Ensure that an attr object doesn't incorrectly stand in as a document object
jurzua
parents:
diff changeset
5976 // Chrome and Firefox seem to allow this to occur and will throw exception
jurzua
parents:
diff changeset
5977 // Fixes #8950
jurzua
parents:
diff changeset
5978 if ( !doc.createDocumentFragment ) {
jurzua
parents:
diff changeset
5979 doc = document;
jurzua
parents:
diff changeset
5980 }
jurzua
parents:
diff changeset
5981
jurzua
parents:
diff changeset
5982 // Only cache "small" (1/2 KB) HTML strings that are associated with the main document
jurzua
parents:
diff changeset
5983 // Cloning options loses the selected state, so don't cache them
jurzua
parents:
diff changeset
5984 // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
jurzua
parents:
diff changeset
5985 // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
jurzua
parents:
diff changeset
5986 if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
jurzua
parents:
diff changeset
5987 args[0].charAt(0) === "<" && !rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
jurzua
parents:
diff changeset
5988
jurzua
parents:
diff changeset
5989 cacheable = true;
jurzua
parents:
diff changeset
5990
jurzua
parents:
diff changeset
5991 cacheresults = jQuery.fragments[ args[0] ];
jurzua
parents:
diff changeset
5992 if ( cacheresults && cacheresults !== 1 ) {
jurzua
parents:
diff changeset
5993 fragment = cacheresults;
jurzua
parents:
diff changeset
5994 }
jurzua
parents:
diff changeset
5995 }
jurzua
parents:
diff changeset
5996
jurzua
parents:
diff changeset
5997 if ( !fragment ) {
jurzua
parents:
diff changeset
5998 fragment = doc.createDocumentFragment();
jurzua
parents:
diff changeset
5999 jQuery.clean( args, doc, fragment, scripts );
jurzua
parents:
diff changeset
6000 }
jurzua
parents:
diff changeset
6001
jurzua
parents:
diff changeset
6002 if ( cacheable ) {
jurzua
parents:
diff changeset
6003 jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
jurzua
parents:
diff changeset
6004 }
jurzua
parents:
diff changeset
6005
jurzua
parents:
diff changeset
6006 return { fragment: fragment, cacheable: cacheable };
jurzua
parents:
diff changeset
6007 };
jurzua
parents:
diff changeset
6008
jurzua
parents:
diff changeset
6009 jQuery.fragments = {};
jurzua
parents:
diff changeset
6010
jurzua
parents:
diff changeset
6011 jQuery.each({
jurzua
parents:
diff changeset
6012 appendTo: "append",
jurzua
parents:
diff changeset
6013 prependTo: "prepend",
jurzua
parents:
diff changeset
6014 insertBefore: "before",
jurzua
parents:
diff changeset
6015 insertAfter: "after",
jurzua
parents:
diff changeset
6016 replaceAll: "replaceWith"
jurzua
parents:
diff changeset
6017 }, function( name, original ) {
jurzua
parents:
diff changeset
6018 jQuery.fn[ name ] = function( selector ) {
jurzua
parents:
diff changeset
6019 var ret = [],
jurzua
parents:
diff changeset
6020 insert = jQuery( selector ),
jurzua
parents:
diff changeset
6021 parent = this.length === 1 && this[0].parentNode;
jurzua
parents:
diff changeset
6022
jurzua
parents:
diff changeset
6023 if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
jurzua
parents:
diff changeset
6024 insert[ original ]( this[0] );
jurzua
parents:
diff changeset
6025 return this;
jurzua
parents:
diff changeset
6026
jurzua
parents:
diff changeset
6027 } else {
jurzua
parents:
diff changeset
6028 for ( var i = 0, l = insert.length; i < l; i++ ) {
jurzua
parents:
diff changeset
6029 var elems = (i > 0 ? this.clone(true) : this).get();
jurzua
parents:
diff changeset
6030 jQuery( insert[i] )[ original ]( elems );
jurzua
parents:
diff changeset
6031 ret = ret.concat( elems );
jurzua
parents:
diff changeset
6032 }
jurzua
parents:
diff changeset
6033
jurzua
parents:
diff changeset
6034 return this.pushStack( ret, name, insert.selector );
jurzua
parents:
diff changeset
6035 }
jurzua
parents:
diff changeset
6036 };
jurzua
parents:
diff changeset
6037 });
jurzua
parents:
diff changeset
6038
jurzua
parents:
diff changeset
6039 function getAll( elem ) {
jurzua
parents:
diff changeset
6040 if ( "getElementsByTagName" in elem ) {
jurzua
parents:
diff changeset
6041 return elem.getElementsByTagName( "*" );
jurzua
parents:
diff changeset
6042
jurzua
parents:
diff changeset
6043 } else if ( "querySelectorAll" in elem ) {
jurzua
parents:
diff changeset
6044 return elem.querySelectorAll( "*" );
jurzua
parents:
diff changeset
6045
jurzua
parents:
diff changeset
6046 } else {
jurzua
parents:
diff changeset
6047 return [];
jurzua
parents:
diff changeset
6048 }
jurzua
parents:
diff changeset
6049 }
jurzua
parents:
diff changeset
6050
jurzua
parents:
diff changeset
6051 // Used in clean, fixes the defaultChecked property
jurzua
parents:
diff changeset
6052 function fixDefaultChecked( elem ) {
jurzua
parents:
diff changeset
6053 if ( elem.type === "checkbox" || elem.type === "radio" ) {
jurzua
parents:
diff changeset
6054 elem.defaultChecked = elem.checked;
jurzua
parents:
diff changeset
6055 }
jurzua
parents:
diff changeset
6056 }
jurzua
parents:
diff changeset
6057 // Finds all inputs and passes them to fixDefaultChecked
jurzua
parents:
diff changeset
6058 function findInputs( elem ) {
jurzua
parents:
diff changeset
6059 if ( jQuery.nodeName( elem, "input" ) ) {
jurzua
parents:
diff changeset
6060 fixDefaultChecked( elem );
jurzua
parents:
diff changeset
6061 } else if ( "getElementsByTagName" in elem ) {
jurzua
parents:
diff changeset
6062 jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked );
jurzua
parents:
diff changeset
6063 }
jurzua
parents:
diff changeset
6064 }
jurzua
parents:
diff changeset
6065
jurzua
parents:
diff changeset
6066 jQuery.extend({
jurzua
parents:
diff changeset
6067 clone: function( elem, dataAndEvents, deepDataAndEvents ) {
jurzua
parents:
diff changeset
6068 var clone = elem.cloneNode(true),
jurzua
parents:
diff changeset
6069 srcElements,
jurzua
parents:
diff changeset
6070 destElements,
jurzua
parents:
diff changeset
6071 i;
jurzua
parents:
diff changeset
6072
jurzua
parents:
diff changeset
6073 if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
jurzua
parents:
diff changeset
6074 (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
jurzua
parents:
diff changeset
6075 // IE copies events bound via attachEvent when using cloneNode.
jurzua
parents:
diff changeset
6076 // Calling detachEvent on the clone will also remove the events
jurzua
parents:
diff changeset
6077 // from the original. In order to get around this, we use some
jurzua
parents:
diff changeset
6078 // proprietary methods to clear the events. Thanks to MooTools
jurzua
parents:
diff changeset
6079 // guys for this hotness.
jurzua
parents:
diff changeset
6080
jurzua
parents:
diff changeset
6081 cloneFixAttributes( elem, clone );
jurzua
parents:
diff changeset
6082
jurzua
parents:
diff changeset
6083 // Using Sizzle here is crazy slow, so we use getElementsByTagName
jurzua
parents:
diff changeset
6084 // instead
jurzua
parents:
diff changeset
6085 srcElements = getAll( elem );
jurzua
parents:
diff changeset
6086 destElements = getAll( clone );
jurzua
parents:
diff changeset
6087
jurzua
parents:
diff changeset
6088 // Weird iteration because IE will replace the length property
jurzua
parents:
diff changeset
6089 // with an element if you are cloning the body and one of the
jurzua
parents:
diff changeset
6090 // elements on the page has a name or id of "length"
jurzua
parents:
diff changeset
6091 for ( i = 0; srcElements[i]; ++i ) {
jurzua
parents:
diff changeset
6092 // Ensure that the destination node is not null; Fixes #9587
jurzua
parents:
diff changeset
6093 if ( destElements[i] ) {
jurzua
parents:
diff changeset
6094 cloneFixAttributes( srcElements[i], destElements[i] );
jurzua
parents:
diff changeset
6095 }
jurzua
parents:
diff changeset
6096 }
jurzua
parents:
diff changeset
6097 }
jurzua
parents:
diff changeset
6098
jurzua
parents:
diff changeset
6099 // Copy the events from the original to the clone
jurzua
parents:
diff changeset
6100 if ( dataAndEvents ) {
jurzua
parents:
diff changeset
6101 cloneCopyEvent( elem, clone );
jurzua
parents:
diff changeset
6102
jurzua
parents:
diff changeset
6103 if ( deepDataAndEvents ) {
jurzua
parents:
diff changeset
6104 srcElements = getAll( elem );
jurzua
parents:
diff changeset
6105 destElements = getAll( clone );
jurzua
parents:
diff changeset
6106
jurzua
parents:
diff changeset
6107 for ( i = 0; srcElements[i]; ++i ) {
jurzua
parents:
diff changeset
6108 cloneCopyEvent( srcElements[i], destElements[i] );
jurzua
parents:
diff changeset
6109 }
jurzua
parents:
diff changeset
6110 }
jurzua
parents:
diff changeset
6111 }
jurzua
parents:
diff changeset
6112
jurzua
parents:
diff changeset
6113 srcElements = destElements = null;
jurzua
parents:
diff changeset
6114
jurzua
parents:
diff changeset
6115 // Return the cloned set
jurzua
parents:
diff changeset
6116 return clone;
jurzua
parents:
diff changeset
6117 },
jurzua
parents:
diff changeset
6118
jurzua
parents:
diff changeset
6119 clean: function( elems, context, fragment, scripts ) {
jurzua
parents:
diff changeset
6120 var checkScriptType;
jurzua
parents:
diff changeset
6121
jurzua
parents:
diff changeset
6122 context = context || document;
jurzua
parents:
diff changeset
6123
jurzua
parents:
diff changeset
6124 // !context.createElement fails in IE with an error but returns typeof 'object'
jurzua
parents:
diff changeset
6125 if ( typeof context.createElement === "undefined" ) {
jurzua
parents:
diff changeset
6126 context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
jurzua
parents:
diff changeset
6127 }
jurzua
parents:
diff changeset
6128
jurzua
parents:
diff changeset
6129 var ret = [], j;
jurzua
parents:
diff changeset
6130
jurzua
parents:
diff changeset
6131 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
jurzua
parents:
diff changeset
6132 if ( typeof elem === "number" ) {
jurzua
parents:
diff changeset
6133 elem += "";
jurzua
parents:
diff changeset
6134 }
jurzua
parents:
diff changeset
6135
jurzua
parents:
diff changeset
6136 if ( !elem ) {
jurzua
parents:
diff changeset
6137 continue;
jurzua
parents:
diff changeset
6138 }
jurzua
parents:
diff changeset
6139
jurzua
parents:
diff changeset
6140 // Convert html string into DOM nodes
jurzua
parents:
diff changeset
6141 if ( typeof elem === "string" ) {
jurzua
parents:
diff changeset
6142 if ( !rhtml.test( elem ) ) {
jurzua
parents:
diff changeset
6143 elem = context.createTextNode( elem );
jurzua
parents:
diff changeset
6144 } else {
jurzua
parents:
diff changeset
6145 // Fix "XHTML"-style tags in all browsers
jurzua
parents:
diff changeset
6146 elem = elem.replace(rxhtmlTag, "<$1></$2>");
jurzua
parents:
diff changeset
6147
jurzua
parents:
diff changeset
6148 // Trim whitespace, otherwise indexOf won't work as expected
jurzua
parents:
diff changeset
6149 var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
jurzua
parents:
diff changeset
6150 wrap = wrapMap[ tag ] || wrapMap._default,
jurzua
parents:
diff changeset
6151 depth = wrap[0],
jurzua
parents:
diff changeset
6152 div = context.createElement("div");
jurzua
parents:
diff changeset
6153
jurzua
parents:
diff changeset
6154 // Go to html and back, then peel off extra wrappers
jurzua
parents:
diff changeset
6155 div.innerHTML = wrap[1] + elem + wrap[2];
jurzua
parents:
diff changeset
6156
jurzua
parents:
diff changeset
6157 // Move to the right depth
jurzua
parents:
diff changeset
6158 while ( depth-- ) {
jurzua
parents:
diff changeset
6159 div = div.lastChild;
jurzua
parents:
diff changeset
6160 }
jurzua
parents:
diff changeset
6161
jurzua
parents:
diff changeset
6162 // Remove IE's autoinserted <tbody> from table fragments
jurzua
parents:
diff changeset
6163 if ( !jQuery.support.tbody ) {
jurzua
parents:
diff changeset
6164
jurzua
parents:
diff changeset
6165 // String was a <table>, *may* have spurious <tbody>
jurzua
parents:
diff changeset
6166 var hasBody = rtbody.test(elem),
jurzua
parents:
diff changeset
6167 tbody = tag === "table" && !hasBody ?
jurzua
parents:
diff changeset
6168 div.firstChild && div.firstChild.childNodes :
jurzua
parents:
diff changeset
6169
jurzua
parents:
diff changeset
6170 // String was a bare <thead> or <tfoot>
jurzua
parents:
diff changeset
6171 wrap[1] === "<table>" && !hasBody ?
jurzua
parents:
diff changeset
6172 div.childNodes :
jurzua
parents:
diff changeset
6173 [];
jurzua
parents:
diff changeset
6174
jurzua
parents:
diff changeset
6175 for ( j = tbody.length - 1; j >= 0 ; --j ) {
jurzua
parents:
diff changeset
6176 if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
jurzua
parents:
diff changeset
6177 tbody[ j ].parentNode.removeChild( tbody[ j ] );
jurzua
parents:
diff changeset
6178 }
jurzua
parents:
diff changeset
6179 }
jurzua
parents:
diff changeset
6180 }
jurzua
parents:
diff changeset
6181
jurzua
parents:
diff changeset
6182 // IE completely kills leading whitespace when innerHTML is used
jurzua
parents:
diff changeset
6183 if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
jurzua
parents:
diff changeset
6184 div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
jurzua
parents:
diff changeset
6185 }
jurzua
parents:
diff changeset
6186
jurzua
parents:
diff changeset
6187 elem = div.childNodes;
jurzua
parents:
diff changeset
6188 }
jurzua
parents:
diff changeset
6189 }
jurzua
parents:
diff changeset
6190
jurzua
parents:
diff changeset
6191 // Resets defaultChecked for any radios and checkboxes
jurzua
parents:
diff changeset
6192 // about to be appended to the DOM in IE 6/7 (#8060)
jurzua
parents:
diff changeset
6193 var len;
jurzua
parents:
diff changeset
6194 if ( !jQuery.support.appendChecked ) {
jurzua
parents:
diff changeset
6195 if ( elem[0] && typeof (len = elem.length) === "number" ) {
jurzua
parents:
diff changeset
6196 for ( j = 0; j < len; j++ ) {
jurzua
parents:
diff changeset
6197 findInputs( elem[j] );
jurzua
parents:
diff changeset
6198 }
jurzua
parents:
diff changeset
6199 } else {
jurzua
parents:
diff changeset
6200 findInputs( elem );
jurzua
parents:
diff changeset
6201 }
jurzua
parents:
diff changeset
6202 }
jurzua
parents:
diff changeset
6203
jurzua
parents:
diff changeset
6204 if ( elem.nodeType ) {
jurzua
parents:
diff changeset
6205 ret.push( elem );
jurzua
parents:
diff changeset
6206 } else {
jurzua
parents:
diff changeset
6207 ret = jQuery.merge( ret, elem );
jurzua
parents:
diff changeset
6208 }
jurzua
parents:
diff changeset
6209 }
jurzua
parents:
diff changeset
6210
jurzua
parents:
diff changeset
6211 if ( fragment ) {
jurzua
parents:
diff changeset
6212 checkScriptType = function( elem ) {
jurzua
parents:
diff changeset
6213 return !elem.type || rscriptType.test( elem.type );
jurzua
parents:
diff changeset
6214 };
jurzua
parents:
diff changeset
6215 for ( i = 0; ret[i]; i++ ) {
jurzua
parents:
diff changeset
6216 if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
jurzua
parents:
diff changeset
6217 scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
jurzua
parents:
diff changeset
6218
jurzua
parents:
diff changeset
6219 } else {
jurzua
parents:
diff changeset
6220 if ( ret[i].nodeType === 1 ) {
jurzua
parents:
diff changeset
6221 var jsTags = jQuery.grep( ret[i].getElementsByTagName( "script" ), checkScriptType );
jurzua
parents:
diff changeset
6222
jurzua
parents:
diff changeset
6223 ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
jurzua
parents:
diff changeset
6224 }
jurzua
parents:
diff changeset
6225 fragment.appendChild( ret[i] );
jurzua
parents:
diff changeset
6226 }
jurzua
parents:
diff changeset
6227 }
jurzua
parents:
diff changeset
6228 }
jurzua
parents:
diff changeset
6229
jurzua
parents:
diff changeset
6230 return ret;
jurzua
parents:
diff changeset
6231 },
jurzua
parents:
diff changeset
6232
jurzua
parents:
diff changeset
6233 cleanData: function( elems ) {
jurzua
parents:
diff changeset
6234 var data, id, cache = jQuery.cache, internalKey = jQuery.expando, special = jQuery.event.special,
jurzua
parents:
diff changeset
6235 deleteExpando = jQuery.support.deleteExpando;
jurzua
parents:
diff changeset
6236
jurzua
parents:
diff changeset
6237 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
jurzua
parents:
diff changeset
6238 if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
jurzua
parents:
diff changeset
6239 continue;
jurzua
parents:
diff changeset
6240 }
jurzua
parents:
diff changeset
6241
jurzua
parents:
diff changeset
6242 id = elem[ jQuery.expando ];
jurzua
parents:
diff changeset
6243
jurzua
parents:
diff changeset
6244 if ( id ) {
jurzua
parents:
diff changeset
6245 data = cache[ id ] && cache[ id ][ internalKey ];
jurzua
parents:
diff changeset
6246
jurzua
parents:
diff changeset
6247 if ( data && data.events ) {
jurzua
parents:
diff changeset
6248 for ( var type in data.events ) {
jurzua
parents:
diff changeset
6249 if ( special[ type ] ) {
jurzua
parents:
diff changeset
6250 jQuery.event.remove( elem, type );
jurzua
parents:
diff changeset
6251
jurzua
parents:
diff changeset
6252 // This is a shortcut to avoid jQuery.event.remove's overhead
jurzua
parents:
diff changeset
6253 } else {
jurzua
parents:
diff changeset
6254 jQuery.removeEvent( elem, type, data.handle );
jurzua
parents:
diff changeset
6255 }
jurzua
parents:
diff changeset
6256 }
jurzua
parents:
diff changeset
6257
jurzua
parents:
diff changeset
6258 // Null the DOM reference to avoid IE6/7/8 leak (#7054)
jurzua
parents:
diff changeset
6259 if ( data.handle ) {
jurzua
parents:
diff changeset
6260 data.handle.elem = null;
jurzua
parents:
diff changeset
6261 }
jurzua
parents:
diff changeset
6262 }
jurzua
parents:
diff changeset
6263
jurzua
parents:
diff changeset
6264 if ( deleteExpando ) {
jurzua
parents:
diff changeset
6265 delete elem[ jQuery.expando ];
jurzua
parents:
diff changeset
6266
jurzua
parents:
diff changeset
6267 } else if ( elem.removeAttribute ) {
jurzua
parents:
diff changeset
6268 elem.removeAttribute( jQuery.expando );
jurzua
parents:
diff changeset
6269 }
jurzua
parents:
diff changeset
6270
jurzua
parents:
diff changeset
6271 delete cache[ id ];
jurzua
parents:
diff changeset
6272 }
jurzua
parents:
diff changeset
6273 }
jurzua
parents:
diff changeset
6274 }
jurzua
parents:
diff changeset
6275 });
jurzua
parents:
diff changeset
6276
jurzua
parents:
diff changeset
6277 function evalScript( i, elem ) {
jurzua
parents:
diff changeset
6278 if ( elem.src ) {
jurzua
parents:
diff changeset
6279 jQuery.ajax({
jurzua
parents:
diff changeset
6280 url: elem.src,
jurzua
parents:
diff changeset
6281 async: false,
jurzua
parents:
diff changeset
6282 dataType: "script"
jurzua
parents:
diff changeset
6283 });
jurzua
parents:
diff changeset
6284 } else {
jurzua
parents:
diff changeset
6285 jQuery.globalEval( ( elem.text || elem.textContent || elem.innerHTML || "" ).replace( rcleanScript, "/*$0*/" ) );
jurzua
parents:
diff changeset
6286 }
jurzua
parents:
diff changeset
6287
jurzua
parents:
diff changeset
6288 if ( elem.parentNode ) {
jurzua
parents:
diff changeset
6289 elem.parentNode.removeChild( elem );
jurzua
parents:
diff changeset
6290 }
jurzua
parents:
diff changeset
6291 }
jurzua
parents:
diff changeset
6292
jurzua
parents:
diff changeset
6293
jurzua
parents:
diff changeset
6294
jurzua
parents:
diff changeset
6295
jurzua
parents:
diff changeset
6296 var ralpha = /alpha\([^)]*\)/i,
jurzua
parents:
diff changeset
6297 ropacity = /opacity=([^)]*)/,
jurzua
parents:
diff changeset
6298 // fixed for IE9, see #8346
jurzua
parents:
diff changeset
6299 rupper = /([A-Z]|^ms)/g,
jurzua
parents:
diff changeset
6300 rnumpx = /^-?\d+(?:px)?$/i,
jurzua
parents:
diff changeset
6301 rnum = /^-?\d/,
jurzua
parents:
diff changeset
6302 rrelNum = /^([\-+])=([\-+.\de]+)/,
jurzua
parents:
diff changeset
6303
jurzua
parents:
diff changeset
6304 cssShow = { position: "absolute", visibility: "hidden", display: "block" },
jurzua
parents:
diff changeset
6305 cssWidth = [ "Left", "Right" ],
jurzua
parents:
diff changeset
6306 cssHeight = [ "Top", "Bottom" ],
jurzua
parents:
diff changeset
6307 curCSS,
jurzua
parents:
diff changeset
6308
jurzua
parents:
diff changeset
6309 getComputedStyle,
jurzua
parents:
diff changeset
6310 currentStyle;
jurzua
parents:
diff changeset
6311
jurzua
parents:
diff changeset
6312 jQuery.fn.css = function( name, value ) {
jurzua
parents:
diff changeset
6313 // Setting 'undefined' is a no-op
jurzua
parents:
diff changeset
6314 if ( arguments.length === 2 && value === undefined ) {
jurzua
parents:
diff changeset
6315 return this;
jurzua
parents:
diff changeset
6316 }
jurzua
parents:
diff changeset
6317
jurzua
parents:
diff changeset
6318 return jQuery.access( this, name, value, true, function( elem, name, value ) {
jurzua
parents:
diff changeset
6319 return value !== undefined ?
jurzua
parents:
diff changeset
6320 jQuery.style( elem, name, value ) :
jurzua
parents:
diff changeset
6321 jQuery.css( elem, name );
jurzua
parents:
diff changeset
6322 });
jurzua
parents:
diff changeset
6323 };
jurzua
parents:
diff changeset
6324
jurzua
parents:
diff changeset
6325 jQuery.extend({
jurzua
parents:
diff changeset
6326 // Add in style property hooks for overriding the default
jurzua
parents:
diff changeset
6327 // behavior of getting and setting a style property
jurzua
parents:
diff changeset
6328 cssHooks: {
jurzua
parents:
diff changeset
6329 opacity: {
jurzua
parents:
diff changeset
6330 get: function( elem, computed ) {
jurzua
parents:
diff changeset
6331 if ( computed ) {
jurzua
parents:
diff changeset
6332 // We should always get a number back from opacity
jurzua
parents:
diff changeset
6333 var ret = curCSS( elem, "opacity", "opacity" );
jurzua
parents:
diff changeset
6334 return ret === "" ? "1" : ret;
jurzua
parents:
diff changeset
6335
jurzua
parents:
diff changeset
6336 } else {
jurzua
parents:
diff changeset
6337 return elem.style.opacity;
jurzua
parents:
diff changeset
6338 }
jurzua
parents:
diff changeset
6339 }
jurzua
parents:
diff changeset
6340 }
jurzua
parents:
diff changeset
6341 },
jurzua
parents:
diff changeset
6342
jurzua
parents:
diff changeset
6343 // Exclude the following css properties to add px
jurzua
parents:
diff changeset
6344 cssNumber: {
jurzua
parents:
diff changeset
6345 "fillOpacity": true,
jurzua
parents:
diff changeset
6346 "fontWeight": true,
jurzua
parents:
diff changeset
6347 "lineHeight": true,
jurzua
parents:
diff changeset
6348 "opacity": true,
jurzua
parents:
diff changeset
6349 "orphans": true,
jurzua
parents:
diff changeset
6350 "widows": true,
jurzua
parents:
diff changeset
6351 "zIndex": true,
jurzua
parents:
diff changeset
6352 "zoom": true
jurzua
parents:
diff changeset
6353 },
jurzua
parents:
diff changeset
6354
jurzua
parents:
diff changeset
6355 // Add in properties whose names you wish to fix before
jurzua
parents:
diff changeset
6356 // setting or getting the value
jurzua
parents:
diff changeset
6357 cssProps: {
jurzua
parents:
diff changeset
6358 // normalize float css property
jurzua
parents:
diff changeset
6359 "float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
jurzua
parents:
diff changeset
6360 },
jurzua
parents:
diff changeset
6361
jurzua
parents:
diff changeset
6362 // Get and set the style property on a DOM Node
jurzua
parents:
diff changeset
6363 style: function( elem, name, value, extra ) {
jurzua
parents:
diff changeset
6364 // Don't set styles on text and comment nodes
jurzua
parents:
diff changeset
6365 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
jurzua
parents:
diff changeset
6366 return;
jurzua
parents:
diff changeset
6367 }
jurzua
parents:
diff changeset
6368
jurzua
parents:
diff changeset
6369 // Make sure that we're working with the right name
jurzua
parents:
diff changeset
6370 var ret, type, origName = jQuery.camelCase( name ),
jurzua
parents:
diff changeset
6371 style = elem.style, hooks = jQuery.cssHooks[ origName ];
jurzua
parents:
diff changeset
6372
jurzua
parents:
diff changeset
6373 name = jQuery.cssProps[ origName ] || origName;
jurzua
parents:
diff changeset
6374
jurzua
parents:
diff changeset
6375 // Check if we're setting a value
jurzua
parents:
diff changeset
6376 if ( value !== undefined ) {
jurzua
parents:
diff changeset
6377 type = typeof value;
jurzua
parents:
diff changeset
6378
jurzua
parents:
diff changeset
6379 // convert relative number strings (+= or -=) to relative numbers. #7345
jurzua
parents:
diff changeset
6380 if ( type === "string" && (ret = rrelNum.exec( value )) ) {
jurzua
parents:
diff changeset
6381 value = ( +( ret[1] + 1) * +ret[2] ) + parseFloat( jQuery.css( elem, name ) );
jurzua
parents:
diff changeset
6382 // Fixes bug #9237
jurzua
parents:
diff changeset
6383 type = "number";
jurzua
parents:
diff changeset
6384 }
jurzua
parents:
diff changeset
6385
jurzua
parents:
diff changeset
6386 // Make sure that NaN and null values aren't set. See: #7116
jurzua
parents:
diff changeset
6387 if ( value == null || type === "number" && isNaN( value ) ) {
jurzua
parents:
diff changeset
6388 return;
jurzua
parents:
diff changeset
6389 }
jurzua
parents:
diff changeset
6390
jurzua
parents:
diff changeset
6391 // If a number was passed in, add 'px' to the (except for certain CSS properties)
jurzua
parents:
diff changeset
6392 if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
jurzua
parents:
diff changeset
6393 value += "px";
jurzua
parents:
diff changeset
6394 }
jurzua
parents:
diff changeset
6395
jurzua
parents:
diff changeset
6396 // If a hook was provided, use that value, otherwise just set the specified value
jurzua
parents:
diff changeset
6397 if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
jurzua
parents:
diff changeset
6398 // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
jurzua
parents:
diff changeset
6399 // Fixes bug #5509
jurzua
parents:
diff changeset
6400 try {
jurzua
parents:
diff changeset
6401 style[ name ] = value;
jurzua
parents:
diff changeset
6402 } catch(e) {}
jurzua
parents:
diff changeset
6403 }
jurzua
parents:
diff changeset
6404
jurzua
parents:
diff changeset
6405 } else {
jurzua
parents:
diff changeset
6406 // If a hook was provided get the non-computed value from there
jurzua
parents:
diff changeset
6407 if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
jurzua
parents:
diff changeset
6408 return ret;
jurzua
parents:
diff changeset
6409 }
jurzua
parents:
diff changeset
6410
jurzua
parents:
diff changeset
6411 // Otherwise just get the value from the style object
jurzua
parents:
diff changeset
6412 return style[ name ];
jurzua
parents:
diff changeset
6413 }
jurzua
parents:
diff changeset
6414 },
jurzua
parents:
diff changeset
6415
jurzua
parents:
diff changeset
6416 css: function( elem, name, extra ) {
jurzua
parents:
diff changeset
6417 var ret, hooks;
jurzua
parents:
diff changeset
6418
jurzua
parents:
diff changeset
6419 // Make sure that we're working with the right name
jurzua
parents:
diff changeset
6420 name = jQuery.camelCase( name );
jurzua
parents:
diff changeset
6421 hooks = jQuery.cssHooks[ name ];
jurzua
parents:
diff changeset
6422 name = jQuery.cssProps[ name ] || name;
jurzua
parents:
diff changeset
6423
jurzua
parents:
diff changeset
6424 // cssFloat needs a special treatment
jurzua
parents:
diff changeset
6425 if ( name === "cssFloat" ) {
jurzua
parents:
diff changeset
6426 name = "float";
jurzua
parents:
diff changeset
6427 }
jurzua
parents:
diff changeset
6428
jurzua
parents:
diff changeset
6429 // If a hook was provided get the computed value from there
jurzua
parents:
diff changeset
6430 if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
jurzua
parents:
diff changeset
6431 return ret;
jurzua
parents:
diff changeset
6432
jurzua
parents:
diff changeset
6433 // Otherwise, if a way to get the computed value exists, use that
jurzua
parents:
diff changeset
6434 } else if ( curCSS ) {
jurzua
parents:
diff changeset
6435 return curCSS( elem, name );
jurzua
parents:
diff changeset
6436 }
jurzua
parents:
diff changeset
6437 },
jurzua
parents:
diff changeset
6438
jurzua
parents:
diff changeset
6439 // A method for quickly swapping in/out CSS properties to get correct calculations
jurzua
parents:
diff changeset
6440 swap: function( elem, options, callback ) {
jurzua
parents:
diff changeset
6441 var old = {};
jurzua
parents:
diff changeset
6442
jurzua
parents:
diff changeset
6443 // Remember the old values, and insert the new ones
jurzua
parents:
diff changeset
6444 for ( var name in options ) {
jurzua
parents:
diff changeset
6445 old[ name ] = elem.style[ name ];
jurzua
parents:
diff changeset
6446 elem.style[ name ] = options[ name ];
jurzua
parents:
diff changeset
6447 }
jurzua
parents:
diff changeset
6448
jurzua
parents:
diff changeset
6449 callback.call( elem );
jurzua
parents:
diff changeset
6450
jurzua
parents:
diff changeset
6451 // Revert the old values
jurzua
parents:
diff changeset
6452 for ( name in options ) {
jurzua
parents:
diff changeset
6453 elem.style[ name ] = old[ name ];
jurzua
parents:
diff changeset
6454 }
jurzua
parents:
diff changeset
6455 }
jurzua
parents:
diff changeset
6456 });
jurzua
parents:
diff changeset
6457
jurzua
parents:
diff changeset
6458 // DEPRECATED, Use jQuery.css() instead
jurzua
parents:
diff changeset
6459 jQuery.curCSS = jQuery.css;
jurzua
parents:
diff changeset
6460
jurzua
parents:
diff changeset
6461 jQuery.each(["height", "width"], function( i, name ) {
jurzua
parents:
diff changeset
6462 jQuery.cssHooks[ name ] = {
jurzua
parents:
diff changeset
6463 get: function( elem, computed, extra ) {
jurzua
parents:
diff changeset
6464 var val;
jurzua
parents:
diff changeset
6465
jurzua
parents:
diff changeset
6466 if ( computed ) {
jurzua
parents:
diff changeset
6467 if ( elem.offsetWidth !== 0 ) {
jurzua
parents:
diff changeset
6468 return getWH( elem, name, extra );
jurzua
parents:
diff changeset
6469 } else {
jurzua
parents:
diff changeset
6470 jQuery.swap( elem, cssShow, function() {
jurzua
parents:
diff changeset
6471 val = getWH( elem, name, extra );
jurzua
parents:
diff changeset
6472 });
jurzua
parents:
diff changeset
6473 }
jurzua
parents:
diff changeset
6474
jurzua
parents:
diff changeset
6475 return val;
jurzua
parents:
diff changeset
6476 }
jurzua
parents:
diff changeset
6477 },
jurzua
parents:
diff changeset
6478
jurzua
parents:
diff changeset
6479 set: function( elem, value ) {
jurzua
parents:
diff changeset
6480 if ( rnumpx.test( value ) ) {
jurzua
parents:
diff changeset
6481 // ignore negative width and height values #1599
jurzua
parents:
diff changeset
6482 value = parseFloat( value );
jurzua
parents:
diff changeset
6483
jurzua
parents:
diff changeset
6484 if ( value >= 0 ) {
jurzua
parents:
diff changeset
6485 return value + "px";
jurzua
parents:
diff changeset
6486 }
jurzua
parents:
diff changeset
6487
jurzua
parents:
diff changeset
6488 } else {
jurzua
parents:
diff changeset
6489 return value;
jurzua
parents:
diff changeset
6490 }
jurzua
parents:
diff changeset
6491 }
jurzua
parents:
diff changeset
6492 };
jurzua
parents:
diff changeset
6493 });
jurzua
parents:
diff changeset
6494
jurzua
parents:
diff changeset
6495 if ( !jQuery.support.opacity ) {
jurzua
parents:
diff changeset
6496 jQuery.cssHooks.opacity = {
jurzua
parents:
diff changeset
6497 get: function( elem, computed ) {
jurzua
parents:
diff changeset
6498 // IE uses filters for opacity
jurzua
parents:
diff changeset
6499 return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
jurzua
parents:
diff changeset
6500 ( parseFloat( RegExp.$1 ) / 100 ) + "" :
jurzua
parents:
diff changeset
6501 computed ? "1" : "";
jurzua
parents:
diff changeset
6502 },
jurzua
parents:
diff changeset
6503
jurzua
parents:
diff changeset
6504 set: function( elem, value ) {
jurzua
parents:
diff changeset
6505 var style = elem.style,
jurzua
parents:
diff changeset
6506 currentStyle = elem.currentStyle,
jurzua
parents:
diff changeset
6507 opacity = jQuery.isNaN( value ) ? "" : "alpha(opacity=" + value * 100 + ")",
jurzua
parents:
diff changeset
6508 filter = currentStyle && currentStyle.filter || style.filter || "";
jurzua
parents:
diff changeset
6509
jurzua
parents:
diff changeset
6510 // IE has trouble with opacity if it does not have layout
jurzua
parents:
diff changeset
6511 // Force it by setting the zoom level
jurzua
parents:
diff changeset
6512 style.zoom = 1;
jurzua
parents:
diff changeset
6513
jurzua
parents:
diff changeset
6514 // if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
jurzua
parents:
diff changeset
6515 if ( value >= 1 && jQuery.trim( filter.replace( ralpha, "" ) ) === "" ) {
jurzua
parents:
diff changeset
6516
jurzua
parents:
diff changeset
6517 // Setting style.filter to null, "" & " " still leave "filter:" in the cssText
jurzua
parents:
diff changeset
6518 // if "filter:" is present at all, clearType is disabled, we want to avoid this
jurzua
parents:
diff changeset
6519 // style.removeAttribute is IE Only, but so apparently is this code path...
jurzua
parents:
diff changeset
6520 style.removeAttribute( "filter" );
jurzua
parents:
diff changeset
6521
jurzua
parents:
diff changeset
6522 // if there there is no filter style applied in a css rule, we are done
jurzua
parents:
diff changeset
6523 if ( currentStyle && !currentStyle.filter ) {
jurzua
parents:
diff changeset
6524 return;
jurzua
parents:
diff changeset
6525 }
jurzua
parents:
diff changeset
6526 }
jurzua
parents:
diff changeset
6527
jurzua
parents:
diff changeset
6528 // otherwise, set new filter values
jurzua
parents:
diff changeset
6529 style.filter = ralpha.test( filter ) ?
jurzua
parents:
diff changeset
6530 filter.replace( ralpha, opacity ) :
jurzua
parents:
diff changeset
6531 filter + " " + opacity;
jurzua
parents:
diff changeset
6532 }
jurzua
parents:
diff changeset
6533 };
jurzua
parents:
diff changeset
6534 }
jurzua
parents:
diff changeset
6535
jurzua
parents:
diff changeset
6536 jQuery(function() {
jurzua
parents:
diff changeset
6537 // This hook cannot be added until DOM ready because the support test
jurzua
parents:
diff changeset
6538 // for it is not run until after DOM ready
jurzua
parents:
diff changeset
6539 if ( !jQuery.support.reliableMarginRight ) {
jurzua
parents:
diff changeset
6540 jQuery.cssHooks.marginRight = {
jurzua
parents:
diff changeset
6541 get: function( elem, computed ) {
jurzua
parents:
diff changeset
6542 // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
jurzua
parents:
diff changeset
6543 // Work around by temporarily setting element display to inline-block
jurzua
parents:
diff changeset
6544 var ret;
jurzua
parents:
diff changeset
6545 jQuery.swap( elem, { "display": "inline-block" }, function() {
jurzua
parents:
diff changeset
6546 if ( computed ) {
jurzua
parents:
diff changeset
6547 ret = curCSS( elem, "margin-right", "marginRight" );
jurzua
parents:
diff changeset
6548 } else {
jurzua
parents:
diff changeset
6549 ret = elem.style.marginRight;
jurzua
parents:
diff changeset
6550 }
jurzua
parents:
diff changeset
6551 });
jurzua
parents:
diff changeset
6552 return ret;
jurzua
parents:
diff changeset
6553 }
jurzua
parents:
diff changeset
6554 };
jurzua
parents:
diff changeset
6555 }
jurzua
parents:
diff changeset
6556 });
jurzua
parents:
diff changeset
6557
jurzua
parents:
diff changeset
6558 if ( document.defaultView && document.defaultView.getComputedStyle ) {
jurzua
parents:
diff changeset
6559 getComputedStyle = function( elem, name ) {
jurzua
parents:
diff changeset
6560 var ret, defaultView, computedStyle;
jurzua
parents:
diff changeset
6561
jurzua
parents:
diff changeset
6562 name = name.replace( rupper, "-$1" ).toLowerCase();
jurzua
parents:
diff changeset
6563
jurzua
parents:
diff changeset
6564 if ( !(defaultView = elem.ownerDocument.defaultView) ) {
jurzua
parents:
diff changeset
6565 return undefined;
jurzua
parents:
diff changeset
6566 }
jurzua
parents:
diff changeset
6567
jurzua
parents:
diff changeset
6568 if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
jurzua
parents:
diff changeset
6569 ret = computedStyle.getPropertyValue( name );
jurzua
parents:
diff changeset
6570 if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
jurzua
parents:
diff changeset
6571 ret = jQuery.style( elem, name );
jurzua
parents:
diff changeset
6572 }
jurzua
parents:
diff changeset
6573 }
jurzua
parents:
diff changeset
6574
jurzua
parents:
diff changeset
6575 return ret;
jurzua
parents:
diff changeset
6576 };
jurzua
parents:
diff changeset
6577 }
jurzua
parents:
diff changeset
6578
jurzua
parents:
diff changeset
6579 if ( document.documentElement.currentStyle ) {
jurzua
parents:
diff changeset
6580 currentStyle = function( elem, name ) {
jurzua
parents:
diff changeset
6581 var left,
jurzua
parents:
diff changeset
6582 ret = elem.currentStyle && elem.currentStyle[ name ],
jurzua
parents:
diff changeset
6583 rsLeft = elem.runtimeStyle && elem.runtimeStyle[ name ],
jurzua
parents:
diff changeset
6584 style = elem.style;
jurzua
parents:
diff changeset
6585
jurzua
parents:
diff changeset
6586 // From the awesome hack by Dean Edwards
jurzua
parents:
diff changeset
6587 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
jurzua
parents:
diff changeset
6588
jurzua
parents:
diff changeset
6589 // If we're not dealing with a regular pixel number
jurzua
parents:
diff changeset
6590 // but a number that has a weird ending, we need to convert it to pixels
jurzua
parents:
diff changeset
6591 if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
jurzua
parents:
diff changeset
6592 // Remember the original values
jurzua
parents:
diff changeset
6593 left = style.left;
jurzua
parents:
diff changeset
6594
jurzua
parents:
diff changeset
6595 // Put in the new values to get a computed value out
jurzua
parents:
diff changeset
6596 if ( rsLeft ) {
jurzua
parents:
diff changeset
6597 elem.runtimeStyle.left = elem.currentStyle.left;
jurzua
parents:
diff changeset
6598 }
jurzua
parents:
diff changeset
6599 style.left = name === "fontSize" ? "1em" : (ret || 0);
jurzua
parents:
diff changeset
6600 ret = style.pixelLeft + "px";
jurzua
parents:
diff changeset
6601
jurzua
parents:
diff changeset
6602 // Revert the changed values
jurzua
parents:
diff changeset
6603 style.left = left;
jurzua
parents:
diff changeset
6604 if ( rsLeft ) {
jurzua
parents:
diff changeset
6605 elem.runtimeStyle.left = rsLeft;
jurzua
parents:
diff changeset
6606 }
jurzua
parents:
diff changeset
6607 }
jurzua
parents:
diff changeset
6608
jurzua
parents:
diff changeset
6609 return ret === "" ? "auto" : ret;
jurzua
parents:
diff changeset
6610 };
jurzua
parents:
diff changeset
6611 }
jurzua
parents:
diff changeset
6612
jurzua
parents:
diff changeset
6613 curCSS = getComputedStyle || currentStyle;
jurzua
parents:
diff changeset
6614
jurzua
parents:
diff changeset
6615 function getWH( elem, name, extra ) {
jurzua
parents:
diff changeset
6616
jurzua
parents:
diff changeset
6617 // Start with offset property
jurzua
parents:
diff changeset
6618 var val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
jurzua
parents:
diff changeset
6619 which = name === "width" ? cssWidth : cssHeight;
jurzua
parents:
diff changeset
6620
jurzua
parents:
diff changeset
6621 if ( val > 0 ) {
jurzua
parents:
diff changeset
6622 if ( extra !== "border" ) {
jurzua
parents:
diff changeset
6623 jQuery.each( which, function() {
jurzua
parents:
diff changeset
6624 if ( !extra ) {
jurzua
parents:
diff changeset
6625 val -= parseFloat( jQuery.css( elem, "padding" + this ) ) || 0;
jurzua
parents:
diff changeset
6626 }
jurzua
parents:
diff changeset
6627 if ( extra === "margin" ) {
jurzua
parents:
diff changeset
6628 val += parseFloat( jQuery.css( elem, extra + this ) ) || 0;
jurzua
parents:
diff changeset
6629 } else {
jurzua
parents:
diff changeset
6630 val -= parseFloat( jQuery.css( elem, "border" + this + "Width" ) ) || 0;
jurzua
parents:
diff changeset
6631 }
jurzua
parents:
diff changeset
6632 });
jurzua
parents:
diff changeset
6633 }
jurzua
parents:
diff changeset
6634
jurzua
parents:
diff changeset
6635 return val + "px";
jurzua
parents:
diff changeset
6636 }
jurzua
parents:
diff changeset
6637
jurzua
parents:
diff changeset
6638 // Fall back to computed then uncomputed css if necessary
jurzua
parents:
diff changeset
6639 val = curCSS( elem, name, name );
jurzua
parents:
diff changeset
6640 if ( val < 0 || val == null ) {
jurzua
parents:
diff changeset
6641 val = elem.style[ name ] || 0;
jurzua
parents:
diff changeset
6642 }
jurzua
parents:
diff changeset
6643 // Normalize "", auto, and prepare for extra
jurzua
parents:
diff changeset
6644 val = parseFloat( val ) || 0;
jurzua
parents:
diff changeset
6645
jurzua
parents:
diff changeset
6646 // Add padding, border, margin
jurzua
parents:
diff changeset
6647 if ( extra ) {
jurzua
parents:
diff changeset
6648 jQuery.each( which, function() {
jurzua
parents:
diff changeset
6649 val += parseFloat( jQuery.css( elem, "padding" + this ) ) || 0;
jurzua
parents:
diff changeset
6650 if ( extra !== "padding" ) {
jurzua
parents:
diff changeset
6651 val += parseFloat( jQuery.css( elem, "border" + this + "Width" ) ) || 0;
jurzua
parents:
diff changeset
6652 }
jurzua
parents:
diff changeset
6653 if ( extra === "margin" ) {
jurzua
parents:
diff changeset
6654 val += parseFloat( jQuery.css( elem, extra + this ) ) || 0;
jurzua
parents:
diff changeset
6655 }
jurzua
parents:
diff changeset
6656 });
jurzua
parents:
diff changeset
6657 }
jurzua
parents:
diff changeset
6658
jurzua
parents:
diff changeset
6659 return val + "px";
jurzua
parents:
diff changeset
6660 }
jurzua
parents:
diff changeset
6661
jurzua
parents:
diff changeset
6662 if ( jQuery.expr && jQuery.expr.filters ) {
jurzua
parents:
diff changeset
6663 jQuery.expr.filters.hidden = function( elem ) {
jurzua
parents:
diff changeset
6664 var width = elem.offsetWidth,
jurzua
parents:
diff changeset
6665 height = elem.offsetHeight;
jurzua
parents:
diff changeset
6666
jurzua
parents:
diff changeset
6667 return (width === 0 && height === 0) || (!jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css( elem, "display" )) === "none");
jurzua
parents:
diff changeset
6668 };
jurzua
parents:
diff changeset
6669
jurzua
parents:
diff changeset
6670 jQuery.expr.filters.visible = function( elem ) {
jurzua
parents:
diff changeset
6671 return !jQuery.expr.filters.hidden( elem );
jurzua
parents:
diff changeset
6672 };
jurzua
parents:
diff changeset
6673 }
jurzua
parents:
diff changeset
6674
jurzua
parents:
diff changeset
6675
jurzua
parents:
diff changeset
6676
jurzua
parents:
diff changeset
6677
jurzua
parents:
diff changeset
6678 var r20 = /%20/g,
jurzua
parents:
diff changeset
6679 rbracket = /\[\]$/,
jurzua
parents:
diff changeset
6680 rCRLF = /\r?\n/g,
jurzua
parents:
diff changeset
6681 rhash = /#.*$/,
jurzua
parents:
diff changeset
6682 rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
jurzua
parents:
diff changeset
6683 rinput = /^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
jurzua
parents:
diff changeset
6684 // #7653, #8125, #8152: local protocol detection
jurzua
parents:
diff changeset
6685 rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,
jurzua
parents:
diff changeset
6686 rnoContent = /^(?:GET|HEAD)$/,
jurzua
parents:
diff changeset
6687 rprotocol = /^\/\//,
jurzua
parents:
diff changeset
6688 rquery = /\?/,
jurzua
parents:
diff changeset
6689 rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
jurzua
parents:
diff changeset
6690 rselectTextarea = /^(?:select|textarea)/i,
jurzua
parents:
diff changeset
6691 rspacesAjax = /\s+/,
jurzua
parents:
diff changeset
6692 rts = /([?&])_=[^&]*/,
jurzua
parents:
diff changeset
6693 rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,
jurzua
parents:
diff changeset
6694
jurzua
parents:
diff changeset
6695 // Keep a copy of the old load method
jurzua
parents:
diff changeset
6696 _load = jQuery.fn.load,
jurzua
parents:
diff changeset
6697
jurzua
parents:
diff changeset
6698 /* Prefilters
jurzua
parents:
diff changeset
6699 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
jurzua
parents:
diff changeset
6700 * 2) These are called:
jurzua
parents:
diff changeset
6701 * - BEFORE asking for a transport
jurzua
parents:
diff changeset
6702 * - AFTER param serialization (s.data is a string if s.processData is true)
jurzua
parents:
diff changeset
6703 * 3) key is the dataType
jurzua
parents:
diff changeset
6704 * 4) the catchall symbol "*" can be used
jurzua
parents:
diff changeset
6705 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
jurzua
parents:
diff changeset
6706 */
jurzua
parents:
diff changeset
6707 prefilters = {},
jurzua
parents:
diff changeset
6708
jurzua
parents:
diff changeset
6709 /* Transports bindings
jurzua
parents:
diff changeset
6710 * 1) key is the dataType
jurzua
parents:
diff changeset
6711 * 2) the catchall symbol "*" can be used
jurzua
parents:
diff changeset
6712 * 3) selection will start with transport dataType and THEN go to "*" if needed
jurzua
parents:
diff changeset
6713 */
jurzua
parents:
diff changeset
6714 transports = {},
jurzua
parents:
diff changeset
6715
jurzua
parents:
diff changeset
6716 // Document location
jurzua
parents:
diff changeset
6717 ajaxLocation,
jurzua
parents:
diff changeset
6718
jurzua
parents:
diff changeset
6719 // Document location segments
jurzua
parents:
diff changeset
6720 ajaxLocParts,
jurzua
parents:
diff changeset
6721
jurzua
parents:
diff changeset
6722 // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
jurzua
parents:
diff changeset
6723 allTypes = ["*/"] + ["*"];
jurzua
parents:
diff changeset
6724
jurzua
parents:
diff changeset
6725 // #8138, IE may throw an exception when accessing
jurzua
parents:
diff changeset
6726 // a field from window.location if document.domain has been set
jurzua
parents:
diff changeset
6727 try {
jurzua
parents:
diff changeset
6728 ajaxLocation = location.href;
jurzua
parents:
diff changeset
6729 } catch( e ) {
jurzua
parents:
diff changeset
6730 // Use the href attribute of an A element
jurzua
parents:
diff changeset
6731 // since IE will modify it given document.location
jurzua
parents:
diff changeset
6732 ajaxLocation = document.createElement( "a" );
jurzua
parents:
diff changeset
6733 ajaxLocation.href = "";
jurzua
parents:
diff changeset
6734 ajaxLocation = ajaxLocation.href;
jurzua
parents:
diff changeset
6735 }
jurzua
parents:
diff changeset
6736
jurzua
parents:
diff changeset
6737 // Segment location into parts
jurzua
parents:
diff changeset
6738 ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
jurzua
parents:
diff changeset
6739
jurzua
parents:
diff changeset
6740 // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
jurzua
parents:
diff changeset
6741 function addToPrefiltersOrTransports( structure ) {
jurzua
parents:
diff changeset
6742
jurzua
parents:
diff changeset
6743 // dataTypeExpression is optional and defaults to "*"
jurzua
parents:
diff changeset
6744 return function( dataTypeExpression, func ) {
jurzua
parents:
diff changeset
6745
jurzua
parents:
diff changeset
6746 if ( typeof dataTypeExpression !== "string" ) {
jurzua
parents:
diff changeset
6747 func = dataTypeExpression;
jurzua
parents:
diff changeset
6748 dataTypeExpression = "*";
jurzua
parents:
diff changeset
6749 }
jurzua
parents:
diff changeset
6750
jurzua
parents:
diff changeset
6751 if ( jQuery.isFunction( func ) ) {
jurzua
parents:
diff changeset
6752 var dataTypes = dataTypeExpression.toLowerCase().split( rspacesAjax ),
jurzua
parents:
diff changeset
6753 i = 0,
jurzua
parents:
diff changeset
6754 length = dataTypes.length,
jurzua
parents:
diff changeset
6755 dataType,
jurzua
parents:
diff changeset
6756 list,
jurzua
parents:
diff changeset
6757 placeBefore;
jurzua
parents:
diff changeset
6758
jurzua
parents:
diff changeset
6759 // For each dataType in the dataTypeExpression
jurzua
parents:
diff changeset
6760 for(; i < length; i++ ) {
jurzua
parents:
diff changeset
6761 dataType = dataTypes[ i ];
jurzua
parents:
diff changeset
6762 // We control if we're asked to add before
jurzua
parents:
diff changeset
6763 // any existing element
jurzua
parents:
diff changeset
6764 placeBefore = /^\+/.test( dataType );
jurzua
parents:
diff changeset
6765 if ( placeBefore ) {
jurzua
parents:
diff changeset
6766 dataType = dataType.substr( 1 ) || "*";
jurzua
parents:
diff changeset
6767 }
jurzua
parents:
diff changeset
6768 list = structure[ dataType ] = structure[ dataType ] || [];
jurzua
parents:
diff changeset
6769 // then we add to the structure accordingly
jurzua
parents:
diff changeset
6770 list[ placeBefore ? "unshift" : "push" ]( func );
jurzua
parents:
diff changeset
6771 }
jurzua
parents:
diff changeset
6772 }
jurzua
parents:
diff changeset
6773 };
jurzua
parents:
diff changeset
6774 }
jurzua
parents:
diff changeset
6775
jurzua
parents:
diff changeset
6776 // Base inspection function for prefilters and transports
jurzua
parents:
diff changeset
6777 function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,
jurzua
parents:
diff changeset
6778 dataType /* internal */, inspected /* internal */ ) {
jurzua
parents:
diff changeset
6779
jurzua
parents:
diff changeset
6780 dataType = dataType || options.dataTypes[ 0 ];
jurzua
parents:
diff changeset
6781 inspected = inspected || {};
jurzua
parents:
diff changeset
6782
jurzua
parents:
diff changeset
6783 inspected[ dataType ] = true;
jurzua
parents:
diff changeset
6784
jurzua
parents:
diff changeset
6785 var list = structure[ dataType ],
jurzua
parents:
diff changeset
6786 i = 0,
jurzua
parents:
diff changeset
6787 length = list ? list.length : 0,
jurzua
parents:
diff changeset
6788 executeOnly = ( structure === prefilters ),
jurzua
parents:
diff changeset
6789 selection;
jurzua
parents:
diff changeset
6790
jurzua
parents:
diff changeset
6791 for(; i < length && ( executeOnly || !selection ); i++ ) {
jurzua
parents:
diff changeset
6792 selection = list[ i ]( options, originalOptions, jqXHR );
jurzua
parents:
diff changeset
6793 // If we got redirected to another dataType
jurzua
parents:
diff changeset
6794 // we try there if executing only and not done already
jurzua
parents:
diff changeset
6795 if ( typeof selection === "string" ) {
jurzua
parents:
diff changeset
6796 if ( !executeOnly || inspected[ selection ] ) {
jurzua
parents:
diff changeset
6797 selection = undefined;
jurzua
parents:
diff changeset
6798 } else {
jurzua
parents:
diff changeset
6799 options.dataTypes.unshift( selection );
jurzua
parents:
diff changeset
6800 selection = inspectPrefiltersOrTransports(
jurzua
parents:
diff changeset
6801 structure, options, originalOptions, jqXHR, selection, inspected );
jurzua
parents:
diff changeset
6802 }
jurzua
parents:
diff changeset
6803 }
jurzua
parents:
diff changeset
6804 }
jurzua
parents:
diff changeset
6805 // If we're only executing or nothing was selected
jurzua
parents:
diff changeset
6806 // we try the catchall dataType if not done already
jurzua
parents:
diff changeset
6807 if ( ( executeOnly || !selection ) && !inspected[ "*" ] ) {
jurzua
parents:
diff changeset
6808 selection = inspectPrefiltersOrTransports(
jurzua
parents:
diff changeset
6809 structure, options, originalOptions, jqXHR, "*", inspected );
jurzua
parents:
diff changeset
6810 }
jurzua
parents:
diff changeset
6811 // unnecessary when only executing (prefilters)
jurzua
parents:
diff changeset
6812 // but it'll be ignored by the caller in that case
jurzua
parents:
diff changeset
6813 return selection;
jurzua
parents:
diff changeset
6814 }
jurzua
parents:
diff changeset
6815
jurzua
parents:
diff changeset
6816 // A special extend for ajax options
jurzua
parents:
diff changeset
6817 // that takes "flat" options (not to be deep extended)
jurzua
parents:
diff changeset
6818 // Fixes #9887
jurzua
parents:
diff changeset
6819 function ajaxExtend( target, src ) {
jurzua
parents:
diff changeset
6820 var key, deep,
jurzua
parents:
diff changeset
6821 flatOptions = jQuery.ajaxSettings.flatOptions || {};
jurzua
parents:
diff changeset
6822 for( key in src ) {
jurzua
parents:
diff changeset
6823 if ( src[ key ] !== undefined ) {
jurzua
parents:
diff changeset
6824 ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
jurzua
parents:
diff changeset
6825 }
jurzua
parents:
diff changeset
6826 }
jurzua
parents:
diff changeset
6827 if ( deep ) {
jurzua
parents:
diff changeset
6828 jQuery.extend( true, target, deep );
jurzua
parents:
diff changeset
6829 }
jurzua
parents:
diff changeset
6830 }
jurzua
parents:
diff changeset
6831
jurzua
parents:
diff changeset
6832 jQuery.fn.extend({
jurzua
parents:
diff changeset
6833 load: function( url, params, callback ) {
jurzua
parents:
diff changeset
6834 if ( typeof url !== "string" && _load ) {
jurzua
parents:
diff changeset
6835 return _load.apply( this, arguments );
jurzua
parents:
diff changeset
6836
jurzua
parents:
diff changeset
6837 // Don't do a request if no elements are being requested
jurzua
parents:
diff changeset
6838 } else if ( !this.length ) {
jurzua
parents:
diff changeset
6839 return this;
jurzua
parents:
diff changeset
6840 }
jurzua
parents:
diff changeset
6841
jurzua
parents:
diff changeset
6842 var off = url.indexOf( " " );
jurzua
parents:
diff changeset
6843 if ( off >= 0 ) {
jurzua
parents:
diff changeset
6844 var selector = url.slice( off, url.length );
jurzua
parents:
diff changeset
6845 url = url.slice( 0, off );
jurzua
parents:
diff changeset
6846 }
jurzua
parents:
diff changeset
6847
jurzua
parents:
diff changeset
6848 // Default to a GET request
jurzua
parents:
diff changeset
6849 var type = "GET";
jurzua
parents:
diff changeset
6850
jurzua
parents:
diff changeset
6851 // If the second parameter was provided
jurzua
parents:
diff changeset
6852 if ( params ) {
jurzua
parents:
diff changeset
6853 // If it's a function
jurzua
parents:
diff changeset
6854 if ( jQuery.isFunction( params ) ) {
jurzua
parents:
diff changeset
6855 // We assume that it's the callback
jurzua
parents:
diff changeset
6856 callback = params;
jurzua
parents:
diff changeset
6857 params = undefined;
jurzua
parents:
diff changeset
6858
jurzua
parents:
diff changeset
6859 // Otherwise, build a param string
jurzua
parents:
diff changeset
6860 } else if ( typeof params === "object" ) {
jurzua
parents:
diff changeset
6861 params = jQuery.param( params, jQuery.ajaxSettings.traditional );
jurzua
parents:
diff changeset
6862 type = "POST";
jurzua
parents:
diff changeset
6863 }
jurzua
parents:
diff changeset
6864 }
jurzua
parents:
diff changeset
6865
jurzua
parents:
diff changeset
6866 var self = this;
jurzua
parents:
diff changeset
6867
jurzua
parents:
diff changeset
6868 // Request the remote document
jurzua
parents:
diff changeset
6869 jQuery.ajax({
jurzua
parents:
diff changeset
6870 url: url,
jurzua
parents:
diff changeset
6871 type: type,
jurzua
parents:
diff changeset
6872 dataType: "html",
jurzua
parents:
diff changeset
6873 data: params,
jurzua
parents:
diff changeset
6874 // Complete callback (responseText is used internally)
jurzua
parents:
diff changeset
6875 complete: function( jqXHR, status, responseText ) {
jurzua
parents:
diff changeset
6876 // Store the response as specified by the jqXHR object
jurzua
parents:
diff changeset
6877 responseText = jqXHR.responseText;
jurzua
parents:
diff changeset
6878 // If successful, inject the HTML into all the matched elements
jurzua
parents:
diff changeset
6879 if ( jqXHR.isResolved() ) {
jurzua
parents:
diff changeset
6880 // #4825: Get the actual response in case
jurzua
parents:
diff changeset
6881 // a dataFilter is present in ajaxSettings
jurzua
parents:
diff changeset
6882 jqXHR.done(function( r ) {
jurzua
parents:
diff changeset
6883 responseText = r;
jurzua
parents:
diff changeset
6884 });
jurzua
parents:
diff changeset
6885 // See if a selector was specified
jurzua
parents:
diff changeset
6886 self.html( selector ?
jurzua
parents:
diff changeset
6887 // Create a dummy div to hold the results
jurzua
parents:
diff changeset
6888 jQuery("<div>")
jurzua
parents:
diff changeset
6889 // inject the contents of the document in, removing the scripts
jurzua
parents:
diff changeset
6890 // to avoid any 'Permission Denied' errors in IE
jurzua
parents:
diff changeset
6891 .append(responseText.replace(rscript, ""))
jurzua
parents:
diff changeset
6892
jurzua
parents:
diff changeset
6893 // Locate the specified elements
jurzua
parents:
diff changeset
6894 .find(selector) :
jurzua
parents:
diff changeset
6895
jurzua
parents:
diff changeset
6896 // If not, just inject the full result
jurzua
parents:
diff changeset
6897 responseText );
jurzua
parents:
diff changeset
6898 }
jurzua
parents:
diff changeset
6899
jurzua
parents:
diff changeset
6900 if ( callback ) {
jurzua
parents:
diff changeset
6901 self.each( callback, [ responseText, status, jqXHR ] );
jurzua
parents:
diff changeset
6902 }
jurzua
parents:
diff changeset
6903 }
jurzua
parents:
diff changeset
6904 });
jurzua
parents:
diff changeset
6905
jurzua
parents:
diff changeset
6906 return this;
jurzua
parents:
diff changeset
6907 },
jurzua
parents:
diff changeset
6908
jurzua
parents:
diff changeset
6909 serialize: function() {
jurzua
parents:
diff changeset
6910 return jQuery.param( this.serializeArray() );
jurzua
parents:
diff changeset
6911 },
jurzua
parents:
diff changeset
6912
jurzua
parents:
diff changeset
6913 serializeArray: function() {
jurzua
parents:
diff changeset
6914 return this.map(function(){
jurzua
parents:
diff changeset
6915 return this.elements ? jQuery.makeArray( this.elements ) : this;
jurzua
parents:
diff changeset
6916 })
jurzua
parents:
diff changeset
6917 .filter(function(){
jurzua
parents:
diff changeset
6918 return this.name && !this.disabled &&
jurzua
parents:
diff changeset
6919 ( this.checked || rselectTextarea.test( this.nodeName ) ||
jurzua
parents:
diff changeset
6920 rinput.test( this.type ) );
jurzua
parents:
diff changeset
6921 })
jurzua
parents:
diff changeset
6922 .map(function( i, elem ){
jurzua
parents:
diff changeset
6923 var val = jQuery( this ).val();
jurzua
parents:
diff changeset
6924
jurzua
parents:
diff changeset
6925 return val == null ?
jurzua
parents:
diff changeset
6926 null :
jurzua
parents:
diff changeset
6927 jQuery.isArray( val ) ?
jurzua
parents:
diff changeset
6928 jQuery.map( val, function( val, i ){
jurzua
parents:
diff changeset
6929 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
jurzua
parents:
diff changeset
6930 }) :
jurzua
parents:
diff changeset
6931 { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
jurzua
parents:
diff changeset
6932 }).get();
jurzua
parents:
diff changeset
6933 }
jurzua
parents:
diff changeset
6934 });
jurzua
parents:
diff changeset
6935
jurzua
parents:
diff changeset
6936 // Attach a bunch of functions for handling common AJAX events
jurzua
parents:
diff changeset
6937 jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
jurzua
parents:
diff changeset
6938 jQuery.fn[ o ] = function( f ){
jurzua
parents:
diff changeset
6939 return this.bind( o, f );
jurzua
parents:
diff changeset
6940 };
jurzua
parents:
diff changeset
6941 });
jurzua
parents:
diff changeset
6942
jurzua
parents:
diff changeset
6943 jQuery.each( [ "get", "post" ], function( i, method ) {
jurzua
parents:
diff changeset
6944 jQuery[ method ] = function( url, data, callback, type ) {
jurzua
parents:
diff changeset
6945 // shift arguments if data argument was omitted
jurzua
parents:
diff changeset
6946 if ( jQuery.isFunction( data ) ) {
jurzua
parents:
diff changeset
6947 type = type || callback;
jurzua
parents:
diff changeset
6948 callback = data;
jurzua
parents:
diff changeset
6949 data = undefined;
jurzua
parents:
diff changeset
6950 }
jurzua
parents:
diff changeset
6951
jurzua
parents:
diff changeset
6952 return jQuery.ajax({
jurzua
parents:
diff changeset
6953 type: method,
jurzua
parents:
diff changeset
6954 url: url,
jurzua
parents:
diff changeset
6955 data: data,
jurzua
parents:
diff changeset
6956 success: callback,
jurzua
parents:
diff changeset
6957 dataType: type
jurzua
parents:
diff changeset
6958 });
jurzua
parents:
diff changeset
6959 };
jurzua
parents:
diff changeset
6960 });
jurzua
parents:
diff changeset
6961
jurzua
parents:
diff changeset
6962 jQuery.extend({
jurzua
parents:
diff changeset
6963
jurzua
parents:
diff changeset
6964 getScript: function( url, callback ) {
jurzua
parents:
diff changeset
6965 return jQuery.get( url, undefined, callback, "script" );
jurzua
parents:
diff changeset
6966 },
jurzua
parents:
diff changeset
6967
jurzua
parents:
diff changeset
6968 getJSON: function( url, data, callback ) {
jurzua
parents:
diff changeset
6969 return jQuery.get( url, data, callback, "json" );
jurzua
parents:
diff changeset
6970 },
jurzua
parents:
diff changeset
6971
jurzua
parents:
diff changeset
6972 // Creates a full fledged settings object into target
jurzua
parents:
diff changeset
6973 // with both ajaxSettings and settings fields.
jurzua
parents:
diff changeset
6974 // If target is omitted, writes into ajaxSettings.
jurzua
parents:
diff changeset
6975 ajaxSetup: function( target, settings ) {
jurzua
parents:
diff changeset
6976 if ( settings ) {
jurzua
parents:
diff changeset
6977 // Building a settings object
jurzua
parents:
diff changeset
6978 ajaxExtend( target, jQuery.ajaxSettings );
jurzua
parents:
diff changeset
6979 } else {
jurzua
parents:
diff changeset
6980 // Extending ajaxSettings
jurzua
parents:
diff changeset
6981 settings = target;
jurzua
parents:
diff changeset
6982 target = jQuery.ajaxSettings;
jurzua
parents:
diff changeset
6983 }
jurzua
parents:
diff changeset
6984 ajaxExtend( target, settings );
jurzua
parents:
diff changeset
6985 return target;
jurzua
parents:
diff changeset
6986 },
jurzua
parents:
diff changeset
6987
jurzua
parents:
diff changeset
6988 ajaxSettings: {
jurzua
parents:
diff changeset
6989 url: ajaxLocation,
jurzua
parents:
diff changeset
6990 isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
jurzua
parents:
diff changeset
6991 global: true,
jurzua
parents:
diff changeset
6992 type: "GET",
jurzua
parents:
diff changeset
6993 contentType: "application/x-www-form-urlencoded",
jurzua
parents:
diff changeset
6994 processData: true,
jurzua
parents:
diff changeset
6995 async: true,
jurzua
parents:
diff changeset
6996 /*
jurzua
parents:
diff changeset
6997 timeout: 0,
jurzua
parents:
diff changeset
6998 data: null,
jurzua
parents:
diff changeset
6999 dataType: null,
jurzua
parents:
diff changeset
7000 username: null,
jurzua
parents:
diff changeset
7001 password: null,
jurzua
parents:
diff changeset
7002 cache: null,
jurzua
parents:
diff changeset
7003 traditional: false,
jurzua
parents:
diff changeset
7004 headers: {},
jurzua
parents:
diff changeset
7005 */
jurzua
parents:
diff changeset
7006
jurzua
parents:
diff changeset
7007 accepts: {
jurzua
parents:
diff changeset
7008 xml: "application/xml, text/xml",
jurzua
parents:
diff changeset
7009 html: "text/html",
jurzua
parents:
diff changeset
7010 text: "text/plain",
jurzua
parents:
diff changeset
7011 json: "application/json, text/javascript",
jurzua
parents:
diff changeset
7012 "*": allTypes
jurzua
parents:
diff changeset
7013 },
jurzua
parents:
diff changeset
7014
jurzua
parents:
diff changeset
7015 contents: {
jurzua
parents:
diff changeset
7016 xml: /xml/,
jurzua
parents:
diff changeset
7017 html: /html/,
jurzua
parents:
diff changeset
7018 json: /json/
jurzua
parents:
diff changeset
7019 },
jurzua
parents:
diff changeset
7020
jurzua
parents:
diff changeset
7021 responseFields: {
jurzua
parents:
diff changeset
7022 xml: "responseXML",
jurzua
parents:
diff changeset
7023 text: "responseText"
jurzua
parents:
diff changeset
7024 },
jurzua
parents:
diff changeset
7025
jurzua
parents:
diff changeset
7026 // List of data converters
jurzua
parents:
diff changeset
7027 // 1) key format is "source_type destination_type" (a single space in-between)
jurzua
parents:
diff changeset
7028 // 2) the catchall symbol "*" can be used for source_type
jurzua
parents:
diff changeset
7029 converters: {
jurzua
parents:
diff changeset
7030
jurzua
parents:
diff changeset
7031 // Convert anything to text
jurzua
parents:
diff changeset
7032 "* text": window.String,
jurzua
parents:
diff changeset
7033
jurzua
parents:
diff changeset
7034 // Text to html (true = no transformation)
jurzua
parents:
diff changeset
7035 "text html": true,
jurzua
parents:
diff changeset
7036
jurzua
parents:
diff changeset
7037 // Evaluate text as a json expression
jurzua
parents:
diff changeset
7038 "text json": jQuery.parseJSON,
jurzua
parents:
diff changeset
7039
jurzua
parents:
diff changeset
7040 // Parse text as xml
jurzua
parents:
diff changeset
7041 "text xml": jQuery.parseXML
jurzua
parents:
diff changeset
7042 },
jurzua
parents:
diff changeset
7043
jurzua
parents:
diff changeset
7044 // For options that shouldn't be deep extended:
jurzua
parents:
diff changeset
7045 // you can add your own custom options here if
jurzua
parents:
diff changeset
7046 // and when you create one that shouldn't be
jurzua
parents:
diff changeset
7047 // deep extended (see ajaxExtend)
jurzua
parents:
diff changeset
7048 flatOptions: {
jurzua
parents:
diff changeset
7049 context: true,
jurzua
parents:
diff changeset
7050 url: true
jurzua
parents:
diff changeset
7051 }
jurzua
parents:
diff changeset
7052 },
jurzua
parents:
diff changeset
7053
jurzua
parents:
diff changeset
7054 ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
jurzua
parents:
diff changeset
7055 ajaxTransport: addToPrefiltersOrTransports( transports ),
jurzua
parents:
diff changeset
7056
jurzua
parents:
diff changeset
7057 // Main method
jurzua
parents:
diff changeset
7058 ajax: function( url, options ) {
jurzua
parents:
diff changeset
7059
jurzua
parents:
diff changeset
7060 // If url is an object, simulate pre-1.5 signature
jurzua
parents:
diff changeset
7061 if ( typeof url === "object" ) {
jurzua
parents:
diff changeset
7062 options = url;
jurzua
parents:
diff changeset
7063 url = undefined;
jurzua
parents:
diff changeset
7064 }
jurzua
parents:
diff changeset
7065
jurzua
parents:
diff changeset
7066 // Force options to be an object
jurzua
parents:
diff changeset
7067 options = options || {};
jurzua
parents:
diff changeset
7068
jurzua
parents:
diff changeset
7069 var // Create the final options object
jurzua
parents:
diff changeset
7070 s = jQuery.ajaxSetup( {}, options ),
jurzua
parents:
diff changeset
7071 // Callbacks context
jurzua
parents:
diff changeset
7072 callbackContext = s.context || s,
jurzua
parents:
diff changeset
7073 // Context for global events
jurzua
parents:
diff changeset
7074 // It's the callbackContext if one was provided in the options
jurzua
parents:
diff changeset
7075 // and if it's a DOM node or a jQuery collection
jurzua
parents:
diff changeset
7076 globalEventContext = callbackContext !== s &&
jurzua
parents:
diff changeset
7077 ( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
jurzua
parents:
diff changeset
7078 jQuery( callbackContext ) : jQuery.event,
jurzua
parents:
diff changeset
7079 // Deferreds
jurzua
parents:
diff changeset
7080 deferred = jQuery.Deferred(),
jurzua
parents:
diff changeset
7081 completeDeferred = jQuery._Deferred(),
jurzua
parents:
diff changeset
7082 // Status-dependent callbacks
jurzua
parents:
diff changeset
7083 statusCode = s.statusCode || {},
jurzua
parents:
diff changeset
7084 // ifModified key
jurzua
parents:
diff changeset
7085 ifModifiedKey,
jurzua
parents:
diff changeset
7086 // Headers (they are sent all at once)
jurzua
parents:
diff changeset
7087 requestHeaders = {},
jurzua
parents:
diff changeset
7088 requestHeadersNames = {},
jurzua
parents:
diff changeset
7089 // Response headers
jurzua
parents:
diff changeset
7090 responseHeadersString,
jurzua
parents:
diff changeset
7091 responseHeaders,
jurzua
parents:
diff changeset
7092 // transport
jurzua
parents:
diff changeset
7093 transport,
jurzua
parents:
diff changeset
7094 // timeout handle
jurzua
parents:
diff changeset
7095 timeoutTimer,
jurzua
parents:
diff changeset
7096 // Cross-domain detection vars
jurzua
parents:
diff changeset
7097 parts,
jurzua
parents:
diff changeset
7098 // The jqXHR state
jurzua
parents:
diff changeset
7099 state = 0,
jurzua
parents:
diff changeset
7100 // To know if global events are to be dispatched
jurzua
parents:
diff changeset
7101 fireGlobals,
jurzua
parents:
diff changeset
7102 // Loop variable
jurzua
parents:
diff changeset
7103 i,
jurzua
parents:
diff changeset
7104 // Fake xhr
jurzua
parents:
diff changeset
7105 jqXHR = {
jurzua
parents:
diff changeset
7106
jurzua
parents:
diff changeset
7107 readyState: 0,
jurzua
parents:
diff changeset
7108
jurzua
parents:
diff changeset
7109 // Caches the header
jurzua
parents:
diff changeset
7110 setRequestHeader: function( name, value ) {
jurzua
parents:
diff changeset
7111 if ( !state ) {
jurzua
parents:
diff changeset
7112 var lname = name.toLowerCase();
jurzua
parents:
diff changeset
7113 name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
jurzua
parents:
diff changeset
7114 requestHeaders[ name ] = value;
jurzua
parents:
diff changeset
7115 }
jurzua
parents:
diff changeset
7116 return this;
jurzua
parents:
diff changeset
7117 },
jurzua
parents:
diff changeset
7118
jurzua
parents:
diff changeset
7119 // Raw string
jurzua
parents:
diff changeset
7120 getAllResponseHeaders: function() {
jurzua
parents:
diff changeset
7121 return state === 2 ? responseHeadersString : null;
jurzua
parents:
diff changeset
7122 },
jurzua
parents:
diff changeset
7123
jurzua
parents:
diff changeset
7124 // Builds headers hashtable if needed
jurzua
parents:
diff changeset
7125 getResponseHeader: function( key ) {
jurzua
parents:
diff changeset
7126 var match;
jurzua
parents:
diff changeset
7127 if ( state === 2 ) {
jurzua
parents:
diff changeset
7128 if ( !responseHeaders ) {
jurzua
parents:
diff changeset
7129 responseHeaders = {};
jurzua
parents:
diff changeset
7130 while( ( match = rheaders.exec( responseHeadersString ) ) ) {
jurzua
parents:
diff changeset
7131 responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
jurzua
parents:
diff changeset
7132 }
jurzua
parents:
diff changeset
7133 }
jurzua
parents:
diff changeset
7134 match = responseHeaders[ key.toLowerCase() ];
jurzua
parents:
diff changeset
7135 }
jurzua
parents:
diff changeset
7136 return match === undefined ? null : match;
jurzua
parents:
diff changeset
7137 },
jurzua
parents:
diff changeset
7138
jurzua
parents:
diff changeset
7139 // Overrides response content-type header
jurzua
parents:
diff changeset
7140 overrideMimeType: function( type ) {
jurzua
parents:
diff changeset
7141 if ( !state ) {
jurzua
parents:
diff changeset
7142 s.mimeType = type;
jurzua
parents:
diff changeset
7143 }
jurzua
parents:
diff changeset
7144 return this;
jurzua
parents:
diff changeset
7145 },
jurzua
parents:
diff changeset
7146
jurzua
parents:
diff changeset
7147 // Cancel the request
jurzua
parents:
diff changeset
7148 abort: function( statusText ) {
jurzua
parents:
diff changeset
7149 statusText = statusText || "abort";
jurzua
parents:
diff changeset
7150 if ( transport ) {
jurzua
parents:
diff changeset
7151 transport.abort( statusText );
jurzua
parents:
diff changeset
7152 }
jurzua
parents:
diff changeset
7153 done( 0, statusText );
jurzua
parents:
diff changeset
7154 return this;
jurzua
parents:
diff changeset
7155 }
jurzua
parents:
diff changeset
7156 };
jurzua
parents:
diff changeset
7157
jurzua
parents:
diff changeset
7158 // Callback for when everything is done
jurzua
parents:
diff changeset
7159 // It is defined here because jslint complains if it is declared
jurzua
parents:
diff changeset
7160 // at the end of the function (which would be more logical and readable)
jurzua
parents:
diff changeset
7161 function done( status, nativeStatusText, responses, headers ) {
jurzua
parents:
diff changeset
7162
jurzua
parents:
diff changeset
7163 // Called once
jurzua
parents:
diff changeset
7164 if ( state === 2 ) {
jurzua
parents:
diff changeset
7165 return;
jurzua
parents:
diff changeset
7166 }
jurzua
parents:
diff changeset
7167
jurzua
parents:
diff changeset
7168 // State is "done" now
jurzua
parents:
diff changeset
7169 state = 2;
jurzua
parents:
diff changeset
7170
jurzua
parents:
diff changeset
7171 // Clear timeout if it exists
jurzua
parents:
diff changeset
7172 if ( timeoutTimer ) {
jurzua
parents:
diff changeset
7173 clearTimeout( timeoutTimer );
jurzua
parents:
diff changeset
7174 }
jurzua
parents:
diff changeset
7175
jurzua
parents:
diff changeset
7176 // Dereference transport for early garbage collection
jurzua
parents:
diff changeset
7177 // (no matter how long the jqXHR object will be used)
jurzua
parents:
diff changeset
7178 transport = undefined;
jurzua
parents:
diff changeset
7179
jurzua
parents:
diff changeset
7180 // Cache response headers
jurzua
parents:
diff changeset
7181 responseHeadersString = headers || "";
jurzua
parents:
diff changeset
7182
jurzua
parents:
diff changeset
7183 // Set readyState
jurzua
parents:
diff changeset
7184 jqXHR.readyState = status > 0 ? 4 : 0;
jurzua
parents:
diff changeset
7185
jurzua
parents:
diff changeset
7186 var isSuccess,
jurzua
parents:
diff changeset
7187 success,
jurzua
parents:
diff changeset
7188 error,
jurzua
parents:
diff changeset
7189 statusText = nativeStatusText,
jurzua
parents:
diff changeset
7190 response = responses ? ajaxHandleResponses( s, jqXHR, responses ) : undefined,
jurzua
parents:
diff changeset
7191 lastModified,
jurzua
parents:
diff changeset
7192 etag;
jurzua
parents:
diff changeset
7193
jurzua
parents:
diff changeset
7194 // If successful, handle type chaining
jurzua
parents:
diff changeset
7195 if ( status >= 200 && status < 300 || status === 304 ) {
jurzua
parents:
diff changeset
7196
jurzua
parents:
diff changeset
7197 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
jurzua
parents:
diff changeset
7198 if ( s.ifModified ) {
jurzua
parents:
diff changeset
7199
jurzua
parents:
diff changeset
7200 if ( ( lastModified = jqXHR.getResponseHeader( "Last-Modified" ) ) ) {
jurzua
parents:
diff changeset
7201 jQuery.lastModified[ ifModifiedKey ] = lastModified;
jurzua
parents:
diff changeset
7202 }
jurzua
parents:
diff changeset
7203 if ( ( etag = jqXHR.getResponseHeader( "Etag" ) ) ) {
jurzua
parents:
diff changeset
7204 jQuery.etag[ ifModifiedKey ] = etag;
jurzua
parents:
diff changeset
7205 }
jurzua
parents:
diff changeset
7206 }
jurzua
parents:
diff changeset
7207
jurzua
parents:
diff changeset
7208 // If not modified
jurzua
parents:
diff changeset
7209 if ( status === 304 ) {
jurzua
parents:
diff changeset
7210
jurzua
parents:
diff changeset
7211 statusText = "notmodified";
jurzua
parents:
diff changeset
7212 isSuccess = true;
jurzua
parents:
diff changeset
7213
jurzua
parents:
diff changeset
7214 // If we have data
jurzua
parents:
diff changeset
7215 } else {
jurzua
parents:
diff changeset
7216
jurzua
parents:
diff changeset
7217 try {
jurzua
parents:
diff changeset
7218 success = ajaxConvert( s, response );
jurzua
parents:
diff changeset
7219 statusText = "success";
jurzua
parents:
diff changeset
7220 isSuccess = true;
jurzua
parents:
diff changeset
7221 } catch(e) {
jurzua
parents:
diff changeset
7222 // We have a parsererror
jurzua
parents:
diff changeset
7223 statusText = "parsererror";
jurzua
parents:
diff changeset
7224 error = e;
jurzua
parents:
diff changeset
7225 }
jurzua
parents:
diff changeset
7226 }
jurzua
parents:
diff changeset
7227 } else {
jurzua
parents:
diff changeset
7228 // We extract error from statusText
jurzua
parents:
diff changeset
7229 // then normalize statusText and status for non-aborts
jurzua
parents:
diff changeset
7230 error = statusText;
jurzua
parents:
diff changeset
7231 if( !statusText || status ) {
jurzua
parents:
diff changeset
7232 statusText = "error";
jurzua
parents:
diff changeset
7233 if ( status < 0 ) {
jurzua
parents:
diff changeset
7234 status = 0;
jurzua
parents:
diff changeset
7235 }
jurzua
parents:
diff changeset
7236 }
jurzua
parents:
diff changeset
7237 }
jurzua
parents:
diff changeset
7238
jurzua
parents:
diff changeset
7239 // Set data for the fake xhr object
jurzua
parents:
diff changeset
7240 jqXHR.status = status;
jurzua
parents:
diff changeset
7241 jqXHR.statusText = "" + ( nativeStatusText || statusText );
jurzua
parents:
diff changeset
7242
jurzua
parents:
diff changeset
7243 // Success/Error
jurzua
parents:
diff changeset
7244 if ( isSuccess ) {
jurzua
parents:
diff changeset
7245 deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
jurzua
parents:
diff changeset
7246 } else {
jurzua
parents:
diff changeset
7247 deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
jurzua
parents:
diff changeset
7248 }
jurzua
parents:
diff changeset
7249
jurzua
parents:
diff changeset
7250 // Status-dependent callbacks
jurzua
parents:
diff changeset
7251 jqXHR.statusCode( statusCode );
jurzua
parents:
diff changeset
7252 statusCode = undefined;
jurzua
parents:
diff changeset
7253
jurzua
parents:
diff changeset
7254 if ( fireGlobals ) {
jurzua
parents:
diff changeset
7255 globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
jurzua
parents:
diff changeset
7256 [ jqXHR, s, isSuccess ? success : error ] );
jurzua
parents:
diff changeset
7257 }
jurzua
parents:
diff changeset
7258
jurzua
parents:
diff changeset
7259 // Complete
jurzua
parents:
diff changeset
7260 completeDeferred.resolveWith( callbackContext, [ jqXHR, statusText ] );
jurzua
parents:
diff changeset
7261
jurzua
parents:
diff changeset
7262 if ( fireGlobals ) {
jurzua
parents:
diff changeset
7263 globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
jurzua
parents:
diff changeset
7264 // Handle the global AJAX counter
jurzua
parents:
diff changeset
7265 if ( !( --jQuery.active ) ) {
jurzua
parents:
diff changeset
7266 jQuery.event.trigger( "ajaxStop" );
jurzua
parents:
diff changeset
7267 }
jurzua
parents:
diff changeset
7268 }
jurzua
parents:
diff changeset
7269 }
jurzua
parents:
diff changeset
7270
jurzua
parents:
diff changeset
7271 // Attach deferreds
jurzua
parents:
diff changeset
7272 deferred.promise( jqXHR );
jurzua
parents:
diff changeset
7273 jqXHR.success = jqXHR.done;
jurzua
parents:
diff changeset
7274 jqXHR.error = jqXHR.fail;
jurzua
parents:
diff changeset
7275 jqXHR.complete = completeDeferred.done;
jurzua
parents:
diff changeset
7276
jurzua
parents:
diff changeset
7277 // Status-dependent callbacks
jurzua
parents:
diff changeset
7278 jqXHR.statusCode = function( map ) {
jurzua
parents:
diff changeset
7279 if ( map ) {
jurzua
parents:
diff changeset
7280 var tmp;
jurzua
parents:
diff changeset
7281 if ( state < 2 ) {
jurzua
parents:
diff changeset
7282 for( tmp in map ) {
jurzua
parents:
diff changeset
7283 statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
jurzua
parents:
diff changeset
7284 }
jurzua
parents:
diff changeset
7285 } else {
jurzua
parents:
diff changeset
7286 tmp = map[ jqXHR.status ];
jurzua
parents:
diff changeset
7287 jqXHR.then( tmp, tmp );
jurzua
parents:
diff changeset
7288 }
jurzua
parents:
diff changeset
7289 }
jurzua
parents:
diff changeset
7290 return this;
jurzua
parents:
diff changeset
7291 };
jurzua
parents:
diff changeset
7292
jurzua
parents:
diff changeset
7293 // Remove hash character (#7531: and string promotion)
jurzua
parents:
diff changeset
7294 // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
jurzua
parents:
diff changeset
7295 // We also use the url parameter if available
jurzua
parents:
diff changeset
7296 s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
jurzua
parents:
diff changeset
7297
jurzua
parents:
diff changeset
7298 // Extract dataTypes list
jurzua
parents:
diff changeset
7299 s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( rspacesAjax );
jurzua
parents:
diff changeset
7300
jurzua
parents:
diff changeset
7301 // Determine if a cross-domain request is in order
jurzua
parents:
diff changeset
7302 if ( s.crossDomain == null ) {
jurzua
parents:
diff changeset
7303 parts = rurl.exec( s.url.toLowerCase() );
jurzua
parents:
diff changeset
7304 s.crossDomain = !!( parts &&
jurzua
parents:
diff changeset
7305 ( parts[ 1 ] != ajaxLocParts[ 1 ] || parts[ 2 ] != ajaxLocParts[ 2 ] ||
jurzua
parents:
diff changeset
7306 ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
jurzua
parents:
diff changeset
7307 ( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
jurzua
parents:
diff changeset
7308 );
jurzua
parents:
diff changeset
7309 }
jurzua
parents:
diff changeset
7310
jurzua
parents:
diff changeset
7311 // Convert data if not already a string
jurzua
parents:
diff changeset
7312 if ( s.data && s.processData && typeof s.data !== "string" ) {
jurzua
parents:
diff changeset
7313 s.data = jQuery.param( s.data, s.traditional );
jurzua
parents:
diff changeset
7314 }
jurzua
parents:
diff changeset
7315
jurzua
parents:
diff changeset
7316 // Apply prefilters
jurzua
parents:
diff changeset
7317 inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
jurzua
parents:
diff changeset
7318
jurzua
parents:
diff changeset
7319 // If request was aborted inside a prefiler, stop there
jurzua
parents:
diff changeset
7320 if ( state === 2 ) {
jurzua
parents:
diff changeset
7321 return false;
jurzua
parents:
diff changeset
7322 }
jurzua
parents:
diff changeset
7323
jurzua
parents:
diff changeset
7324 // We can fire global events as of now if asked to
jurzua
parents:
diff changeset
7325 fireGlobals = s.global;
jurzua
parents:
diff changeset
7326
jurzua
parents:
diff changeset
7327 // Uppercase the type
jurzua
parents:
diff changeset
7328 s.type = s.type.toUpperCase();
jurzua
parents:
diff changeset
7329
jurzua
parents:
diff changeset
7330 // Determine if request has content
jurzua
parents:
diff changeset
7331 s.hasContent = !rnoContent.test( s.type );
jurzua
parents:
diff changeset
7332
jurzua
parents:
diff changeset
7333 // Watch for a new set of requests
jurzua
parents:
diff changeset
7334 if ( fireGlobals && jQuery.active++ === 0 ) {
jurzua
parents:
diff changeset
7335 jQuery.event.trigger( "ajaxStart" );
jurzua
parents:
diff changeset
7336 }
jurzua
parents:
diff changeset
7337
jurzua
parents:
diff changeset
7338 // More options handling for requests with no content
jurzua
parents:
diff changeset
7339 if ( !s.hasContent ) {
jurzua
parents:
diff changeset
7340
jurzua
parents:
diff changeset
7341 // If data is available, append data to url
jurzua
parents:
diff changeset
7342 if ( s.data ) {
jurzua
parents:
diff changeset
7343 s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
jurzua
parents:
diff changeset
7344 // #9682: remove data so that it's not used in an eventual retry
jurzua
parents:
diff changeset
7345 delete s.data;
jurzua
parents:
diff changeset
7346 }
jurzua
parents:
diff changeset
7347
jurzua
parents:
diff changeset
7348 // Get ifModifiedKey before adding the anti-cache parameter
jurzua
parents:
diff changeset
7349 ifModifiedKey = s.url;
jurzua
parents:
diff changeset
7350
jurzua
parents:
diff changeset
7351 // Add anti-cache in url if needed
jurzua
parents:
diff changeset
7352 if ( s.cache === false ) {
jurzua
parents:
diff changeset
7353
jurzua
parents:
diff changeset
7354 var ts = jQuery.now(),
jurzua
parents:
diff changeset
7355 // try replacing _= if it is there
jurzua
parents:
diff changeset
7356 ret = s.url.replace( rts, "$1_=" + ts );
jurzua
parents:
diff changeset
7357
jurzua
parents:
diff changeset
7358 // if nothing was replaced, add timestamp to the end
jurzua
parents:
diff changeset
7359 s.url = ret + ( (ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
jurzua
parents:
diff changeset
7360 }
jurzua
parents:
diff changeset
7361 }
jurzua
parents:
diff changeset
7362
jurzua
parents:
diff changeset
7363 // Set the correct header, if data is being sent
jurzua
parents:
diff changeset
7364 if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
jurzua
parents:
diff changeset
7365 jqXHR.setRequestHeader( "Content-Type", s.contentType );
jurzua
parents:
diff changeset
7366 }
jurzua
parents:
diff changeset
7367
jurzua
parents:
diff changeset
7368 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
jurzua
parents:
diff changeset
7369 if ( s.ifModified ) {
jurzua
parents:
diff changeset
7370 ifModifiedKey = ifModifiedKey || s.url;
jurzua
parents:
diff changeset
7371 if ( jQuery.lastModified[ ifModifiedKey ] ) {
jurzua
parents:
diff changeset
7372 jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] );
jurzua
parents:
diff changeset
7373 }
jurzua
parents:
diff changeset
7374 if ( jQuery.etag[ ifModifiedKey ] ) {
jurzua
parents:
diff changeset
7375 jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] );
jurzua
parents:
diff changeset
7376 }
jurzua
parents:
diff changeset
7377 }
jurzua
parents:
diff changeset
7378
jurzua
parents:
diff changeset
7379 // Set the Accepts header for the server, depending on the dataType
jurzua
parents:
diff changeset
7380 jqXHR.setRequestHeader(
jurzua
parents:
diff changeset
7381 "Accept",
jurzua
parents:
diff changeset
7382 s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
jurzua
parents:
diff changeset
7383 s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
jurzua
parents:
diff changeset
7384 s.accepts[ "*" ]
jurzua
parents:
diff changeset
7385 );
jurzua
parents:
diff changeset
7386
jurzua
parents:
diff changeset
7387 // Check for headers option
jurzua
parents:
diff changeset
7388 for ( i in s.headers ) {
jurzua
parents:
diff changeset
7389 jqXHR.setRequestHeader( i, s.headers[ i ] );
jurzua
parents:
diff changeset
7390 }
jurzua
parents:
diff changeset
7391
jurzua
parents:
diff changeset
7392 // Allow custom headers/mimetypes and early abort
jurzua
parents:
diff changeset
7393 if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
jurzua
parents:
diff changeset
7394 // Abort if not done already
jurzua
parents:
diff changeset
7395 jqXHR.abort();
jurzua
parents:
diff changeset
7396 return false;
jurzua
parents:
diff changeset
7397
jurzua
parents:
diff changeset
7398 }
jurzua
parents:
diff changeset
7399
jurzua
parents:
diff changeset
7400 // Install callbacks on deferreds
jurzua
parents:
diff changeset
7401 for ( i in { success: 1, error: 1, complete: 1 } ) {
jurzua
parents:
diff changeset
7402 jqXHR[ i ]( s[ i ] );
jurzua
parents:
diff changeset
7403 }
jurzua
parents:
diff changeset
7404
jurzua
parents:
diff changeset
7405 // Get transport
jurzua
parents:
diff changeset
7406 transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
jurzua
parents:
diff changeset
7407
jurzua
parents:
diff changeset
7408 // If no transport, we auto-abort
jurzua
parents:
diff changeset
7409 if ( !transport ) {
jurzua
parents:
diff changeset
7410 done( -1, "No Transport" );
jurzua
parents:
diff changeset
7411 } else {
jurzua
parents:
diff changeset
7412 jqXHR.readyState = 1;
jurzua
parents:
diff changeset
7413 // Send global event
jurzua
parents:
diff changeset
7414 if ( fireGlobals ) {
jurzua
parents:
diff changeset
7415 globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
jurzua
parents:
diff changeset
7416 }
jurzua
parents:
diff changeset
7417 // Timeout
jurzua
parents:
diff changeset
7418 if ( s.async && s.timeout > 0 ) {
jurzua
parents:
diff changeset
7419 timeoutTimer = setTimeout( function(){
jurzua
parents:
diff changeset
7420 jqXHR.abort( "timeout" );
jurzua
parents:
diff changeset
7421 }, s.timeout );
jurzua
parents:
diff changeset
7422 }
jurzua
parents:
diff changeset
7423
jurzua
parents:
diff changeset
7424 try {
jurzua
parents:
diff changeset
7425 state = 1;
jurzua
parents:
diff changeset
7426 transport.send( requestHeaders, done );
jurzua
parents:
diff changeset
7427 } catch (e) {
jurzua
parents:
diff changeset
7428 // Propagate exception as error if not done
jurzua
parents:
diff changeset
7429 if ( state < 2 ) {
jurzua
parents:
diff changeset
7430 done( -1, e );
jurzua
parents:
diff changeset
7431 // Simply rethrow otherwise
jurzua
parents:
diff changeset
7432 } else {
jurzua
parents:
diff changeset
7433 jQuery.error( e );
jurzua
parents:
diff changeset
7434 }
jurzua
parents:
diff changeset
7435 }
jurzua
parents:
diff changeset
7436 }
jurzua
parents:
diff changeset
7437
jurzua
parents:
diff changeset
7438 return jqXHR;
jurzua
parents:
diff changeset
7439 },
jurzua
parents:
diff changeset
7440
jurzua
parents:
diff changeset
7441 // Serialize an array of form elements or a set of
jurzua
parents:
diff changeset
7442 // key/values into a query string
jurzua
parents:
diff changeset
7443 param: function( a, traditional ) {
jurzua
parents:
diff changeset
7444 var s = [],
jurzua
parents:
diff changeset
7445 add = function( key, value ) {
jurzua
parents:
diff changeset
7446 // If value is a function, invoke it and return its value
jurzua
parents:
diff changeset
7447 value = jQuery.isFunction( value ) ? value() : value;
jurzua
parents:
diff changeset
7448 s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
jurzua
parents:
diff changeset
7449 };
jurzua
parents:
diff changeset
7450
jurzua
parents:
diff changeset
7451 // Set traditional to true for jQuery <= 1.3.2 behavior.
jurzua
parents:
diff changeset
7452 if ( traditional === undefined ) {
jurzua
parents:
diff changeset
7453 traditional = jQuery.ajaxSettings.traditional;
jurzua
parents:
diff changeset
7454 }
jurzua
parents:
diff changeset
7455
jurzua
parents:
diff changeset
7456 // If an array was passed in, assume that it is an array of form elements.
jurzua
parents:
diff changeset
7457 if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
jurzua
parents:
diff changeset
7458 // Serialize the form elements
jurzua
parents:
diff changeset
7459 jQuery.each( a, function() {
jurzua
parents:
diff changeset
7460 add( this.name, this.value );
jurzua
parents:
diff changeset
7461 });
jurzua
parents:
diff changeset
7462
jurzua
parents:
diff changeset
7463 } else {
jurzua
parents:
diff changeset
7464 // If traditional, encode the "old" way (the way 1.3.2 or older
jurzua
parents:
diff changeset
7465 // did it), otherwise encode params recursively.
jurzua
parents:
diff changeset
7466 for ( var prefix in a ) {
jurzua
parents:
diff changeset
7467 buildParams( prefix, a[ prefix ], traditional, add );
jurzua
parents:
diff changeset
7468 }
jurzua
parents:
diff changeset
7469 }
jurzua
parents:
diff changeset
7470
jurzua
parents:
diff changeset
7471 // Return the resulting serialization
jurzua
parents:
diff changeset
7472 return s.join( "&" ).replace( r20, "+" );
jurzua
parents:
diff changeset
7473 }
jurzua
parents:
diff changeset
7474 });
jurzua
parents:
diff changeset
7475
jurzua
parents:
diff changeset
7476 function buildParams( prefix, obj, traditional, add ) {
jurzua
parents:
diff changeset
7477 if ( jQuery.isArray( obj ) ) {
jurzua
parents:
diff changeset
7478 // Serialize array item.
jurzua
parents:
diff changeset
7479 jQuery.each( obj, function( i, v ) {
jurzua
parents:
diff changeset
7480 if ( traditional || rbracket.test( prefix ) ) {
jurzua
parents:
diff changeset
7481 // Treat each array item as a scalar.
jurzua
parents:
diff changeset
7482 add( prefix, v );
jurzua
parents:
diff changeset
7483
jurzua
parents:
diff changeset
7484 } else {
jurzua
parents:
diff changeset
7485 // If array item is non-scalar (array or object), encode its
jurzua
parents:
diff changeset
7486 // numeric index to resolve deserialization ambiguity issues.
jurzua
parents:
diff changeset
7487 // Note that rack (as of 1.0.0) can't currently deserialize
jurzua
parents:
diff changeset
7488 // nested arrays properly, and attempting to do so may cause
jurzua
parents:
diff changeset
7489 // a server error. Possible fixes are to modify rack's
jurzua
parents:
diff changeset
7490 // deserialization algorithm or to provide an option or flag
jurzua
parents:
diff changeset
7491 // to force array serialization to be shallow.
jurzua
parents:
diff changeset
7492 buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
jurzua
parents:
diff changeset
7493 }
jurzua
parents:
diff changeset
7494 });
jurzua
parents:
diff changeset
7495
jurzua
parents:
diff changeset
7496 } else if ( !traditional && obj != null && typeof obj === "object" ) {
jurzua
parents:
diff changeset
7497 // Serialize object item.
jurzua
parents:
diff changeset
7498 for ( var name in obj ) {
jurzua
parents:
diff changeset
7499 buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
jurzua
parents:
diff changeset
7500 }
jurzua
parents:
diff changeset
7501
jurzua
parents:
diff changeset
7502 } else {
jurzua
parents:
diff changeset
7503 // Serialize scalar item.
jurzua
parents:
diff changeset
7504 add( prefix, obj );
jurzua
parents:
diff changeset
7505 }
jurzua
parents:
diff changeset
7506 }
jurzua
parents:
diff changeset
7507
jurzua
parents:
diff changeset
7508 // This is still on the jQuery object... for now
jurzua
parents:
diff changeset
7509 // Want to move this to jQuery.ajax some day
jurzua
parents:
diff changeset
7510 jQuery.extend({
jurzua
parents:
diff changeset
7511
jurzua
parents:
diff changeset
7512 // Counter for holding the number of active queries
jurzua
parents:
diff changeset
7513 active: 0,
jurzua
parents:
diff changeset
7514
jurzua
parents:
diff changeset
7515 // Last-Modified header cache for next request
jurzua
parents:
diff changeset
7516 lastModified: {},
jurzua
parents:
diff changeset
7517 etag: {}
jurzua
parents:
diff changeset
7518
jurzua
parents:
diff changeset
7519 });
jurzua
parents:
diff changeset
7520
jurzua
parents:
diff changeset
7521 /* Handles responses to an ajax request:
jurzua
parents:
diff changeset
7522 * - sets all responseXXX fields accordingly
jurzua
parents:
diff changeset
7523 * - finds the right dataType (mediates between content-type and expected dataType)
jurzua
parents:
diff changeset
7524 * - returns the corresponding response
jurzua
parents:
diff changeset
7525 */
jurzua
parents:
diff changeset
7526 function ajaxHandleResponses( s, jqXHR, responses ) {
jurzua
parents:
diff changeset
7527
jurzua
parents:
diff changeset
7528 var contents = s.contents,
jurzua
parents:
diff changeset
7529 dataTypes = s.dataTypes,
jurzua
parents:
diff changeset
7530 responseFields = s.responseFields,
jurzua
parents:
diff changeset
7531 ct,
jurzua
parents:
diff changeset
7532 type,
jurzua
parents:
diff changeset
7533 finalDataType,
jurzua
parents:
diff changeset
7534 firstDataType;
jurzua
parents:
diff changeset
7535
jurzua
parents:
diff changeset
7536 // Fill responseXXX fields
jurzua
parents:
diff changeset
7537 for( type in responseFields ) {
jurzua
parents:
diff changeset
7538 if ( type in responses ) {
jurzua
parents:
diff changeset
7539 jqXHR[ responseFields[type] ] = responses[ type ];
jurzua
parents:
diff changeset
7540 }
jurzua
parents:
diff changeset
7541 }
jurzua
parents:
diff changeset
7542
jurzua
parents:
diff changeset
7543 // Remove auto dataType and get content-type in the process
jurzua
parents:
diff changeset
7544 while( dataTypes[ 0 ] === "*" ) {
jurzua
parents:
diff changeset
7545 dataTypes.shift();
jurzua
parents:
diff changeset
7546 if ( ct === undefined ) {
jurzua
parents:
diff changeset
7547 ct = s.mimeType || jqXHR.getResponseHeader( "content-type" );
jurzua
parents:
diff changeset
7548 }
jurzua
parents:
diff changeset
7549 }
jurzua
parents:
diff changeset
7550
jurzua
parents:
diff changeset
7551 // Check if we're dealing with a known content-type
jurzua
parents:
diff changeset
7552 if ( ct ) {
jurzua
parents:
diff changeset
7553 for ( type in contents ) {
jurzua
parents:
diff changeset
7554 if ( contents[ type ] && contents[ type ].test( ct ) ) {
jurzua
parents:
diff changeset
7555 dataTypes.unshift( type );
jurzua
parents:
diff changeset
7556 break;
jurzua
parents:
diff changeset
7557 }
jurzua
parents:
diff changeset
7558 }
jurzua
parents:
diff changeset
7559 }
jurzua
parents:
diff changeset
7560
jurzua
parents:
diff changeset
7561 // Check to see if we have a response for the expected dataType
jurzua
parents:
diff changeset
7562 if ( dataTypes[ 0 ] in responses ) {
jurzua
parents:
diff changeset
7563 finalDataType = dataTypes[ 0 ];
jurzua
parents:
diff changeset
7564 } else {
jurzua
parents:
diff changeset
7565 // Try convertible dataTypes
jurzua
parents:
diff changeset
7566 for ( type in responses ) {
jurzua
parents:
diff changeset
7567 if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
jurzua
parents:
diff changeset
7568 finalDataType = type;
jurzua
parents:
diff changeset
7569 break;
jurzua
parents:
diff changeset
7570 }
jurzua
parents:
diff changeset
7571 if ( !firstDataType ) {
jurzua
parents:
diff changeset
7572 firstDataType = type;
jurzua
parents:
diff changeset
7573 }
jurzua
parents:
diff changeset
7574 }
jurzua
parents:
diff changeset
7575 // Or just use first one
jurzua
parents:
diff changeset
7576 finalDataType = finalDataType || firstDataType;
jurzua
parents:
diff changeset
7577 }
jurzua
parents:
diff changeset
7578
jurzua
parents:
diff changeset
7579 // If we found a dataType
jurzua
parents:
diff changeset
7580 // We add the dataType to the list if needed
jurzua
parents:
diff changeset
7581 // and return the corresponding response
jurzua
parents:
diff changeset
7582 if ( finalDataType ) {
jurzua
parents:
diff changeset
7583 if ( finalDataType !== dataTypes[ 0 ] ) {
jurzua
parents:
diff changeset
7584 dataTypes.unshift( finalDataType );
jurzua
parents:
diff changeset
7585 }
jurzua
parents:
diff changeset
7586 return responses[ finalDataType ];
jurzua
parents:
diff changeset
7587 }
jurzua
parents:
diff changeset
7588 }
jurzua
parents:
diff changeset
7589
jurzua
parents:
diff changeset
7590 // Chain conversions given the request and the original response
jurzua
parents:
diff changeset
7591 function ajaxConvert( s, response ) {
jurzua
parents:
diff changeset
7592
jurzua
parents:
diff changeset
7593 // Apply the dataFilter if provided
jurzua
parents:
diff changeset
7594 if ( s.dataFilter ) {
jurzua
parents:
diff changeset
7595 response = s.dataFilter( response, s.dataType );
jurzua
parents:
diff changeset
7596 }
jurzua
parents:
diff changeset
7597
jurzua
parents:
diff changeset
7598 var dataTypes = s.dataTypes,
jurzua
parents:
diff changeset
7599 converters = {},
jurzua
parents:
diff changeset
7600 i,
jurzua
parents:
diff changeset
7601 key,
jurzua
parents:
diff changeset
7602 length = dataTypes.length,
jurzua
parents:
diff changeset
7603 tmp,
jurzua
parents:
diff changeset
7604 // Current and previous dataTypes
jurzua
parents:
diff changeset
7605 current = dataTypes[ 0 ],
jurzua
parents:
diff changeset
7606 prev,
jurzua
parents:
diff changeset
7607 // Conversion expression
jurzua
parents:
diff changeset
7608 conversion,
jurzua
parents:
diff changeset
7609 // Conversion function
jurzua
parents:
diff changeset
7610 conv,
jurzua
parents:
diff changeset
7611 // Conversion functions (transitive conversion)
jurzua
parents:
diff changeset
7612 conv1,
jurzua
parents:
diff changeset
7613 conv2;
jurzua
parents:
diff changeset
7614
jurzua
parents:
diff changeset
7615 // For each dataType in the chain
jurzua
parents:
diff changeset
7616 for( i = 1; i < length; i++ ) {
jurzua
parents:
diff changeset
7617
jurzua
parents:
diff changeset
7618 // Create converters map
jurzua
parents:
diff changeset
7619 // with lowercased keys
jurzua
parents:
diff changeset
7620 if ( i === 1 ) {
jurzua
parents:
diff changeset
7621 for( key in s.converters ) {
jurzua
parents:
diff changeset
7622 if( typeof key === "string" ) {
jurzua
parents:
diff changeset
7623 converters[ key.toLowerCase() ] = s.converters[ key ];
jurzua
parents:
diff changeset
7624 }
jurzua
parents:
diff changeset
7625 }
jurzua
parents:
diff changeset
7626 }
jurzua
parents:
diff changeset
7627
jurzua
parents:
diff changeset
7628 // Get the dataTypes
jurzua
parents:
diff changeset
7629 prev = current;
jurzua
parents:
diff changeset
7630 current = dataTypes[ i ];
jurzua
parents:
diff changeset
7631
jurzua
parents:
diff changeset
7632 // If current is auto dataType, update it to prev
jurzua
parents:
diff changeset
7633 if( current === "*" ) {
jurzua
parents:
diff changeset
7634 current = prev;
jurzua
parents:
diff changeset
7635 // If no auto and dataTypes are actually different
jurzua
parents:
diff changeset
7636 } else if ( prev !== "*" && prev !== current ) {
jurzua
parents:
diff changeset
7637
jurzua
parents:
diff changeset
7638 // Get the converter
jurzua
parents:
diff changeset
7639 conversion = prev + " " + current;
jurzua
parents:
diff changeset
7640 conv = converters[ conversion ] || converters[ "* " + current ];
jurzua
parents:
diff changeset
7641
jurzua
parents:
diff changeset
7642 // If there is no direct converter, search transitively
jurzua
parents:
diff changeset
7643 if ( !conv ) {
jurzua
parents:
diff changeset
7644 conv2 = undefined;
jurzua
parents:
diff changeset
7645 for( conv1 in converters ) {
jurzua
parents:
diff changeset
7646 tmp = conv1.split( " " );
jurzua
parents:
diff changeset
7647 if ( tmp[ 0 ] === prev || tmp[ 0 ] === "*" ) {
jurzua
parents:
diff changeset
7648 conv2 = converters[ tmp[1] + " " + current ];
jurzua
parents:
diff changeset
7649 if ( conv2 ) {
jurzua
parents:
diff changeset
7650 conv1 = converters[ conv1 ];
jurzua
parents:
diff changeset
7651 if ( conv1 === true ) {
jurzua
parents:
diff changeset
7652 conv = conv2;
jurzua
parents:
diff changeset
7653 } else if ( conv2 === true ) {
jurzua
parents:
diff changeset
7654 conv = conv1;
jurzua
parents:
diff changeset
7655 }
jurzua
parents:
diff changeset
7656 break;
jurzua
parents:
diff changeset
7657 }
jurzua
parents:
diff changeset
7658 }
jurzua
parents:
diff changeset
7659 }
jurzua
parents:
diff changeset
7660 }
jurzua
parents:
diff changeset
7661 // If we found no converter, dispatch an error
jurzua
parents:
diff changeset
7662 if ( !( conv || conv2 ) ) {
jurzua
parents:
diff changeset
7663 jQuery.error( "No conversion from " + conversion.replace(" "," to ") );
jurzua
parents:
diff changeset
7664 }
jurzua
parents:
diff changeset
7665 // If found converter is not an equivalence
jurzua
parents:
diff changeset
7666 if ( conv !== true ) {
jurzua
parents:
diff changeset
7667 // Convert with 1 or 2 converters accordingly
jurzua
parents:
diff changeset
7668 response = conv ? conv( response ) : conv2( conv1(response) );
jurzua
parents:
diff changeset
7669 }
jurzua
parents:
diff changeset
7670 }
jurzua
parents:
diff changeset
7671 }
jurzua
parents:
diff changeset
7672 return response;
jurzua
parents:
diff changeset
7673 }
jurzua
parents:
diff changeset
7674
jurzua
parents:
diff changeset
7675
jurzua
parents:
diff changeset
7676
jurzua
parents:
diff changeset
7677
jurzua
parents:
diff changeset
7678 var jsc = jQuery.now(),
jurzua
parents:
diff changeset
7679 jsre = /(\=)\?(&|$)|\?\?/i;
jurzua
parents:
diff changeset
7680
jurzua
parents:
diff changeset
7681 // Default jsonp settings
jurzua
parents:
diff changeset
7682 jQuery.ajaxSetup({
jurzua
parents:
diff changeset
7683 jsonp: "callback",
jurzua
parents:
diff changeset
7684 jsonpCallback: function() {
jurzua
parents:
diff changeset
7685 return jQuery.expando + "_" + ( jsc++ );
jurzua
parents:
diff changeset
7686 }
jurzua
parents:
diff changeset
7687 });
jurzua
parents:
diff changeset
7688
jurzua
parents:
diff changeset
7689 // Detect, normalize options and install callbacks for jsonp requests
jurzua
parents:
diff changeset
7690 jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
jurzua
parents:
diff changeset
7691
jurzua
parents:
diff changeset
7692 var inspectData = s.contentType === "application/x-www-form-urlencoded" &&
jurzua
parents:
diff changeset
7693 ( typeof s.data === "string" );
jurzua
parents:
diff changeset
7694
jurzua
parents:
diff changeset
7695 if ( s.dataTypes[ 0 ] === "jsonp" ||
jurzua
parents:
diff changeset
7696 s.jsonp !== false && ( jsre.test( s.url ) ||
jurzua
parents:
diff changeset
7697 inspectData && jsre.test( s.data ) ) ) {
jurzua
parents:
diff changeset
7698
jurzua
parents:
diff changeset
7699 var responseContainer,
jurzua
parents:
diff changeset
7700 jsonpCallback = s.jsonpCallback =
jurzua
parents:
diff changeset
7701 jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
jurzua
parents:
diff changeset
7702 previous = window[ jsonpCallback ],
jurzua
parents:
diff changeset
7703 url = s.url,
jurzua
parents:
diff changeset
7704 data = s.data,
jurzua
parents:
diff changeset
7705 replace = "$1" + jsonpCallback + "$2";
jurzua
parents:
diff changeset
7706
jurzua
parents:
diff changeset
7707 if ( s.jsonp !== false ) {
jurzua
parents:
diff changeset
7708 url = url.replace( jsre, replace );
jurzua
parents:
diff changeset
7709 if ( s.url === url ) {
jurzua
parents:
diff changeset
7710 if ( inspectData ) {
jurzua
parents:
diff changeset
7711 data = data.replace( jsre, replace );
jurzua
parents:
diff changeset
7712 }
jurzua
parents:
diff changeset
7713 if ( s.data === data ) {
jurzua
parents:
diff changeset
7714 // Add callback manually
jurzua
parents:
diff changeset
7715 url += (/\?/.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
jurzua
parents:
diff changeset
7716 }
jurzua
parents:
diff changeset
7717 }
jurzua
parents:
diff changeset
7718 }
jurzua
parents:
diff changeset
7719
jurzua
parents:
diff changeset
7720 s.url = url;
jurzua
parents:
diff changeset
7721 s.data = data;
jurzua
parents:
diff changeset
7722
jurzua
parents:
diff changeset
7723 // Install callback
jurzua
parents:
diff changeset
7724 window[ jsonpCallback ] = function( response ) {
jurzua
parents:
diff changeset
7725 responseContainer = [ response ];
jurzua
parents:
diff changeset
7726 };
jurzua
parents:
diff changeset
7727
jurzua
parents:
diff changeset
7728 // Clean-up function
jurzua
parents:
diff changeset
7729 jqXHR.always(function() {
jurzua
parents:
diff changeset
7730 // Set callback back to previous value
jurzua
parents:
diff changeset
7731 window[ jsonpCallback ] = previous;
jurzua
parents:
diff changeset
7732 // Call if it was a function and we have a response
jurzua
parents:
diff changeset
7733 if ( responseContainer && jQuery.isFunction( previous ) ) {
jurzua
parents:
diff changeset
7734 window[ jsonpCallback ]( responseContainer[ 0 ] );
jurzua
parents:
diff changeset
7735 }
jurzua
parents:
diff changeset
7736 });
jurzua
parents:
diff changeset
7737
jurzua
parents:
diff changeset
7738 // Use data converter to retrieve json after script execution
jurzua
parents:
diff changeset
7739 s.converters["script json"] = function() {
jurzua
parents:
diff changeset
7740 if ( !responseContainer ) {
jurzua
parents:
diff changeset
7741 jQuery.error( jsonpCallback + " was not called" );
jurzua
parents:
diff changeset
7742 }
jurzua
parents:
diff changeset
7743 return responseContainer[ 0 ];
jurzua
parents:
diff changeset
7744 };
jurzua
parents:
diff changeset
7745
jurzua
parents:
diff changeset
7746 // force json dataType
jurzua
parents:
diff changeset
7747 s.dataTypes[ 0 ] = "json";
jurzua
parents:
diff changeset
7748
jurzua
parents:
diff changeset
7749 // Delegate to script
jurzua
parents:
diff changeset
7750 return "script";
jurzua
parents:
diff changeset
7751 }
jurzua
parents:
diff changeset
7752 });
jurzua
parents:
diff changeset
7753
jurzua
parents:
diff changeset
7754
jurzua
parents:
diff changeset
7755
jurzua
parents:
diff changeset
7756
jurzua
parents:
diff changeset
7757 // Install script dataType
jurzua
parents:
diff changeset
7758 jQuery.ajaxSetup({
jurzua
parents:
diff changeset
7759 accepts: {
jurzua
parents:
diff changeset
7760 script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
jurzua
parents:
diff changeset
7761 },
jurzua
parents:
diff changeset
7762 contents: {
jurzua
parents:
diff changeset
7763 script: /javascript|ecmascript/
jurzua
parents:
diff changeset
7764 },
jurzua
parents:
diff changeset
7765 converters: {
jurzua
parents:
diff changeset
7766 "text script": function( text ) {
jurzua
parents:
diff changeset
7767 jQuery.globalEval( text );
jurzua
parents:
diff changeset
7768 return text;
jurzua
parents:
diff changeset
7769 }
jurzua
parents:
diff changeset
7770 }
jurzua
parents:
diff changeset
7771 });
jurzua
parents:
diff changeset
7772
jurzua
parents:
diff changeset
7773 // Handle cache's special case and global
jurzua
parents:
diff changeset
7774 jQuery.ajaxPrefilter( "script", function( s ) {
jurzua
parents:
diff changeset
7775 if ( s.cache === undefined ) {
jurzua
parents:
diff changeset
7776 s.cache = false;
jurzua
parents:
diff changeset
7777 }
jurzua
parents:
diff changeset
7778 if ( s.crossDomain ) {
jurzua
parents:
diff changeset
7779 s.type = "GET";
jurzua
parents:
diff changeset
7780 s.global = false;
jurzua
parents:
diff changeset
7781 }
jurzua
parents:
diff changeset
7782 });
jurzua
parents:
diff changeset
7783
jurzua
parents:
diff changeset
7784 // Bind script tag hack transport
jurzua
parents:
diff changeset
7785 jQuery.ajaxTransport( "script", function(s) {
jurzua
parents:
diff changeset
7786
jurzua
parents:
diff changeset
7787 // This transport only deals with cross domain requests
jurzua
parents:
diff changeset
7788 if ( s.crossDomain ) {
jurzua
parents:
diff changeset
7789
jurzua
parents:
diff changeset
7790 var script,
jurzua
parents:
diff changeset
7791 head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement;
jurzua
parents:
diff changeset
7792
jurzua
parents:
diff changeset
7793 return {
jurzua
parents:
diff changeset
7794
jurzua
parents:
diff changeset
7795 send: function( _, callback ) {
jurzua
parents:
diff changeset
7796
jurzua
parents:
diff changeset
7797 script = document.createElement( "script" );
jurzua
parents:
diff changeset
7798
jurzua
parents:
diff changeset
7799 script.async = "async";
jurzua
parents:
diff changeset
7800
jurzua
parents:
diff changeset
7801 if ( s.scriptCharset ) {
jurzua
parents:
diff changeset
7802 script.charset = s.scriptCharset;
jurzua
parents:
diff changeset
7803 }
jurzua
parents:
diff changeset
7804
jurzua
parents:
diff changeset
7805 script.src = s.url;
jurzua
parents:
diff changeset
7806
jurzua
parents:
diff changeset
7807 // Attach handlers for all browsers
jurzua
parents:
diff changeset
7808 script.onload = script.onreadystatechange = function( _, isAbort ) {
jurzua
parents:
diff changeset
7809
jurzua
parents:
diff changeset
7810 if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
jurzua
parents:
diff changeset
7811
jurzua
parents:
diff changeset
7812 // Handle memory leak in IE
jurzua
parents:
diff changeset
7813 script.onload = script.onreadystatechange = null;
jurzua
parents:
diff changeset
7814
jurzua
parents:
diff changeset
7815 // Remove the script
jurzua
parents:
diff changeset
7816 if ( head && script.parentNode ) {
jurzua
parents:
diff changeset
7817 head.removeChild( script );
jurzua
parents:
diff changeset
7818 }
jurzua
parents:
diff changeset
7819
jurzua
parents:
diff changeset
7820 // Dereference the script
jurzua
parents:
diff changeset
7821 script = undefined;
jurzua
parents:
diff changeset
7822
jurzua
parents:
diff changeset
7823 // Callback if not abort
jurzua
parents:
diff changeset
7824 if ( !isAbort ) {
jurzua
parents:
diff changeset
7825 callback( 200, "success" );
jurzua
parents:
diff changeset
7826 }
jurzua
parents:
diff changeset
7827 }
jurzua
parents:
diff changeset
7828 };
jurzua
parents:
diff changeset
7829 // Use insertBefore instead of appendChild to circumvent an IE6 bug.
jurzua
parents:
diff changeset
7830 // This arises when a base node is used (#2709 and #4378).
jurzua
parents:
diff changeset
7831 head.insertBefore( script, head.firstChild );
jurzua
parents:
diff changeset
7832 },
jurzua
parents:
diff changeset
7833
jurzua
parents:
diff changeset
7834 abort: function() {
jurzua
parents:
diff changeset
7835 if ( script ) {
jurzua
parents:
diff changeset
7836 script.onload( 0, 1 );
jurzua
parents:
diff changeset
7837 }
jurzua
parents:
diff changeset
7838 }
jurzua
parents:
diff changeset
7839 };
jurzua
parents:
diff changeset
7840 }
jurzua
parents:
diff changeset
7841 });
jurzua
parents:
diff changeset
7842
jurzua
parents:
diff changeset
7843
jurzua
parents:
diff changeset
7844
jurzua
parents:
diff changeset
7845
jurzua
parents:
diff changeset
7846 var // #5280: Internet Explorer will keep connections alive if we don't abort on unload
jurzua
parents:
diff changeset
7847 xhrOnUnloadAbort = window.ActiveXObject ? function() {
jurzua
parents:
diff changeset
7848 // Abort all pending requests
jurzua
parents:
diff changeset
7849 for ( var key in xhrCallbacks ) {
jurzua
parents:
diff changeset
7850 xhrCallbacks[ key ]( 0, 1 );
jurzua
parents:
diff changeset
7851 }
jurzua
parents:
diff changeset
7852 } : false,
jurzua
parents:
diff changeset
7853 xhrId = 0,
jurzua
parents:
diff changeset
7854 xhrCallbacks;
jurzua
parents:
diff changeset
7855
jurzua
parents:
diff changeset
7856 // Functions to create xhrs
jurzua
parents:
diff changeset
7857 function createStandardXHR() {
jurzua
parents:
diff changeset
7858 try {
jurzua
parents:
diff changeset
7859 return new window.XMLHttpRequest();
jurzua
parents:
diff changeset
7860 } catch( e ) {}
jurzua
parents:
diff changeset
7861 }
jurzua
parents:
diff changeset
7862
jurzua
parents:
diff changeset
7863 function createActiveXHR() {
jurzua
parents:
diff changeset
7864 try {
jurzua
parents:
diff changeset
7865 return new window.ActiveXObject( "Microsoft.XMLHTTP" );
jurzua
parents:
diff changeset
7866 } catch( e ) {}
jurzua
parents:
diff changeset
7867 }
jurzua
parents:
diff changeset
7868
jurzua
parents:
diff changeset
7869 // Create the request object
jurzua
parents:
diff changeset
7870 // (This is still attached to ajaxSettings for backward compatibility)
jurzua
parents:
diff changeset
7871 jQuery.ajaxSettings.xhr = window.ActiveXObject ?
jurzua
parents:
diff changeset
7872 /* Microsoft failed to properly
jurzua
parents:
diff changeset
7873 * implement the XMLHttpRequest in IE7 (can't request local files),
jurzua
parents:
diff changeset
7874 * so we use the ActiveXObject when it is available
jurzua
parents:
diff changeset
7875 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
jurzua
parents:
diff changeset
7876 * we need a fallback.
jurzua
parents:
diff changeset
7877 */
jurzua
parents:
diff changeset
7878 function() {
jurzua
parents:
diff changeset
7879 return !this.isLocal && createStandardXHR() || createActiveXHR();
jurzua
parents:
diff changeset
7880 } :
jurzua
parents:
diff changeset
7881 // For all other browsers, use the standard XMLHttpRequest object
jurzua
parents:
diff changeset
7882 createStandardXHR;
jurzua
parents:
diff changeset
7883
jurzua
parents:
diff changeset
7884 // Determine support properties
jurzua
parents:
diff changeset
7885 (function( xhr ) {
jurzua
parents:
diff changeset
7886 jQuery.extend( jQuery.support, {
jurzua
parents:
diff changeset
7887 ajax: !!xhr,
jurzua
parents:
diff changeset
7888 cors: !!xhr && ( "withCredentials" in xhr )
jurzua
parents:
diff changeset
7889 });
jurzua
parents:
diff changeset
7890 })( jQuery.ajaxSettings.xhr() );
jurzua
parents:
diff changeset
7891
jurzua
parents:
diff changeset
7892 // Create transport if the browser can provide an xhr
jurzua
parents:
diff changeset
7893 if ( jQuery.support.ajax ) {
jurzua
parents:
diff changeset
7894
jurzua
parents:
diff changeset
7895 jQuery.ajaxTransport(function( s ) {
jurzua
parents:
diff changeset
7896 // Cross domain only allowed if supported through XMLHttpRequest
jurzua
parents:
diff changeset
7897 if ( !s.crossDomain || jQuery.support.cors ) {
jurzua
parents:
diff changeset
7898
jurzua
parents:
diff changeset
7899 var callback;
jurzua
parents:
diff changeset
7900
jurzua
parents:
diff changeset
7901 return {
jurzua
parents:
diff changeset
7902 send: function( headers, complete ) {
jurzua
parents:
diff changeset
7903
jurzua
parents:
diff changeset
7904 // Get a new xhr
jurzua
parents:
diff changeset
7905 var xhr = s.xhr(),
jurzua
parents:
diff changeset
7906 handle,
jurzua
parents:
diff changeset
7907 i;
jurzua
parents:
diff changeset
7908
jurzua
parents:
diff changeset
7909 // Open the socket
jurzua
parents:
diff changeset
7910 // Passing null username, generates a login popup on Opera (#2865)
jurzua
parents:
diff changeset
7911 if ( s.username ) {
jurzua
parents:
diff changeset
7912 xhr.open( s.type, s.url, s.async, s.username, s.password );
jurzua
parents:
diff changeset
7913 } else {
jurzua
parents:
diff changeset
7914 xhr.open( s.type, s.url, s.async );
jurzua
parents:
diff changeset
7915 }
jurzua
parents:
diff changeset
7916
jurzua
parents:
diff changeset
7917 // Apply custom fields if provided
jurzua
parents:
diff changeset
7918 if ( s.xhrFields ) {
jurzua
parents:
diff changeset
7919 for ( i in s.xhrFields ) {
jurzua
parents:
diff changeset
7920 xhr[ i ] = s.xhrFields[ i ];
jurzua
parents:
diff changeset
7921 }
jurzua
parents:
diff changeset
7922 }
jurzua
parents:
diff changeset
7923
jurzua
parents:
diff changeset
7924 // Override mime type if needed
jurzua
parents:
diff changeset
7925 if ( s.mimeType && xhr.overrideMimeType ) {
jurzua
parents:
diff changeset
7926 xhr.overrideMimeType( s.mimeType );
jurzua
parents:
diff changeset
7927 }
jurzua
parents:
diff changeset
7928
jurzua
parents:
diff changeset
7929 // X-Requested-With header
jurzua
parents:
diff changeset
7930 // For cross-domain requests, seeing as conditions for a preflight are
jurzua
parents:
diff changeset
7931 // akin to a jigsaw puzzle, we simply never set it to be sure.
jurzua
parents:
diff changeset
7932 // (it can always be set on a per-request basis or even using ajaxSetup)
jurzua
parents:
diff changeset
7933 // For same-domain requests, won't change header if already provided.
jurzua
parents:
diff changeset
7934 if ( !s.crossDomain && !headers["X-Requested-With"] ) {
jurzua
parents:
diff changeset
7935 headers[ "X-Requested-With" ] = "XMLHttpRequest";
jurzua
parents:
diff changeset
7936 }
jurzua
parents:
diff changeset
7937
jurzua
parents:
diff changeset
7938 // Need an extra try/catch for cross domain requests in Firefox 3
jurzua
parents:
diff changeset
7939 try {
jurzua
parents:
diff changeset
7940 for ( i in headers ) {
jurzua
parents:
diff changeset
7941 xhr.setRequestHeader( i, headers[ i ] );
jurzua
parents:
diff changeset
7942 }
jurzua
parents:
diff changeset
7943 } catch( _ ) {}
jurzua
parents:
diff changeset
7944
jurzua
parents:
diff changeset
7945 // Do send the request
jurzua
parents:
diff changeset
7946 // This may raise an exception which is actually
jurzua
parents:
diff changeset
7947 // handled in jQuery.ajax (so no try/catch here)
jurzua
parents:
diff changeset
7948 xhr.send( ( s.hasContent && s.data ) || null );
jurzua
parents:
diff changeset
7949
jurzua
parents:
diff changeset
7950 // Listener
jurzua
parents:
diff changeset
7951 callback = function( _, isAbort ) {
jurzua
parents:
diff changeset
7952
jurzua
parents:
diff changeset
7953 var status,
jurzua
parents:
diff changeset
7954 statusText,
jurzua
parents:
diff changeset
7955 responseHeaders,
jurzua
parents:
diff changeset
7956 responses,
jurzua
parents:
diff changeset
7957 xml;
jurzua
parents:
diff changeset
7958
jurzua
parents:
diff changeset
7959 // Firefox throws exceptions when accessing properties
jurzua
parents:
diff changeset
7960 // of an xhr when a network error occured
jurzua
parents:
diff changeset
7961 // http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
jurzua
parents:
diff changeset
7962 try {
jurzua
parents:
diff changeset
7963
jurzua
parents:
diff changeset
7964 // Was never called and is aborted or complete
jurzua
parents:
diff changeset
7965 if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
jurzua
parents:
diff changeset
7966
jurzua
parents:
diff changeset
7967 // Only called once
jurzua
parents:
diff changeset
7968 callback = undefined;
jurzua
parents:
diff changeset
7969
jurzua
parents:
diff changeset
7970 // Do not keep as active anymore
jurzua
parents:
diff changeset
7971 if ( handle ) {
jurzua
parents:
diff changeset
7972 xhr.onreadystatechange = jQuery.noop;
jurzua
parents:
diff changeset
7973 if ( xhrOnUnloadAbort ) {
jurzua
parents:
diff changeset
7974 delete xhrCallbacks[ handle ];
jurzua
parents:
diff changeset
7975 }
jurzua
parents:
diff changeset
7976 }
jurzua
parents:
diff changeset
7977
jurzua
parents:
diff changeset
7978 // If it's an abort
jurzua
parents:
diff changeset
7979 if ( isAbort ) {
jurzua
parents:
diff changeset
7980 // Abort it manually if needed
jurzua
parents:
diff changeset
7981 if ( xhr.readyState !== 4 ) {
jurzua
parents:
diff changeset
7982 xhr.abort();
jurzua
parents:
diff changeset
7983 }
jurzua
parents:
diff changeset
7984 } else {
jurzua
parents:
diff changeset
7985 status = xhr.status;
jurzua
parents:
diff changeset
7986 responseHeaders = xhr.getAllResponseHeaders();
jurzua
parents:
diff changeset
7987 responses = {};
jurzua
parents:
diff changeset
7988 xml = xhr.responseXML;
jurzua
parents:
diff changeset
7989
jurzua
parents:
diff changeset
7990 // Construct response list
jurzua
parents:
diff changeset
7991 if ( xml && xml.documentElement /* #4958 */ ) {
jurzua
parents:
diff changeset
7992 responses.xml = xml;
jurzua
parents:
diff changeset
7993 }
jurzua
parents:
diff changeset
7994 responses.text = xhr.responseText;
jurzua
parents:
diff changeset
7995
jurzua
parents:
diff changeset
7996 // Firefox throws an exception when accessing
jurzua
parents:
diff changeset
7997 // statusText for faulty cross-domain requests
jurzua
parents:
diff changeset
7998 try {
jurzua
parents:
diff changeset
7999 statusText = xhr.statusText;
jurzua
parents:
diff changeset
8000 } catch( e ) {
jurzua
parents:
diff changeset
8001 // We normalize with Webkit giving an empty statusText
jurzua
parents:
diff changeset
8002 statusText = "";
jurzua
parents:
diff changeset
8003 }
jurzua
parents:
diff changeset
8004
jurzua
parents:
diff changeset
8005 // Filter status for non standard behaviors
jurzua
parents:
diff changeset
8006
jurzua
parents:
diff changeset
8007 // If the request is local and we have data: assume a success
jurzua
parents:
diff changeset
8008 // (success with no data won't get notified, that's the best we
jurzua
parents:
diff changeset
8009 // can do given current implementations)
jurzua
parents:
diff changeset
8010 if ( !status && s.isLocal && !s.crossDomain ) {
jurzua
parents:
diff changeset
8011 status = responses.text ? 200 : 404;
jurzua
parents:
diff changeset
8012 // IE - #1450: sometimes returns 1223 when it should be 204
jurzua
parents:
diff changeset
8013 } else if ( status === 1223 ) {
jurzua
parents:
diff changeset
8014 status = 204;
jurzua
parents:
diff changeset
8015 }
jurzua
parents:
diff changeset
8016 }
jurzua
parents:
diff changeset
8017 }
jurzua
parents:
diff changeset
8018 } catch( firefoxAccessException ) {
jurzua
parents:
diff changeset
8019 if ( !isAbort ) {
jurzua
parents:
diff changeset
8020 complete( -1, firefoxAccessException );
jurzua
parents:
diff changeset
8021 }
jurzua
parents:
diff changeset
8022 }
jurzua
parents:
diff changeset
8023
jurzua
parents:
diff changeset
8024 // Call complete if needed
jurzua
parents:
diff changeset
8025 if ( responses ) {
jurzua
parents:
diff changeset
8026 complete( status, statusText, responses, responseHeaders );
jurzua
parents:
diff changeset
8027 }
jurzua
parents:
diff changeset
8028 };
jurzua
parents:
diff changeset
8029
jurzua
parents:
diff changeset
8030 // if we're in sync mode or it's in cache
jurzua
parents:
diff changeset
8031 // and has been retrieved directly (IE6 & IE7)
jurzua
parents:
diff changeset
8032 // we need to manually fire the callback
jurzua
parents:
diff changeset
8033 if ( !s.async || xhr.readyState === 4 ) {
jurzua
parents:
diff changeset
8034 callback();
jurzua
parents:
diff changeset
8035 } else {
jurzua
parents:
diff changeset
8036 handle = ++xhrId;
jurzua
parents:
diff changeset
8037 if ( xhrOnUnloadAbort ) {
jurzua
parents:
diff changeset
8038 // Create the active xhrs callbacks list if needed
jurzua
parents:
diff changeset
8039 // and attach the unload handler
jurzua
parents:
diff changeset
8040 if ( !xhrCallbacks ) {
jurzua
parents:
diff changeset
8041 xhrCallbacks = {};
jurzua
parents:
diff changeset
8042 jQuery( window ).unload( xhrOnUnloadAbort );
jurzua
parents:
diff changeset
8043 }
jurzua
parents:
diff changeset
8044 // Add to list of active xhrs callbacks
jurzua
parents:
diff changeset
8045 xhrCallbacks[ handle ] = callback;
jurzua
parents:
diff changeset
8046 }
jurzua
parents:
diff changeset
8047 xhr.onreadystatechange = callback;
jurzua
parents:
diff changeset
8048 }
jurzua
parents:
diff changeset
8049 },
jurzua
parents:
diff changeset
8050
jurzua
parents:
diff changeset
8051 abort: function() {
jurzua
parents:
diff changeset
8052 if ( callback ) {
jurzua
parents:
diff changeset
8053 callback(0,1);
jurzua
parents:
diff changeset
8054 }
jurzua
parents:
diff changeset
8055 }
jurzua
parents:
diff changeset
8056 };
jurzua
parents:
diff changeset
8057 }
jurzua
parents:
diff changeset
8058 });
jurzua
parents:
diff changeset
8059 }
jurzua
parents:
diff changeset
8060
jurzua
parents:
diff changeset
8061
jurzua
parents:
diff changeset
8062
jurzua
parents:
diff changeset
8063
jurzua
parents:
diff changeset
8064 var elemdisplay = {},
jurzua
parents:
diff changeset
8065 iframe, iframeDoc,
jurzua
parents:
diff changeset
8066 rfxtypes = /^(?:toggle|show|hide)$/,
jurzua
parents:
diff changeset
8067 rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
jurzua
parents:
diff changeset
8068 timerId,
jurzua
parents:
diff changeset
8069 fxAttrs = [
jurzua
parents:
diff changeset
8070 // height animations
jurzua
parents:
diff changeset
8071 [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
jurzua
parents:
diff changeset
8072 // width animations
jurzua
parents:
diff changeset
8073 [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
jurzua
parents:
diff changeset
8074 // opacity animations
jurzua
parents:
diff changeset
8075 [ "opacity" ]
jurzua
parents:
diff changeset
8076 ],
jurzua
parents:
diff changeset
8077 fxNow;
jurzua
parents:
diff changeset
8078
jurzua
parents:
diff changeset
8079 jQuery.fn.extend({
jurzua
parents:
diff changeset
8080 show: function( speed, easing, callback ) {
jurzua
parents:
diff changeset
8081 var elem, display;
jurzua
parents:
diff changeset
8082
jurzua
parents:
diff changeset
8083 if ( speed || speed === 0 ) {
jurzua
parents:
diff changeset
8084 return this.animate( genFx("show", 3), speed, easing, callback);
jurzua
parents:
diff changeset
8085
jurzua
parents:
diff changeset
8086 } else {
jurzua
parents:
diff changeset
8087 for ( var i = 0, j = this.length; i < j; i++ ) {
jurzua
parents:
diff changeset
8088 elem = this[i];
jurzua
parents:
diff changeset
8089
jurzua
parents:
diff changeset
8090 if ( elem.style ) {
jurzua
parents:
diff changeset
8091 display = elem.style.display;
jurzua
parents:
diff changeset
8092
jurzua
parents:
diff changeset
8093 // Reset the inline display of this element to learn if it is
jurzua
parents:
diff changeset
8094 // being hidden by cascaded rules or not
jurzua
parents:
diff changeset
8095 if ( !jQuery._data(elem, "olddisplay") && display === "none" ) {
jurzua
parents:
diff changeset
8096 display = elem.style.display = "";
jurzua
parents:
diff changeset
8097 }
jurzua
parents:
diff changeset
8098
jurzua
parents:
diff changeset
8099 // Set elements which have been overridden with display: none
jurzua
parents:
diff changeset
8100 // in a stylesheet to whatever the default browser style is
jurzua
parents:
diff changeset
8101 // for such an element
jurzua
parents:
diff changeset
8102 if ( display === "" && jQuery.css( elem, "display" ) === "none" ) {
jurzua
parents:
diff changeset
8103 jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName));
jurzua
parents:
diff changeset
8104 }
jurzua
parents:
diff changeset
8105 }
jurzua
parents:
diff changeset
8106 }
jurzua
parents:
diff changeset
8107
jurzua
parents:
diff changeset
8108 // Set the display of most of the elements in a second loop
jurzua
parents:
diff changeset
8109 // to avoid the constant reflow
jurzua
parents:
diff changeset
8110 for ( i = 0; i < j; i++ ) {
jurzua
parents:
diff changeset
8111 elem = this[i];
jurzua
parents:
diff changeset
8112
jurzua
parents:
diff changeset
8113 if ( elem.style ) {
jurzua
parents:
diff changeset
8114 display = elem.style.display;
jurzua
parents:
diff changeset
8115
jurzua
parents:
diff changeset
8116 if ( display === "" || display === "none" ) {
jurzua
parents:
diff changeset
8117 elem.style.display = jQuery._data(elem, "olddisplay") || "";
jurzua
parents:
diff changeset
8118 }
jurzua
parents:
diff changeset
8119 }
jurzua
parents:
diff changeset
8120 }
jurzua
parents:
diff changeset
8121
jurzua
parents:
diff changeset
8122 return this;
jurzua
parents:
diff changeset
8123 }
jurzua
parents:
diff changeset
8124 },
jurzua
parents:
diff changeset
8125
jurzua
parents:
diff changeset
8126 hide: function( speed, easing, callback ) {
jurzua
parents:
diff changeset
8127 if ( speed || speed === 0 ) {
jurzua
parents:
diff changeset
8128 return this.animate( genFx("hide", 3), speed, easing, callback);
jurzua
parents:
diff changeset
8129
jurzua
parents:
diff changeset
8130 } else {
jurzua
parents:
diff changeset
8131 for ( var i = 0, j = this.length; i < j; i++ ) {
jurzua
parents:
diff changeset
8132 if ( this[i].style ) {
jurzua
parents:
diff changeset
8133 var display = jQuery.css( this[i], "display" );
jurzua
parents:
diff changeset
8134
jurzua
parents:
diff changeset
8135 if ( display !== "none" && !jQuery._data( this[i], "olddisplay" ) ) {
jurzua
parents:
diff changeset
8136 jQuery._data( this[i], "olddisplay", display );
jurzua
parents:
diff changeset
8137 }
jurzua
parents:
diff changeset
8138 }
jurzua
parents:
diff changeset
8139 }
jurzua
parents:
diff changeset
8140
jurzua
parents:
diff changeset
8141 // Set the display of the elements in a second loop
jurzua
parents:
diff changeset
8142 // to avoid the constant reflow
jurzua
parents:
diff changeset
8143 for ( i = 0; i < j; i++ ) {
jurzua
parents:
diff changeset
8144 if ( this[i].style ) {
jurzua
parents:
diff changeset
8145 this[i].style.display = "none";
jurzua
parents:
diff changeset
8146 }
jurzua
parents:
diff changeset
8147 }
jurzua
parents:
diff changeset
8148
jurzua
parents:
diff changeset
8149 return this;
jurzua
parents:
diff changeset
8150 }
jurzua
parents:
diff changeset
8151 },
jurzua
parents:
diff changeset
8152
jurzua
parents:
diff changeset
8153 // Save the old toggle function
jurzua
parents:
diff changeset
8154 _toggle: jQuery.fn.toggle,
jurzua
parents:
diff changeset
8155
jurzua
parents:
diff changeset
8156 toggle: function( fn, fn2, callback ) {
jurzua
parents:
diff changeset
8157 var bool = typeof fn === "boolean";
jurzua
parents:
diff changeset
8158
jurzua
parents:
diff changeset
8159 if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
jurzua
parents:
diff changeset
8160 this._toggle.apply( this, arguments );
jurzua
parents:
diff changeset
8161
jurzua
parents:
diff changeset
8162 } else if ( fn == null || bool ) {
jurzua
parents:
diff changeset
8163 this.each(function() {
jurzua
parents:
diff changeset
8164 var state = bool ? fn : jQuery(this).is(":hidden");
jurzua
parents:
diff changeset
8165 jQuery(this)[ state ? "show" : "hide" ]();
jurzua
parents:
diff changeset
8166 });
jurzua
parents:
diff changeset
8167
jurzua
parents:
diff changeset
8168 } else {
jurzua
parents:
diff changeset
8169 this.animate(genFx("toggle", 3), fn, fn2, callback);
jurzua
parents:
diff changeset
8170 }
jurzua
parents:
diff changeset
8171
jurzua
parents:
diff changeset
8172 return this;
jurzua
parents:
diff changeset
8173 },
jurzua
parents:
diff changeset
8174
jurzua
parents:
diff changeset
8175 fadeTo: function( speed, to, easing, callback ) {
jurzua
parents:
diff changeset
8176 return this.filter(":hidden").css("opacity", 0).show().end()
jurzua
parents:
diff changeset
8177 .animate({opacity: to}, speed, easing, callback);
jurzua
parents:
diff changeset
8178 },
jurzua
parents:
diff changeset
8179
jurzua
parents:
diff changeset
8180 animate: function( prop, speed, easing, callback ) {
jurzua
parents:
diff changeset
8181 var optall = jQuery.speed(speed, easing, callback);
jurzua
parents:
diff changeset
8182
jurzua
parents:
diff changeset
8183 if ( jQuery.isEmptyObject( prop ) ) {
jurzua
parents:
diff changeset
8184 return this.each( optall.complete, [ false ] );
jurzua
parents:
diff changeset
8185 }
jurzua
parents:
diff changeset
8186
jurzua
parents:
diff changeset
8187 // Do not change referenced properties as per-property easing will be lost
jurzua
parents:
diff changeset
8188 prop = jQuery.extend( {}, prop );
jurzua
parents:
diff changeset
8189
jurzua
parents:
diff changeset
8190 return this[ optall.queue === false ? "each" : "queue" ](function() {
jurzua
parents:
diff changeset
8191 // XXX 'this' does not always have a nodeName when running the
jurzua
parents:
diff changeset
8192 // test suite
jurzua
parents:
diff changeset
8193
jurzua
parents:
diff changeset
8194 if ( optall.queue === false ) {
jurzua
parents:
diff changeset
8195 jQuery._mark( this );
jurzua
parents:
diff changeset
8196 }
jurzua
parents:
diff changeset
8197
jurzua
parents:
diff changeset
8198 var opt = jQuery.extend( {}, optall ),
jurzua
parents:
diff changeset
8199 isElement = this.nodeType === 1,
jurzua
parents:
diff changeset
8200 hidden = isElement && jQuery(this).is(":hidden"),
jurzua
parents:
diff changeset
8201 name, val, p,
jurzua
parents:
diff changeset
8202 display, e,
jurzua
parents:
diff changeset
8203 parts, start, end, unit;
jurzua
parents:
diff changeset
8204
jurzua
parents:
diff changeset
8205 // will store per property easing and be used to determine when an animation is complete
jurzua
parents:
diff changeset
8206 opt.animatedProperties = {};
jurzua
parents:
diff changeset
8207
jurzua
parents:
diff changeset
8208 for ( p in prop ) {
jurzua
parents:
diff changeset
8209
jurzua
parents:
diff changeset
8210 // property name normalization
jurzua
parents:
diff changeset
8211 name = jQuery.camelCase( p );
jurzua
parents:
diff changeset
8212 if ( p !== name ) {
jurzua
parents:
diff changeset
8213 prop[ name ] = prop[ p ];
jurzua
parents:
diff changeset
8214 delete prop[ p ];
jurzua
parents:
diff changeset
8215 }
jurzua
parents:
diff changeset
8216
jurzua
parents:
diff changeset
8217 val = prop[ name ];
jurzua
parents:
diff changeset
8218
jurzua
parents:
diff changeset
8219 // easing resolution: per property > opt.specialEasing > opt.easing > 'swing' (default)
jurzua
parents:
diff changeset
8220 if ( jQuery.isArray( val ) ) {
jurzua
parents:
diff changeset
8221 opt.animatedProperties[ name ] = val[ 1 ];
jurzua
parents:
diff changeset
8222 val = prop[ name ] = val[ 0 ];
jurzua
parents:
diff changeset
8223 } else {
jurzua
parents:
diff changeset
8224 opt.animatedProperties[ name ] = opt.specialEasing && opt.specialEasing[ name ] || opt.easing || 'swing';
jurzua
parents:
diff changeset
8225 }
jurzua
parents:
diff changeset
8226
jurzua
parents:
diff changeset
8227 if ( val === "hide" && hidden || val === "show" && !hidden ) {
jurzua
parents:
diff changeset
8228 return opt.complete.call( this );
jurzua
parents:
diff changeset
8229 }
jurzua
parents:
diff changeset
8230
jurzua
parents:
diff changeset
8231 if ( isElement && ( name === "height" || name === "width" ) ) {
jurzua
parents:
diff changeset
8232 // Make sure that nothing sneaks out
jurzua
parents:
diff changeset
8233 // Record all 3 overflow attributes because IE does not
jurzua
parents:
diff changeset
8234 // change the overflow attribute when overflowX and
jurzua
parents:
diff changeset
8235 // overflowY are set to the same value
jurzua
parents:
diff changeset
8236 opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
jurzua
parents:
diff changeset
8237
jurzua
parents:
diff changeset
8238 // Set display property to inline-block for height/width
jurzua
parents:
diff changeset
8239 // animations on inline elements that are having width/height
jurzua
parents:
diff changeset
8240 // animated
jurzua
parents:
diff changeset
8241 if ( jQuery.css( this, "display" ) === "inline" &&
jurzua
parents:
diff changeset
8242 jQuery.css( this, "float" ) === "none" ) {
jurzua
parents:
diff changeset
8243 if ( !jQuery.support.inlineBlockNeedsLayout ) {
jurzua
parents:
diff changeset
8244 this.style.display = "inline-block";
jurzua
parents:
diff changeset
8245
jurzua
parents:
diff changeset
8246 } else {
jurzua
parents:
diff changeset
8247 display = defaultDisplay( this.nodeName );
jurzua
parents:
diff changeset
8248
jurzua
parents:
diff changeset
8249 // inline-level elements accept inline-block;
jurzua
parents:
diff changeset
8250 // block-level elements need to be inline with layout
jurzua
parents:
diff changeset
8251 if ( display === "inline" ) {
jurzua
parents:
diff changeset
8252 this.style.display = "inline-block";
jurzua
parents:
diff changeset
8253
jurzua
parents:
diff changeset
8254 } else {
jurzua
parents:
diff changeset
8255 this.style.display = "inline";
jurzua
parents:
diff changeset
8256 this.style.zoom = 1;
jurzua
parents:
diff changeset
8257 }
jurzua
parents:
diff changeset
8258 }
jurzua
parents:
diff changeset
8259 }
jurzua
parents:
diff changeset
8260 }
jurzua
parents:
diff changeset
8261 }
jurzua
parents:
diff changeset
8262
jurzua
parents:
diff changeset
8263 if ( opt.overflow != null ) {
jurzua
parents:
diff changeset
8264 this.style.overflow = "hidden";
jurzua
parents:
diff changeset
8265 }
jurzua
parents:
diff changeset
8266
jurzua
parents:
diff changeset
8267 for ( p in prop ) {
jurzua
parents:
diff changeset
8268 e = new jQuery.fx( this, opt, p );
jurzua
parents:
diff changeset
8269 val = prop[ p ];
jurzua
parents:
diff changeset
8270
jurzua
parents:
diff changeset
8271 if ( rfxtypes.test(val) ) {
jurzua
parents:
diff changeset
8272 e[ val === "toggle" ? hidden ? "show" : "hide" : val ]();
jurzua
parents:
diff changeset
8273
jurzua
parents:
diff changeset
8274 } else {
jurzua
parents:
diff changeset
8275 parts = rfxnum.exec( val );
jurzua
parents:
diff changeset
8276 start = e.cur();
jurzua
parents:
diff changeset
8277
jurzua
parents:
diff changeset
8278 if ( parts ) {
jurzua
parents:
diff changeset
8279 end = parseFloat( parts[2] );
jurzua
parents:
diff changeset
8280 unit = parts[3] || ( jQuery.cssNumber[ p ] ? "" : "px" );
jurzua
parents:
diff changeset
8281
jurzua
parents:
diff changeset
8282 // We need to compute starting value
jurzua
parents:
diff changeset
8283 if ( unit !== "px" ) {
jurzua
parents:
diff changeset
8284 jQuery.style( this, p, (end || 1) + unit);
jurzua
parents:
diff changeset
8285 start = ((end || 1) / e.cur()) * start;
jurzua
parents:
diff changeset
8286 jQuery.style( this, p, start + unit);
jurzua
parents:
diff changeset
8287 }
jurzua
parents:
diff changeset
8288
jurzua
parents:
diff changeset
8289 // If a +=/-= token was provided, we're doing a relative animation
jurzua
parents:
diff changeset
8290 if ( parts[1] ) {
jurzua
parents:
diff changeset
8291 end = ( (parts[ 1 ] === "-=" ? -1 : 1) * end ) + start;
jurzua
parents:
diff changeset
8292 }
jurzua
parents:
diff changeset
8293
jurzua
parents:
diff changeset
8294 e.custom( start, end, unit );
jurzua
parents:
diff changeset
8295
jurzua
parents:
diff changeset
8296 } else {
jurzua
parents:
diff changeset
8297 e.custom( start, val, "" );
jurzua
parents:
diff changeset
8298 }
jurzua
parents:
diff changeset
8299 }
jurzua
parents:
diff changeset
8300 }
jurzua
parents:
diff changeset
8301
jurzua
parents:
diff changeset
8302 // For JS strict compliance
jurzua
parents:
diff changeset
8303 return true;
jurzua
parents:
diff changeset
8304 });
jurzua
parents:
diff changeset
8305 },
jurzua
parents:
diff changeset
8306
jurzua
parents:
diff changeset
8307 stop: function( clearQueue, gotoEnd ) {
jurzua
parents:
diff changeset
8308 if ( clearQueue ) {
jurzua
parents:
diff changeset
8309 this.queue([]);
jurzua
parents:
diff changeset
8310 }
jurzua
parents:
diff changeset
8311
jurzua
parents:
diff changeset
8312 this.each(function() {
jurzua
parents:
diff changeset
8313 var timers = jQuery.timers,
jurzua
parents:
diff changeset
8314 i = timers.length;
jurzua
parents:
diff changeset
8315 // clear marker counters if we know they won't be
jurzua
parents:
diff changeset
8316 if ( !gotoEnd ) {
jurzua
parents:
diff changeset
8317 jQuery._unmark( true, this );
jurzua
parents:
diff changeset
8318 }
jurzua
parents:
diff changeset
8319 while ( i-- ) {
jurzua
parents:
diff changeset
8320 if ( timers[i].elem === this ) {
jurzua
parents:
diff changeset
8321 if (gotoEnd) {
jurzua
parents:
diff changeset
8322 // force the next step to be the last
jurzua
parents:
diff changeset
8323 timers[i](true);
jurzua
parents:
diff changeset
8324 }
jurzua
parents:
diff changeset
8325
jurzua
parents:
diff changeset
8326 timers.splice(i, 1);
jurzua
parents:
diff changeset
8327 }
jurzua
parents:
diff changeset
8328 }
jurzua
parents:
diff changeset
8329 });
jurzua
parents:
diff changeset
8330
jurzua
parents:
diff changeset
8331 // start the next in the queue if the last step wasn't forced
jurzua
parents:
diff changeset
8332 if ( !gotoEnd ) {
jurzua
parents:
diff changeset
8333 this.dequeue();
jurzua
parents:
diff changeset
8334 }
jurzua
parents:
diff changeset
8335
jurzua
parents:
diff changeset
8336 return this;
jurzua
parents:
diff changeset
8337 }
jurzua
parents:
diff changeset
8338
jurzua
parents:
diff changeset
8339 });
jurzua
parents:
diff changeset
8340
jurzua
parents:
diff changeset
8341 // Animations created synchronously will run synchronously
jurzua
parents:
diff changeset
8342 function createFxNow() {
jurzua
parents:
diff changeset
8343 setTimeout( clearFxNow, 0 );
jurzua
parents:
diff changeset
8344 return ( fxNow = jQuery.now() );
jurzua
parents:
diff changeset
8345 }
jurzua
parents:
diff changeset
8346
jurzua
parents:
diff changeset
8347 function clearFxNow() {
jurzua
parents:
diff changeset
8348 fxNow = undefined;
jurzua
parents:
diff changeset
8349 }
jurzua
parents:
diff changeset
8350
jurzua
parents:
diff changeset
8351 // Generate parameters to create a standard animation
jurzua
parents:
diff changeset
8352 function genFx( type, num ) {
jurzua
parents:
diff changeset
8353 var obj = {};
jurzua
parents:
diff changeset
8354
jurzua
parents:
diff changeset
8355 jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
jurzua
parents:
diff changeset
8356 obj[ this ] = type;
jurzua
parents:
diff changeset
8357 });
jurzua
parents:
diff changeset
8358
jurzua
parents:
diff changeset
8359 return obj;
jurzua
parents:
diff changeset
8360 }
jurzua
parents:
diff changeset
8361
jurzua
parents:
diff changeset
8362 // Generate shortcuts for custom animations
jurzua
parents:
diff changeset
8363 jQuery.each({
jurzua
parents:
diff changeset
8364 slideDown: genFx("show", 1),
jurzua
parents:
diff changeset
8365 slideUp: genFx("hide", 1),
jurzua
parents:
diff changeset
8366 slideToggle: genFx("toggle", 1),
jurzua
parents:
diff changeset
8367 fadeIn: { opacity: "show" },
jurzua
parents:
diff changeset
8368 fadeOut: { opacity: "hide" },
jurzua
parents:
diff changeset
8369 fadeToggle: { opacity: "toggle" }
jurzua
parents:
diff changeset
8370 }, function( name, props ) {
jurzua
parents:
diff changeset
8371 jQuery.fn[ name ] = function( speed, easing, callback ) {
jurzua
parents:
diff changeset
8372 return this.animate( props, speed, easing, callback );
jurzua
parents:
diff changeset
8373 };
jurzua
parents:
diff changeset
8374 });
jurzua
parents:
diff changeset
8375
jurzua
parents:
diff changeset
8376 jQuery.extend({
jurzua
parents:
diff changeset
8377 speed: function( speed, easing, fn ) {
jurzua
parents:
diff changeset
8378 var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
jurzua
parents:
diff changeset
8379 complete: fn || !fn && easing ||
jurzua
parents:
diff changeset
8380 jQuery.isFunction( speed ) && speed,
jurzua
parents:
diff changeset
8381 duration: speed,
jurzua
parents:
diff changeset
8382 easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
jurzua
parents:
diff changeset
8383 };
jurzua
parents:
diff changeset
8384
jurzua
parents:
diff changeset
8385 opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
jurzua
parents:
diff changeset
8386 opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
jurzua
parents:
diff changeset
8387
jurzua
parents:
diff changeset
8388 // Queueing
jurzua
parents:
diff changeset
8389 opt.old = opt.complete;
jurzua
parents:
diff changeset
8390 opt.complete = function( noUnmark ) {
jurzua
parents:
diff changeset
8391 if ( jQuery.isFunction( opt.old ) ) {
jurzua
parents:
diff changeset
8392 opt.old.call( this );
jurzua
parents:
diff changeset
8393 }
jurzua
parents:
diff changeset
8394
jurzua
parents:
diff changeset
8395 if ( opt.queue !== false ) {
jurzua
parents:
diff changeset
8396 jQuery.dequeue( this );
jurzua
parents:
diff changeset
8397 } else if ( noUnmark !== false ) {
jurzua
parents:
diff changeset
8398 jQuery._unmark( this );
jurzua
parents:
diff changeset
8399 }
jurzua
parents:
diff changeset
8400 };
jurzua
parents:
diff changeset
8401
jurzua
parents:
diff changeset
8402 return opt;
jurzua
parents:
diff changeset
8403 },
jurzua
parents:
diff changeset
8404
jurzua
parents:
diff changeset
8405 easing: {
jurzua
parents:
diff changeset
8406 linear: function( p, n, firstNum, diff ) {
jurzua
parents:
diff changeset
8407 return firstNum + diff * p;
jurzua
parents:
diff changeset
8408 },
jurzua
parents:
diff changeset
8409 swing: function( p, n, firstNum, diff ) {
jurzua
parents:
diff changeset
8410 return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
jurzua
parents:
diff changeset
8411 }
jurzua
parents:
diff changeset
8412 },
jurzua
parents:
diff changeset
8413
jurzua
parents:
diff changeset
8414 timers: [],
jurzua
parents:
diff changeset
8415
jurzua
parents:
diff changeset
8416 fx: function( elem, options, prop ) {
jurzua
parents:
diff changeset
8417 this.options = options;
jurzua
parents:
diff changeset
8418 this.elem = elem;
jurzua
parents:
diff changeset
8419 this.prop = prop;
jurzua
parents:
diff changeset
8420
jurzua
parents:
diff changeset
8421 options.orig = options.orig || {};
jurzua
parents:
diff changeset
8422 }
jurzua
parents:
diff changeset
8423
jurzua
parents:
diff changeset
8424 });
jurzua
parents:
diff changeset
8425
jurzua
parents:
diff changeset
8426 jQuery.fx.prototype = {
jurzua
parents:
diff changeset
8427 // Simple function for setting a style value
jurzua
parents:
diff changeset
8428 update: function() {
jurzua
parents:
diff changeset
8429 if ( this.options.step ) {
jurzua
parents:
diff changeset
8430 this.options.step.call( this.elem, this.now, this );
jurzua
parents:
diff changeset
8431 }
jurzua
parents:
diff changeset
8432
jurzua
parents:
diff changeset
8433 (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
jurzua
parents:
diff changeset
8434 },
jurzua
parents:
diff changeset
8435
jurzua
parents:
diff changeset
8436 // Get the current size
jurzua
parents:
diff changeset
8437 cur: function() {
jurzua
parents:
diff changeset
8438 if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
jurzua
parents:
diff changeset
8439 return this.elem[ this.prop ];
jurzua
parents:
diff changeset
8440 }
jurzua
parents:
diff changeset
8441
jurzua
parents:
diff changeset
8442 var parsed,
jurzua
parents:
diff changeset
8443 r = jQuery.css( this.elem, this.prop );
jurzua
parents:
diff changeset
8444 // Empty strings, null, undefined and "auto" are converted to 0,
jurzua
parents:
diff changeset
8445 // complex values such as "rotate(1rad)" are returned as is,
jurzua
parents:
diff changeset
8446 // simple values such as "10px" are parsed to Float.
jurzua
parents:
diff changeset
8447 return isNaN( parsed = parseFloat( r ) ) ? !r || r === "auto" ? 0 : r : parsed;
jurzua
parents:
diff changeset
8448 },
jurzua
parents:
diff changeset
8449
jurzua
parents:
diff changeset
8450 // Start an animation from one number to another
jurzua
parents:
diff changeset
8451 custom: function( from, to, unit ) {
jurzua
parents:
diff changeset
8452 var self = this,
jurzua
parents:
diff changeset
8453 fx = jQuery.fx;
jurzua
parents:
diff changeset
8454
jurzua
parents:
diff changeset
8455 this.startTime = fxNow || createFxNow();
jurzua
parents:
diff changeset
8456 this.start = from;
jurzua
parents:
diff changeset
8457 this.end = to;
jurzua
parents:
diff changeset
8458 this.unit = unit || this.unit || ( jQuery.cssNumber[ this.prop ] ? "" : "px" );
jurzua
parents:
diff changeset
8459 this.now = this.start;
jurzua
parents:
diff changeset
8460 this.pos = this.state = 0;
jurzua
parents:
diff changeset
8461
jurzua
parents:
diff changeset
8462 function t( gotoEnd ) {
jurzua
parents:
diff changeset
8463 return self.step(gotoEnd);
jurzua
parents:
diff changeset
8464 }
jurzua
parents:
diff changeset
8465
jurzua
parents:
diff changeset
8466 t.elem = this.elem;
jurzua
parents:
diff changeset
8467
jurzua
parents:
diff changeset
8468 if ( t() && jQuery.timers.push(t) && !timerId ) {
jurzua
parents:
diff changeset
8469 timerId = setInterval( fx.tick, fx.interval );
jurzua
parents:
diff changeset
8470 }
jurzua
parents:
diff changeset
8471 },
jurzua
parents:
diff changeset
8472
jurzua
parents:
diff changeset
8473 // Simple 'show' function
jurzua
parents:
diff changeset
8474 show: function() {
jurzua
parents:
diff changeset
8475 // Remember where we started, so that we can go back to it later
jurzua
parents:
diff changeset
8476 this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
jurzua
parents:
diff changeset
8477 this.options.show = true;
jurzua
parents:
diff changeset
8478
jurzua
parents:
diff changeset
8479 // Begin the animation
jurzua
parents:
diff changeset
8480 // Make sure that we start at a small width/height to avoid any
jurzua
parents:
diff changeset
8481 // flash of content
jurzua
parents:
diff changeset
8482 this.custom(this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur());
jurzua
parents:
diff changeset
8483
jurzua
parents:
diff changeset
8484 // Start by showing the element
jurzua
parents:
diff changeset
8485 jQuery( this.elem ).show();
jurzua
parents:
diff changeset
8486 },
jurzua
parents:
diff changeset
8487
jurzua
parents:
diff changeset
8488 // Simple 'hide' function
jurzua
parents:
diff changeset
8489 hide: function() {
jurzua
parents:
diff changeset
8490 // Remember where we started, so that we can go back to it later
jurzua
parents:
diff changeset
8491 this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
jurzua
parents:
diff changeset
8492 this.options.hide = true;
jurzua
parents:
diff changeset
8493
jurzua
parents:
diff changeset
8494 // Begin the animation
jurzua
parents:
diff changeset
8495 this.custom(this.cur(), 0);
jurzua
parents:
diff changeset
8496 },
jurzua
parents:
diff changeset
8497
jurzua
parents:
diff changeset
8498 // Each step of an animation
jurzua
parents:
diff changeset
8499 step: function( gotoEnd ) {
jurzua
parents:
diff changeset
8500 var t = fxNow || createFxNow(),
jurzua
parents:
diff changeset
8501 done = true,
jurzua
parents:
diff changeset
8502 elem = this.elem,
jurzua
parents:
diff changeset
8503 options = this.options,
jurzua
parents:
diff changeset
8504 i, n;
jurzua
parents:
diff changeset
8505
jurzua
parents:
diff changeset
8506 if ( gotoEnd || t >= options.duration + this.startTime ) {
jurzua
parents:
diff changeset
8507 this.now = this.end;
jurzua
parents:
diff changeset
8508 this.pos = this.state = 1;
jurzua
parents:
diff changeset
8509 this.update();
jurzua
parents:
diff changeset
8510
jurzua
parents:
diff changeset
8511 options.animatedProperties[ this.prop ] = true;
jurzua
parents:
diff changeset
8512
jurzua
parents:
diff changeset
8513 for ( i in options.animatedProperties ) {
jurzua
parents:
diff changeset
8514 if ( options.animatedProperties[i] !== true ) {
jurzua
parents:
diff changeset
8515 done = false;
jurzua
parents:
diff changeset
8516 }
jurzua
parents:
diff changeset
8517 }
jurzua
parents:
diff changeset
8518
jurzua
parents:
diff changeset
8519 if ( done ) {
jurzua
parents:
diff changeset
8520 // Reset the overflow
jurzua
parents:
diff changeset
8521 if ( options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
jurzua
parents:
diff changeset
8522
jurzua
parents:
diff changeset
8523 jQuery.each( [ "", "X", "Y" ], function (index, value) {
jurzua
parents:
diff changeset
8524 elem.style[ "overflow" + value ] = options.overflow[index];
jurzua
parents:
diff changeset
8525 });
jurzua
parents:
diff changeset
8526 }
jurzua
parents:
diff changeset
8527
jurzua
parents:
diff changeset
8528 // Hide the element if the "hide" operation was done
jurzua
parents:
diff changeset
8529 if ( options.hide ) {
jurzua
parents:
diff changeset
8530 jQuery(elem).hide();
jurzua
parents:
diff changeset
8531 }
jurzua
parents:
diff changeset
8532
jurzua
parents:
diff changeset
8533 // Reset the properties, if the item has been hidden or shown
jurzua
parents:
diff changeset
8534 if ( options.hide || options.show ) {
jurzua
parents:
diff changeset
8535 for ( var p in options.animatedProperties ) {
jurzua
parents:
diff changeset
8536 jQuery.style( elem, p, options.orig[p] );
jurzua
parents:
diff changeset
8537 }
jurzua
parents:
diff changeset
8538 }
jurzua
parents:
diff changeset
8539
jurzua
parents:
diff changeset
8540 // Execute the complete function
jurzua
parents:
diff changeset
8541 options.complete.call( elem );
jurzua
parents:
diff changeset
8542 }
jurzua
parents:
diff changeset
8543
jurzua
parents:
diff changeset
8544 return false;
jurzua
parents:
diff changeset
8545
jurzua
parents:
diff changeset
8546 } else {
jurzua
parents:
diff changeset
8547 // classical easing cannot be used with an Infinity duration
jurzua
parents:
diff changeset
8548 if ( options.duration == Infinity ) {
jurzua
parents:
diff changeset
8549 this.now = t;
jurzua
parents:
diff changeset
8550 } else {
jurzua
parents:
diff changeset
8551 n = t - this.startTime;
jurzua
parents:
diff changeset
8552 this.state = n / options.duration;
jurzua
parents:
diff changeset
8553
jurzua
parents:
diff changeset
8554 // Perform the easing function, defaults to swing
jurzua
parents:
diff changeset
8555 this.pos = jQuery.easing[ options.animatedProperties[ this.prop ] ]( this.state, n, 0, 1, options.duration );
jurzua
parents:
diff changeset
8556 this.now = this.start + ((this.end - this.start) * this.pos);
jurzua
parents:
diff changeset
8557 }
jurzua
parents:
diff changeset
8558 // Perform the next step of the animation
jurzua
parents:
diff changeset
8559 this.update();
jurzua
parents:
diff changeset
8560 }
jurzua
parents:
diff changeset
8561
jurzua
parents:
diff changeset
8562 return true;
jurzua
parents:
diff changeset
8563 }
jurzua
parents:
diff changeset
8564 };
jurzua
parents:
diff changeset
8565
jurzua
parents:
diff changeset
8566 jQuery.extend( jQuery.fx, {
jurzua
parents:
diff changeset
8567 tick: function() {
jurzua
parents:
diff changeset
8568 for ( var timers = jQuery.timers, i = 0 ; i < timers.length ; ++i ) {
jurzua
parents:
diff changeset
8569 if ( !timers[i]() ) {
jurzua
parents:
diff changeset
8570 timers.splice(i--, 1);
jurzua
parents:
diff changeset
8571 }
jurzua
parents:
diff changeset
8572 }
jurzua
parents:
diff changeset
8573
jurzua
parents:
diff changeset
8574 if ( !timers.length ) {
jurzua
parents:
diff changeset
8575 jQuery.fx.stop();
jurzua
parents:
diff changeset
8576 }
jurzua
parents:
diff changeset
8577 },
jurzua
parents:
diff changeset
8578
jurzua
parents:
diff changeset
8579 interval: 13,
jurzua
parents:
diff changeset
8580
jurzua
parents:
diff changeset
8581 stop: function() {
jurzua
parents:
diff changeset
8582 clearInterval( timerId );
jurzua
parents:
diff changeset
8583 timerId = null;
jurzua
parents:
diff changeset
8584 },
jurzua
parents:
diff changeset
8585
jurzua
parents:
diff changeset
8586 speeds: {
jurzua
parents:
diff changeset
8587 slow: 600,
jurzua
parents:
diff changeset
8588 fast: 200,
jurzua
parents:
diff changeset
8589 // Default speed
jurzua
parents:
diff changeset
8590 _default: 400
jurzua
parents:
diff changeset
8591 },
jurzua
parents:
diff changeset
8592
jurzua
parents:
diff changeset
8593 step: {
jurzua
parents:
diff changeset
8594 opacity: function( fx ) {
jurzua
parents:
diff changeset
8595 jQuery.style( fx.elem, "opacity", fx.now );
jurzua
parents:
diff changeset
8596 },
jurzua
parents:
diff changeset
8597
jurzua
parents:
diff changeset
8598 _default: function( fx ) {
jurzua
parents:
diff changeset
8599 if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
jurzua
parents:
diff changeset
8600 fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
jurzua
parents:
diff changeset
8601 } else {
jurzua
parents:
diff changeset
8602 fx.elem[ fx.prop ] = fx.now;
jurzua
parents:
diff changeset
8603 }
jurzua
parents:
diff changeset
8604 }
jurzua
parents:
diff changeset
8605 }
jurzua
parents:
diff changeset
8606 });
jurzua
parents:
diff changeset
8607
jurzua
parents:
diff changeset
8608 if ( jQuery.expr && jQuery.expr.filters ) {
jurzua
parents:
diff changeset
8609 jQuery.expr.filters.animated = function( elem ) {
jurzua
parents:
diff changeset
8610 return jQuery.grep(jQuery.timers, function( fn ) {
jurzua
parents:
diff changeset
8611 return elem === fn.elem;
jurzua
parents:
diff changeset
8612 }).length;
jurzua
parents:
diff changeset
8613 };
jurzua
parents:
diff changeset
8614 }
jurzua
parents:
diff changeset
8615
jurzua
parents:
diff changeset
8616 // Try to restore the default display value of an element
jurzua
parents:
diff changeset
8617 function defaultDisplay( nodeName ) {
jurzua
parents:
diff changeset
8618
jurzua
parents:
diff changeset
8619 if ( !elemdisplay[ nodeName ] ) {
jurzua
parents:
diff changeset
8620
jurzua
parents:
diff changeset
8621 var body = document.body,
jurzua
parents:
diff changeset
8622 elem = jQuery( "<" + nodeName + ">" ).appendTo( body ),
jurzua
parents:
diff changeset
8623 display = elem.css( "display" );
jurzua
parents:
diff changeset
8624
jurzua
parents:
diff changeset
8625 elem.remove();
jurzua
parents:
diff changeset
8626
jurzua
parents:
diff changeset
8627 // If the simple way fails,
jurzua
parents:
diff changeset
8628 // get element's real default display by attaching it to a temp iframe
jurzua
parents:
diff changeset
8629 if ( display === "none" || display === "" ) {
jurzua
parents:
diff changeset
8630 // No iframe to use yet, so create it
jurzua
parents:
diff changeset
8631 if ( !iframe ) {
jurzua
parents:
diff changeset
8632 iframe = document.createElement( "iframe" );
jurzua
parents:
diff changeset
8633 iframe.frameBorder = iframe.width = iframe.height = 0;
jurzua
parents:
diff changeset
8634 }
jurzua
parents:
diff changeset
8635
jurzua
parents:
diff changeset
8636 body.appendChild( iframe );
jurzua
parents:
diff changeset
8637
jurzua
parents:
diff changeset
8638 // Create a cacheable copy of the iframe document on first call.
jurzua
parents:
diff changeset
8639 // IE and Opera will allow us to reuse the iframeDoc without re-writing the fake HTML
jurzua
parents:
diff changeset
8640 // document to it; WebKit & Firefox won't allow reusing the iframe document.
jurzua
parents:
diff changeset
8641 if ( !iframeDoc || !iframe.createElement ) {
jurzua
parents:
diff changeset
8642 iframeDoc = ( iframe.contentWindow || iframe.contentDocument ).document;
jurzua
parents:
diff changeset
8643 iframeDoc.write( ( document.compatMode === "CSS1Compat" ? "<!doctype html>" : "" ) + "<html><body>" );
jurzua
parents:
diff changeset
8644 iframeDoc.close();
jurzua
parents:
diff changeset
8645 }
jurzua
parents:
diff changeset
8646
jurzua
parents:
diff changeset
8647 elem = iframeDoc.createElement( nodeName );
jurzua
parents:
diff changeset
8648
jurzua
parents:
diff changeset
8649 iframeDoc.body.appendChild( elem );
jurzua
parents:
diff changeset
8650
jurzua
parents:
diff changeset
8651 display = jQuery.css( elem, "display" );
jurzua
parents:
diff changeset
8652
jurzua
parents:
diff changeset
8653 body.removeChild( iframe );
jurzua
parents:
diff changeset
8654 }
jurzua
parents:
diff changeset
8655
jurzua
parents:
diff changeset
8656 // Store the correct default display
jurzua
parents:
diff changeset
8657 elemdisplay[ nodeName ] = display;
jurzua
parents:
diff changeset
8658 }
jurzua
parents:
diff changeset
8659
jurzua
parents:
diff changeset
8660 return elemdisplay[ nodeName ];
jurzua
parents:
diff changeset
8661 }
jurzua
parents:
diff changeset
8662
jurzua
parents:
diff changeset
8663
jurzua
parents:
diff changeset
8664
jurzua
parents:
diff changeset
8665
jurzua
parents:
diff changeset
8666 var rtable = /^t(?:able|d|h)$/i,
jurzua
parents:
diff changeset
8667 rroot = /^(?:body|html)$/i;
jurzua
parents:
diff changeset
8668
jurzua
parents:
diff changeset
8669 if ( "getBoundingClientRect" in document.documentElement ) {
jurzua
parents:
diff changeset
8670 jQuery.fn.offset = function( options ) {
jurzua
parents:
diff changeset
8671 var elem = this[0], box;
jurzua
parents:
diff changeset
8672
jurzua
parents:
diff changeset
8673 if ( options ) {
jurzua
parents:
diff changeset
8674 return this.each(function( i ) {
jurzua
parents:
diff changeset
8675 jQuery.offset.setOffset( this, options, i );
jurzua
parents:
diff changeset
8676 });
jurzua
parents:
diff changeset
8677 }
jurzua
parents:
diff changeset
8678
jurzua
parents:
diff changeset
8679 if ( !elem || !elem.ownerDocument ) {
jurzua
parents:
diff changeset
8680 return null;
jurzua
parents:
diff changeset
8681 }
jurzua
parents:
diff changeset
8682
jurzua
parents:
diff changeset
8683 if ( elem === elem.ownerDocument.body ) {
jurzua
parents:
diff changeset
8684 return jQuery.offset.bodyOffset( elem );
jurzua
parents:
diff changeset
8685 }
jurzua
parents:
diff changeset
8686
jurzua
parents:
diff changeset
8687 try {
jurzua
parents:
diff changeset
8688 box = elem.getBoundingClientRect();
jurzua
parents:
diff changeset
8689 } catch(e) {}
jurzua
parents:
diff changeset
8690
jurzua
parents:
diff changeset
8691 var doc = elem.ownerDocument,
jurzua
parents:
diff changeset
8692 docElem = doc.documentElement;
jurzua
parents:
diff changeset
8693
jurzua
parents:
diff changeset
8694 // Make sure we're not dealing with a disconnected DOM node
jurzua
parents:
diff changeset
8695 if ( !box || !jQuery.contains( docElem, elem ) ) {
jurzua
parents:
diff changeset
8696 return box ? { top: box.top, left: box.left } : { top: 0, left: 0 };
jurzua
parents:
diff changeset
8697 }
jurzua
parents:
diff changeset
8698
jurzua
parents:
diff changeset
8699 var body = doc.body,
jurzua
parents:
diff changeset
8700 win = getWindow(doc),
jurzua
parents:
diff changeset
8701 clientTop = docElem.clientTop || body.clientTop || 0,
jurzua
parents:
diff changeset
8702 clientLeft = docElem.clientLeft || body.clientLeft || 0,
jurzua
parents:
diff changeset
8703 scrollTop = win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop || body.scrollTop,
jurzua
parents:
diff changeset
8704 scrollLeft = win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft,
jurzua
parents:
diff changeset
8705 top = box.top + scrollTop - clientTop,
jurzua
parents:
diff changeset
8706 left = box.left + scrollLeft - clientLeft;
jurzua
parents:
diff changeset
8707
jurzua
parents:
diff changeset
8708 return { top: top, left: left };
jurzua
parents:
diff changeset
8709 };
jurzua
parents:
diff changeset
8710
jurzua
parents:
diff changeset
8711 } else {
jurzua
parents:
diff changeset
8712 jQuery.fn.offset = function( options ) {
jurzua
parents:
diff changeset
8713 var elem = this[0];
jurzua
parents:
diff changeset
8714
jurzua
parents:
diff changeset
8715 if ( options ) {
jurzua
parents:
diff changeset
8716 return this.each(function( i ) {
jurzua
parents:
diff changeset
8717 jQuery.offset.setOffset( this, options, i );
jurzua
parents:
diff changeset
8718 });
jurzua
parents:
diff changeset
8719 }
jurzua
parents:
diff changeset
8720
jurzua
parents:
diff changeset
8721 if ( !elem || !elem.ownerDocument ) {
jurzua
parents:
diff changeset
8722 return null;
jurzua
parents:
diff changeset
8723 }
jurzua
parents:
diff changeset
8724
jurzua
parents:
diff changeset
8725 if ( elem === elem.ownerDocument.body ) {
jurzua
parents:
diff changeset
8726 return jQuery.offset.bodyOffset( elem );
jurzua
parents:
diff changeset
8727 }
jurzua
parents:
diff changeset
8728
jurzua
parents:
diff changeset
8729 jQuery.offset.initialize();
jurzua
parents:
diff changeset
8730
jurzua
parents:
diff changeset
8731 var computedStyle,
jurzua
parents:
diff changeset
8732 offsetParent = elem.offsetParent,
jurzua
parents:
diff changeset
8733 prevOffsetParent = elem,
jurzua
parents:
diff changeset
8734 doc = elem.ownerDocument,
jurzua
parents:
diff changeset
8735 docElem = doc.documentElement,
jurzua
parents:
diff changeset
8736 body = doc.body,
jurzua
parents:
diff changeset
8737 defaultView = doc.defaultView,
jurzua
parents:
diff changeset
8738 prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
jurzua
parents:
diff changeset
8739 top = elem.offsetTop,
jurzua
parents:
diff changeset
8740 left = elem.offsetLeft;
jurzua
parents:
diff changeset
8741
jurzua
parents:
diff changeset
8742 while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
jurzua
parents:
diff changeset
8743 if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
jurzua
parents:
diff changeset
8744 break;
jurzua
parents:
diff changeset
8745 }
jurzua
parents:
diff changeset
8746
jurzua
parents:
diff changeset
8747 computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
jurzua
parents:
diff changeset
8748 top -= elem.scrollTop;
jurzua
parents:
diff changeset
8749 left -= elem.scrollLeft;
jurzua
parents:
diff changeset
8750
jurzua
parents:
diff changeset
8751 if ( elem === offsetParent ) {
jurzua
parents:
diff changeset
8752 top += elem.offsetTop;
jurzua
parents:
diff changeset
8753 left += elem.offsetLeft;
jurzua
parents:
diff changeset
8754
jurzua
parents:
diff changeset
8755 if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
jurzua
parents:
diff changeset
8756 top += parseFloat( computedStyle.borderTopWidth ) || 0;
jurzua
parents:
diff changeset
8757 left += parseFloat( computedStyle.borderLeftWidth ) || 0;
jurzua
parents:
diff changeset
8758 }
jurzua
parents:
diff changeset
8759
jurzua
parents:
diff changeset
8760 prevOffsetParent = offsetParent;
jurzua
parents:
diff changeset
8761 offsetParent = elem.offsetParent;
jurzua
parents:
diff changeset
8762 }
jurzua
parents:
diff changeset
8763
jurzua
parents:
diff changeset
8764 if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
jurzua
parents:
diff changeset
8765 top += parseFloat( computedStyle.borderTopWidth ) || 0;
jurzua
parents:
diff changeset
8766 left += parseFloat( computedStyle.borderLeftWidth ) || 0;
jurzua
parents:
diff changeset
8767 }
jurzua
parents:
diff changeset
8768
jurzua
parents:
diff changeset
8769 prevComputedStyle = computedStyle;
jurzua
parents:
diff changeset
8770 }
jurzua
parents:
diff changeset
8771
jurzua
parents:
diff changeset
8772 if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
jurzua
parents:
diff changeset
8773 top += body.offsetTop;
jurzua
parents:
diff changeset
8774 left += body.offsetLeft;
jurzua
parents:
diff changeset
8775 }
jurzua
parents:
diff changeset
8776
jurzua
parents:
diff changeset
8777 if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
jurzua
parents:
diff changeset
8778 top += Math.max( docElem.scrollTop, body.scrollTop );
jurzua
parents:
diff changeset
8779 left += Math.max( docElem.scrollLeft, body.scrollLeft );
jurzua
parents:
diff changeset
8780 }
jurzua
parents:
diff changeset
8781
jurzua
parents:
diff changeset
8782 return { top: top, left: left };
jurzua
parents:
diff changeset
8783 };
jurzua
parents:
diff changeset
8784 }
jurzua
parents:
diff changeset
8785
jurzua
parents:
diff changeset
8786 jQuery.offset = {
jurzua
parents:
diff changeset
8787 initialize: function() {
jurzua
parents:
diff changeset
8788 var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.css(body, "marginTop") ) || 0,
jurzua
parents:
diff changeset
8789 html = "<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";
jurzua
parents:
diff changeset
8790
jurzua
parents:
diff changeset
8791 jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
jurzua
parents:
diff changeset
8792
jurzua
parents:
diff changeset
8793 container.innerHTML = html;
jurzua
parents:
diff changeset
8794 body.insertBefore( container, body.firstChild );
jurzua
parents:
diff changeset
8795 innerDiv = container.firstChild;
jurzua
parents:
diff changeset
8796 checkDiv = innerDiv.firstChild;
jurzua
parents:
diff changeset
8797 td = innerDiv.nextSibling.firstChild.firstChild;
jurzua
parents:
diff changeset
8798
jurzua
parents:
diff changeset
8799 this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
jurzua
parents:
diff changeset
8800 this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
jurzua
parents:
diff changeset
8801
jurzua
parents:
diff changeset
8802 checkDiv.style.position = "fixed";
jurzua
parents:
diff changeset
8803 checkDiv.style.top = "20px";
jurzua
parents:
diff changeset
8804
jurzua
parents:
diff changeset
8805 // safari subtracts parent border width here which is 5px
jurzua
parents:
diff changeset
8806 this.supportsFixedPosition = (checkDiv.offsetTop === 20 || checkDiv.offsetTop === 15);
jurzua
parents:
diff changeset
8807 checkDiv.style.position = checkDiv.style.top = "";
jurzua
parents:
diff changeset
8808
jurzua
parents:
diff changeset
8809 innerDiv.style.overflow = "hidden";
jurzua
parents:
diff changeset
8810 innerDiv.style.position = "relative";
jurzua
parents:
diff changeset
8811
jurzua
parents:
diff changeset
8812 this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
jurzua
parents:
diff changeset
8813
jurzua
parents:
diff changeset
8814 this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);
jurzua
parents:
diff changeset
8815
jurzua
parents:
diff changeset
8816 body.removeChild( container );
jurzua
parents:
diff changeset
8817 jQuery.offset.initialize = jQuery.noop;
jurzua
parents:
diff changeset
8818 },
jurzua
parents:
diff changeset
8819
jurzua
parents:
diff changeset
8820 bodyOffset: function( body ) {
jurzua
parents:
diff changeset
8821 var top = body.offsetTop,
jurzua
parents:
diff changeset
8822 left = body.offsetLeft;
jurzua
parents:
diff changeset
8823
jurzua
parents:
diff changeset
8824 jQuery.offset.initialize();
jurzua
parents:
diff changeset
8825
jurzua
parents:
diff changeset
8826 if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
jurzua
parents:
diff changeset
8827 top += parseFloat( jQuery.css(body, "marginTop") ) || 0;
jurzua
parents:
diff changeset
8828 left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
jurzua
parents:
diff changeset
8829 }
jurzua
parents:
diff changeset
8830
jurzua
parents:
diff changeset
8831 return { top: top, left: left };
jurzua
parents:
diff changeset
8832 },
jurzua
parents:
diff changeset
8833
jurzua
parents:
diff changeset
8834 setOffset: function( elem, options, i ) {
jurzua
parents:
diff changeset
8835 var position = jQuery.css( elem, "position" );
jurzua
parents:
diff changeset
8836
jurzua
parents:
diff changeset
8837 // set position first, in-case top/left are set even on static elem
jurzua
parents:
diff changeset
8838 if ( position === "static" ) {
jurzua
parents:
diff changeset
8839 elem.style.position = "relative";
jurzua
parents:
diff changeset
8840 }
jurzua
parents:
diff changeset
8841
jurzua
parents:
diff changeset
8842 var curElem = jQuery( elem ),
jurzua
parents:
diff changeset
8843 curOffset = curElem.offset(),
jurzua
parents:
diff changeset
8844 curCSSTop = jQuery.css( elem, "top" ),
jurzua
parents:
diff changeset
8845 curCSSLeft = jQuery.css( elem, "left" ),
jurzua
parents:
diff changeset
8846 calculatePosition = (position === "absolute" || position === "fixed") && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
jurzua
parents:
diff changeset
8847 props = {}, curPosition = {}, curTop, curLeft;
jurzua
parents:
diff changeset
8848
jurzua
parents:
diff changeset
8849 // need to be able to calculate position if either top or left is auto and position is either absolute or fixed
jurzua
parents:
diff changeset
8850 if ( calculatePosition ) {
jurzua
parents:
diff changeset
8851 curPosition = curElem.position();
jurzua
parents:
diff changeset
8852 curTop = curPosition.top;
jurzua
parents:
diff changeset
8853 curLeft = curPosition.left;
jurzua
parents:
diff changeset
8854 } else {
jurzua
parents:
diff changeset
8855 curTop = parseFloat( curCSSTop ) || 0;
jurzua
parents:
diff changeset
8856 curLeft = parseFloat( curCSSLeft ) || 0;
jurzua
parents:
diff changeset
8857 }
jurzua
parents:
diff changeset
8858
jurzua
parents:
diff changeset
8859 if ( jQuery.isFunction( options ) ) {
jurzua
parents:
diff changeset
8860 options = options.call( elem, i, curOffset );
jurzua
parents:
diff changeset
8861 }
jurzua
parents:
diff changeset
8862
jurzua
parents:
diff changeset
8863 if (options.top != null) {
jurzua
parents:
diff changeset
8864 props.top = (options.top - curOffset.top) + curTop;
jurzua
parents:
diff changeset
8865 }
jurzua
parents:
diff changeset
8866 if (options.left != null) {
jurzua
parents:
diff changeset
8867 props.left = (options.left - curOffset.left) + curLeft;
jurzua
parents:
diff changeset
8868 }
jurzua
parents:
diff changeset
8869
jurzua
parents:
diff changeset
8870 if ( "using" in options ) {
jurzua
parents:
diff changeset
8871 options.using.call( elem, props );
jurzua
parents:
diff changeset
8872 } else {
jurzua
parents:
diff changeset
8873 curElem.css( props );
jurzua
parents:
diff changeset
8874 }
jurzua
parents:
diff changeset
8875 }
jurzua
parents:
diff changeset
8876 };
jurzua
parents:
diff changeset
8877
jurzua
parents:
diff changeset
8878
jurzua
parents:
diff changeset
8879 jQuery.fn.extend({
jurzua
parents:
diff changeset
8880 position: function() {
jurzua
parents:
diff changeset
8881 if ( !this[0] ) {
jurzua
parents:
diff changeset
8882 return null;
jurzua
parents:
diff changeset
8883 }
jurzua
parents:
diff changeset
8884
jurzua
parents:
diff changeset
8885 var elem = this[0],
jurzua
parents:
diff changeset
8886
jurzua
parents:
diff changeset
8887 // Get *real* offsetParent
jurzua
parents:
diff changeset
8888 offsetParent = this.offsetParent(),
jurzua
parents:
diff changeset
8889
jurzua
parents:
diff changeset
8890 // Get correct offsets
jurzua
parents:
diff changeset
8891 offset = this.offset(),
jurzua
parents:
diff changeset
8892 parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
jurzua
parents:
diff changeset
8893
jurzua
parents:
diff changeset
8894 // Subtract element margins
jurzua
parents:
diff changeset
8895 // note: when an element has margin: auto the offsetLeft and marginLeft
jurzua
parents:
diff changeset
8896 // are the same in Safari causing offset.left to incorrectly be 0
jurzua
parents:
diff changeset
8897 offset.top -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
jurzua
parents:
diff changeset
8898 offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;
jurzua
parents:
diff changeset
8899
jurzua
parents:
diff changeset
8900 // Add offsetParent borders
jurzua
parents:
diff changeset
8901 parentOffset.top += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
jurzua
parents:
diff changeset
8902 parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;
jurzua
parents:
diff changeset
8903
jurzua
parents:
diff changeset
8904 // Subtract the two offsets
jurzua
parents:
diff changeset
8905 return {
jurzua
parents:
diff changeset
8906 top: offset.top - parentOffset.top,
jurzua
parents:
diff changeset
8907 left: offset.left - parentOffset.left
jurzua
parents:
diff changeset
8908 };
jurzua
parents:
diff changeset
8909 },
jurzua
parents:
diff changeset
8910
jurzua
parents:
diff changeset
8911 offsetParent: function() {
jurzua
parents:
diff changeset
8912 return this.map(function() {
jurzua
parents:
diff changeset
8913 var offsetParent = this.offsetParent || document.body;
jurzua
parents:
diff changeset
8914 while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
jurzua
parents:
diff changeset
8915 offsetParent = offsetParent.offsetParent;
jurzua
parents:
diff changeset
8916 }
jurzua
parents:
diff changeset
8917 return offsetParent;
jurzua
parents:
diff changeset
8918 });
jurzua
parents:
diff changeset
8919 }
jurzua
parents:
diff changeset
8920 });
jurzua
parents:
diff changeset
8921
jurzua
parents:
diff changeset
8922
jurzua
parents:
diff changeset
8923 // Create scrollLeft and scrollTop methods
jurzua
parents:
diff changeset
8924 jQuery.each( ["Left", "Top"], function( i, name ) {
jurzua
parents:
diff changeset
8925 var method = "scroll" + name;
jurzua
parents:
diff changeset
8926
jurzua
parents:
diff changeset
8927 jQuery.fn[ method ] = function( val ) {
jurzua
parents:
diff changeset
8928 var elem, win;
jurzua
parents:
diff changeset
8929
jurzua
parents:
diff changeset
8930 if ( val === undefined ) {
jurzua
parents:
diff changeset
8931 elem = this[ 0 ];
jurzua
parents:
diff changeset
8932
jurzua
parents:
diff changeset
8933 if ( !elem ) {
jurzua
parents:
diff changeset
8934 return null;
jurzua
parents:
diff changeset
8935 }
jurzua
parents:
diff changeset
8936
jurzua
parents:
diff changeset
8937 win = getWindow( elem );
jurzua
parents:
diff changeset
8938
jurzua
parents:
diff changeset
8939 // Return the scroll offset
jurzua
parents:
diff changeset
8940 return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
jurzua
parents:
diff changeset
8941 jQuery.support.boxModel && win.document.documentElement[ method ] ||
jurzua
parents:
diff changeset
8942 win.document.body[ method ] :
jurzua
parents:
diff changeset
8943 elem[ method ];
jurzua
parents:
diff changeset
8944 }
jurzua
parents:
diff changeset
8945
jurzua
parents:
diff changeset
8946 // Set the scroll offset
jurzua
parents:
diff changeset
8947 return this.each(function() {
jurzua
parents:
diff changeset
8948 win = getWindow( this );
jurzua
parents:
diff changeset
8949
jurzua
parents:
diff changeset
8950 if ( win ) {
jurzua
parents:
diff changeset
8951 win.scrollTo(
jurzua
parents:
diff changeset
8952 !i ? val : jQuery( win ).scrollLeft(),
jurzua
parents:
diff changeset
8953 i ? val : jQuery( win ).scrollTop()
jurzua
parents:
diff changeset
8954 );
jurzua
parents:
diff changeset
8955
jurzua
parents:
diff changeset
8956 } else {
jurzua
parents:
diff changeset
8957 this[ method ] = val;
jurzua
parents:
diff changeset
8958 }
jurzua
parents:
diff changeset
8959 });
jurzua
parents:
diff changeset
8960 };
jurzua
parents:
diff changeset
8961 });
jurzua
parents:
diff changeset
8962
jurzua
parents:
diff changeset
8963 function getWindow( elem ) {
jurzua
parents:
diff changeset
8964 return jQuery.isWindow( elem ) ?
jurzua
parents:
diff changeset
8965 elem :
jurzua
parents:
diff changeset
8966 elem.nodeType === 9 ?
jurzua
parents:
diff changeset
8967 elem.defaultView || elem.parentWindow :
jurzua
parents:
diff changeset
8968 false;
jurzua
parents:
diff changeset
8969 }
jurzua
parents:
diff changeset
8970
jurzua
parents:
diff changeset
8971
jurzua
parents:
diff changeset
8972
jurzua
parents:
diff changeset
8973
jurzua
parents:
diff changeset
8974 // Create width, height, innerHeight, innerWidth, outerHeight and outerWidth methods
jurzua
parents:
diff changeset
8975 jQuery.each([ "Height", "Width" ], function( i, name ) {
jurzua
parents:
diff changeset
8976
jurzua
parents:
diff changeset
8977 var type = name.toLowerCase();
jurzua
parents:
diff changeset
8978
jurzua
parents:
diff changeset
8979 // innerHeight and innerWidth
jurzua
parents:
diff changeset
8980 jQuery.fn[ "inner" + name ] = function() {
jurzua
parents:
diff changeset
8981 var elem = this[0];
jurzua
parents:
diff changeset
8982 return elem && elem.style ?
jurzua
parents:
diff changeset
8983 parseFloat( jQuery.css( elem, type, "padding" ) ) :
jurzua
parents:
diff changeset
8984 null;
jurzua
parents:
diff changeset
8985 };
jurzua
parents:
diff changeset
8986
jurzua
parents:
diff changeset
8987 // outerHeight and outerWidth
jurzua
parents:
diff changeset
8988 jQuery.fn[ "outer" + name ] = function( margin ) {
jurzua
parents:
diff changeset
8989 var elem = this[0];
jurzua
parents:
diff changeset
8990 return elem && elem.style ?
jurzua
parents:
diff changeset
8991 parseFloat( jQuery.css( elem, type, margin ? "margin" : "border" ) ) :
jurzua
parents:
diff changeset
8992 null;
jurzua
parents:
diff changeset
8993 };
jurzua
parents:
diff changeset
8994
jurzua
parents:
diff changeset
8995 jQuery.fn[ type ] = function( size ) {
jurzua
parents:
diff changeset
8996 // Get window width or height
jurzua
parents:
diff changeset
8997 var elem = this[0];
jurzua
parents:
diff changeset
8998 if ( !elem ) {
jurzua
parents:
diff changeset
8999 return size == null ? null : this;
jurzua
parents:
diff changeset
9000 }
jurzua
parents:
diff changeset
9001
jurzua
parents:
diff changeset
9002 if ( jQuery.isFunction( size ) ) {
jurzua
parents:
diff changeset
9003 return this.each(function( i ) {
jurzua
parents:
diff changeset
9004 var self = jQuery( this );
jurzua
parents:
diff changeset
9005 self[ type ]( size.call( this, i, self[ type ]() ) );
jurzua
parents:
diff changeset
9006 });
jurzua
parents:
diff changeset
9007 }
jurzua
parents:
diff changeset
9008
jurzua
parents:
diff changeset
9009 if ( jQuery.isWindow( elem ) ) {
jurzua
parents:
diff changeset
9010 // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
jurzua
parents:
diff changeset
9011 // 3rd condition allows Nokia support, as it supports the docElem prop but not CSS1Compat
jurzua
parents:
diff changeset
9012 var docElemProp = elem.document.documentElement[ "client" + name ],
jurzua
parents:
diff changeset
9013 body = elem.document.body;
jurzua
parents:
diff changeset
9014 return elem.document.compatMode === "CSS1Compat" && docElemProp ||
jurzua
parents:
diff changeset
9015 body && body[ "client" + name ] || docElemProp;
jurzua
parents:
diff changeset
9016
jurzua
parents:
diff changeset
9017 // Get document width or height
jurzua
parents:
diff changeset
9018 } else if ( elem.nodeType === 9 ) {
jurzua
parents:
diff changeset
9019 // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
jurzua
parents:
diff changeset
9020 return Math.max(
jurzua
parents:
diff changeset
9021 elem.documentElement["client" + name],
jurzua
parents:
diff changeset
9022 elem.body["scroll" + name], elem.documentElement["scroll" + name],
jurzua
parents:
diff changeset
9023 elem.body["offset" + name], elem.documentElement["offset" + name]
jurzua
parents:
diff changeset
9024 );
jurzua
parents:
diff changeset
9025
jurzua
parents:
diff changeset
9026 // Get or set width or height on the element
jurzua
parents:
diff changeset
9027 } else if ( size === undefined ) {
jurzua
parents:
diff changeset
9028 var orig = jQuery.css( elem, type ),
jurzua
parents:
diff changeset
9029 ret = parseFloat( orig );
jurzua
parents:
diff changeset
9030
jurzua
parents:
diff changeset
9031 return jQuery.isNaN( ret ) ? orig : ret;
jurzua
parents:
diff changeset
9032
jurzua
parents:
diff changeset
9033 // Set the width or height on the element (default to pixels if value is unitless)
jurzua
parents:
diff changeset
9034 } else {
jurzua
parents:
diff changeset
9035 return this.css( type, typeof size === "string" ? size : size + "px" );
jurzua
parents:
diff changeset
9036 }
jurzua
parents:
diff changeset
9037 };
jurzua
parents:
diff changeset
9038
jurzua
parents:
diff changeset
9039 });
jurzua
parents:
diff changeset
9040
jurzua
parents:
diff changeset
9041
jurzua
parents:
diff changeset
9042 // Expose jQuery to the global object
jurzua
parents:
diff changeset
9043 window.jQuery = window.$ = jQuery;
jurzua
parents:
diff changeset
9044 })(window);