annotate src/main/webapp/imageServer/resources/js/jquery-ui-1.10.4/tests/jquery-1.6.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
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: Mon May 2 13:50:00 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 // (both of which we optimize for)
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 // Keep a UserAgent string for use with jQuery.browser
jurzua
parents:
diff changeset
69 userAgent = navigator.userAgent,
jurzua
parents:
diff changeset
70
jurzua
parents:
diff changeset
71 // For matching the engine and version of the browser
jurzua
parents:
diff changeset
72 browserMatch,
jurzua
parents:
diff changeset
73
jurzua
parents:
diff changeset
74 // The deferred used on DOM ready
jurzua
parents:
diff changeset
75 readyList,
jurzua
parents:
diff changeset
76
jurzua
parents:
diff changeset
77 // The ready event handler
jurzua
parents:
diff changeset
78 DOMContentLoaded,
jurzua
parents:
diff changeset
79
jurzua
parents:
diff changeset
80 // Save a reference to some core methods
jurzua
parents:
diff changeset
81 toString = Object.prototype.toString,
jurzua
parents:
diff changeset
82 hasOwn = Object.prototype.hasOwnProperty,
jurzua
parents:
diff changeset
83 push = Array.prototype.push,
jurzua
parents:
diff changeset
84 slice = Array.prototype.slice,
jurzua
parents:
diff changeset
85 trim = String.prototype.trim,
jurzua
parents:
diff changeset
86 indexOf = Array.prototype.indexOf,
jurzua
parents:
diff changeset
87
jurzua
parents:
diff changeset
88 // [[Class]] -> type pairs
jurzua
parents:
diff changeset
89 class2type = {};
jurzua
parents:
diff changeset
90
jurzua
parents:
diff changeset
91 jQuery.fn = jQuery.prototype = {
jurzua
parents:
diff changeset
92 constructor: jQuery,
jurzua
parents:
diff changeset
93 init: function( selector, context, rootjQuery ) {
jurzua
parents:
diff changeset
94 var match, elem, ret, doc;
jurzua
parents:
diff changeset
95
jurzua
parents:
diff changeset
96 // Handle $(""), $(null), or $(undefined)
jurzua
parents:
diff changeset
97 if ( !selector ) {
jurzua
parents:
diff changeset
98 return this;
jurzua
parents:
diff changeset
99 }
jurzua
parents:
diff changeset
100
jurzua
parents:
diff changeset
101 // Handle $(DOMElement)
jurzua
parents:
diff changeset
102 if ( selector.nodeType ) {
jurzua
parents:
diff changeset
103 this.context = this[0] = selector;
jurzua
parents:
diff changeset
104 this.length = 1;
jurzua
parents:
diff changeset
105 return this;
jurzua
parents:
diff changeset
106 }
jurzua
parents:
diff changeset
107
jurzua
parents:
diff changeset
108 // The body element only exists once, optimize finding it
jurzua
parents:
diff changeset
109 if ( selector === "body" && !context && document.body ) {
jurzua
parents:
diff changeset
110 this.context = document;
jurzua
parents:
diff changeset
111 this[0] = document.body;
jurzua
parents:
diff changeset
112 this.selector = 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 // Handle HTML strings
jurzua
parents:
diff changeset
118 if ( typeof selector === "string" ) {
jurzua
parents:
diff changeset
119 // Are we dealing with HTML string or an ID?
jurzua
parents:
diff changeset
120 if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
jurzua
parents:
diff changeset
121 // Assume that strings that start and end with <> are HTML and skip the regex check
jurzua
parents:
diff changeset
122 match = [ null, selector, null ];
jurzua
parents:
diff changeset
123
jurzua
parents:
diff changeset
124 } else {
jurzua
parents:
diff changeset
125 match = quickExpr.exec( selector );
jurzua
parents:
diff changeset
126 }
jurzua
parents:
diff changeset
127
jurzua
parents:
diff changeset
128 // Verify a match, and that no context was specified for #id
jurzua
parents:
diff changeset
129 if ( match && (match[1] || !context) ) {
jurzua
parents:
diff changeset
130
jurzua
parents:
diff changeset
131 // HANDLE: $(html) -> $(array)
jurzua
parents:
diff changeset
132 if ( match[1] ) {
jurzua
parents:
diff changeset
133 context = context instanceof jQuery ? context[0] : context;
jurzua
parents:
diff changeset
134 doc = (context ? context.ownerDocument || context : document);
jurzua
parents:
diff changeset
135
jurzua
parents:
diff changeset
136 // If a single string is passed in and it's a single tag
jurzua
parents:
diff changeset
137 // just do a createElement and skip the rest
jurzua
parents:
diff changeset
138 ret = rsingleTag.exec( selector );
jurzua
parents:
diff changeset
139
jurzua
parents:
diff changeset
140 if ( ret ) {
jurzua
parents:
diff changeset
141 if ( jQuery.isPlainObject( context ) ) {
jurzua
parents:
diff changeset
142 selector = [ document.createElement( ret[1] ) ];
jurzua
parents:
diff changeset
143 jQuery.fn.attr.call( selector, context, true );
jurzua
parents:
diff changeset
144
jurzua
parents:
diff changeset
145 } else {
jurzua
parents:
diff changeset
146 selector = [ doc.createElement( ret[1] ) ];
jurzua
parents:
diff changeset
147 }
jurzua
parents:
diff changeset
148
jurzua
parents:
diff changeset
149 } else {
jurzua
parents:
diff changeset
150 ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
jurzua
parents:
diff changeset
151 selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
jurzua
parents:
diff changeset
152 }
jurzua
parents:
diff changeset
153
jurzua
parents:
diff changeset
154 return jQuery.merge( this, selector );
jurzua
parents:
diff changeset
155
jurzua
parents:
diff changeset
156 // HANDLE: $("#id")
jurzua
parents:
diff changeset
157 } else {
jurzua
parents:
diff changeset
158 elem = document.getElementById( match[2] );
jurzua
parents:
diff changeset
159
jurzua
parents:
diff changeset
160 // Check parentNode to catch when Blackberry 4.6 returns
jurzua
parents:
diff changeset
161 // nodes that are no longer in the document #6963
jurzua
parents:
diff changeset
162 if ( elem && elem.parentNode ) {
jurzua
parents:
diff changeset
163 // Handle the case where IE and Opera return items
jurzua
parents:
diff changeset
164 // by name instead of ID
jurzua
parents:
diff changeset
165 if ( elem.id !== match[2] ) {
jurzua
parents:
diff changeset
166 return rootjQuery.find( selector );
jurzua
parents:
diff changeset
167 }
jurzua
parents:
diff changeset
168
jurzua
parents:
diff changeset
169 // Otherwise, we inject the element directly into the jQuery object
jurzua
parents:
diff changeset
170 this.length = 1;
jurzua
parents:
diff changeset
171 this[0] = elem;
jurzua
parents:
diff changeset
172 }
jurzua
parents:
diff changeset
173
jurzua
parents:
diff changeset
174 this.context = document;
jurzua
parents:
diff changeset
175 this.selector = selector;
jurzua
parents:
diff changeset
176 return this;
jurzua
parents:
diff changeset
177 }
jurzua
parents:
diff changeset
178
jurzua
parents:
diff changeset
179 // HANDLE: $(expr, $(...))
jurzua
parents:
diff changeset
180 } else if ( !context || context.jquery ) {
jurzua
parents:
diff changeset
181 return (context || rootjQuery).find( selector );
jurzua
parents:
diff changeset
182
jurzua
parents:
diff changeset
183 // HANDLE: $(expr, context)
jurzua
parents:
diff changeset
184 // (which is just equivalent to: $(context).find(expr)
jurzua
parents:
diff changeset
185 } else {
jurzua
parents:
diff changeset
186 return this.constructor( context ).find( selector );
jurzua
parents:
diff changeset
187 }
jurzua
parents:
diff changeset
188
jurzua
parents:
diff changeset
189 // HANDLE: $(function)
jurzua
parents:
diff changeset
190 // Shortcut for document ready
jurzua
parents:
diff changeset
191 } else if ( jQuery.isFunction( selector ) ) {
jurzua
parents:
diff changeset
192 return rootjQuery.ready( selector );
jurzua
parents:
diff changeset
193 }
jurzua
parents:
diff changeset
194
jurzua
parents:
diff changeset
195 if (selector.selector !== undefined) {
jurzua
parents:
diff changeset
196 this.selector = selector.selector;
jurzua
parents:
diff changeset
197 this.context = selector.context;
jurzua
parents:
diff changeset
198 }
jurzua
parents:
diff changeset
199
jurzua
parents:
diff changeset
200 return jQuery.makeArray( selector, this );
jurzua
parents:
diff changeset
201 },
jurzua
parents:
diff changeset
202
jurzua
parents:
diff changeset
203 // Start with an empty selector
jurzua
parents:
diff changeset
204 selector: "",
jurzua
parents:
diff changeset
205
jurzua
parents:
diff changeset
206 // The current version of jQuery being used
jurzua
parents:
diff changeset
207 jquery: "1.6",
jurzua
parents:
diff changeset
208
jurzua
parents:
diff changeset
209 // The default length of a jQuery object is 0
jurzua
parents:
diff changeset
210 length: 0,
jurzua
parents:
diff changeset
211
jurzua
parents:
diff changeset
212 // The number of elements contained in the matched element set
jurzua
parents:
diff changeset
213 size: function() {
jurzua
parents:
diff changeset
214 return this.length;
jurzua
parents:
diff changeset
215 },
jurzua
parents:
diff changeset
216
jurzua
parents:
diff changeset
217 toArray: function() {
jurzua
parents:
diff changeset
218 return slice.call( this, 0 );
jurzua
parents:
diff changeset
219 },
jurzua
parents:
diff changeset
220
jurzua
parents:
diff changeset
221 // Get the Nth element in the matched element set OR
jurzua
parents:
diff changeset
222 // Get the whole matched element set as a clean array
jurzua
parents:
diff changeset
223 get: function( num ) {
jurzua
parents:
diff changeset
224 return num == null ?
jurzua
parents:
diff changeset
225
jurzua
parents:
diff changeset
226 // Return a 'clean' array
jurzua
parents:
diff changeset
227 this.toArray() :
jurzua
parents:
diff changeset
228
jurzua
parents:
diff changeset
229 // Return just the object
jurzua
parents:
diff changeset
230 ( num < 0 ? this[ this.length + num ] : this[ num ] );
jurzua
parents:
diff changeset
231 },
jurzua
parents:
diff changeset
232
jurzua
parents:
diff changeset
233 // Take an array of elements and push it onto the stack
jurzua
parents:
diff changeset
234 // (returning the new matched element set)
jurzua
parents:
diff changeset
235 pushStack: function( elems, name, selector ) {
jurzua
parents:
diff changeset
236 // Build a new jQuery matched element set
jurzua
parents:
diff changeset
237 var ret = this.constructor();
jurzua
parents:
diff changeset
238
jurzua
parents:
diff changeset
239 if ( jQuery.isArray( elems ) ) {
jurzua
parents:
diff changeset
240 push.apply( ret, elems );
jurzua
parents:
diff changeset
241
jurzua
parents:
diff changeset
242 } else {
jurzua
parents:
diff changeset
243 jQuery.merge( ret, elems );
jurzua
parents:
diff changeset
244 }
jurzua
parents:
diff changeset
245
jurzua
parents:
diff changeset
246 // Add the old object onto the stack (as a reference)
jurzua
parents:
diff changeset
247 ret.prevObject = this;
jurzua
parents:
diff changeset
248
jurzua
parents:
diff changeset
249 ret.context = this.context;
jurzua
parents:
diff changeset
250
jurzua
parents:
diff changeset
251 if ( name === "find" ) {
jurzua
parents:
diff changeset
252 ret.selector = this.selector + (this.selector ? " " : "") + selector;
jurzua
parents:
diff changeset
253 } else if ( name ) {
jurzua
parents:
diff changeset
254 ret.selector = this.selector + "." + name + "(" + selector + ")";
jurzua
parents:
diff changeset
255 }
jurzua
parents:
diff changeset
256
jurzua
parents:
diff changeset
257 // Return the newly-formed element set
jurzua
parents:
diff changeset
258 return ret;
jurzua
parents:
diff changeset
259 },
jurzua
parents:
diff changeset
260
jurzua
parents:
diff changeset
261 // Execute a callback for every element in the matched set.
jurzua
parents:
diff changeset
262 // (You can seed the arguments with an array of args, but this is
jurzua
parents:
diff changeset
263 // only used internally.)
jurzua
parents:
diff changeset
264 each: function( callback, args ) {
jurzua
parents:
diff changeset
265 return jQuery.each( this, callback, args );
jurzua
parents:
diff changeset
266 },
jurzua
parents:
diff changeset
267
jurzua
parents:
diff changeset
268 ready: function( fn ) {
jurzua
parents:
diff changeset
269 // Attach the listeners
jurzua
parents:
diff changeset
270 jQuery.bindReady();
jurzua
parents:
diff changeset
271
jurzua
parents:
diff changeset
272 // Add the callback
jurzua
parents:
diff changeset
273 readyList.done( fn );
jurzua
parents:
diff changeset
274
jurzua
parents:
diff changeset
275 return this;
jurzua
parents:
diff changeset
276 },
jurzua
parents:
diff changeset
277
jurzua
parents:
diff changeset
278 eq: function( i ) {
jurzua
parents:
diff changeset
279 return i === -1 ?
jurzua
parents:
diff changeset
280 this.slice( i ) :
jurzua
parents:
diff changeset
281 this.slice( i, +i + 1 );
jurzua
parents:
diff changeset
282 },
jurzua
parents:
diff changeset
283
jurzua
parents:
diff changeset
284 first: function() {
jurzua
parents:
diff changeset
285 return this.eq( 0 );
jurzua
parents:
diff changeset
286 },
jurzua
parents:
diff changeset
287
jurzua
parents:
diff changeset
288 last: function() {
jurzua
parents:
diff changeset
289 return this.eq( -1 );
jurzua
parents:
diff changeset
290 },
jurzua
parents:
diff changeset
291
jurzua
parents:
diff changeset
292 slice: function() {
jurzua
parents:
diff changeset
293 return this.pushStack( slice.apply( this, arguments ),
jurzua
parents:
diff changeset
294 "slice", slice.call(arguments).join(",") );
jurzua
parents:
diff changeset
295 },
jurzua
parents:
diff changeset
296
jurzua
parents:
diff changeset
297 map: function( callback ) {
jurzua
parents:
diff changeset
298 return this.pushStack( jQuery.map(this, function( elem, i ) {
jurzua
parents:
diff changeset
299 return callback.call( elem, i, elem );
jurzua
parents:
diff changeset
300 }));
jurzua
parents:
diff changeset
301 },
jurzua
parents:
diff changeset
302
jurzua
parents:
diff changeset
303 end: function() {
jurzua
parents:
diff changeset
304 return this.prevObject || this.constructor(null);
jurzua
parents:
diff changeset
305 },
jurzua
parents:
diff changeset
306
jurzua
parents:
diff changeset
307 // For internal use only.
jurzua
parents:
diff changeset
308 // Behaves like an Array's method, not like a jQuery method.
jurzua
parents:
diff changeset
309 push: push,
jurzua
parents:
diff changeset
310 sort: [].sort,
jurzua
parents:
diff changeset
311 splice: [].splice
jurzua
parents:
diff changeset
312 };
jurzua
parents:
diff changeset
313
jurzua
parents:
diff changeset
314 // Give the init function the jQuery prototype for later instantiation
jurzua
parents:
diff changeset
315 jQuery.fn.init.prototype = jQuery.fn;
jurzua
parents:
diff changeset
316
jurzua
parents:
diff changeset
317 jQuery.extend = jQuery.fn.extend = function() {
jurzua
parents:
diff changeset
318 var options, name, src, copy, copyIsArray, clone,
jurzua
parents:
diff changeset
319 target = arguments[0] || {},
jurzua
parents:
diff changeset
320 i = 1,
jurzua
parents:
diff changeset
321 length = arguments.length,
jurzua
parents:
diff changeset
322 deep = false;
jurzua
parents:
diff changeset
323
jurzua
parents:
diff changeset
324 // Handle a deep copy situation
jurzua
parents:
diff changeset
325 if ( typeof target === "boolean" ) {
jurzua
parents:
diff changeset
326 deep = target;
jurzua
parents:
diff changeset
327 target = arguments[1] || {};
jurzua
parents:
diff changeset
328 // skip the boolean and the target
jurzua
parents:
diff changeset
329 i = 2;
jurzua
parents:
diff changeset
330 }
jurzua
parents:
diff changeset
331
jurzua
parents:
diff changeset
332 // Handle case when target is a string or something (possible in deep copy)
jurzua
parents:
diff changeset
333 if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
jurzua
parents:
diff changeset
334 target = {};
jurzua
parents:
diff changeset
335 }
jurzua
parents:
diff changeset
336
jurzua
parents:
diff changeset
337 // extend jQuery itself if only one argument is passed
jurzua
parents:
diff changeset
338 if ( length === i ) {
jurzua
parents:
diff changeset
339 target = this;
jurzua
parents:
diff changeset
340 --i;
jurzua
parents:
diff changeset
341 }
jurzua
parents:
diff changeset
342
jurzua
parents:
diff changeset
343 for ( ; i < length; i++ ) {
jurzua
parents:
diff changeset
344 // Only deal with non-null/undefined values
jurzua
parents:
diff changeset
345 if ( (options = arguments[ i ]) != null ) {
jurzua
parents:
diff changeset
346 // Extend the base object
jurzua
parents:
diff changeset
347 for ( name in options ) {
jurzua
parents:
diff changeset
348 src = target[ name ];
jurzua
parents:
diff changeset
349 copy = options[ name ];
jurzua
parents:
diff changeset
350
jurzua
parents:
diff changeset
351 // Prevent never-ending loop
jurzua
parents:
diff changeset
352 if ( target === copy ) {
jurzua
parents:
diff changeset
353 continue;
jurzua
parents:
diff changeset
354 }
jurzua
parents:
diff changeset
355
jurzua
parents:
diff changeset
356 // Recurse if we're merging plain objects or arrays
jurzua
parents:
diff changeset
357 if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
jurzua
parents:
diff changeset
358 if ( copyIsArray ) {
jurzua
parents:
diff changeset
359 copyIsArray = false;
jurzua
parents:
diff changeset
360 clone = src && jQuery.isArray(src) ? src : [];
jurzua
parents:
diff changeset
361
jurzua
parents:
diff changeset
362 } else {
jurzua
parents:
diff changeset
363 clone = src && jQuery.isPlainObject(src) ? src : {};
jurzua
parents:
diff changeset
364 }
jurzua
parents:
diff changeset
365
jurzua
parents:
diff changeset
366 // Never move original objects, clone them
jurzua
parents:
diff changeset
367 target[ name ] = jQuery.extend( deep, clone, copy );
jurzua
parents:
diff changeset
368
jurzua
parents:
diff changeset
369 // Don't bring in undefined values
jurzua
parents:
diff changeset
370 } else if ( copy !== undefined ) {
jurzua
parents:
diff changeset
371 target[ name ] = copy;
jurzua
parents:
diff changeset
372 }
jurzua
parents:
diff changeset
373 }
jurzua
parents:
diff changeset
374 }
jurzua
parents:
diff changeset
375 }
jurzua
parents:
diff changeset
376
jurzua
parents:
diff changeset
377 // Return the modified object
jurzua
parents:
diff changeset
378 return target;
jurzua
parents:
diff changeset
379 };
jurzua
parents:
diff changeset
380
jurzua
parents:
diff changeset
381 jQuery.extend({
jurzua
parents:
diff changeset
382 noConflict: function( deep ) {
jurzua
parents:
diff changeset
383 if ( window.$ === jQuery ) {
jurzua
parents:
diff changeset
384 window.$ = _$;
jurzua
parents:
diff changeset
385 }
jurzua
parents:
diff changeset
386
jurzua
parents:
diff changeset
387 if ( deep && window.jQuery === jQuery ) {
jurzua
parents:
diff changeset
388 window.jQuery = _jQuery;
jurzua
parents:
diff changeset
389 }
jurzua
parents:
diff changeset
390
jurzua
parents:
diff changeset
391 return jQuery;
jurzua
parents:
diff changeset
392 },
jurzua
parents:
diff changeset
393
jurzua
parents:
diff changeset
394 // Is the DOM ready to be used? Set to true once it occurs.
jurzua
parents:
diff changeset
395 isReady: false,
jurzua
parents:
diff changeset
396
jurzua
parents:
diff changeset
397 // A counter to track how many items to wait for before
jurzua
parents:
diff changeset
398 // the ready event fires. See #6781
jurzua
parents:
diff changeset
399 readyWait: 1,
jurzua
parents:
diff changeset
400
jurzua
parents:
diff changeset
401 // Hold (or release) the ready event
jurzua
parents:
diff changeset
402 holdReady: function( hold ) {
jurzua
parents:
diff changeset
403 if ( hold ) {
jurzua
parents:
diff changeset
404 jQuery.readyWait++;
jurzua
parents:
diff changeset
405 } else {
jurzua
parents:
diff changeset
406 jQuery.ready( true );
jurzua
parents:
diff changeset
407 }
jurzua
parents:
diff changeset
408 },
jurzua
parents:
diff changeset
409
jurzua
parents:
diff changeset
410 // Handle when the DOM is ready
jurzua
parents:
diff changeset
411 ready: function( wait ) {
jurzua
parents:
diff changeset
412 // Either a released hold or an DOMready/load event and not yet ready
jurzua
parents:
diff changeset
413 if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
jurzua
parents:
diff changeset
414 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
jurzua
parents:
diff changeset
415 if ( !document.body ) {
jurzua
parents:
diff changeset
416 return setTimeout( jQuery.ready, 1 );
jurzua
parents:
diff changeset
417 }
jurzua
parents:
diff changeset
418
jurzua
parents:
diff changeset
419 // Remember that the DOM is ready
jurzua
parents:
diff changeset
420 jQuery.isReady = true;
jurzua
parents:
diff changeset
421
jurzua
parents:
diff changeset
422 // If a normal DOM Ready event fired, decrement, and wait if need be
jurzua
parents:
diff changeset
423 if ( wait !== true && --jQuery.readyWait > 0 ) {
jurzua
parents:
diff changeset
424 return;
jurzua
parents:
diff changeset
425 }
jurzua
parents:
diff changeset
426
jurzua
parents:
diff changeset
427 // If there are functions bound, to execute
jurzua
parents:
diff changeset
428 readyList.resolveWith( document, [ jQuery ] );
jurzua
parents:
diff changeset
429
jurzua
parents:
diff changeset
430 // Trigger any bound ready events
jurzua
parents:
diff changeset
431 if ( jQuery.fn.trigger ) {
jurzua
parents:
diff changeset
432 jQuery( document ).trigger( "ready" ).unbind( "ready" );
jurzua
parents:
diff changeset
433 }
jurzua
parents:
diff changeset
434 }
jurzua
parents:
diff changeset
435 },
jurzua
parents:
diff changeset
436
jurzua
parents:
diff changeset
437 bindReady: function() {
jurzua
parents:
diff changeset
438 if ( readyList ) {
jurzua
parents:
diff changeset
439 return;
jurzua
parents:
diff changeset
440 }
jurzua
parents:
diff changeset
441
jurzua
parents:
diff changeset
442 readyList = jQuery._Deferred();
jurzua
parents:
diff changeset
443
jurzua
parents:
diff changeset
444 // Catch cases where $(document).ready() is called after the
jurzua
parents:
diff changeset
445 // browser event has already occurred.
jurzua
parents:
diff changeset
446 if ( document.readyState === "complete" ) {
jurzua
parents:
diff changeset
447 // Handle it asynchronously to allow scripts the opportunity to delay ready
jurzua
parents:
diff changeset
448 return setTimeout( jQuery.ready, 1 );
jurzua
parents:
diff changeset
449 }
jurzua
parents:
diff changeset
450
jurzua
parents:
diff changeset
451 // Mozilla, Opera and webkit nightlies currently support this event
jurzua
parents:
diff changeset
452 if ( document.addEventListener ) {
jurzua
parents:
diff changeset
453 // Use the handy event callback
jurzua
parents:
diff changeset
454 document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
jurzua
parents:
diff changeset
455
jurzua
parents:
diff changeset
456 // A fallback to window.onload, that will always work
jurzua
parents:
diff changeset
457 window.addEventListener( "load", jQuery.ready, false );
jurzua
parents:
diff changeset
458
jurzua
parents:
diff changeset
459 // If IE event model is used
jurzua
parents:
diff changeset
460 } else if ( document.attachEvent ) {
jurzua
parents:
diff changeset
461 // ensure firing before onload,
jurzua
parents:
diff changeset
462 // maybe late but safe also for iframes
jurzua
parents:
diff changeset
463 document.attachEvent( "onreadystatechange", DOMContentLoaded );
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.attachEvent( "onload", jQuery.ready );
jurzua
parents:
diff changeset
467
jurzua
parents:
diff changeset
468 // If IE and not a frame
jurzua
parents:
diff changeset
469 // continually check to see if the document is ready
jurzua
parents:
diff changeset
470 var toplevel = false;
jurzua
parents:
diff changeset
471
jurzua
parents:
diff changeset
472 try {
jurzua
parents:
diff changeset
473 toplevel = window.frameElement == null;
jurzua
parents:
diff changeset
474 } catch(e) {}
jurzua
parents:
diff changeset
475
jurzua
parents:
diff changeset
476 if ( document.documentElement.doScroll && toplevel ) {
jurzua
parents:
diff changeset
477 doScrollCheck();
jurzua
parents:
diff changeset
478 }
jurzua
parents:
diff changeset
479 }
jurzua
parents:
diff changeset
480 },
jurzua
parents:
diff changeset
481
jurzua
parents:
diff changeset
482 // See test/unit/core.js for details concerning isFunction.
jurzua
parents:
diff changeset
483 // Since version 1.3, DOM methods and functions like alert
jurzua
parents:
diff changeset
484 // aren't supported. They return false on IE (#2968).
jurzua
parents:
diff changeset
485 isFunction: function( obj ) {
jurzua
parents:
diff changeset
486 return jQuery.type(obj) === "function";
jurzua
parents:
diff changeset
487 },
jurzua
parents:
diff changeset
488
jurzua
parents:
diff changeset
489 isArray: Array.isArray || function( obj ) {
jurzua
parents:
diff changeset
490 return jQuery.type(obj) === "array";
jurzua
parents:
diff changeset
491 },
jurzua
parents:
diff changeset
492
jurzua
parents:
diff changeset
493 // A crude way of determining if an object is a window
jurzua
parents:
diff changeset
494 isWindow: function( obj ) {
jurzua
parents:
diff changeset
495 return obj && typeof obj === "object" && "setInterval" in obj;
jurzua
parents:
diff changeset
496 },
jurzua
parents:
diff changeset
497
jurzua
parents:
diff changeset
498 isNaN: function( obj ) {
jurzua
parents:
diff changeset
499 return obj == null || !rdigit.test( obj ) || isNaN( obj );
jurzua
parents:
diff changeset
500 },
jurzua
parents:
diff changeset
501
jurzua
parents:
diff changeset
502 type: function( obj ) {
jurzua
parents:
diff changeset
503 return obj == null ?
jurzua
parents:
diff changeset
504 String( obj ) :
jurzua
parents:
diff changeset
505 class2type[ toString.call(obj) ] || "object";
jurzua
parents:
diff changeset
506 },
jurzua
parents:
diff changeset
507
jurzua
parents:
diff changeset
508 isPlainObject: function( obj ) {
jurzua
parents:
diff changeset
509 // Must be an Object.
jurzua
parents:
diff changeset
510 // Because of IE, we also have to check the presence of the constructor property.
jurzua
parents:
diff changeset
511 // Make sure that DOM nodes and window objects don't pass through, as well
jurzua
parents:
diff changeset
512 if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
jurzua
parents:
diff changeset
513 return false;
jurzua
parents:
diff changeset
514 }
jurzua
parents:
diff changeset
515
jurzua
parents:
diff changeset
516 // Not own constructor property must be Object
jurzua
parents:
diff changeset
517 if ( obj.constructor &&
jurzua
parents:
diff changeset
518 !hasOwn.call(obj, "constructor") &&
jurzua
parents:
diff changeset
519 !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
jurzua
parents:
diff changeset
520 return false;
jurzua
parents:
diff changeset
521 }
jurzua
parents:
diff changeset
522
jurzua
parents:
diff changeset
523 // Own properties are enumerated firstly, so to speed up,
jurzua
parents:
diff changeset
524 // if last one is own, then all properties are own.
jurzua
parents:
diff changeset
525
jurzua
parents:
diff changeset
526 var key;
jurzua
parents:
diff changeset
527 for ( key in obj ) {}
jurzua
parents:
diff changeset
528
jurzua
parents:
diff changeset
529 return key === undefined || hasOwn.call( obj, key );
jurzua
parents:
diff changeset
530 },
jurzua
parents:
diff changeset
531
jurzua
parents:
diff changeset
532 isEmptyObject: function( obj ) {
jurzua
parents:
diff changeset
533 for ( var name in obj ) {
jurzua
parents:
diff changeset
534 return false;
jurzua
parents:
diff changeset
535 }
jurzua
parents:
diff changeset
536 return true;
jurzua
parents:
diff changeset
537 },
jurzua
parents:
diff changeset
538
jurzua
parents:
diff changeset
539 error: function( msg ) {
jurzua
parents:
diff changeset
540 throw msg;
jurzua
parents:
diff changeset
541 },
jurzua
parents:
diff changeset
542
jurzua
parents:
diff changeset
543 parseJSON: function( data ) {
jurzua
parents:
diff changeset
544 if ( typeof data !== "string" || !data ) {
jurzua
parents:
diff changeset
545 return null;
jurzua
parents:
diff changeset
546 }
jurzua
parents:
diff changeset
547
jurzua
parents:
diff changeset
548 // Make sure leading/trailing whitespace is removed (IE can't handle it)
jurzua
parents:
diff changeset
549 data = jQuery.trim( data );
jurzua
parents:
diff changeset
550
jurzua
parents:
diff changeset
551 // Attempt to parse using the native JSON parser first
jurzua
parents:
diff changeset
552 if ( window.JSON && window.JSON.parse ) {
jurzua
parents:
diff changeset
553 return window.JSON.parse( data );
jurzua
parents:
diff changeset
554 }
jurzua
parents:
diff changeset
555
jurzua
parents:
diff changeset
556 // Make sure the incoming data is actual JSON
jurzua
parents:
diff changeset
557 // Logic borrowed from http://json.org/json2.js
jurzua
parents:
diff changeset
558 if ( rvalidchars.test( data.replace( rvalidescape, "@" )
jurzua
parents:
diff changeset
559 .replace( rvalidtokens, "]" )
jurzua
parents:
diff changeset
560 .replace( rvalidbraces, "")) ) {
jurzua
parents:
diff changeset
561
jurzua
parents:
diff changeset
562 return (new Function( "return " + data ))();
jurzua
parents:
diff changeset
563
jurzua
parents:
diff changeset
564 }
jurzua
parents:
diff changeset
565 jQuery.error( "Invalid JSON: " + data );
jurzua
parents:
diff changeset
566 },
jurzua
parents:
diff changeset
567
jurzua
parents:
diff changeset
568 // Cross-browser xml parsing
jurzua
parents:
diff changeset
569 // (xml & tmp used internally)
jurzua
parents:
diff changeset
570 parseXML: function( data , xml , tmp ) {
jurzua
parents:
diff changeset
571
jurzua
parents:
diff changeset
572 if ( window.DOMParser ) { // Standard
jurzua
parents:
diff changeset
573 tmp = new DOMParser();
jurzua
parents:
diff changeset
574 xml = tmp.parseFromString( data , "text/xml" );
jurzua
parents:
diff changeset
575 } else { // IE
jurzua
parents:
diff changeset
576 xml = new ActiveXObject( "Microsoft.XMLDOM" );
jurzua
parents:
diff changeset
577 xml.async = "false";
jurzua
parents:
diff changeset
578 xml.loadXML( data );
jurzua
parents:
diff changeset
579 }
jurzua
parents:
diff changeset
580
jurzua
parents:
diff changeset
581 tmp = xml.documentElement;
jurzua
parents:
diff changeset
582
jurzua
parents:
diff changeset
583 if ( ! tmp || ! tmp.nodeName || tmp.nodeName === "parsererror" ) {
jurzua
parents:
diff changeset
584 jQuery.error( "Invalid XML: " + data );
jurzua
parents:
diff changeset
585 }
jurzua
parents:
diff changeset
586
jurzua
parents:
diff changeset
587 return xml;
jurzua
parents:
diff changeset
588 },
jurzua
parents:
diff changeset
589
jurzua
parents:
diff changeset
590 noop: function() {},
jurzua
parents:
diff changeset
591
jurzua
parents:
diff changeset
592 // Evaluates a script in a global context
jurzua
parents:
diff changeset
593 // Workarounds based on findings by Jim Driscoll
jurzua
parents:
diff changeset
594 // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
jurzua
parents:
diff changeset
595 globalEval: function( data ) {
jurzua
parents:
diff changeset
596 if ( data && rnotwhite.test( data ) ) {
jurzua
parents:
diff changeset
597 // We use execScript on Internet Explorer
jurzua
parents:
diff changeset
598 // We use an anonymous function so that context is window
jurzua
parents:
diff changeset
599 // rather than jQuery in Firefox
jurzua
parents:
diff changeset
600 ( window.execScript || function( data ) {
jurzua
parents:
diff changeset
601 window[ "eval" ].call( window, data );
jurzua
parents:
diff changeset
602 } )( data );
jurzua
parents:
diff changeset
603 }
jurzua
parents:
diff changeset
604 },
jurzua
parents:
diff changeset
605
jurzua
parents:
diff changeset
606 nodeName: function( elem, name ) {
jurzua
parents:
diff changeset
607 return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
jurzua
parents:
diff changeset
608 },
jurzua
parents:
diff changeset
609
jurzua
parents:
diff changeset
610 // args is for internal usage only
jurzua
parents:
diff changeset
611 each: function( object, callback, args ) {
jurzua
parents:
diff changeset
612 var name, i = 0,
jurzua
parents:
diff changeset
613 length = object.length,
jurzua
parents:
diff changeset
614 isObj = length === undefined || jQuery.isFunction( object );
jurzua
parents:
diff changeset
615
jurzua
parents:
diff changeset
616 if ( args ) {
jurzua
parents:
diff changeset
617 if ( isObj ) {
jurzua
parents:
diff changeset
618 for ( name in object ) {
jurzua
parents:
diff changeset
619 if ( callback.apply( object[ name ], args ) === false ) {
jurzua
parents:
diff changeset
620 break;
jurzua
parents:
diff changeset
621 }
jurzua
parents:
diff changeset
622 }
jurzua
parents:
diff changeset
623 } else {
jurzua
parents:
diff changeset
624 for ( ; i < length; ) {
jurzua
parents:
diff changeset
625 if ( callback.apply( object[ i++ ], args ) === false ) {
jurzua
parents:
diff changeset
626 break;
jurzua
parents:
diff changeset
627 }
jurzua
parents:
diff changeset
628 }
jurzua
parents:
diff changeset
629 }
jurzua
parents:
diff changeset
630
jurzua
parents:
diff changeset
631 // A special, fast, case for the most common use of each
jurzua
parents:
diff changeset
632 } else {
jurzua
parents:
diff changeset
633 if ( isObj ) {
jurzua
parents:
diff changeset
634 for ( name in object ) {
jurzua
parents:
diff changeset
635 if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
jurzua
parents:
diff changeset
636 break;
jurzua
parents:
diff changeset
637 }
jurzua
parents:
diff changeset
638 }
jurzua
parents:
diff changeset
639 } else {
jurzua
parents:
diff changeset
640 for ( ; i < length; ) {
jurzua
parents:
diff changeset
641 if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
jurzua
parents:
diff changeset
642 break;
jurzua
parents:
diff changeset
643 }
jurzua
parents:
diff changeset
644 }
jurzua
parents:
diff changeset
645 }
jurzua
parents:
diff changeset
646 }
jurzua
parents:
diff changeset
647
jurzua
parents:
diff changeset
648 return object;
jurzua
parents:
diff changeset
649 },
jurzua
parents:
diff changeset
650
jurzua
parents:
diff changeset
651 // Use native String.trim function wherever possible
jurzua
parents:
diff changeset
652 trim: trim ?
jurzua
parents:
diff changeset
653 function( text ) {
jurzua
parents:
diff changeset
654 return text == null ?
jurzua
parents:
diff changeset
655 "" :
jurzua
parents:
diff changeset
656 trim.call( text );
jurzua
parents:
diff changeset
657 } :
jurzua
parents:
diff changeset
658
jurzua
parents:
diff changeset
659 // Otherwise use our own trimming functionality
jurzua
parents:
diff changeset
660 function( text ) {
jurzua
parents:
diff changeset
661 return text == null ?
jurzua
parents:
diff changeset
662 "" :
jurzua
parents:
diff changeset
663 text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
jurzua
parents:
diff changeset
664 },
jurzua
parents:
diff changeset
665
jurzua
parents:
diff changeset
666 // results is for internal usage only
jurzua
parents:
diff changeset
667 makeArray: function( array, results ) {
jurzua
parents:
diff changeset
668 var ret = results || [];
jurzua
parents:
diff changeset
669
jurzua
parents:
diff changeset
670 if ( array != null ) {
jurzua
parents:
diff changeset
671 // The window, strings (and functions) also have 'length'
jurzua
parents:
diff changeset
672 // The extra typeof function check is to prevent crashes
jurzua
parents:
diff changeset
673 // in Safari 2 (See: #3039)
jurzua
parents:
diff changeset
674 // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
jurzua
parents:
diff changeset
675 var type = jQuery.type( array );
jurzua
parents:
diff changeset
676
jurzua
parents:
diff changeset
677 if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
jurzua
parents:
diff changeset
678 push.call( ret, array );
jurzua
parents:
diff changeset
679 } else {
jurzua
parents:
diff changeset
680 jQuery.merge( ret, array );
jurzua
parents:
diff changeset
681 }
jurzua
parents:
diff changeset
682 }
jurzua
parents:
diff changeset
683
jurzua
parents:
diff changeset
684 return ret;
jurzua
parents:
diff changeset
685 },
jurzua
parents:
diff changeset
686
jurzua
parents:
diff changeset
687 inArray: function( elem, array ) {
jurzua
parents:
diff changeset
688
jurzua
parents:
diff changeset
689 if ( indexOf ) {
jurzua
parents:
diff changeset
690 return indexOf.call( array, elem );
jurzua
parents:
diff changeset
691 }
jurzua
parents:
diff changeset
692
jurzua
parents:
diff changeset
693 for ( var i = 0, length = array.length; i < length; i++ ) {
jurzua
parents:
diff changeset
694 if ( array[ i ] === elem ) {
jurzua
parents:
diff changeset
695 return i;
jurzua
parents:
diff changeset
696 }
jurzua
parents:
diff changeset
697 }
jurzua
parents:
diff changeset
698
jurzua
parents:
diff changeset
699 return -1;
jurzua
parents:
diff changeset
700 },
jurzua
parents:
diff changeset
701
jurzua
parents:
diff changeset
702 merge: function( first, second ) {
jurzua
parents:
diff changeset
703 var i = first.length,
jurzua
parents:
diff changeset
704 j = 0;
jurzua
parents:
diff changeset
705
jurzua
parents:
diff changeset
706 if ( typeof second.length === "number" ) {
jurzua
parents:
diff changeset
707 for ( var l = second.length; j < l; j++ ) {
jurzua
parents:
diff changeset
708 first[ i++ ] = second[ j ];
jurzua
parents:
diff changeset
709 }
jurzua
parents:
diff changeset
710
jurzua
parents:
diff changeset
711 } else {
jurzua
parents:
diff changeset
712 while ( second[j] !== undefined ) {
jurzua
parents:
diff changeset
713 first[ i++ ] = second[ j++ ];
jurzua
parents:
diff changeset
714 }
jurzua
parents:
diff changeset
715 }
jurzua
parents:
diff changeset
716
jurzua
parents:
diff changeset
717 first.length = i;
jurzua
parents:
diff changeset
718
jurzua
parents:
diff changeset
719 return first;
jurzua
parents:
diff changeset
720 },
jurzua
parents:
diff changeset
721
jurzua
parents:
diff changeset
722 grep: function( elems, callback, inv ) {
jurzua
parents:
diff changeset
723 var ret = [], retVal;
jurzua
parents:
diff changeset
724 inv = !!inv;
jurzua
parents:
diff changeset
725
jurzua
parents:
diff changeset
726 // Go through the array, only saving the items
jurzua
parents:
diff changeset
727 // that pass the validator function
jurzua
parents:
diff changeset
728 for ( var i = 0, length = elems.length; i < length; i++ ) {
jurzua
parents:
diff changeset
729 retVal = !!callback( elems[ i ], i );
jurzua
parents:
diff changeset
730 if ( inv !== retVal ) {
jurzua
parents:
diff changeset
731 ret.push( elems[ i ] );
jurzua
parents:
diff changeset
732 }
jurzua
parents:
diff changeset
733 }
jurzua
parents:
diff changeset
734
jurzua
parents:
diff changeset
735 return ret;
jurzua
parents:
diff changeset
736 },
jurzua
parents:
diff changeset
737
jurzua
parents:
diff changeset
738 // arg is for internal usage only
jurzua
parents:
diff changeset
739 map: function( elems, callback, arg ) {
jurzua
parents:
diff changeset
740 var value, key, ret = [],
jurzua
parents:
diff changeset
741 i = 0,
jurzua
parents:
diff changeset
742 length = elems.length,
jurzua
parents:
diff changeset
743 // jquery objects are treated as arrays
jurzua
parents:
diff changeset
744 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
745
jurzua
parents:
diff changeset
746 // Go through the array, translating each of the items to their
jurzua
parents:
diff changeset
747 if ( isArray ) {
jurzua
parents:
diff changeset
748 for ( ; i < length; i++ ) {
jurzua
parents:
diff changeset
749 value = callback( elems[ i ], i, arg );
jurzua
parents:
diff changeset
750
jurzua
parents:
diff changeset
751 if ( value != null ) {
jurzua
parents:
diff changeset
752 ret[ ret.length ] = value;
jurzua
parents:
diff changeset
753 }
jurzua
parents:
diff changeset
754 }
jurzua
parents:
diff changeset
755
jurzua
parents:
diff changeset
756 // Go through every key on the object,
jurzua
parents:
diff changeset
757 } else {
jurzua
parents:
diff changeset
758 for ( key in elems ) {
jurzua
parents:
diff changeset
759 value = callback( elems[ key ], key, arg );
jurzua
parents:
diff changeset
760
jurzua
parents:
diff changeset
761 if ( value != null ) {
jurzua
parents:
diff changeset
762 ret[ ret.length ] = value;
jurzua
parents:
diff changeset
763 }
jurzua
parents:
diff changeset
764 }
jurzua
parents:
diff changeset
765 }
jurzua
parents:
diff changeset
766
jurzua
parents:
diff changeset
767 // Flatten any nested arrays
jurzua
parents:
diff changeset
768 return ret.concat.apply( [], ret );
jurzua
parents:
diff changeset
769 },
jurzua
parents:
diff changeset
770
jurzua
parents:
diff changeset
771 // A global GUID counter for objects
jurzua
parents:
diff changeset
772 guid: 1,
jurzua
parents:
diff changeset
773
jurzua
parents:
diff changeset
774 // Bind a function to a context, optionally partially applying any
jurzua
parents:
diff changeset
775 // arguments.
jurzua
parents:
diff changeset
776 proxy: function( fn, context ) {
jurzua
parents:
diff changeset
777 if ( typeof context === "string" ) {
jurzua
parents:
diff changeset
778 var tmp = fn[ context ];
jurzua
parents:
diff changeset
779 context = fn;
jurzua
parents:
diff changeset
780 fn = tmp;
jurzua
parents:
diff changeset
781 }
jurzua
parents:
diff changeset
782
jurzua
parents:
diff changeset
783 // Quick check to determine if target is callable, in the spec
jurzua
parents:
diff changeset
784 // this throws a TypeError, but we will just return undefined.
jurzua
parents:
diff changeset
785 if ( !jQuery.isFunction( fn ) ) {
jurzua
parents:
diff changeset
786 return undefined;
jurzua
parents:
diff changeset
787 }
jurzua
parents:
diff changeset
788
jurzua
parents:
diff changeset
789 // Simulated bind
jurzua
parents:
diff changeset
790 var args = slice.call( arguments, 2 ),
jurzua
parents:
diff changeset
791 proxy = function() {
jurzua
parents:
diff changeset
792 return fn.apply( context, args.concat( slice.call( arguments ) ) );
jurzua
parents:
diff changeset
793 };
jurzua
parents:
diff changeset
794
jurzua
parents:
diff changeset
795 // Set the guid of unique handler to the same of original handler, so it can be removed
jurzua
parents:
diff changeset
796 proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
jurzua
parents:
diff changeset
797
jurzua
parents:
diff changeset
798 return proxy;
jurzua
parents:
diff changeset
799 },
jurzua
parents:
diff changeset
800
jurzua
parents:
diff changeset
801 // Mutifunctional method to get and set values to a collection
jurzua
parents:
diff changeset
802 // The value/s can be optionally by executed if its a function
jurzua
parents:
diff changeset
803 access: function( elems, key, value, exec, fn, pass ) {
jurzua
parents:
diff changeset
804 var length = elems.length;
jurzua
parents:
diff changeset
805
jurzua
parents:
diff changeset
806 // Setting many attributes
jurzua
parents:
diff changeset
807 if ( typeof key === "object" ) {
jurzua
parents:
diff changeset
808 for ( var k in key ) {
jurzua
parents:
diff changeset
809 jQuery.access( elems, k, key[k], exec, fn, value );
jurzua
parents:
diff changeset
810 }
jurzua
parents:
diff changeset
811 return elems;
jurzua
parents:
diff changeset
812 }
jurzua
parents:
diff changeset
813
jurzua
parents:
diff changeset
814 // Setting one attribute
jurzua
parents:
diff changeset
815 if ( value !== undefined ) {
jurzua
parents:
diff changeset
816 // Optionally, function values get executed if exec is true
jurzua
parents:
diff changeset
817 exec = !pass && exec && jQuery.isFunction(value);
jurzua
parents:
diff changeset
818
jurzua
parents:
diff changeset
819 for ( var i = 0; i < length; i++ ) {
jurzua
parents:
diff changeset
820 fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
jurzua
parents:
diff changeset
821 }
jurzua
parents:
diff changeset
822
jurzua
parents:
diff changeset
823 return elems;
jurzua
parents:
diff changeset
824 }
jurzua
parents:
diff changeset
825
jurzua
parents:
diff changeset
826 // Getting an attribute
jurzua
parents:
diff changeset
827 return length ? fn( elems[0], key ) : undefined;
jurzua
parents:
diff changeset
828 },
jurzua
parents:
diff changeset
829
jurzua
parents:
diff changeset
830 now: function() {
jurzua
parents:
diff changeset
831 return (new Date()).getTime();
jurzua
parents:
diff changeset
832 },
jurzua
parents:
diff changeset
833
jurzua
parents:
diff changeset
834 // Use of jQuery.browser is frowned upon.
jurzua
parents:
diff changeset
835 // More details: http://docs.jquery.com/Utilities/jQuery.browser
jurzua
parents:
diff changeset
836 uaMatch: function( ua ) {
jurzua
parents:
diff changeset
837 ua = ua.toLowerCase();
jurzua
parents:
diff changeset
838
jurzua
parents:
diff changeset
839 var match = rwebkit.exec( ua ) ||
jurzua
parents:
diff changeset
840 ropera.exec( ua ) ||
jurzua
parents:
diff changeset
841 rmsie.exec( ua ) ||
jurzua
parents:
diff changeset
842 ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
jurzua
parents:
diff changeset
843 [];
jurzua
parents:
diff changeset
844
jurzua
parents:
diff changeset
845 return { browser: match[1] || "", version: match[2] || "0" };
jurzua
parents:
diff changeset
846 },
jurzua
parents:
diff changeset
847
jurzua
parents:
diff changeset
848 sub: function() {
jurzua
parents:
diff changeset
849 function jQuerySub( selector, context ) {
jurzua
parents:
diff changeset
850 return new jQuerySub.fn.init( selector, context );
jurzua
parents:
diff changeset
851 }
jurzua
parents:
diff changeset
852 jQuery.extend( true, jQuerySub, this );
jurzua
parents:
diff changeset
853 jQuerySub.superclass = this;
jurzua
parents:
diff changeset
854 jQuerySub.fn = jQuerySub.prototype = this();
jurzua
parents:
diff changeset
855 jQuerySub.fn.constructor = jQuerySub;
jurzua
parents:
diff changeset
856 jQuerySub.sub = this.sub;
jurzua
parents:
diff changeset
857 jQuerySub.fn.init = function init( selector, context ) {
jurzua
parents:
diff changeset
858 if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
jurzua
parents:
diff changeset
859 context = jQuerySub( context );
jurzua
parents:
diff changeset
860 }
jurzua
parents:
diff changeset
861
jurzua
parents:
diff changeset
862 return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
jurzua
parents:
diff changeset
863 };
jurzua
parents:
diff changeset
864 jQuerySub.fn.init.prototype = jQuerySub.fn;
jurzua
parents:
diff changeset
865 var rootjQuerySub = jQuerySub(document);
jurzua
parents:
diff changeset
866 return jQuerySub;
jurzua
parents:
diff changeset
867 },
jurzua
parents:
diff changeset
868
jurzua
parents:
diff changeset
869 browser: {}
jurzua
parents:
diff changeset
870 });
jurzua
parents:
diff changeset
871
jurzua
parents:
diff changeset
872 // Populate the class2type map
jurzua
parents:
diff changeset
873 jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
jurzua
parents:
diff changeset
874 class2type[ "[object " + name + "]" ] = name.toLowerCase();
jurzua
parents:
diff changeset
875 });
jurzua
parents:
diff changeset
876
jurzua
parents:
diff changeset
877 browserMatch = jQuery.uaMatch( userAgent );
jurzua
parents:
diff changeset
878 if ( browserMatch.browser ) {
jurzua
parents:
diff changeset
879 jQuery.browser[ browserMatch.browser ] = true;
jurzua
parents:
diff changeset
880 jQuery.browser.version = browserMatch.version;
jurzua
parents:
diff changeset
881 }
jurzua
parents:
diff changeset
882
jurzua
parents:
diff changeset
883 // Deprecated, use jQuery.browser.webkit instead
jurzua
parents:
diff changeset
884 if ( jQuery.browser.webkit ) {
jurzua
parents:
diff changeset
885 jQuery.browser.safari = true;
jurzua
parents:
diff changeset
886 }
jurzua
parents:
diff changeset
887
jurzua
parents:
diff changeset
888 // IE doesn't match non-breaking spaces with \s
jurzua
parents:
diff changeset
889 if ( rnotwhite.test( "\xA0" ) ) {
jurzua
parents:
diff changeset
890 trimLeft = /^[\s\xA0]+/;
jurzua
parents:
diff changeset
891 trimRight = /[\s\xA0]+$/;
jurzua
parents:
diff changeset
892 }
jurzua
parents:
diff changeset
893
jurzua
parents:
diff changeset
894 // All jQuery objects should point back to these
jurzua
parents:
diff changeset
895 rootjQuery = jQuery(document);
jurzua
parents:
diff changeset
896
jurzua
parents:
diff changeset
897 // Cleanup functions for the document ready method
jurzua
parents:
diff changeset
898 if ( document.addEventListener ) {
jurzua
parents:
diff changeset
899 DOMContentLoaded = function() {
jurzua
parents:
diff changeset
900 document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
jurzua
parents:
diff changeset
901 jQuery.ready();
jurzua
parents:
diff changeset
902 };
jurzua
parents:
diff changeset
903
jurzua
parents:
diff changeset
904 } else if ( document.attachEvent ) {
jurzua
parents:
diff changeset
905 DOMContentLoaded = function() {
jurzua
parents:
diff changeset
906 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
jurzua
parents:
diff changeset
907 if ( document.readyState === "complete" ) {
jurzua
parents:
diff changeset
908 document.detachEvent( "onreadystatechange", DOMContentLoaded );
jurzua
parents:
diff changeset
909 jQuery.ready();
jurzua
parents:
diff changeset
910 }
jurzua
parents:
diff changeset
911 };
jurzua
parents:
diff changeset
912 }
jurzua
parents:
diff changeset
913
jurzua
parents:
diff changeset
914 // The DOM ready check for Internet Explorer
jurzua
parents:
diff changeset
915 function doScrollCheck() {
jurzua
parents:
diff changeset
916 if ( jQuery.isReady ) {
jurzua
parents:
diff changeset
917 return;
jurzua
parents:
diff changeset
918 }
jurzua
parents:
diff changeset
919
jurzua
parents:
diff changeset
920 try {
jurzua
parents:
diff changeset
921 // If IE is used, use the trick by Diego Perini
jurzua
parents:
diff changeset
922 // http://javascript.nwbox.com/IEContentLoaded/
jurzua
parents:
diff changeset
923 document.documentElement.doScroll("left");
jurzua
parents:
diff changeset
924 } catch(e) {
jurzua
parents:
diff changeset
925 setTimeout( doScrollCheck, 1 );
jurzua
parents:
diff changeset
926 return;
jurzua
parents:
diff changeset
927 }
jurzua
parents:
diff changeset
928
jurzua
parents:
diff changeset
929 // and execute any waiting functions
jurzua
parents:
diff changeset
930 jQuery.ready();
jurzua
parents:
diff changeset
931 }
jurzua
parents:
diff changeset
932
jurzua
parents:
diff changeset
933 // Expose jQuery to the global object
jurzua
parents:
diff changeset
934 return jQuery;
jurzua
parents:
diff changeset
935
jurzua
parents:
diff changeset
936 })();
jurzua
parents:
diff changeset
937
jurzua
parents:
diff changeset
938
jurzua
parents:
diff changeset
939 var // Promise methods
jurzua
parents:
diff changeset
940 promiseMethods = "done fail isResolved isRejected promise then always pipe".split( " " ),
jurzua
parents:
diff changeset
941 // Static reference to slice
jurzua
parents:
diff changeset
942 sliceDeferred = [].slice;
jurzua
parents:
diff changeset
943
jurzua
parents:
diff changeset
944 jQuery.extend({
jurzua
parents:
diff changeset
945 // Create a simple deferred (one callbacks list)
jurzua
parents:
diff changeset
946 _Deferred: function() {
jurzua
parents:
diff changeset
947 var // callbacks list
jurzua
parents:
diff changeset
948 callbacks = [],
jurzua
parents:
diff changeset
949 // stored [ context , args ]
jurzua
parents:
diff changeset
950 fired,
jurzua
parents:
diff changeset
951 // to avoid firing when already doing so
jurzua
parents:
diff changeset
952 firing,
jurzua
parents:
diff changeset
953 // flag to know if the deferred has been cancelled
jurzua
parents:
diff changeset
954 cancelled,
jurzua
parents:
diff changeset
955 // the deferred itself
jurzua
parents:
diff changeset
956 deferred = {
jurzua
parents:
diff changeset
957
jurzua
parents:
diff changeset
958 // done( f1, f2, ...)
jurzua
parents:
diff changeset
959 done: function() {
jurzua
parents:
diff changeset
960 if ( !cancelled ) {
jurzua
parents:
diff changeset
961 var args = arguments,
jurzua
parents:
diff changeset
962 i,
jurzua
parents:
diff changeset
963 length,
jurzua
parents:
diff changeset
964 elem,
jurzua
parents:
diff changeset
965 type,
jurzua
parents:
diff changeset
966 _fired;
jurzua
parents:
diff changeset
967 if ( fired ) {
jurzua
parents:
diff changeset
968 _fired = fired;
jurzua
parents:
diff changeset
969 fired = 0;
jurzua
parents:
diff changeset
970 }
jurzua
parents:
diff changeset
971 for ( i = 0, length = args.length; i < length; i++ ) {
jurzua
parents:
diff changeset
972 elem = args[ i ];
jurzua
parents:
diff changeset
973 type = jQuery.type( elem );
jurzua
parents:
diff changeset
974 if ( type === "array" ) {
jurzua
parents:
diff changeset
975 deferred.done.apply( deferred, elem );
jurzua
parents:
diff changeset
976 } else if ( type === "function" ) {
jurzua
parents:
diff changeset
977 callbacks.push( elem );
jurzua
parents:
diff changeset
978 }
jurzua
parents:
diff changeset
979 }
jurzua
parents:
diff changeset
980 if ( _fired ) {
jurzua
parents:
diff changeset
981 deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
jurzua
parents:
diff changeset
982 }
jurzua
parents:
diff changeset
983 }
jurzua
parents:
diff changeset
984 return this;
jurzua
parents:
diff changeset
985 },
jurzua
parents:
diff changeset
986
jurzua
parents:
diff changeset
987 // resolve with given context and args
jurzua
parents:
diff changeset
988 resolveWith: function( context, args ) {
jurzua
parents:
diff changeset
989 if ( !cancelled && !fired && !firing ) {
jurzua
parents:
diff changeset
990 // make sure args are available (#8421)
jurzua
parents:
diff changeset
991 args = args || [];
jurzua
parents:
diff changeset
992 firing = 1;
jurzua
parents:
diff changeset
993 try {
jurzua
parents:
diff changeset
994 while( callbacks[ 0 ] ) {
jurzua
parents:
diff changeset
995 callbacks.shift().apply( context, args );
jurzua
parents:
diff changeset
996 }
jurzua
parents:
diff changeset
997 }
jurzua
parents:
diff changeset
998 finally {
jurzua
parents:
diff changeset
999 fired = [ context, args ];
jurzua
parents:
diff changeset
1000 firing = 0;
jurzua
parents:
diff changeset
1001 }
jurzua
parents:
diff changeset
1002 }
jurzua
parents:
diff changeset
1003 return this;
jurzua
parents:
diff changeset
1004 },
jurzua
parents:
diff changeset
1005
jurzua
parents:
diff changeset
1006 // resolve with this as context and given arguments
jurzua
parents:
diff changeset
1007 resolve: function() {
jurzua
parents:
diff changeset
1008 deferred.resolveWith( this, arguments );
jurzua
parents:
diff changeset
1009 return this;
jurzua
parents:
diff changeset
1010 },
jurzua
parents:
diff changeset
1011
jurzua
parents:
diff changeset
1012 // Has this deferred been resolved?
jurzua
parents:
diff changeset
1013 isResolved: function() {
jurzua
parents:
diff changeset
1014 return !!( firing || fired );
jurzua
parents:
diff changeset
1015 },
jurzua
parents:
diff changeset
1016
jurzua
parents:
diff changeset
1017 // Cancel
jurzua
parents:
diff changeset
1018 cancel: function() {
jurzua
parents:
diff changeset
1019 cancelled = 1;
jurzua
parents:
diff changeset
1020 callbacks = [];
jurzua
parents:
diff changeset
1021 return this;
jurzua
parents:
diff changeset
1022 }
jurzua
parents:
diff changeset
1023 };
jurzua
parents:
diff changeset
1024
jurzua
parents:
diff changeset
1025 return deferred;
jurzua
parents:
diff changeset
1026 },
jurzua
parents:
diff changeset
1027
jurzua
parents:
diff changeset
1028 // Full fledged deferred (two callbacks list)
jurzua
parents:
diff changeset
1029 Deferred: function( func ) {
jurzua
parents:
diff changeset
1030 var deferred = jQuery._Deferred(),
jurzua
parents:
diff changeset
1031 failDeferred = jQuery._Deferred(),
jurzua
parents:
diff changeset
1032 promise;
jurzua
parents:
diff changeset
1033 // Add errorDeferred methods, then and promise
jurzua
parents:
diff changeset
1034 jQuery.extend( deferred, {
jurzua
parents:
diff changeset
1035 then: function( doneCallbacks, failCallbacks ) {
jurzua
parents:
diff changeset
1036 deferred.done( doneCallbacks ).fail( failCallbacks );
jurzua
parents:
diff changeset
1037 return this;
jurzua
parents:
diff changeset
1038 },
jurzua
parents:
diff changeset
1039 always: function() {
jurzua
parents:
diff changeset
1040 return deferred.done.apply( deferred, arguments ).fail.apply( this, arguments );
jurzua
parents:
diff changeset
1041 },
jurzua
parents:
diff changeset
1042 fail: failDeferred.done,
jurzua
parents:
diff changeset
1043 rejectWith: failDeferred.resolveWith,
jurzua
parents:
diff changeset
1044 reject: failDeferred.resolve,
jurzua
parents:
diff changeset
1045 isRejected: failDeferred.isResolved,
jurzua
parents:
diff changeset
1046 pipe: function( fnDone, fnFail ) {
jurzua
parents:
diff changeset
1047 return jQuery.Deferred(function( newDefer ) {
jurzua
parents:
diff changeset
1048 jQuery.each( {
jurzua
parents:
diff changeset
1049 done: [ fnDone, "resolve" ],
jurzua
parents:
diff changeset
1050 fail: [ fnFail, "reject" ]
jurzua
parents:
diff changeset
1051 }, function( handler, data ) {
jurzua
parents:
diff changeset
1052 var fn = data[ 0 ],
jurzua
parents:
diff changeset
1053 action = data[ 1 ],
jurzua
parents:
diff changeset
1054 returned;
jurzua
parents:
diff changeset
1055 if ( jQuery.isFunction( fn ) ) {
jurzua
parents:
diff changeset
1056 deferred[ handler ](function() {
jurzua
parents:
diff changeset
1057 returned = fn.apply( this, arguments );
jurzua
parents:
diff changeset
1058 if ( jQuery.isFunction( returned.promise ) ) {
jurzua
parents:
diff changeset
1059 returned.promise().then( newDefer.resolve, newDefer.reject );
jurzua
parents:
diff changeset
1060 } else {
jurzua
parents:
diff changeset
1061 newDefer[ action ]( returned );
jurzua
parents:
diff changeset
1062 }
jurzua
parents:
diff changeset
1063 });
jurzua
parents:
diff changeset
1064 } else {
jurzua
parents:
diff changeset
1065 deferred[ handler ]( newDefer[ action ] );
jurzua
parents:
diff changeset
1066 }
jurzua
parents:
diff changeset
1067 });
jurzua
parents:
diff changeset
1068 }).promise();
jurzua
parents:
diff changeset
1069 },
jurzua
parents:
diff changeset
1070 // Get a promise for this deferred
jurzua
parents:
diff changeset
1071 // If obj is provided, the promise aspect is added to the object
jurzua
parents:
diff changeset
1072 promise: function( obj ) {
jurzua
parents:
diff changeset
1073 if ( obj == null ) {
jurzua
parents:
diff changeset
1074 if ( promise ) {
jurzua
parents:
diff changeset
1075 return promise;
jurzua
parents:
diff changeset
1076 }
jurzua
parents:
diff changeset
1077 promise = obj = {};
jurzua
parents:
diff changeset
1078 }
jurzua
parents:
diff changeset
1079 var i = promiseMethods.length;
jurzua
parents:
diff changeset
1080 while( i-- ) {
jurzua
parents:
diff changeset
1081 obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ];
jurzua
parents:
diff changeset
1082 }
jurzua
parents:
diff changeset
1083 return obj;
jurzua
parents:
diff changeset
1084 }
jurzua
parents:
diff changeset
1085 });
jurzua
parents:
diff changeset
1086 // Make sure only one callback list will be used
jurzua
parents:
diff changeset
1087 deferred.done( failDeferred.cancel ).fail( deferred.cancel );
jurzua
parents:
diff changeset
1088 // Unexpose cancel
jurzua
parents:
diff changeset
1089 delete deferred.cancel;
jurzua
parents:
diff changeset
1090 // Call given func if any
jurzua
parents:
diff changeset
1091 if ( func ) {
jurzua
parents:
diff changeset
1092 func.call( deferred, deferred );
jurzua
parents:
diff changeset
1093 }
jurzua
parents:
diff changeset
1094 return deferred;
jurzua
parents:
diff changeset
1095 },
jurzua
parents:
diff changeset
1096
jurzua
parents:
diff changeset
1097 // Deferred helper
jurzua
parents:
diff changeset
1098 when: function( firstParam ) {
jurzua
parents:
diff changeset
1099 var args = arguments,
jurzua
parents:
diff changeset
1100 i = 0,
jurzua
parents:
diff changeset
1101 length = args.length,
jurzua
parents:
diff changeset
1102 count = length,
jurzua
parents:
diff changeset
1103 deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
jurzua
parents:
diff changeset
1104 firstParam :
jurzua
parents:
diff changeset
1105 jQuery.Deferred();
jurzua
parents:
diff changeset
1106 function resolveFunc( i ) {
jurzua
parents:
diff changeset
1107 return function( value ) {
jurzua
parents:
diff changeset
1108 args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
jurzua
parents:
diff changeset
1109 if ( !( --count ) ) {
jurzua
parents:
diff changeset
1110 // Strange bug in FF4:
jurzua
parents:
diff changeset
1111 // Values changed onto the arguments object sometimes end up as undefined values
jurzua
parents:
diff changeset
1112 // outside the $.when method. Cloning the object into a fresh array solves the issue
jurzua
parents:
diff changeset
1113 deferred.resolveWith( deferred, sliceDeferred.call( args, 0 ) );
jurzua
parents:
diff changeset
1114 }
jurzua
parents:
diff changeset
1115 };
jurzua
parents:
diff changeset
1116 }
jurzua
parents:
diff changeset
1117 if ( length > 1 ) {
jurzua
parents:
diff changeset
1118 for( ; i < length; i++ ) {
jurzua
parents:
diff changeset
1119 if ( args[ i ] && jQuery.isFunction( args[ i ].promise ) ) {
jurzua
parents:
diff changeset
1120 args[ i ].promise().then( resolveFunc(i), deferred.reject );
jurzua
parents:
diff changeset
1121 } else {
jurzua
parents:
diff changeset
1122 --count;
jurzua
parents:
diff changeset
1123 }
jurzua
parents:
diff changeset
1124 }
jurzua
parents:
diff changeset
1125 if ( !count ) {
jurzua
parents:
diff changeset
1126 deferred.resolveWith( deferred, args );
jurzua
parents:
diff changeset
1127 }
jurzua
parents:
diff changeset
1128 } else if ( deferred !== firstParam ) {
jurzua
parents:
diff changeset
1129 deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
jurzua
parents:
diff changeset
1130 }
jurzua
parents:
diff changeset
1131 return deferred.promise();
jurzua
parents:
diff changeset
1132 }
jurzua
parents:
diff changeset
1133 });
jurzua
parents:
diff changeset
1134
jurzua
parents:
diff changeset
1135
jurzua
parents:
diff changeset
1136
jurzua
parents:
diff changeset
1137 jQuery.support = (function() {
jurzua
parents:
diff changeset
1138
jurzua
parents:
diff changeset
1139 var div = document.createElement( "div" ),
jurzua
parents:
diff changeset
1140 all,
jurzua
parents:
diff changeset
1141 a,
jurzua
parents:
diff changeset
1142 select,
jurzua
parents:
diff changeset
1143 opt,
jurzua
parents:
diff changeset
1144 input,
jurzua
parents:
diff changeset
1145 marginDiv,
jurzua
parents:
diff changeset
1146 support,
jurzua
parents:
diff changeset
1147 fragment,
jurzua
parents:
diff changeset
1148 body,
jurzua
parents:
diff changeset
1149 bodyStyle,
jurzua
parents:
diff changeset
1150 tds,
jurzua
parents:
diff changeset
1151 events,
jurzua
parents:
diff changeset
1152 eventName,
jurzua
parents:
diff changeset
1153 i,
jurzua
parents:
diff changeset
1154 isSupported;
jurzua
parents:
diff changeset
1155
jurzua
parents:
diff changeset
1156 // Preliminary tests
jurzua
parents:
diff changeset
1157 div.setAttribute("className", "t");
jurzua
parents:
diff changeset
1158 div.innerHTML = " <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
jurzua
parents:
diff changeset
1159
jurzua
parents:
diff changeset
1160 all = div.getElementsByTagName( "*" );
jurzua
parents:
diff changeset
1161 a = div.getElementsByTagName( "a" )[ 0 ];
jurzua
parents:
diff changeset
1162
jurzua
parents:
diff changeset
1163 // Can't get basic test support
jurzua
parents:
diff changeset
1164 if ( !all || !all.length || !a ) {
jurzua
parents:
diff changeset
1165 return {};
jurzua
parents:
diff changeset
1166 }
jurzua
parents:
diff changeset
1167
jurzua
parents:
diff changeset
1168 // First batch of supports tests
jurzua
parents:
diff changeset
1169 select = document.createElement( "select" );
jurzua
parents:
diff changeset
1170 opt = select.appendChild( document.createElement("option") );
jurzua
parents:
diff changeset
1171 input = div.getElementsByTagName( "input" )[ 0 ];
jurzua
parents:
diff changeset
1172
jurzua
parents:
diff changeset
1173 support = {
jurzua
parents:
diff changeset
1174 // IE strips leading whitespace when .innerHTML is used
jurzua
parents:
diff changeset
1175 leadingWhitespace: ( div.firstChild.nodeType === 3 ),
jurzua
parents:
diff changeset
1176
jurzua
parents:
diff changeset
1177 // Make sure that tbody elements aren't automatically inserted
jurzua
parents:
diff changeset
1178 // IE will insert them into empty tables
jurzua
parents:
diff changeset
1179 tbody: !div.getElementsByTagName( "tbody" ).length,
jurzua
parents:
diff changeset
1180
jurzua
parents:
diff changeset
1181 // Make sure that link elements get serialized correctly by innerHTML
jurzua
parents:
diff changeset
1182 // This requires a wrapper element in IE
jurzua
parents:
diff changeset
1183 htmlSerialize: !!div.getElementsByTagName( "link" ).length,
jurzua
parents:
diff changeset
1184
jurzua
parents:
diff changeset
1185 // Get the style information from getAttribute
jurzua
parents:
diff changeset
1186 // (IE uses .cssText instead)
jurzua
parents:
diff changeset
1187 style: /top/.test( a.getAttribute("style") ),
jurzua
parents:
diff changeset
1188
jurzua
parents:
diff changeset
1189 // Make sure that URLs aren't manipulated
jurzua
parents:
diff changeset
1190 // (IE normalizes it by default)
jurzua
parents:
diff changeset
1191 hrefNormalized: ( a.getAttribute( "href" ) === "/a" ),
jurzua
parents:
diff changeset
1192
jurzua
parents:
diff changeset
1193 // Make sure that element opacity exists
jurzua
parents:
diff changeset
1194 // (IE uses filter instead)
jurzua
parents:
diff changeset
1195 // Use a regex to work around a WebKit issue. See #5145
jurzua
parents:
diff changeset
1196 opacity: /^0.55$/.test( a.style.opacity ),
jurzua
parents:
diff changeset
1197
jurzua
parents:
diff changeset
1198 // Verify style float existence
jurzua
parents:
diff changeset
1199 // (IE uses styleFloat instead of cssFloat)
jurzua
parents:
diff changeset
1200 cssFloat: !!a.style.cssFloat,
jurzua
parents:
diff changeset
1201
jurzua
parents:
diff changeset
1202 // Make sure that if no value is specified for a checkbox
jurzua
parents:
diff changeset
1203 // that it defaults to "on".
jurzua
parents:
diff changeset
1204 // (WebKit defaults to "" instead)
jurzua
parents:
diff changeset
1205 checkOn: ( input.value === "on" ),
jurzua
parents:
diff changeset
1206
jurzua
parents:
diff changeset
1207 // Make sure that a selected-by-default option has a working selected property.
jurzua
parents:
diff changeset
1208 // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
jurzua
parents:
diff changeset
1209 optSelected: opt.selected,
jurzua
parents:
diff changeset
1210
jurzua
parents:
diff changeset
1211 // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
jurzua
parents:
diff changeset
1212 getSetAttribute: div.className !== "t",
jurzua
parents:
diff changeset
1213
jurzua
parents:
diff changeset
1214 // Will be defined later
jurzua
parents:
diff changeset
1215 submitBubbles: true,
jurzua
parents:
diff changeset
1216 changeBubbles: true,
jurzua
parents:
diff changeset
1217 focusinBubbles: false,
jurzua
parents:
diff changeset
1218 deleteExpando: true,
jurzua
parents:
diff changeset
1219 noCloneEvent: true,
jurzua
parents:
diff changeset
1220 inlineBlockNeedsLayout: false,
jurzua
parents:
diff changeset
1221 shrinkWrapBlocks: false,
jurzua
parents:
diff changeset
1222 reliableMarginRight: true
jurzua
parents:
diff changeset
1223 };
jurzua
parents:
diff changeset
1224
jurzua
parents:
diff changeset
1225 // Make sure checked status is properly cloned
jurzua
parents:
diff changeset
1226 input.checked = true;
jurzua
parents:
diff changeset
1227 support.noCloneChecked = input.cloneNode( true ).checked;
jurzua
parents:
diff changeset
1228
jurzua
parents:
diff changeset
1229 // Make sure that the options inside disabled selects aren't marked as disabled
jurzua
parents:
diff changeset
1230 // (WebKit marks them as disabled)
jurzua
parents:
diff changeset
1231 select.disabled = true;
jurzua
parents:
diff changeset
1232 support.optDisabled = !opt.disabled;
jurzua
parents:
diff changeset
1233
jurzua
parents:
diff changeset
1234 // Test to see if it's possible to delete an expando from an element
jurzua
parents:
diff changeset
1235 // Fails in Internet Explorer
jurzua
parents:
diff changeset
1236 try {
jurzua
parents:
diff changeset
1237 delete div.test;
jurzua
parents:
diff changeset
1238 } catch( e ) {
jurzua
parents:
diff changeset
1239 support.deleteExpando = false;
jurzua
parents:
diff changeset
1240 }
jurzua
parents:
diff changeset
1241
jurzua
parents:
diff changeset
1242 if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
jurzua
parents:
diff changeset
1243 div.attachEvent( "onclick", function click() {
jurzua
parents:
diff changeset
1244 // Cloning a node shouldn't copy over any
jurzua
parents:
diff changeset
1245 // bound event handlers (IE does this)
jurzua
parents:
diff changeset
1246 support.noCloneEvent = false;
jurzua
parents:
diff changeset
1247 div.detachEvent( "onclick", click );
jurzua
parents:
diff changeset
1248 });
jurzua
parents:
diff changeset
1249 div.cloneNode( true ).fireEvent( "onclick" );
jurzua
parents:
diff changeset
1250 }
jurzua
parents:
diff changeset
1251
jurzua
parents:
diff changeset
1252 // Check if a radio maintains it's value
jurzua
parents:
diff changeset
1253 // after being appended to the DOM
jurzua
parents:
diff changeset
1254 input = document.createElement("input");
jurzua
parents:
diff changeset
1255 input.value = "t";
jurzua
parents:
diff changeset
1256 input.setAttribute("type", "radio");
jurzua
parents:
diff changeset
1257 support.radioValue = input.value === "t";
jurzua
parents:
diff changeset
1258
jurzua
parents:
diff changeset
1259 input.setAttribute("checked", "checked");
jurzua
parents:
diff changeset
1260 div.appendChild( input );
jurzua
parents:
diff changeset
1261 fragment = document.createDocumentFragment();
jurzua
parents:
diff changeset
1262 fragment.appendChild( div.firstChild );
jurzua
parents:
diff changeset
1263
jurzua
parents:
diff changeset
1264 // WebKit doesn't clone checked state correctly in fragments
jurzua
parents:
diff changeset
1265 support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
jurzua
parents:
diff changeset
1266
jurzua
parents:
diff changeset
1267 div.innerHTML = "";
jurzua
parents:
diff changeset
1268
jurzua
parents:
diff changeset
1269 // Figure out if the W3C box model works as expected
jurzua
parents:
diff changeset
1270 div.style.width = div.style.paddingLeft = "1px";
jurzua
parents:
diff changeset
1271
jurzua
parents:
diff changeset
1272 // We use our own, invisible, body
jurzua
parents:
diff changeset
1273 body = document.createElement( "body" );
jurzua
parents:
diff changeset
1274 bodyStyle = {
jurzua
parents:
diff changeset
1275 visibility: "hidden",
jurzua
parents:
diff changeset
1276 width: 0,
jurzua
parents:
diff changeset
1277 height: 0,
jurzua
parents:
diff changeset
1278 border: 0,
jurzua
parents:
diff changeset
1279 margin: 0,
jurzua
parents:
diff changeset
1280 // Set background to avoid IE crashes when removing (#9028)
jurzua
parents:
diff changeset
1281 background: "none"
jurzua
parents:
diff changeset
1282 };
jurzua
parents:
diff changeset
1283 for ( i in bodyStyle ) {
jurzua
parents:
diff changeset
1284 body.style[ i ] = bodyStyle[ i ];
jurzua
parents:
diff changeset
1285 }
jurzua
parents:
diff changeset
1286 body.appendChild( div );
jurzua
parents:
diff changeset
1287 document.documentElement.appendChild( body );
jurzua
parents:
diff changeset
1288
jurzua
parents:
diff changeset
1289 // Check if a disconnected checkbox will retain its checked
jurzua
parents:
diff changeset
1290 // value of true after appended to the DOM (IE6/7)
jurzua
parents:
diff changeset
1291 support.appendChecked = input.checked;
jurzua
parents:
diff changeset
1292
jurzua
parents:
diff changeset
1293 support.boxModel = div.offsetWidth === 2;
jurzua
parents:
diff changeset
1294
jurzua
parents:
diff changeset
1295 if ( "zoom" in div.style ) {
jurzua
parents:
diff changeset
1296 // Check if natively block-level elements act like inline-block
jurzua
parents:
diff changeset
1297 // elements when setting their display to 'inline' and giving
jurzua
parents:
diff changeset
1298 // them layout
jurzua
parents:
diff changeset
1299 // (IE < 8 does this)
jurzua
parents:
diff changeset
1300 div.style.display = "inline";
jurzua
parents:
diff changeset
1301 div.style.zoom = 1;
jurzua
parents:
diff changeset
1302 support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 );
jurzua
parents:
diff changeset
1303
jurzua
parents:
diff changeset
1304 // Check if elements with layout shrink-wrap their children
jurzua
parents:
diff changeset
1305 // (IE 6 does this)
jurzua
parents:
diff changeset
1306 div.style.display = "";
jurzua
parents:
diff changeset
1307 div.innerHTML = "<div style='width:4px;'></div>";
jurzua
parents:
diff changeset
1308 support.shrinkWrapBlocks = ( div.offsetWidth !== 2 );
jurzua
parents:
diff changeset
1309 }
jurzua
parents:
diff changeset
1310
jurzua
parents:
diff changeset
1311 div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
jurzua
parents:
diff changeset
1312 tds = div.getElementsByTagName( "td" );
jurzua
parents:
diff changeset
1313
jurzua
parents:
diff changeset
1314 // Check if table cells still have offsetWidth/Height when they are set
jurzua
parents:
diff changeset
1315 // to display:none and there are still other visible table cells in a
jurzua
parents:
diff changeset
1316 // table row; if so, offsetWidth/Height are not reliable for use when
jurzua
parents:
diff changeset
1317 // determining if an element has been hidden directly using
jurzua
parents:
diff changeset
1318 // display:none (it is still safe to use offsets if a parent element is
jurzua
parents:
diff changeset
1319 // hidden; don safety goggles and see bug #4512 for more information).
jurzua
parents:
diff changeset
1320 // (only IE 8 fails this test)
jurzua
parents:
diff changeset
1321 isSupported = ( tds[ 0 ].offsetHeight === 0 );
jurzua
parents:
diff changeset
1322
jurzua
parents:
diff changeset
1323 tds[ 0 ].style.display = "";
jurzua
parents:
diff changeset
1324 tds[ 1 ].style.display = "none";
jurzua
parents:
diff changeset
1325
jurzua
parents:
diff changeset
1326 // Check if empty table cells still have offsetWidth/Height
jurzua
parents:
diff changeset
1327 // (IE < 8 fail this test)
jurzua
parents:
diff changeset
1328 support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
jurzua
parents:
diff changeset
1329 div.innerHTML = "";
jurzua
parents:
diff changeset
1330
jurzua
parents:
diff changeset
1331 // Check if div with explicit width and no margin-right incorrectly
jurzua
parents:
diff changeset
1332 // gets computed margin-right based on width of container. For more
jurzua
parents:
diff changeset
1333 // info see bug #3333
jurzua
parents:
diff changeset
1334 // Fails in WebKit before Feb 2011 nightlies
jurzua
parents:
diff changeset
1335 // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
jurzua
parents:
diff changeset
1336 if ( document.defaultView && document.defaultView.getComputedStyle ) {
jurzua
parents:
diff changeset
1337 marginDiv = document.createElement( "div" );
jurzua
parents:
diff changeset
1338 marginDiv.style.width = "0";
jurzua
parents:
diff changeset
1339 marginDiv.style.marginRight = "0";
jurzua
parents:
diff changeset
1340 div.appendChild( marginDiv );
jurzua
parents:
diff changeset
1341 support.reliableMarginRight =
jurzua
parents:
diff changeset
1342 ( parseInt( document.defaultView.getComputedStyle( marginDiv, null ).marginRight, 10 ) || 0 ) === 0;
jurzua
parents:
diff changeset
1343 }
jurzua
parents:
diff changeset
1344
jurzua
parents:
diff changeset
1345 // Remove the body element we added
jurzua
parents:
diff changeset
1346 body.innerHTML = "";
jurzua
parents:
diff changeset
1347 document.documentElement.removeChild( body );
jurzua
parents:
diff changeset
1348
jurzua
parents:
diff changeset
1349 // Technique from Juriy Zaytsev
jurzua
parents:
diff changeset
1350 // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
jurzua
parents:
diff changeset
1351 // We only care about the case where non-standard event systems
jurzua
parents:
diff changeset
1352 // are used, namely in IE. Short-circuiting here helps us to
jurzua
parents:
diff changeset
1353 // avoid an eval call (in setAttribute) which can cause CSP
jurzua
parents:
diff changeset
1354 // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
jurzua
parents:
diff changeset
1355 if ( div.attachEvent ) {
jurzua
parents:
diff changeset
1356 for( i in {
jurzua
parents:
diff changeset
1357 submit: 1,
jurzua
parents:
diff changeset
1358 change: 1,
jurzua
parents:
diff changeset
1359 focusin: 1
jurzua
parents:
diff changeset
1360 } ) {
jurzua
parents:
diff changeset
1361 eventName = "on" + i;
jurzua
parents:
diff changeset
1362 isSupported = ( eventName in div );
jurzua
parents:
diff changeset
1363 if ( !isSupported ) {
jurzua
parents:
diff changeset
1364 div.setAttribute( eventName, "return;" );
jurzua
parents:
diff changeset
1365 isSupported = ( typeof div[ eventName ] === "function" );
jurzua
parents:
diff changeset
1366 }
jurzua
parents:
diff changeset
1367 support[ i + "Bubbles" ] = isSupported;
jurzua
parents:
diff changeset
1368 }
jurzua
parents:
diff changeset
1369 }
jurzua
parents:
diff changeset
1370
jurzua
parents:
diff changeset
1371 return support;
jurzua
parents:
diff changeset
1372 })();
jurzua
parents:
diff changeset
1373
jurzua
parents:
diff changeset
1374 // Keep track of boxModel
jurzua
parents:
diff changeset
1375 jQuery.boxModel = jQuery.support.boxModel;
jurzua
parents:
diff changeset
1376
jurzua
parents:
diff changeset
1377
jurzua
parents:
diff changeset
1378
jurzua
parents:
diff changeset
1379
jurzua
parents:
diff changeset
1380 var rbrace = /^(?:\{.*\}|\[.*\])$/,
jurzua
parents:
diff changeset
1381 rmultiDash = /([a-z])([A-Z])/g;
jurzua
parents:
diff changeset
1382
jurzua
parents:
diff changeset
1383 jQuery.extend({
jurzua
parents:
diff changeset
1384 cache: {},
jurzua
parents:
diff changeset
1385
jurzua
parents:
diff changeset
1386 // Please use with caution
jurzua
parents:
diff changeset
1387 uuid: 0,
jurzua
parents:
diff changeset
1388
jurzua
parents:
diff changeset
1389 // Unique for each copy of jQuery on the page
jurzua
parents:
diff changeset
1390 // Non-digits removed to match rinlinejQuery
jurzua
parents:
diff changeset
1391 expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
jurzua
parents:
diff changeset
1392
jurzua
parents:
diff changeset
1393 // The following elements throw uncatchable exceptions if you
jurzua
parents:
diff changeset
1394 // attempt to add expando properties to them.
jurzua
parents:
diff changeset
1395 noData: {
jurzua
parents:
diff changeset
1396 "embed": true,
jurzua
parents:
diff changeset
1397 // Ban all objects except for Flash (which handle expandos)
jurzua
parents:
diff changeset
1398 "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
jurzua
parents:
diff changeset
1399 "applet": true
jurzua
parents:
diff changeset
1400 },
jurzua
parents:
diff changeset
1401
jurzua
parents:
diff changeset
1402 hasData: function( elem ) {
jurzua
parents:
diff changeset
1403 elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
jurzua
parents:
diff changeset
1404
jurzua
parents:
diff changeset
1405 return !!elem && !isEmptyDataObject( elem );
jurzua
parents:
diff changeset
1406 },
jurzua
parents:
diff changeset
1407
jurzua
parents:
diff changeset
1408 data: function( elem, name, data, pvt /* Internal Use Only */ ) {
jurzua
parents:
diff changeset
1409 if ( !jQuery.acceptData( elem ) ) {
jurzua
parents:
diff changeset
1410 return;
jurzua
parents:
diff changeset
1411 }
jurzua
parents:
diff changeset
1412
jurzua
parents:
diff changeset
1413 var internalKey = jQuery.expando, getByName = typeof name === "string", thisCache,
jurzua
parents:
diff changeset
1414
jurzua
parents:
diff changeset
1415 // We have to handle DOM nodes and JS objects differently because IE6-7
jurzua
parents:
diff changeset
1416 // can't GC object references properly across the DOM-JS boundary
jurzua
parents:
diff changeset
1417 isNode = elem.nodeType,
jurzua
parents:
diff changeset
1418
jurzua
parents:
diff changeset
1419 // Only DOM nodes need the global jQuery cache; JS object data is
jurzua
parents:
diff changeset
1420 // attached directly to the object so GC can occur automatically
jurzua
parents:
diff changeset
1421 cache = isNode ? jQuery.cache : elem,
jurzua
parents:
diff changeset
1422
jurzua
parents:
diff changeset
1423 // Only defining an ID for JS objects if its cache already exists allows
jurzua
parents:
diff changeset
1424 // the code to shortcut on the same path as a DOM node with no cache
jurzua
parents:
diff changeset
1425 id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando;
jurzua
parents:
diff changeset
1426
jurzua
parents:
diff changeset
1427 // Avoid doing any more work than we need to when trying to get data on an
jurzua
parents:
diff changeset
1428 // object that has no data at all
jurzua
parents:
diff changeset
1429 if ( (!id || (pvt && id && !cache[ id ][ internalKey ])) && getByName && data === undefined ) {
jurzua
parents:
diff changeset
1430 return;
jurzua
parents:
diff changeset
1431 }
jurzua
parents:
diff changeset
1432
jurzua
parents:
diff changeset
1433 if ( !id ) {
jurzua
parents:
diff changeset
1434 // Only DOM nodes need a new unique ID for each element since their data
jurzua
parents:
diff changeset
1435 // ends up in the global cache
jurzua
parents:
diff changeset
1436 if ( isNode ) {
jurzua
parents:
diff changeset
1437 elem[ jQuery.expando ] = id = ++jQuery.uuid;
jurzua
parents:
diff changeset
1438 } else {
jurzua
parents:
diff changeset
1439 id = jQuery.expando;
jurzua
parents:
diff changeset
1440 }
jurzua
parents:
diff changeset
1441 }
jurzua
parents:
diff changeset
1442
jurzua
parents:
diff changeset
1443 if ( !cache[ id ] ) {
jurzua
parents:
diff changeset
1444 cache[ id ] = {};
jurzua
parents:
diff changeset
1445
jurzua
parents:
diff changeset
1446 // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
jurzua
parents:
diff changeset
1447 // metadata on plain JS objects when the object is serialized using
jurzua
parents:
diff changeset
1448 // JSON.stringify
jurzua
parents:
diff changeset
1449 if ( !isNode ) {
jurzua
parents:
diff changeset
1450 cache[ id ].toJSON = jQuery.noop;
jurzua
parents:
diff changeset
1451 }
jurzua
parents:
diff changeset
1452 }
jurzua
parents:
diff changeset
1453
jurzua
parents:
diff changeset
1454 // An object can be passed to jQuery.data instead of a key/value pair; this gets
jurzua
parents:
diff changeset
1455 // shallow copied over onto the existing cache
jurzua
parents:
diff changeset
1456 if ( typeof name === "object" || typeof name === "function" ) {
jurzua
parents:
diff changeset
1457 if ( pvt ) {
jurzua
parents:
diff changeset
1458 cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
jurzua
parents:
diff changeset
1459 } else {
jurzua
parents:
diff changeset
1460 cache[ id ] = jQuery.extend(cache[ id ], name);
jurzua
parents:
diff changeset
1461 }
jurzua
parents:
diff changeset
1462 }
jurzua
parents:
diff changeset
1463
jurzua
parents:
diff changeset
1464 thisCache = cache[ id ];
jurzua
parents:
diff changeset
1465
jurzua
parents:
diff changeset
1466 // Internal jQuery data is stored in a separate object inside the object's data
jurzua
parents:
diff changeset
1467 // cache in order to avoid key collisions between internal data and user-defined
jurzua
parents:
diff changeset
1468 // data
jurzua
parents:
diff changeset
1469 if ( pvt ) {
jurzua
parents:
diff changeset
1470 if ( !thisCache[ internalKey ] ) {
jurzua
parents:
diff changeset
1471 thisCache[ internalKey ] = {};
jurzua
parents:
diff changeset
1472 }
jurzua
parents:
diff changeset
1473
jurzua
parents:
diff changeset
1474 thisCache = thisCache[ internalKey ];
jurzua
parents:
diff changeset
1475 }
jurzua
parents:
diff changeset
1476
jurzua
parents:
diff changeset
1477 if ( data !== undefined ) {
jurzua
parents:
diff changeset
1478 thisCache[ name ] = data;
jurzua
parents:
diff changeset
1479 }
jurzua
parents:
diff changeset
1480
jurzua
parents:
diff changeset
1481 // TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
jurzua
parents:
diff changeset
1482 // not attempt to inspect the internal events object using jQuery.data, as this
jurzua
parents:
diff changeset
1483 // internal data object is undocumented and subject to change.
jurzua
parents:
diff changeset
1484 if ( name === "events" && !thisCache[name] ) {
jurzua
parents:
diff changeset
1485 return thisCache[ internalKey ] && thisCache[ internalKey ].events;
jurzua
parents:
diff changeset
1486 }
jurzua
parents:
diff changeset
1487
jurzua
parents:
diff changeset
1488 return getByName ? thisCache[ name ] : thisCache;
jurzua
parents:
diff changeset
1489 },
jurzua
parents:
diff changeset
1490
jurzua
parents:
diff changeset
1491 removeData: function( elem, name, pvt /* Internal Use Only */ ) {
jurzua
parents:
diff changeset
1492 if ( !jQuery.acceptData( elem ) ) {
jurzua
parents:
diff changeset
1493 return;
jurzua
parents:
diff changeset
1494 }
jurzua
parents:
diff changeset
1495
jurzua
parents:
diff changeset
1496 var internalKey = jQuery.expando, isNode = elem.nodeType,
jurzua
parents:
diff changeset
1497
jurzua
parents:
diff changeset
1498 // See jQuery.data for more information
jurzua
parents:
diff changeset
1499 cache = isNode ? jQuery.cache : elem,
jurzua
parents:
diff changeset
1500
jurzua
parents:
diff changeset
1501 // See jQuery.data for more information
jurzua
parents:
diff changeset
1502 id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
jurzua
parents:
diff changeset
1503
jurzua
parents:
diff changeset
1504 // If there is already no cache entry for this object, there is no
jurzua
parents:
diff changeset
1505 // purpose in continuing
jurzua
parents:
diff changeset
1506 if ( !cache[ id ] ) {
jurzua
parents:
diff changeset
1507 return;
jurzua
parents:
diff changeset
1508 }
jurzua
parents:
diff changeset
1509
jurzua
parents:
diff changeset
1510 if ( name ) {
jurzua
parents:
diff changeset
1511 var thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];
jurzua
parents:
diff changeset
1512
jurzua
parents:
diff changeset
1513 if ( thisCache ) {
jurzua
parents:
diff changeset
1514 delete thisCache[ name ];
jurzua
parents:
diff changeset
1515
jurzua
parents:
diff changeset
1516 // If there is no data left in the cache, we want to continue
jurzua
parents:
diff changeset
1517 // and let the cache object itself get destroyed
jurzua
parents:
diff changeset
1518 if ( !isEmptyDataObject(thisCache) ) {
jurzua
parents:
diff changeset
1519 return;
jurzua
parents:
diff changeset
1520 }
jurzua
parents:
diff changeset
1521 }
jurzua
parents:
diff changeset
1522 }
jurzua
parents:
diff changeset
1523
jurzua
parents:
diff changeset
1524 // See jQuery.data for more information
jurzua
parents:
diff changeset
1525 if ( pvt ) {
jurzua
parents:
diff changeset
1526 delete cache[ id ][ internalKey ];
jurzua
parents:
diff changeset
1527
jurzua
parents:
diff changeset
1528 // Don't destroy the parent cache unless the internal data object
jurzua
parents:
diff changeset
1529 // had been the only thing left in it
jurzua
parents:
diff changeset
1530 if ( !isEmptyDataObject(cache[ id ]) ) {
jurzua
parents:
diff changeset
1531 return;
jurzua
parents:
diff changeset
1532 }
jurzua
parents:
diff changeset
1533 }
jurzua
parents:
diff changeset
1534
jurzua
parents:
diff changeset
1535 var internalCache = cache[ id ][ internalKey ];
jurzua
parents:
diff changeset
1536
jurzua
parents:
diff changeset
1537 // Browsers that fail expando deletion also refuse to delete expandos on
jurzua
parents:
diff changeset
1538 // the window, but it will allow it on all other JS objects; other browsers
jurzua
parents:
diff changeset
1539 // don't care
jurzua
parents:
diff changeset
1540 if ( jQuery.support.deleteExpando || cache != window ) {
jurzua
parents:
diff changeset
1541 delete cache[ id ];
jurzua
parents:
diff changeset
1542 } else {
jurzua
parents:
diff changeset
1543 cache[ id ] = null;
jurzua
parents:
diff changeset
1544 }
jurzua
parents:
diff changeset
1545
jurzua
parents:
diff changeset
1546 // We destroyed the entire user cache at once because it's faster than
jurzua
parents:
diff changeset
1547 // iterating through each key, but we need to continue to persist internal
jurzua
parents:
diff changeset
1548 // data if it existed
jurzua
parents:
diff changeset
1549 if ( internalCache ) {
jurzua
parents:
diff changeset
1550 cache[ id ] = {};
jurzua
parents:
diff changeset
1551 // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
jurzua
parents:
diff changeset
1552 // metadata on plain JS objects when the object is serialized using
jurzua
parents:
diff changeset
1553 // JSON.stringify
jurzua
parents:
diff changeset
1554 if ( !isNode ) {
jurzua
parents:
diff changeset
1555 cache[ id ].toJSON = jQuery.noop;
jurzua
parents:
diff changeset
1556 }
jurzua
parents:
diff changeset
1557
jurzua
parents:
diff changeset
1558 cache[ id ][ internalKey ] = internalCache;
jurzua
parents:
diff changeset
1559
jurzua
parents:
diff changeset
1560 // Otherwise, we need to eliminate the expando on the node to avoid
jurzua
parents:
diff changeset
1561 // false lookups in the cache for entries that no longer exist
jurzua
parents:
diff changeset
1562 } else if ( isNode ) {
jurzua
parents:
diff changeset
1563 // IE does not allow us to delete expando properties from nodes,
jurzua
parents:
diff changeset
1564 // nor does it have a removeAttribute function on Document nodes;
jurzua
parents:
diff changeset
1565 // we must handle all of these cases
jurzua
parents:
diff changeset
1566 if ( jQuery.support.deleteExpando ) {
jurzua
parents:
diff changeset
1567 delete elem[ jQuery.expando ];
jurzua
parents:
diff changeset
1568 } else if ( elem.removeAttribute ) {
jurzua
parents:
diff changeset
1569 elem.removeAttribute( jQuery.expando );
jurzua
parents:
diff changeset
1570 } else {
jurzua
parents:
diff changeset
1571 elem[ jQuery.expando ] = null;
jurzua
parents:
diff changeset
1572 }
jurzua
parents:
diff changeset
1573 }
jurzua
parents:
diff changeset
1574 },
jurzua
parents:
diff changeset
1575
jurzua
parents:
diff changeset
1576 // For internal use only.
jurzua
parents:
diff changeset
1577 _data: function( elem, name, data ) {
jurzua
parents:
diff changeset
1578 return jQuery.data( elem, name, data, true );
jurzua
parents:
diff changeset
1579 },
jurzua
parents:
diff changeset
1580
jurzua
parents:
diff changeset
1581 // A method for determining if a DOM node can handle the data expando
jurzua
parents:
diff changeset
1582 acceptData: function( elem ) {
jurzua
parents:
diff changeset
1583 if ( elem.nodeName ) {
jurzua
parents:
diff changeset
1584 var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
jurzua
parents:
diff changeset
1585
jurzua
parents:
diff changeset
1586 if ( match ) {
jurzua
parents:
diff changeset
1587 return !(match === true || elem.getAttribute("classid") !== match);
jurzua
parents:
diff changeset
1588 }
jurzua
parents:
diff changeset
1589 }
jurzua
parents:
diff changeset
1590
jurzua
parents:
diff changeset
1591 return true;
jurzua
parents:
diff changeset
1592 }
jurzua
parents:
diff changeset
1593 });
jurzua
parents:
diff changeset
1594
jurzua
parents:
diff changeset
1595 jQuery.fn.extend({
jurzua
parents:
diff changeset
1596 data: function( key, value ) {
jurzua
parents:
diff changeset
1597 var data = null;
jurzua
parents:
diff changeset
1598
jurzua
parents:
diff changeset
1599 if ( typeof key === "undefined" ) {
jurzua
parents:
diff changeset
1600 if ( this.length ) {
jurzua
parents:
diff changeset
1601 data = jQuery.data( this[0] );
jurzua
parents:
diff changeset
1602
jurzua
parents:
diff changeset
1603 if ( this[0].nodeType === 1 ) {
jurzua
parents:
diff changeset
1604 var attr = this[0].attributes, name;
jurzua
parents:
diff changeset
1605 for ( var i = 0, l = attr.length; i < l; i++ ) {
jurzua
parents:
diff changeset
1606 name = attr[i].name;
jurzua
parents:
diff changeset
1607
jurzua
parents:
diff changeset
1608 if ( name.indexOf( "data-" ) === 0 ) {
jurzua
parents:
diff changeset
1609 name = jQuery.camelCase( name.substring(5) );
jurzua
parents:
diff changeset
1610
jurzua
parents:
diff changeset
1611 dataAttr( this[0], name, data[ name ] );
jurzua
parents:
diff changeset
1612 }
jurzua
parents:
diff changeset
1613 }
jurzua
parents:
diff changeset
1614 }
jurzua
parents:
diff changeset
1615 }
jurzua
parents:
diff changeset
1616
jurzua
parents:
diff changeset
1617 return data;
jurzua
parents:
diff changeset
1618
jurzua
parents:
diff changeset
1619 } else if ( typeof key === "object" ) {
jurzua
parents:
diff changeset
1620 return this.each(function() {
jurzua
parents:
diff changeset
1621 jQuery.data( this, key );
jurzua
parents:
diff changeset
1622 });
jurzua
parents:
diff changeset
1623 }
jurzua
parents:
diff changeset
1624
jurzua
parents:
diff changeset
1625 var parts = key.split(".");
jurzua
parents:
diff changeset
1626 parts[1] = parts[1] ? "." + parts[1] : "";
jurzua
parents:
diff changeset
1627
jurzua
parents:
diff changeset
1628 if ( value === undefined ) {
jurzua
parents:
diff changeset
1629 data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
jurzua
parents:
diff changeset
1630
jurzua
parents:
diff changeset
1631 // Try to fetch any internally stored data first
jurzua
parents:
diff changeset
1632 if ( data === undefined && this.length ) {
jurzua
parents:
diff changeset
1633 data = jQuery.data( this[0], key );
jurzua
parents:
diff changeset
1634 data = dataAttr( this[0], key, data );
jurzua
parents:
diff changeset
1635 }
jurzua
parents:
diff changeset
1636
jurzua
parents:
diff changeset
1637 return data === undefined && parts[1] ?
jurzua
parents:
diff changeset
1638 this.data( parts[0] ) :
jurzua
parents:
diff changeset
1639 data;
jurzua
parents:
diff changeset
1640
jurzua
parents:
diff changeset
1641 } else {
jurzua
parents:
diff changeset
1642 return this.each(function() {
jurzua
parents:
diff changeset
1643 var $this = jQuery( this ),
jurzua
parents:
diff changeset
1644 args = [ parts[0], value ];
jurzua
parents:
diff changeset
1645
jurzua
parents:
diff changeset
1646 $this.triggerHandler( "setData" + parts[1] + "!", args );
jurzua
parents:
diff changeset
1647 jQuery.data( this, key, value );
jurzua
parents:
diff changeset
1648 $this.triggerHandler( "changeData" + parts[1] + "!", args );
jurzua
parents:
diff changeset
1649 });
jurzua
parents:
diff changeset
1650 }
jurzua
parents:
diff changeset
1651 },
jurzua
parents:
diff changeset
1652
jurzua
parents:
diff changeset
1653 removeData: function( key ) {
jurzua
parents:
diff changeset
1654 return this.each(function() {
jurzua
parents:
diff changeset
1655 jQuery.removeData( this, key );
jurzua
parents:
diff changeset
1656 });
jurzua
parents:
diff changeset
1657 }
jurzua
parents:
diff changeset
1658 });
jurzua
parents:
diff changeset
1659
jurzua
parents:
diff changeset
1660 function dataAttr( elem, key, data ) {
jurzua
parents:
diff changeset
1661 // If nothing was found internally, try to fetch any
jurzua
parents:
diff changeset
1662 // data from the HTML5 data-* attribute
jurzua
parents:
diff changeset
1663 if ( data === undefined && elem.nodeType === 1 ) {
jurzua
parents:
diff changeset
1664 name = "data-" + key.replace( rmultiDash, "$1-$2" ).toLowerCase();
jurzua
parents:
diff changeset
1665
jurzua
parents:
diff changeset
1666 data = elem.getAttribute( name );
jurzua
parents:
diff changeset
1667
jurzua
parents:
diff changeset
1668 if ( typeof data === "string" ) {
jurzua
parents:
diff changeset
1669 try {
jurzua
parents:
diff changeset
1670 data = data === "true" ? true :
jurzua
parents:
diff changeset
1671 data === "false" ? false :
jurzua
parents:
diff changeset
1672 data === "null" ? null :
jurzua
parents:
diff changeset
1673 !jQuery.isNaN( data ) ? parseFloat( data ) :
jurzua
parents:
diff changeset
1674 rbrace.test( data ) ? jQuery.parseJSON( data ) :
jurzua
parents:
diff changeset
1675 data;
jurzua
parents:
diff changeset
1676 } catch( e ) {}
jurzua
parents:
diff changeset
1677
jurzua
parents:
diff changeset
1678 // Make sure we set the data so it isn't changed later
jurzua
parents:
diff changeset
1679 jQuery.data( elem, key, data );
jurzua
parents:
diff changeset
1680
jurzua
parents:
diff changeset
1681 } else {
jurzua
parents:
diff changeset
1682 data = undefined;
jurzua
parents:
diff changeset
1683 }
jurzua
parents:
diff changeset
1684 }
jurzua
parents:
diff changeset
1685
jurzua
parents:
diff changeset
1686 return data;
jurzua
parents:
diff changeset
1687 }
jurzua
parents:
diff changeset
1688
jurzua
parents:
diff changeset
1689 // TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON
jurzua
parents:
diff changeset
1690 // property to be considered empty objects; this property always exists in
jurzua
parents:
diff changeset
1691 // order to make sure JSON.stringify does not expose internal metadata
jurzua
parents:
diff changeset
1692 function isEmptyDataObject( obj ) {
jurzua
parents:
diff changeset
1693 for ( var name in obj ) {
jurzua
parents:
diff changeset
1694 if ( name !== "toJSON" ) {
jurzua
parents:
diff changeset
1695 return false;
jurzua
parents:
diff changeset
1696 }
jurzua
parents:
diff changeset
1697 }
jurzua
parents:
diff changeset
1698
jurzua
parents:
diff changeset
1699 return true;
jurzua
parents:
diff changeset
1700 }
jurzua
parents:
diff changeset
1701
jurzua
parents:
diff changeset
1702
jurzua
parents:
diff changeset
1703
jurzua
parents:
diff changeset
1704
jurzua
parents:
diff changeset
1705 function handleQueueMarkDefer( elem, type, src ) {
jurzua
parents:
diff changeset
1706 var deferDataKey = type + "defer",
jurzua
parents:
diff changeset
1707 queueDataKey = type + "queue",
jurzua
parents:
diff changeset
1708 markDataKey = type + "mark",
jurzua
parents:
diff changeset
1709 defer = jQuery.data( elem, deferDataKey, undefined, true );
jurzua
parents:
diff changeset
1710 if ( defer &&
jurzua
parents:
diff changeset
1711 ( src === "queue" || !jQuery.data( elem, queueDataKey, undefined, true ) ) &&
jurzua
parents:
diff changeset
1712 ( src === "mark" || !jQuery.data( elem, markDataKey, undefined, true ) ) ) {
jurzua
parents:
diff changeset
1713 // Give room for hard-coded callbacks to fire first
jurzua
parents:
diff changeset
1714 // and eventually mark/queue something else on the element
jurzua
parents:
diff changeset
1715 setTimeout( function() {
jurzua
parents:
diff changeset
1716 if ( !jQuery.data( elem, queueDataKey, undefined, true ) &&
jurzua
parents:
diff changeset
1717 !jQuery.data( elem, markDataKey, undefined, true ) ) {
jurzua
parents:
diff changeset
1718 jQuery.removeData( elem, deferDataKey, true );
jurzua
parents:
diff changeset
1719 defer.resolve();
jurzua
parents:
diff changeset
1720 }
jurzua
parents:
diff changeset
1721 }, 0 );
jurzua
parents:
diff changeset
1722 }
jurzua
parents:
diff changeset
1723 }
jurzua
parents:
diff changeset
1724
jurzua
parents:
diff changeset
1725 jQuery.extend({
jurzua
parents:
diff changeset
1726
jurzua
parents:
diff changeset
1727 _mark: function( elem, type ) {
jurzua
parents:
diff changeset
1728 if ( elem ) {
jurzua
parents:
diff changeset
1729 type = (type || "fx") + "mark";
jurzua
parents:
diff changeset
1730 jQuery.data( elem, type, (jQuery.data(elem,type,undefined,true) || 0) + 1, true );
jurzua
parents:
diff changeset
1731 }
jurzua
parents:
diff changeset
1732 },
jurzua
parents:
diff changeset
1733
jurzua
parents:
diff changeset
1734 _unmark: function( force, elem, type ) {
jurzua
parents:
diff changeset
1735 if ( force !== true ) {
jurzua
parents:
diff changeset
1736 type = elem;
jurzua
parents:
diff changeset
1737 elem = force;
jurzua
parents:
diff changeset
1738 force = false;
jurzua
parents:
diff changeset
1739 }
jurzua
parents:
diff changeset
1740 if ( elem ) {
jurzua
parents:
diff changeset
1741 type = type || "fx";
jurzua
parents:
diff changeset
1742 var key = type + "mark",
jurzua
parents:
diff changeset
1743 count = force ? 0 : ( (jQuery.data( elem, key, undefined, true) || 1 ) - 1 );
jurzua
parents:
diff changeset
1744 if ( count ) {
jurzua
parents:
diff changeset
1745 jQuery.data( elem, key, count, true );
jurzua
parents:
diff changeset
1746 } else {
jurzua
parents:
diff changeset
1747 jQuery.removeData( elem, key, true );
jurzua
parents:
diff changeset
1748 handleQueueMarkDefer( elem, type, "mark" );
jurzua
parents:
diff changeset
1749 }
jurzua
parents:
diff changeset
1750 }
jurzua
parents:
diff changeset
1751 },
jurzua
parents:
diff changeset
1752
jurzua
parents:
diff changeset
1753 queue: function( elem, type, data ) {
jurzua
parents:
diff changeset
1754 if ( elem ) {
jurzua
parents:
diff changeset
1755 type = (type || "fx") + "queue";
jurzua
parents:
diff changeset
1756 var q = jQuery.data( elem, type, undefined, true );
jurzua
parents:
diff changeset
1757 // Speed up dequeue by getting out quickly if this is just a lookup
jurzua
parents:
diff changeset
1758 if ( data ) {
jurzua
parents:
diff changeset
1759 if ( !q || jQuery.isArray(data) ) {
jurzua
parents:
diff changeset
1760 q = jQuery.data( elem, type, jQuery.makeArray(data), true );
jurzua
parents:
diff changeset
1761 } else {
jurzua
parents:
diff changeset
1762 q.push( data );
jurzua
parents:
diff changeset
1763 }
jurzua
parents:
diff changeset
1764 }
jurzua
parents:
diff changeset
1765 return q || [];
jurzua
parents:
diff changeset
1766 }
jurzua
parents:
diff changeset
1767 },
jurzua
parents:
diff changeset
1768
jurzua
parents:
diff changeset
1769 dequeue: function( elem, type ) {
jurzua
parents:
diff changeset
1770 type = type || "fx";
jurzua
parents:
diff changeset
1771
jurzua
parents:
diff changeset
1772 var queue = jQuery.queue( elem, type ),
jurzua
parents:
diff changeset
1773 fn = queue.shift(),
jurzua
parents:
diff changeset
1774 defer;
jurzua
parents:
diff changeset
1775
jurzua
parents:
diff changeset
1776 // If the fx queue is dequeued, always remove the progress sentinel
jurzua
parents:
diff changeset
1777 if ( fn === "inprogress" ) {
jurzua
parents:
diff changeset
1778 fn = queue.shift();
jurzua
parents:
diff changeset
1779 }
jurzua
parents:
diff changeset
1780
jurzua
parents:
diff changeset
1781 if ( fn ) {
jurzua
parents:
diff changeset
1782 // Add a progress sentinel to prevent the fx queue from being
jurzua
parents:
diff changeset
1783 // automatically dequeued
jurzua
parents:
diff changeset
1784 if ( type === "fx" ) {
jurzua
parents:
diff changeset
1785 queue.unshift("inprogress");
jurzua
parents:
diff changeset
1786 }
jurzua
parents:
diff changeset
1787
jurzua
parents:
diff changeset
1788 fn.call(elem, function() {
jurzua
parents:
diff changeset
1789 jQuery.dequeue(elem, type);
jurzua
parents:
diff changeset
1790 });
jurzua
parents:
diff changeset
1791 }
jurzua
parents:
diff changeset
1792
jurzua
parents:
diff changeset
1793 if ( !queue.length ) {
jurzua
parents:
diff changeset
1794 jQuery.removeData( elem, type + "queue", true );
jurzua
parents:
diff changeset
1795 handleQueueMarkDefer( elem, type, "queue" );
jurzua
parents:
diff changeset
1796 }
jurzua
parents:
diff changeset
1797 }
jurzua
parents:
diff changeset
1798 });
jurzua
parents:
diff changeset
1799
jurzua
parents:
diff changeset
1800 jQuery.fn.extend({
jurzua
parents:
diff changeset
1801 queue: function( type, data ) {
jurzua
parents:
diff changeset
1802 if ( typeof type !== "string" ) {
jurzua
parents:
diff changeset
1803 data = type;
jurzua
parents:
diff changeset
1804 type = "fx";
jurzua
parents:
diff changeset
1805 }
jurzua
parents:
diff changeset
1806
jurzua
parents:
diff changeset
1807 if ( data === undefined ) {
jurzua
parents:
diff changeset
1808 return jQuery.queue( this[0], type );
jurzua
parents:
diff changeset
1809 }
jurzua
parents:
diff changeset
1810 return this.each(function() {
jurzua
parents:
diff changeset
1811 var queue = jQuery.queue( this, type, data );
jurzua
parents:
diff changeset
1812
jurzua
parents:
diff changeset
1813 if ( type === "fx" && queue[0] !== "inprogress" ) {
jurzua
parents:
diff changeset
1814 jQuery.dequeue( this, type );
jurzua
parents:
diff changeset
1815 }
jurzua
parents:
diff changeset
1816 });
jurzua
parents:
diff changeset
1817 },
jurzua
parents:
diff changeset
1818 dequeue: function( type ) {
jurzua
parents:
diff changeset
1819 return this.each(function() {
jurzua
parents:
diff changeset
1820 jQuery.dequeue( this, type );
jurzua
parents:
diff changeset
1821 });
jurzua
parents:
diff changeset
1822 },
jurzua
parents:
diff changeset
1823 // Based off of the plugin by Clint Helfers, with permission.
jurzua
parents:
diff changeset
1824 // http://blindsignals.com/index.php/2009/07/jquery-delay/
jurzua
parents:
diff changeset
1825 delay: function( time, type ) {
jurzua
parents:
diff changeset
1826 time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
jurzua
parents:
diff changeset
1827 type = type || "fx";
jurzua
parents:
diff changeset
1828
jurzua
parents:
diff changeset
1829 return this.queue( type, function() {
jurzua
parents:
diff changeset
1830 var elem = this;
jurzua
parents:
diff changeset
1831 setTimeout(function() {
jurzua
parents:
diff changeset
1832 jQuery.dequeue( elem, type );
jurzua
parents:
diff changeset
1833 }, time );
jurzua
parents:
diff changeset
1834 });
jurzua
parents:
diff changeset
1835 },
jurzua
parents:
diff changeset
1836 clearQueue: function( type ) {
jurzua
parents:
diff changeset
1837 return this.queue( type || "fx", [] );
jurzua
parents:
diff changeset
1838 },
jurzua
parents:
diff changeset
1839 // Get a promise resolved when queues of a certain type
jurzua
parents:
diff changeset
1840 // are emptied (fx is the type by default)
jurzua
parents:
diff changeset
1841 promise: function( type, object ) {
jurzua
parents:
diff changeset
1842 if ( typeof type !== "string" ) {
jurzua
parents:
diff changeset
1843 object = type;
jurzua
parents:
diff changeset
1844 type = undefined;
jurzua
parents:
diff changeset
1845 }
jurzua
parents:
diff changeset
1846 type = type || "fx";
jurzua
parents:
diff changeset
1847 var defer = jQuery.Deferred(),
jurzua
parents:
diff changeset
1848 elements = this,
jurzua
parents:
diff changeset
1849 i = elements.length,
jurzua
parents:
diff changeset
1850 count = 1,
jurzua
parents:
diff changeset
1851 deferDataKey = type + "defer",
jurzua
parents:
diff changeset
1852 queueDataKey = type + "queue",
jurzua
parents:
diff changeset
1853 markDataKey = type + "mark";
jurzua
parents:
diff changeset
1854 function resolve() {
jurzua
parents:
diff changeset
1855 if ( !( --count ) ) {
jurzua
parents:
diff changeset
1856 defer.resolveWith( elements, [ elements ] );
jurzua
parents:
diff changeset
1857 }
jurzua
parents:
diff changeset
1858 }
jurzua
parents:
diff changeset
1859 while( i-- ) {
jurzua
parents:
diff changeset
1860 if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
jurzua
parents:
diff changeset
1861 ( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
jurzua
parents:
diff changeset
1862 jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
jurzua
parents:
diff changeset
1863 jQuery.data( elements[ i ], deferDataKey, jQuery._Deferred(), true ) )) {
jurzua
parents:
diff changeset
1864 count++;
jurzua
parents:
diff changeset
1865 tmp.done( resolve );
jurzua
parents:
diff changeset
1866 }
jurzua
parents:
diff changeset
1867 }
jurzua
parents:
diff changeset
1868 resolve();
jurzua
parents:
diff changeset
1869 return defer.promise();
jurzua
parents:
diff changeset
1870 }
jurzua
parents:
diff changeset
1871 });
jurzua
parents:
diff changeset
1872
jurzua
parents:
diff changeset
1873
jurzua
parents:
diff changeset
1874
jurzua
parents:
diff changeset
1875
jurzua
parents:
diff changeset
1876 var rclass = /[\n\t\r]/g,
jurzua
parents:
diff changeset
1877 rspace = /\s+/,
jurzua
parents:
diff changeset
1878 rreturn = /\r/g,
jurzua
parents:
diff changeset
1879 rtype = /^(?:button|input)$/i,
jurzua
parents:
diff changeset
1880 rfocusable = /^(?:button|input|object|select|textarea)$/i,
jurzua
parents:
diff changeset
1881 rclickable = /^a(?:rea)?$/i,
jurzua
parents:
diff changeset
1882 rspecial = /^(?:data-|aria-)/,
jurzua
parents:
diff changeset
1883 rinvalidChar = /\:/,
jurzua
parents:
diff changeset
1884 formHook;
jurzua
parents:
diff changeset
1885
jurzua
parents:
diff changeset
1886 jQuery.fn.extend({
jurzua
parents:
diff changeset
1887 attr: function( name, value ) {
jurzua
parents:
diff changeset
1888 return jQuery.access( this, name, value, true, jQuery.attr );
jurzua
parents:
diff changeset
1889 },
jurzua
parents:
diff changeset
1890
jurzua
parents:
diff changeset
1891 removeAttr: function( name ) {
jurzua
parents:
diff changeset
1892 return this.each(function() {
jurzua
parents:
diff changeset
1893 jQuery.removeAttr( this, name );
jurzua
parents:
diff changeset
1894 });
jurzua
parents:
diff changeset
1895 },
jurzua
parents:
diff changeset
1896
jurzua
parents:
diff changeset
1897 prop: function( name, value ) {
jurzua
parents:
diff changeset
1898 return jQuery.access( this, name, value, true, jQuery.prop );
jurzua
parents:
diff changeset
1899 },
jurzua
parents:
diff changeset
1900
jurzua
parents:
diff changeset
1901 removeProp: function( name ) {
jurzua
parents:
diff changeset
1902 return this.each(function() {
jurzua
parents:
diff changeset
1903 // try/catch handles cases where IE balks (such as removing a property on window)
jurzua
parents:
diff changeset
1904 try {
jurzua
parents:
diff changeset
1905 this[ name ] = undefined;
jurzua
parents:
diff changeset
1906 delete this[ name ];
jurzua
parents:
diff changeset
1907 } catch( e ) {}
jurzua
parents:
diff changeset
1908 });
jurzua
parents:
diff changeset
1909 },
jurzua
parents:
diff changeset
1910
jurzua
parents:
diff changeset
1911 addClass: function( value ) {
jurzua
parents:
diff changeset
1912 if ( jQuery.isFunction( value ) ) {
jurzua
parents:
diff changeset
1913 return this.each(function(i) {
jurzua
parents:
diff changeset
1914 var self = jQuery(this);
jurzua
parents:
diff changeset
1915 self.addClass( value.call(this, i, self.attr("class") || "") );
jurzua
parents:
diff changeset
1916 });
jurzua
parents:
diff changeset
1917 }
jurzua
parents:
diff changeset
1918
jurzua
parents:
diff changeset
1919 if ( value && typeof value === "string" ) {
jurzua
parents:
diff changeset
1920 var classNames = (value || "").split( rspace );
jurzua
parents:
diff changeset
1921
jurzua
parents:
diff changeset
1922 for ( var i = 0, l = this.length; i < l; i++ ) {
jurzua
parents:
diff changeset
1923 var elem = this[i];
jurzua
parents:
diff changeset
1924
jurzua
parents:
diff changeset
1925 if ( elem.nodeType === 1 ) {
jurzua
parents:
diff changeset
1926 if ( !elem.className ) {
jurzua
parents:
diff changeset
1927 elem.className = value;
jurzua
parents:
diff changeset
1928
jurzua
parents:
diff changeset
1929 } else {
jurzua
parents:
diff changeset
1930 var className = " " + elem.className + " ",
jurzua
parents:
diff changeset
1931 setClass = elem.className;
jurzua
parents:
diff changeset
1932
jurzua
parents:
diff changeset
1933 for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
jurzua
parents:
diff changeset
1934 if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) {
jurzua
parents:
diff changeset
1935 setClass += " " + classNames[c];
jurzua
parents:
diff changeset
1936 }
jurzua
parents:
diff changeset
1937 }
jurzua
parents:
diff changeset
1938 elem.className = jQuery.trim( setClass );
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 return this;
jurzua
parents:
diff changeset
1945 },
jurzua
parents:
diff changeset
1946
jurzua
parents:
diff changeset
1947 removeClass: function( value ) {
jurzua
parents:
diff changeset
1948 if ( jQuery.isFunction(value) ) {
jurzua
parents:
diff changeset
1949 return this.each(function(i) {
jurzua
parents:
diff changeset
1950 var self = jQuery(this);
jurzua
parents:
diff changeset
1951 self.removeClass( value.call(this, i, self.attr("class")) );
jurzua
parents:
diff changeset
1952 });
jurzua
parents:
diff changeset
1953 }
jurzua
parents:
diff changeset
1954
jurzua
parents:
diff changeset
1955 if ( (value && typeof value === "string") || value === undefined ) {
jurzua
parents:
diff changeset
1956 var classNames = (value || "").split( rspace );
jurzua
parents:
diff changeset
1957
jurzua
parents:
diff changeset
1958 for ( var i = 0, l = this.length; i < l; i++ ) {
jurzua
parents:
diff changeset
1959 var elem = this[i];
jurzua
parents:
diff changeset
1960
jurzua
parents:
diff changeset
1961 if ( elem.nodeType === 1 && elem.className ) {
jurzua
parents:
diff changeset
1962 if ( value ) {
jurzua
parents:
diff changeset
1963 var className = (" " + elem.className + " ").replace(rclass, " ");
jurzua
parents:
diff changeset
1964 for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
jurzua
parents:
diff changeset
1965 className = className.replace(" " + classNames[c] + " ", " ");
jurzua
parents:
diff changeset
1966 }
jurzua
parents:
diff changeset
1967 elem.className = jQuery.trim( className );
jurzua
parents:
diff changeset
1968
jurzua
parents:
diff changeset
1969 } else {
jurzua
parents:
diff changeset
1970 elem.className = "";
jurzua
parents:
diff changeset
1971 }
jurzua
parents:
diff changeset
1972 }
jurzua
parents:
diff changeset
1973 }
jurzua
parents:
diff changeset
1974 }
jurzua
parents:
diff changeset
1975
jurzua
parents:
diff changeset
1976 return this;
jurzua
parents:
diff changeset
1977 },
jurzua
parents:
diff changeset
1978
jurzua
parents:
diff changeset
1979 toggleClass: function( value, stateVal ) {
jurzua
parents:
diff changeset
1980 var type = typeof value,
jurzua
parents:
diff changeset
1981 isBool = typeof stateVal === "boolean";
jurzua
parents:
diff changeset
1982
jurzua
parents:
diff changeset
1983 if ( jQuery.isFunction( value ) ) {
jurzua
parents:
diff changeset
1984 return this.each(function(i) {
jurzua
parents:
diff changeset
1985 var self = jQuery(this);
jurzua
parents:
diff changeset
1986 self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal );
jurzua
parents:
diff changeset
1987 });
jurzua
parents:
diff changeset
1988 }
jurzua
parents:
diff changeset
1989
jurzua
parents:
diff changeset
1990 return this.each(function() {
jurzua
parents:
diff changeset
1991 if ( type === "string" ) {
jurzua
parents:
diff changeset
1992 // toggle individual class names
jurzua
parents:
diff changeset
1993 var className,
jurzua
parents:
diff changeset
1994 i = 0,
jurzua
parents:
diff changeset
1995 self = jQuery( this ),
jurzua
parents:
diff changeset
1996 state = stateVal,
jurzua
parents:
diff changeset
1997 classNames = value.split( rspace );
jurzua
parents:
diff changeset
1998
jurzua
parents:
diff changeset
1999 while ( (className = classNames[ i++ ]) ) {
jurzua
parents:
diff changeset
2000 // check each className given, space seperated list
jurzua
parents:
diff changeset
2001 state = isBool ? state : !self.hasClass( className );
jurzua
parents:
diff changeset
2002 self[ state ? "addClass" : "removeClass" ]( className );
jurzua
parents:
diff changeset
2003 }
jurzua
parents:
diff changeset
2004
jurzua
parents:
diff changeset
2005 } else if ( type === "undefined" || type === "boolean" ) {
jurzua
parents:
diff changeset
2006 if ( this.className ) {
jurzua
parents:
diff changeset
2007 // store className if set
jurzua
parents:
diff changeset
2008 jQuery._data( this, "__className__", this.className );
jurzua
parents:
diff changeset
2009 }
jurzua
parents:
diff changeset
2010
jurzua
parents:
diff changeset
2011 // toggle whole className
jurzua
parents:
diff changeset
2012 this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
jurzua
parents:
diff changeset
2013 }
jurzua
parents:
diff changeset
2014 });
jurzua
parents:
diff changeset
2015 },
jurzua
parents:
diff changeset
2016
jurzua
parents:
diff changeset
2017 hasClass: function( selector ) {
jurzua
parents:
diff changeset
2018 var className = " " + selector + " ";
jurzua
parents:
diff changeset
2019 for ( var i = 0, l = this.length; i < l; i++ ) {
jurzua
parents:
diff changeset
2020 if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
jurzua
parents:
diff changeset
2021 return true;
jurzua
parents:
diff changeset
2022 }
jurzua
parents:
diff changeset
2023 }
jurzua
parents:
diff changeset
2024
jurzua
parents:
diff changeset
2025 return false;
jurzua
parents:
diff changeset
2026 },
jurzua
parents:
diff changeset
2027
jurzua
parents:
diff changeset
2028 val: function( value ) {
jurzua
parents:
diff changeset
2029 var hooks, ret,
jurzua
parents:
diff changeset
2030 elem = this[0];
jurzua
parents:
diff changeset
2031
jurzua
parents:
diff changeset
2032 if ( !arguments.length ) {
jurzua
parents:
diff changeset
2033 if ( elem ) {
jurzua
parents:
diff changeset
2034 hooks = jQuery.valHooks[ elem.nodeName.toLowerCase() ] || jQuery.valHooks[ elem.type ];
jurzua
parents:
diff changeset
2035
jurzua
parents:
diff changeset
2036 if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
jurzua
parents:
diff changeset
2037 return ret;
jurzua
parents:
diff changeset
2038 }
jurzua
parents:
diff changeset
2039
jurzua
parents:
diff changeset
2040 return (elem.value || "").replace(rreturn, "");
jurzua
parents:
diff changeset
2041 }
jurzua
parents:
diff changeset
2042
jurzua
parents:
diff changeset
2043 return undefined;
jurzua
parents:
diff changeset
2044 }
jurzua
parents:
diff changeset
2045
jurzua
parents:
diff changeset
2046 var isFunction = jQuery.isFunction( value );
jurzua
parents:
diff changeset
2047
jurzua
parents:
diff changeset
2048 return this.each(function( i ) {
jurzua
parents:
diff changeset
2049 var self = jQuery(this), val;
jurzua
parents:
diff changeset
2050
jurzua
parents:
diff changeset
2051 if ( this.nodeType !== 1 ) {
jurzua
parents:
diff changeset
2052 return;
jurzua
parents:
diff changeset
2053 }
jurzua
parents:
diff changeset
2054
jurzua
parents:
diff changeset
2055 if ( isFunction ) {
jurzua
parents:
diff changeset
2056 val = value.call( this, i, self.val() );
jurzua
parents:
diff changeset
2057 } else {
jurzua
parents:
diff changeset
2058 val = value;
jurzua
parents:
diff changeset
2059 }
jurzua
parents:
diff changeset
2060
jurzua
parents:
diff changeset
2061 // Treat null/undefined as ""; convert numbers to string
jurzua
parents:
diff changeset
2062 if ( val == null ) {
jurzua
parents:
diff changeset
2063 val = "";
jurzua
parents:
diff changeset
2064 } else if ( typeof val === "number" ) {
jurzua
parents:
diff changeset
2065 val += "";
jurzua
parents:
diff changeset
2066 } else if ( jQuery.isArray( val ) ) {
jurzua
parents:
diff changeset
2067 val = jQuery.map(val, function ( value ) {
jurzua
parents:
diff changeset
2068 return value == null ? "" : value + "";
jurzua
parents:
diff changeset
2069 });
jurzua
parents:
diff changeset
2070 }
jurzua
parents:
diff changeset
2071
jurzua
parents:
diff changeset
2072 hooks = jQuery.valHooks[ this.nodeName.toLowerCase() ] || jQuery.valHooks[ this.type ];
jurzua
parents:
diff changeset
2073
jurzua
parents:
diff changeset
2074 // If set returns undefined, fall back to normal setting
jurzua
parents:
diff changeset
2075 if ( !hooks || ("set" in hooks && hooks.set( this, val, "value" ) === undefined) ) {
jurzua
parents:
diff changeset
2076 this.value = val;
jurzua
parents:
diff changeset
2077 }
jurzua
parents:
diff changeset
2078 });
jurzua
parents:
diff changeset
2079 }
jurzua
parents:
diff changeset
2080 });
jurzua
parents:
diff changeset
2081
jurzua
parents:
diff changeset
2082 jQuery.extend({
jurzua
parents:
diff changeset
2083 valHooks: {
jurzua
parents:
diff changeset
2084 option: {
jurzua
parents:
diff changeset
2085 get: function( elem ) {
jurzua
parents:
diff changeset
2086 // attributes.value is undefined in Blackberry 4.7 but
jurzua
parents:
diff changeset
2087 // uses .value. See #6932
jurzua
parents:
diff changeset
2088 var val = elem.attributes.value;
jurzua
parents:
diff changeset
2089 return !val || val.specified ? elem.value : elem.text;
jurzua
parents:
diff changeset
2090 }
jurzua
parents:
diff changeset
2091 },
jurzua
parents:
diff changeset
2092 select: {
jurzua
parents:
diff changeset
2093 get: function( elem ) {
jurzua
parents:
diff changeset
2094 var index = elem.selectedIndex,
jurzua
parents:
diff changeset
2095 values = [],
jurzua
parents:
diff changeset
2096 options = elem.options,
jurzua
parents:
diff changeset
2097 one = elem.type === "select-one";
jurzua
parents:
diff changeset
2098
jurzua
parents:
diff changeset
2099 // Nothing was selected
jurzua
parents:
diff changeset
2100 if ( index < 0 ) {
jurzua
parents:
diff changeset
2101 return null;
jurzua
parents:
diff changeset
2102 }
jurzua
parents:
diff changeset
2103
jurzua
parents:
diff changeset
2104 // Loop through all the selected options
jurzua
parents:
diff changeset
2105 for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
jurzua
parents:
diff changeset
2106 var option = options[ i ];
jurzua
parents:
diff changeset
2107
jurzua
parents:
diff changeset
2108 // Don't return options that are disabled or in a disabled optgroup
jurzua
parents:
diff changeset
2109 if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
jurzua
parents:
diff changeset
2110 (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
jurzua
parents:
diff changeset
2111
jurzua
parents:
diff changeset
2112 // Get the specific value for the option
jurzua
parents:
diff changeset
2113 value = jQuery( option ).val();
jurzua
parents:
diff changeset
2114
jurzua
parents:
diff changeset
2115 // We don't need an array for one selects
jurzua
parents:
diff changeset
2116 if ( one ) {
jurzua
parents:
diff changeset
2117 return value;
jurzua
parents:
diff changeset
2118 }
jurzua
parents:
diff changeset
2119
jurzua
parents:
diff changeset
2120 // Multi-Selects return an array
jurzua
parents:
diff changeset
2121 values.push( value );
jurzua
parents:
diff changeset
2122 }
jurzua
parents:
diff changeset
2123 }
jurzua
parents:
diff changeset
2124
jurzua
parents:
diff changeset
2125 // Fixes Bug #2551 -- select.val() broken in IE after form.reset()
jurzua
parents:
diff changeset
2126 if ( one && !values.length && options.length ) {
jurzua
parents:
diff changeset
2127 return jQuery( options[ index ] ).val();
jurzua
parents:
diff changeset
2128 }
jurzua
parents:
diff changeset
2129
jurzua
parents:
diff changeset
2130 return values;
jurzua
parents:
diff changeset
2131 },
jurzua
parents:
diff changeset
2132
jurzua
parents:
diff changeset
2133 set: function( elem, value ) {
jurzua
parents:
diff changeset
2134 var values = jQuery.makeArray( value );
jurzua
parents:
diff changeset
2135
jurzua
parents:
diff changeset
2136 jQuery(elem).find("option").each(function() {
jurzua
parents:
diff changeset
2137 this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
jurzua
parents:
diff changeset
2138 });
jurzua
parents:
diff changeset
2139
jurzua
parents:
diff changeset
2140 if ( !values.length ) {
jurzua
parents:
diff changeset
2141 elem.selectedIndex = -1;
jurzua
parents:
diff changeset
2142 }
jurzua
parents:
diff changeset
2143 return values;
jurzua
parents:
diff changeset
2144 }
jurzua
parents:
diff changeset
2145 }
jurzua
parents:
diff changeset
2146 },
jurzua
parents:
diff changeset
2147
jurzua
parents:
diff changeset
2148 attrFn: {
jurzua
parents:
diff changeset
2149 val: true,
jurzua
parents:
diff changeset
2150 css: true,
jurzua
parents:
diff changeset
2151 html: true,
jurzua
parents:
diff changeset
2152 text: true,
jurzua
parents:
diff changeset
2153 data: true,
jurzua
parents:
diff changeset
2154 width: true,
jurzua
parents:
diff changeset
2155 height: true,
jurzua
parents:
diff changeset
2156 offset: true
jurzua
parents:
diff changeset
2157 },
jurzua
parents:
diff changeset
2158
jurzua
parents:
diff changeset
2159 attrFix: {
jurzua
parents:
diff changeset
2160 // Always normalize to ensure hook usage
jurzua
parents:
diff changeset
2161 tabindex: "tabIndex",
jurzua
parents:
diff changeset
2162 readonly: "readOnly"
jurzua
parents:
diff changeset
2163 },
jurzua
parents:
diff changeset
2164
jurzua
parents:
diff changeset
2165 attr: function( elem, name, value, pass ) {
jurzua
parents:
diff changeset
2166 var nType = elem.nodeType;
jurzua
parents:
diff changeset
2167
jurzua
parents:
diff changeset
2168 // don't get/set attributes on text, comment and attribute nodes
jurzua
parents:
diff changeset
2169 if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
jurzua
parents:
diff changeset
2170 return undefined;
jurzua
parents:
diff changeset
2171 }
jurzua
parents:
diff changeset
2172
jurzua
parents:
diff changeset
2173 if ( pass && name in jQuery.attrFn ) {
jurzua
parents:
diff changeset
2174 return jQuery( elem )[ name ]( value );
jurzua
parents:
diff changeset
2175 }
jurzua
parents:
diff changeset
2176
jurzua
parents:
diff changeset
2177 var ret, hooks,
jurzua
parents:
diff changeset
2178 notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
jurzua
parents:
diff changeset
2179
jurzua
parents:
diff changeset
2180 // Normalize the name if needed
jurzua
parents:
diff changeset
2181 name = notxml && jQuery.attrFix[ name ] || name;
jurzua
parents:
diff changeset
2182
jurzua
parents:
diff changeset
2183 // Get the appropriate hook, or the formHook
jurzua
parents:
diff changeset
2184 // if getSetAttribute is not supported and we have form objects in IE6/7
jurzua
parents:
diff changeset
2185 hooks = jQuery.attrHooks[ name ] ||
jurzua
parents:
diff changeset
2186 ( formHook && (jQuery.nodeName( elem, "form" ) || rinvalidChar.test( name )) ?
jurzua
parents:
diff changeset
2187 formHook :
jurzua
parents:
diff changeset
2188 undefined );
jurzua
parents:
diff changeset
2189
jurzua
parents:
diff changeset
2190 if ( value !== undefined ) {
jurzua
parents:
diff changeset
2191
jurzua
parents:
diff changeset
2192 if ( value === null || (value === false && !rspecial.test( name )) ) {
jurzua
parents:
diff changeset
2193 jQuery.removeAttr( elem, name );
jurzua
parents:
diff changeset
2194 return undefined;
jurzua
parents:
diff changeset
2195
jurzua
parents:
diff changeset
2196 } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
jurzua
parents:
diff changeset
2197 return ret;
jurzua
parents:
diff changeset
2198
jurzua
parents:
diff changeset
2199 } else {
jurzua
parents:
diff changeset
2200
jurzua
parents:
diff changeset
2201 // Set boolean attributes to the same name
jurzua
parents:
diff changeset
2202 if ( value === true && !rspecial.test( name ) ) {
jurzua
parents:
diff changeset
2203 value = name;
jurzua
parents:
diff changeset
2204 }
jurzua
parents:
diff changeset
2205
jurzua
parents:
diff changeset
2206 elem.setAttribute( name, "" + value );
jurzua
parents:
diff changeset
2207 return value;
jurzua
parents:
diff changeset
2208 }
jurzua
parents:
diff changeset
2209
jurzua
parents:
diff changeset
2210 } else {
jurzua
parents:
diff changeset
2211
jurzua
parents:
diff changeset
2212 if ( hooks && "get" in hooks && notxml ) {
jurzua
parents:
diff changeset
2213 return hooks.get( elem, name );
jurzua
parents:
diff changeset
2214
jurzua
parents:
diff changeset
2215 } else {
jurzua
parents:
diff changeset
2216
jurzua
parents:
diff changeset
2217 ret = elem.getAttribute( name );
jurzua
parents:
diff changeset
2218
jurzua
parents:
diff changeset
2219 // Non-existent attributes return null, we normalize to undefined
jurzua
parents:
diff changeset
2220 return ret === null ?
jurzua
parents:
diff changeset
2221 undefined :
jurzua
parents:
diff changeset
2222 ret;
jurzua
parents:
diff changeset
2223 }
jurzua
parents:
diff changeset
2224 }
jurzua
parents:
diff changeset
2225 },
jurzua
parents:
diff changeset
2226
jurzua
parents:
diff changeset
2227 removeAttr: function( elem, name ) {
jurzua
parents:
diff changeset
2228 if ( elem.nodeType === 1 ) {
jurzua
parents:
diff changeset
2229 name = jQuery.attrFix[ name ] || name;
jurzua
parents:
diff changeset
2230
jurzua
parents:
diff changeset
2231 if ( jQuery.support.getSetAttribute ) {
jurzua
parents:
diff changeset
2232 // Use removeAttribute in browsers that support it
jurzua
parents:
diff changeset
2233 elem.removeAttribute( name );
jurzua
parents:
diff changeset
2234 } else {
jurzua
parents:
diff changeset
2235 jQuery.attr( elem, name, "" );
jurzua
parents:
diff changeset
2236 elem.removeAttributeNode( elem.getAttributeNode( name ) );
jurzua
parents:
diff changeset
2237 }
jurzua
parents:
diff changeset
2238 }
jurzua
parents:
diff changeset
2239 },
jurzua
parents:
diff changeset
2240
jurzua
parents:
diff changeset
2241 attrHooks: {
jurzua
parents:
diff changeset
2242 type: {
jurzua
parents:
diff changeset
2243 set: function( elem, value ) {
jurzua
parents:
diff changeset
2244 // We can't allow the type property to be changed (since it causes problems in IE)
jurzua
parents:
diff changeset
2245 if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
jurzua
parents:
diff changeset
2246 jQuery.error( "type property can't be changed" );
jurzua
parents:
diff changeset
2247 } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
jurzua
parents:
diff changeset
2248 // Setting the type on a radio button after the value resets the value in IE6-9
jurzua
parents:
diff changeset
2249 // Reset value to it's default in case type is set after value
jurzua
parents:
diff changeset
2250 // This is for element creation
jurzua
parents:
diff changeset
2251 var val = elem.getAttribute("value");
jurzua
parents:
diff changeset
2252 elem.setAttribute( "type", value );
jurzua
parents:
diff changeset
2253 if ( val ) {
jurzua
parents:
diff changeset
2254 elem.value = val;
jurzua
parents:
diff changeset
2255 }
jurzua
parents:
diff changeset
2256 return value;
jurzua
parents:
diff changeset
2257 }
jurzua
parents:
diff changeset
2258 }
jurzua
parents:
diff changeset
2259 },
jurzua
parents:
diff changeset
2260 tabIndex: {
jurzua
parents:
diff changeset
2261 get: function( elem ) {
jurzua
parents:
diff changeset
2262 // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
jurzua
parents:
diff changeset
2263 // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
jurzua
parents:
diff changeset
2264 var attributeNode = elem.getAttributeNode("tabIndex");
jurzua
parents:
diff changeset
2265
jurzua
parents:
diff changeset
2266 return attributeNode && attributeNode.specified ?
jurzua
parents:
diff changeset
2267 parseInt( attributeNode.value, 10 ) :
jurzua
parents:
diff changeset
2268 rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
jurzua
parents:
diff changeset
2269 0 :
jurzua
parents:
diff changeset
2270 undefined;
jurzua
parents:
diff changeset
2271 }
jurzua
parents:
diff changeset
2272 }
jurzua
parents:
diff changeset
2273 },
jurzua
parents:
diff changeset
2274
jurzua
parents:
diff changeset
2275 propFix: {},
jurzua
parents:
diff changeset
2276
jurzua
parents:
diff changeset
2277 prop: function( elem, name, value ) {
jurzua
parents:
diff changeset
2278 var nType = elem.nodeType;
jurzua
parents:
diff changeset
2279
jurzua
parents:
diff changeset
2280 // don't get/set properties on text, comment and attribute nodes
jurzua
parents:
diff changeset
2281 if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
jurzua
parents:
diff changeset
2282 return undefined;
jurzua
parents:
diff changeset
2283 }
jurzua
parents:
diff changeset
2284
jurzua
parents:
diff changeset
2285 var ret, hooks,
jurzua
parents:
diff changeset
2286 notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
jurzua
parents:
diff changeset
2287
jurzua
parents:
diff changeset
2288 // Try to normalize/fix the name
jurzua
parents:
diff changeset
2289 name = notxml && jQuery.propFix[ name ] || name;
jurzua
parents:
diff changeset
2290
jurzua
parents:
diff changeset
2291 hooks = jQuery.propHooks[ name ];
jurzua
parents:
diff changeset
2292
jurzua
parents:
diff changeset
2293 if ( value !== undefined ) {
jurzua
parents:
diff changeset
2294 if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
jurzua
parents:
diff changeset
2295 return ret;
jurzua
parents:
diff changeset
2296
jurzua
parents:
diff changeset
2297 } else {
jurzua
parents:
diff changeset
2298 return (elem[ name ] = value);
jurzua
parents:
diff changeset
2299 }
jurzua
parents:
diff changeset
2300
jurzua
parents:
diff changeset
2301 } else {
jurzua
parents:
diff changeset
2302 if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== undefined ) {
jurzua
parents:
diff changeset
2303 return ret;
jurzua
parents:
diff changeset
2304
jurzua
parents:
diff changeset
2305 } else {
jurzua
parents:
diff changeset
2306 return elem[ name ];
jurzua
parents:
diff changeset
2307 }
jurzua
parents:
diff changeset
2308 }
jurzua
parents:
diff changeset
2309 },
jurzua
parents:
diff changeset
2310
jurzua
parents:
diff changeset
2311 propHooks: {}
jurzua
parents:
diff changeset
2312 });
jurzua
parents:
diff changeset
2313
jurzua
parents:
diff changeset
2314 // IE6/7 do not support getting/setting some attributes with get/setAttribute
jurzua
parents:
diff changeset
2315 if ( !jQuery.support.getSetAttribute ) {
jurzua
parents:
diff changeset
2316 jQuery.attrFix = jQuery.extend( jQuery.attrFix, {
jurzua
parents:
diff changeset
2317 "for": "htmlFor",
jurzua
parents:
diff changeset
2318 "class": "className",
jurzua
parents:
diff changeset
2319 maxlength: "maxLength",
jurzua
parents:
diff changeset
2320 cellspacing: "cellSpacing",
jurzua
parents:
diff changeset
2321 cellpadding: "cellPadding",
jurzua
parents:
diff changeset
2322 rowspan: "rowSpan",
jurzua
parents:
diff changeset
2323 colspan: "colSpan",
jurzua
parents:
diff changeset
2324 usemap: "useMap",
jurzua
parents:
diff changeset
2325 frameborder: "frameBorder"
jurzua
parents:
diff changeset
2326 });
jurzua
parents:
diff changeset
2327
jurzua
parents:
diff changeset
2328 // Use this for any attribute on a form in IE6/7
jurzua
parents:
diff changeset
2329 formHook = jQuery.attrHooks.name = jQuery.attrHooks.value = jQuery.valHooks.button = {
jurzua
parents:
diff changeset
2330 get: function( elem, name ) {
jurzua
parents:
diff changeset
2331 var ret;
jurzua
parents:
diff changeset
2332 if ( name === "value" && !jQuery.nodeName( elem, "button" ) ) {
jurzua
parents:
diff changeset
2333 return elem.getAttribute( name );
jurzua
parents:
diff changeset
2334 }
jurzua
parents:
diff changeset
2335 ret = elem.getAttributeNode( name );
jurzua
parents:
diff changeset
2336 // Return undefined if not specified instead of empty string
jurzua
parents:
diff changeset
2337 return ret && ret.specified ?
jurzua
parents:
diff changeset
2338 ret.nodeValue :
jurzua
parents:
diff changeset
2339 undefined;
jurzua
parents:
diff changeset
2340 },
jurzua
parents:
diff changeset
2341 set: function( elem, value, name ) {
jurzua
parents:
diff changeset
2342 // Check form objects in IE (multiple bugs related)
jurzua
parents:
diff changeset
2343 // Only use nodeValue if the attribute node exists on the form
jurzua
parents:
diff changeset
2344 var ret = elem.getAttributeNode( name );
jurzua
parents:
diff changeset
2345 if ( ret ) {
jurzua
parents:
diff changeset
2346 ret.nodeValue = value;
jurzua
parents:
diff changeset
2347 return value;
jurzua
parents:
diff changeset
2348 }
jurzua
parents:
diff changeset
2349 }
jurzua
parents:
diff changeset
2350 };
jurzua
parents:
diff changeset
2351
jurzua
parents:
diff changeset
2352 // Set width and height to auto instead of 0 on empty string( Bug #8150 )
jurzua
parents:
diff changeset
2353 // This is for removals
jurzua
parents:
diff changeset
2354 jQuery.each([ "width", "height" ], function( i, name ) {
jurzua
parents:
diff changeset
2355 jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
jurzua
parents:
diff changeset
2356 set: function( elem, value ) {
jurzua
parents:
diff changeset
2357 if ( value === "" ) {
jurzua
parents:
diff changeset
2358 elem.setAttribute( name, "auto" );
jurzua
parents:
diff changeset
2359 return value;
jurzua
parents:
diff changeset
2360 }
jurzua
parents:
diff changeset
2361 }
jurzua
parents:
diff changeset
2362 });
jurzua
parents:
diff changeset
2363 });
jurzua
parents:
diff changeset
2364 }
jurzua
parents:
diff changeset
2365
jurzua
parents:
diff changeset
2366
jurzua
parents:
diff changeset
2367 // Some attributes require a special call on IE
jurzua
parents:
diff changeset
2368 if ( !jQuery.support.hrefNormalized ) {
jurzua
parents:
diff changeset
2369 jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
jurzua
parents:
diff changeset
2370 jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
jurzua
parents:
diff changeset
2371 get: function( elem ) {
jurzua
parents:
diff changeset
2372 var ret = elem.getAttribute( name, 2 );
jurzua
parents:
diff changeset
2373 return ret === null ? undefined : ret;
jurzua
parents:
diff changeset
2374 }
jurzua
parents:
diff changeset
2375 });
jurzua
parents:
diff changeset
2376 });
jurzua
parents:
diff changeset
2377 }
jurzua
parents:
diff changeset
2378
jurzua
parents:
diff changeset
2379 if ( !jQuery.support.style ) {
jurzua
parents:
diff changeset
2380 jQuery.attrHooks.style = {
jurzua
parents:
diff changeset
2381 get: function( elem ) {
jurzua
parents:
diff changeset
2382 // Return undefined in the case of empty string
jurzua
parents:
diff changeset
2383 // Normalize to lowercase since IE uppercases css property names
jurzua
parents:
diff changeset
2384 return elem.style.cssText.toLowerCase() || undefined;
jurzua
parents:
diff changeset
2385 },
jurzua
parents:
diff changeset
2386 set: function( elem, value ) {
jurzua
parents:
diff changeset
2387 return (elem.style.cssText = "" + value);
jurzua
parents:
diff changeset
2388 }
jurzua
parents:
diff changeset
2389 };
jurzua
parents:
diff changeset
2390 }
jurzua
parents:
diff changeset
2391
jurzua
parents:
diff changeset
2392 // Safari mis-reports the default selected property of an option
jurzua
parents:
diff changeset
2393 // Accessing the parent's selectedIndex property fixes it
jurzua
parents:
diff changeset
2394 if ( !jQuery.support.optSelected ) {
jurzua
parents:
diff changeset
2395 jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
jurzua
parents:
diff changeset
2396 get: function( elem ) {
jurzua
parents:
diff changeset
2397 var parent = elem.parentNode;
jurzua
parents:
diff changeset
2398
jurzua
parents:
diff changeset
2399 if ( parent ) {
jurzua
parents:
diff changeset
2400 parent.selectedIndex;
jurzua
parents:
diff changeset
2401
jurzua
parents:
diff changeset
2402 // Make sure that it also works with optgroups, see #5701
jurzua
parents:
diff changeset
2403 if ( parent.parentNode ) {
jurzua
parents:
diff changeset
2404 parent.parentNode.selectedIndex;
jurzua
parents:
diff changeset
2405 }
jurzua
parents:
diff changeset
2406 }
jurzua
parents:
diff changeset
2407 }
jurzua
parents:
diff changeset
2408 });
jurzua
parents:
diff changeset
2409 }
jurzua
parents:
diff changeset
2410
jurzua
parents:
diff changeset
2411 // Radios and checkboxes getter/setter
jurzua
parents:
diff changeset
2412 if ( !jQuery.support.checkOn ) {
jurzua
parents:
diff changeset
2413 jQuery.each([ "radio", "checkbox" ], function() {
jurzua
parents:
diff changeset
2414 jQuery.valHooks[ this ] = {
jurzua
parents:
diff changeset
2415 get: function( elem ) {
jurzua
parents:
diff changeset
2416 // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
jurzua
parents:
diff changeset
2417 return elem.getAttribute("value") === null ? "on" : elem.value;
jurzua
parents:
diff changeset
2418 }
jurzua
parents:
diff changeset
2419 };
jurzua
parents:
diff changeset
2420 });
jurzua
parents:
diff changeset
2421 }
jurzua
parents:
diff changeset
2422 jQuery.each([ "radio", "checkbox" ], function() {
jurzua
parents:
diff changeset
2423 jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
jurzua
parents:
diff changeset
2424 set: function( elem, value ) {
jurzua
parents:
diff changeset
2425 if ( jQuery.isArray( value ) ) {
jurzua
parents:
diff changeset
2426 return (elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0);
jurzua
parents:
diff changeset
2427 }
jurzua
parents:
diff changeset
2428 }
jurzua
parents:
diff changeset
2429 });
jurzua
parents:
diff changeset
2430 });
jurzua
parents:
diff changeset
2431
jurzua
parents:
diff changeset
2432
jurzua
parents:
diff changeset
2433
jurzua
parents:
diff changeset
2434
jurzua
parents:
diff changeset
2435 var hasOwn = Object.prototype.hasOwnProperty,
jurzua
parents:
diff changeset
2436 rnamespaces = /\.(.*)$/,
jurzua
parents:
diff changeset
2437 rformElems = /^(?:textarea|input|select)$/i,
jurzua
parents:
diff changeset
2438 rperiod = /\./g,
jurzua
parents:
diff changeset
2439 rspaces = / /g,
jurzua
parents:
diff changeset
2440 rescape = /[^\w\s.|`]/g,
jurzua
parents:
diff changeset
2441 fcleanup = function( nm ) {
jurzua
parents:
diff changeset
2442 return nm.replace(rescape, "\\$&");
jurzua
parents:
diff changeset
2443 };
jurzua
parents:
diff changeset
2444
jurzua
parents:
diff changeset
2445 /*
jurzua
parents:
diff changeset
2446 * A number of helper functions used for managing events.
jurzua
parents:
diff changeset
2447 * Many of the ideas behind this code originated from
jurzua
parents:
diff changeset
2448 * Dean Edwards' addEvent library.
jurzua
parents:
diff changeset
2449 */
jurzua
parents:
diff changeset
2450 jQuery.event = {
jurzua
parents:
diff changeset
2451
jurzua
parents:
diff changeset
2452 // Bind an event to an element
jurzua
parents:
diff changeset
2453 // Original by Dean Edwards
jurzua
parents:
diff changeset
2454 add: function( elem, types, handler, data ) {
jurzua
parents:
diff changeset
2455 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
jurzua
parents:
diff changeset
2456 return;
jurzua
parents:
diff changeset
2457 }
jurzua
parents:
diff changeset
2458
jurzua
parents:
diff changeset
2459 if ( handler === false ) {
jurzua
parents:
diff changeset
2460 handler = returnFalse;
jurzua
parents:
diff changeset
2461 } else if ( !handler ) {
jurzua
parents:
diff changeset
2462 // Fixes bug #7229. Fix recommended by jdalton
jurzua
parents:
diff changeset
2463 return;
jurzua
parents:
diff changeset
2464 }
jurzua
parents:
diff changeset
2465
jurzua
parents:
diff changeset
2466 var handleObjIn, handleObj;
jurzua
parents:
diff changeset
2467
jurzua
parents:
diff changeset
2468 if ( handler.handler ) {
jurzua
parents:
diff changeset
2469 handleObjIn = handler;
jurzua
parents:
diff changeset
2470 handler = handleObjIn.handler;
jurzua
parents:
diff changeset
2471 }
jurzua
parents:
diff changeset
2472
jurzua
parents:
diff changeset
2473 // Make sure that the function being executed has a unique ID
jurzua
parents:
diff changeset
2474 if ( !handler.guid ) {
jurzua
parents:
diff changeset
2475 handler.guid = jQuery.guid++;
jurzua
parents:
diff changeset
2476 }
jurzua
parents:
diff changeset
2477
jurzua
parents:
diff changeset
2478 // Init the element's event structure
jurzua
parents:
diff changeset
2479 var elemData = jQuery._data( elem );
jurzua
parents:
diff changeset
2480
jurzua
parents:
diff changeset
2481 // If no elemData is found then we must be trying to bind to one of the
jurzua
parents:
diff changeset
2482 // banned noData elements
jurzua
parents:
diff changeset
2483 if ( !elemData ) {
jurzua
parents:
diff changeset
2484 return;
jurzua
parents:
diff changeset
2485 }
jurzua
parents:
diff changeset
2486
jurzua
parents:
diff changeset
2487 var events = elemData.events,
jurzua
parents:
diff changeset
2488 eventHandle = elemData.handle;
jurzua
parents:
diff changeset
2489
jurzua
parents:
diff changeset
2490 if ( !events ) {
jurzua
parents:
diff changeset
2491 elemData.events = events = {};
jurzua
parents:
diff changeset
2492 }
jurzua
parents:
diff changeset
2493
jurzua
parents:
diff changeset
2494 if ( !eventHandle ) {
jurzua
parents:
diff changeset
2495 elemData.handle = eventHandle = function( e ) {
jurzua
parents:
diff changeset
2496 // Discard the second event of a jQuery.event.trigger() and
jurzua
parents:
diff changeset
2497 // when an event is called after a page has unloaded
jurzua
parents:
diff changeset
2498 return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
jurzua
parents:
diff changeset
2499 jQuery.event.handle.apply( eventHandle.elem, arguments ) :
jurzua
parents:
diff changeset
2500 undefined;
jurzua
parents:
diff changeset
2501 };
jurzua
parents:
diff changeset
2502 }
jurzua
parents:
diff changeset
2503
jurzua
parents:
diff changeset
2504 // Add elem as a property of the handle function
jurzua
parents:
diff changeset
2505 // This is to prevent a memory leak with non-native events in IE.
jurzua
parents:
diff changeset
2506 eventHandle.elem = elem;
jurzua
parents:
diff changeset
2507
jurzua
parents:
diff changeset
2508 // Handle multiple events separated by a space
jurzua
parents:
diff changeset
2509 // jQuery(...).bind("mouseover mouseout", fn);
jurzua
parents:
diff changeset
2510 types = types.split(" ");
jurzua
parents:
diff changeset
2511
jurzua
parents:
diff changeset
2512 var type, i = 0, namespaces;
jurzua
parents:
diff changeset
2513
jurzua
parents:
diff changeset
2514 while ( (type = types[ i++ ]) ) {
jurzua
parents:
diff changeset
2515 handleObj = handleObjIn ?
jurzua
parents:
diff changeset
2516 jQuery.extend({}, handleObjIn) :
jurzua
parents:
diff changeset
2517 { handler: handler, data: data };
jurzua
parents:
diff changeset
2518
jurzua
parents:
diff changeset
2519 // Namespaced event handlers
jurzua
parents:
diff changeset
2520 if ( type.indexOf(".") > -1 ) {
jurzua
parents:
diff changeset
2521 namespaces = type.split(".");
jurzua
parents:
diff changeset
2522 type = namespaces.shift();
jurzua
parents:
diff changeset
2523 handleObj.namespace = namespaces.slice(0).sort().join(".");
jurzua
parents:
diff changeset
2524
jurzua
parents:
diff changeset
2525 } else {
jurzua
parents:
diff changeset
2526 namespaces = [];
jurzua
parents:
diff changeset
2527 handleObj.namespace = "";
jurzua
parents:
diff changeset
2528 }
jurzua
parents:
diff changeset
2529
jurzua
parents:
diff changeset
2530 handleObj.type = type;
jurzua
parents:
diff changeset
2531 if ( !handleObj.guid ) {
jurzua
parents:
diff changeset
2532 handleObj.guid = handler.guid;
jurzua
parents:
diff changeset
2533 }
jurzua
parents:
diff changeset
2534
jurzua
parents:
diff changeset
2535 // Get the current list of functions bound to this event
jurzua
parents:
diff changeset
2536 var handlers = events[ type ],
jurzua
parents:
diff changeset
2537 special = jQuery.event.special[ type ] || {};
jurzua
parents:
diff changeset
2538
jurzua
parents:
diff changeset
2539 // Init the event handler queue
jurzua
parents:
diff changeset
2540 if ( !handlers ) {
jurzua
parents:
diff changeset
2541 handlers = events[ type ] = [];
jurzua
parents:
diff changeset
2542
jurzua
parents:
diff changeset
2543 // Check for a special event handler
jurzua
parents:
diff changeset
2544 // Only use addEventListener/attachEvent if the special
jurzua
parents:
diff changeset
2545 // events handler returns false
jurzua
parents:
diff changeset
2546 if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
jurzua
parents:
diff changeset
2547 // Bind the global event handler to the element
jurzua
parents:
diff changeset
2548 if ( elem.addEventListener ) {
jurzua
parents:
diff changeset
2549 elem.addEventListener( type, eventHandle, false );
jurzua
parents:
diff changeset
2550
jurzua
parents:
diff changeset
2551 } else if ( elem.attachEvent ) {
jurzua
parents:
diff changeset
2552 elem.attachEvent( "on" + type, eventHandle );
jurzua
parents:
diff changeset
2553 }
jurzua
parents:
diff changeset
2554 }
jurzua
parents:
diff changeset
2555 }
jurzua
parents:
diff changeset
2556
jurzua
parents:
diff changeset
2557 if ( special.add ) {
jurzua
parents:
diff changeset
2558 special.add.call( elem, handleObj );
jurzua
parents:
diff changeset
2559
jurzua
parents:
diff changeset
2560 if ( !handleObj.handler.guid ) {
jurzua
parents:
diff changeset
2561 handleObj.handler.guid = handler.guid;
jurzua
parents:
diff changeset
2562 }
jurzua
parents:
diff changeset
2563 }
jurzua
parents:
diff changeset
2564
jurzua
parents:
diff changeset
2565 // Add the function to the element's handler list
jurzua
parents:
diff changeset
2566 handlers.push( handleObj );
jurzua
parents:
diff changeset
2567
jurzua
parents:
diff changeset
2568 // Keep track of which events have been used, for event optimization
jurzua
parents:
diff changeset
2569 jQuery.event.global[ type ] = true;
jurzua
parents:
diff changeset
2570 }
jurzua
parents:
diff changeset
2571
jurzua
parents:
diff changeset
2572 // Nullify elem to prevent memory leaks in IE
jurzua
parents:
diff changeset
2573 elem = null;
jurzua
parents:
diff changeset
2574 },
jurzua
parents:
diff changeset
2575
jurzua
parents:
diff changeset
2576 global: {},
jurzua
parents:
diff changeset
2577
jurzua
parents:
diff changeset
2578 // Detach an event or set of events from an element
jurzua
parents:
diff changeset
2579 remove: function( elem, types, handler, pos ) {
jurzua
parents:
diff changeset
2580 // don't do events on text and comment nodes
jurzua
parents:
diff changeset
2581 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
jurzua
parents:
diff changeset
2582 return;
jurzua
parents:
diff changeset
2583 }
jurzua
parents:
diff changeset
2584
jurzua
parents:
diff changeset
2585 if ( handler === false ) {
jurzua
parents:
diff changeset
2586 handler = returnFalse;
jurzua
parents:
diff changeset
2587 }
jurzua
parents:
diff changeset
2588
jurzua
parents:
diff changeset
2589 var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
jurzua
parents:
diff changeset
2590 elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
jurzua
parents:
diff changeset
2591 events = elemData && elemData.events;
jurzua
parents:
diff changeset
2592
jurzua
parents:
diff changeset
2593 if ( !elemData || !events ) {
jurzua
parents:
diff changeset
2594 return;
jurzua
parents:
diff changeset
2595 }
jurzua
parents:
diff changeset
2596
jurzua
parents:
diff changeset
2597 // types is actually an event object here
jurzua
parents:
diff changeset
2598 if ( types && types.type ) {
jurzua
parents:
diff changeset
2599 handler = types.handler;
jurzua
parents:
diff changeset
2600 types = types.type;
jurzua
parents:
diff changeset
2601 }
jurzua
parents:
diff changeset
2602
jurzua
parents:
diff changeset
2603 // Unbind all events for the element
jurzua
parents:
diff changeset
2604 if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
jurzua
parents:
diff changeset
2605 types = types || "";
jurzua
parents:
diff changeset
2606
jurzua
parents:
diff changeset
2607 for ( type in events ) {
jurzua
parents:
diff changeset
2608 jQuery.event.remove( elem, type + types );
jurzua
parents:
diff changeset
2609 }
jurzua
parents:
diff changeset
2610
jurzua
parents:
diff changeset
2611 return;
jurzua
parents:
diff changeset
2612 }
jurzua
parents:
diff changeset
2613
jurzua
parents:
diff changeset
2614 // Handle multiple events separated by a space
jurzua
parents:
diff changeset
2615 // jQuery(...).unbind("mouseover mouseout", fn);
jurzua
parents:
diff changeset
2616 types = types.split(" ");
jurzua
parents:
diff changeset
2617
jurzua
parents:
diff changeset
2618 while ( (type = types[ i++ ]) ) {
jurzua
parents:
diff changeset
2619 origType = type;
jurzua
parents:
diff changeset
2620 handleObj = null;
jurzua
parents:
diff changeset
2621 all = type.indexOf(".") < 0;
jurzua
parents:
diff changeset
2622 namespaces = [];
jurzua
parents:
diff changeset
2623
jurzua
parents:
diff changeset
2624 if ( !all ) {
jurzua
parents:
diff changeset
2625 // Namespaced event handlers
jurzua
parents:
diff changeset
2626 namespaces = type.split(".");
jurzua
parents:
diff changeset
2627 type = namespaces.shift();
jurzua
parents:
diff changeset
2628
jurzua
parents:
diff changeset
2629 namespace = new RegExp("(^|\\.)" +
jurzua
parents:
diff changeset
2630 jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
jurzua
parents:
diff changeset
2631 }
jurzua
parents:
diff changeset
2632
jurzua
parents:
diff changeset
2633 eventType = events[ type ];
jurzua
parents:
diff changeset
2634
jurzua
parents:
diff changeset
2635 if ( !eventType ) {
jurzua
parents:
diff changeset
2636 continue;
jurzua
parents:
diff changeset
2637 }
jurzua
parents:
diff changeset
2638
jurzua
parents:
diff changeset
2639 if ( !handler ) {
jurzua
parents:
diff changeset
2640 for ( j = 0; j < eventType.length; j++ ) {
jurzua
parents:
diff changeset
2641 handleObj = eventType[ j ];
jurzua
parents:
diff changeset
2642
jurzua
parents:
diff changeset
2643 if ( all || namespace.test( handleObj.namespace ) ) {
jurzua
parents:
diff changeset
2644 jQuery.event.remove( elem, origType, handleObj.handler, j );
jurzua
parents:
diff changeset
2645 eventType.splice( j--, 1 );
jurzua
parents:
diff changeset
2646 }
jurzua
parents:
diff changeset
2647 }
jurzua
parents:
diff changeset
2648
jurzua
parents:
diff changeset
2649 continue;
jurzua
parents:
diff changeset
2650 }
jurzua
parents:
diff changeset
2651
jurzua
parents:
diff changeset
2652 special = jQuery.event.special[ type ] || {};
jurzua
parents:
diff changeset
2653
jurzua
parents:
diff changeset
2654 for ( j = pos || 0; j < eventType.length; j++ ) {
jurzua
parents:
diff changeset
2655 handleObj = eventType[ j ];
jurzua
parents:
diff changeset
2656
jurzua
parents:
diff changeset
2657 if ( handler.guid === handleObj.guid ) {
jurzua
parents:
diff changeset
2658 // remove the given handler for the given type
jurzua
parents:
diff changeset
2659 if ( all || namespace.test( handleObj.namespace ) ) {
jurzua
parents:
diff changeset
2660 if ( pos == null ) {
jurzua
parents:
diff changeset
2661 eventType.splice( j--, 1 );
jurzua
parents:
diff changeset
2662 }
jurzua
parents:
diff changeset
2663
jurzua
parents:
diff changeset
2664 if ( special.remove ) {
jurzua
parents:
diff changeset
2665 special.remove.call( elem, handleObj );
jurzua
parents:
diff changeset
2666 }
jurzua
parents:
diff changeset
2667 }
jurzua
parents:
diff changeset
2668
jurzua
parents:
diff changeset
2669 if ( pos != null ) {
jurzua
parents:
diff changeset
2670 break;
jurzua
parents:
diff changeset
2671 }
jurzua
parents:
diff changeset
2672 }
jurzua
parents:
diff changeset
2673 }
jurzua
parents:
diff changeset
2674
jurzua
parents:
diff changeset
2675 // remove generic event handler if no more handlers exist
jurzua
parents:
diff changeset
2676 if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
jurzua
parents:
diff changeset
2677 if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
jurzua
parents:
diff changeset
2678 jQuery.removeEvent( elem, type, elemData.handle );
jurzua
parents:
diff changeset
2679 }
jurzua
parents:
diff changeset
2680
jurzua
parents:
diff changeset
2681 ret = null;
jurzua
parents:
diff changeset
2682 delete events[ type ];
jurzua
parents:
diff changeset
2683 }
jurzua
parents:
diff changeset
2684 }
jurzua
parents:
diff changeset
2685
jurzua
parents:
diff changeset
2686 // Remove the expando if it's no longer used
jurzua
parents:
diff changeset
2687 if ( jQuery.isEmptyObject( events ) ) {
jurzua
parents:
diff changeset
2688 var handle = elemData.handle;
jurzua
parents:
diff changeset
2689 if ( handle ) {
jurzua
parents:
diff changeset
2690 handle.elem = null;
jurzua
parents:
diff changeset
2691 }
jurzua
parents:
diff changeset
2692
jurzua
parents:
diff changeset
2693 delete elemData.events;
jurzua
parents:
diff changeset
2694 delete elemData.handle;
jurzua
parents:
diff changeset
2695
jurzua
parents:
diff changeset
2696 if ( jQuery.isEmptyObject( elemData ) ) {
jurzua
parents:
diff changeset
2697 jQuery.removeData( elem, undefined, true );
jurzua
parents:
diff changeset
2698 }
jurzua
parents:
diff changeset
2699 }
jurzua
parents:
diff changeset
2700 },
jurzua
parents:
diff changeset
2701
jurzua
parents:
diff changeset
2702 // Events that are safe to short-circuit if no handlers are attached.
jurzua
parents:
diff changeset
2703 // Native DOM events should not be added, they may have inline handlers.
jurzua
parents:
diff changeset
2704 customEvent: {
jurzua
parents:
diff changeset
2705 "getData": true,
jurzua
parents:
diff changeset
2706 "setData": true,
jurzua
parents:
diff changeset
2707 "changeData": true
jurzua
parents:
diff changeset
2708 },
jurzua
parents:
diff changeset
2709
jurzua
parents:
diff changeset
2710 trigger: function( event, data, elem, onlyHandlers ) {
jurzua
parents:
diff changeset
2711 // Event object or event type
jurzua
parents:
diff changeset
2712 var type = event.type || event,
jurzua
parents:
diff changeset
2713 namespaces = [],
jurzua
parents:
diff changeset
2714 exclusive;
jurzua
parents:
diff changeset
2715
jurzua
parents:
diff changeset
2716 if ( type.indexOf("!") >= 0 ) {
jurzua
parents:
diff changeset
2717 // Exclusive events trigger only for the exact event (no namespaces)
jurzua
parents:
diff changeset
2718 type = type.slice(0, -1);
jurzua
parents:
diff changeset
2719 exclusive = true;
jurzua
parents:
diff changeset
2720 }
jurzua
parents:
diff changeset
2721
jurzua
parents:
diff changeset
2722 if ( type.indexOf(".") >= 0 ) {
jurzua
parents:
diff changeset
2723 // Namespaced trigger; create a regexp to match event type in handle()
jurzua
parents:
diff changeset
2724 namespaces = type.split(".");
jurzua
parents:
diff changeset
2725 type = namespaces.shift();
jurzua
parents:
diff changeset
2726 namespaces.sort();
jurzua
parents:
diff changeset
2727 }
jurzua
parents:
diff changeset
2728
jurzua
parents:
diff changeset
2729 if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
jurzua
parents:
diff changeset
2730 // No jQuery handlers for this event type, and it can't have inline handlers
jurzua
parents:
diff changeset
2731 return;
jurzua
parents:
diff changeset
2732 }
jurzua
parents:
diff changeset
2733
jurzua
parents:
diff changeset
2734 // Caller can pass in an Event, Object, or just an event type string
jurzua
parents:
diff changeset
2735 event = typeof event === "object" ?
jurzua
parents:
diff changeset
2736 // jQuery.Event object
jurzua
parents:
diff changeset
2737 event[ jQuery.expando ] ? event :
jurzua
parents:
diff changeset
2738 // Object literal
jurzua
parents:
diff changeset
2739 new jQuery.Event( type, event ) :
jurzua
parents:
diff changeset
2740 // Just the event type (string)
jurzua
parents:
diff changeset
2741 new jQuery.Event( type );
jurzua
parents:
diff changeset
2742
jurzua
parents:
diff changeset
2743 event.type = type;
jurzua
parents:
diff changeset
2744 event.exclusive = exclusive;
jurzua
parents:
diff changeset
2745 event.namespace = namespaces.join(".");
jurzua
parents:
diff changeset
2746 event.namespace_re = new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)");
jurzua
parents:
diff changeset
2747
jurzua
parents:
diff changeset
2748 // triggerHandler() and global events don't bubble or run the default action
jurzua
parents:
diff changeset
2749 if ( onlyHandlers || !elem ) {
jurzua
parents:
diff changeset
2750 event.preventDefault();
jurzua
parents:
diff changeset
2751 event.stopPropagation();
jurzua
parents:
diff changeset
2752 }
jurzua
parents:
diff changeset
2753
jurzua
parents:
diff changeset
2754 // Handle a global trigger
jurzua
parents:
diff changeset
2755 if ( !elem ) {
jurzua
parents:
diff changeset
2756 // TODO: Stop taunting the data cache; remove global events and always attach to document
jurzua
parents:
diff changeset
2757 jQuery.each( jQuery.cache, function() {
jurzua
parents:
diff changeset
2758 // internalKey variable is just used to make it easier to find
jurzua
parents:
diff changeset
2759 // and potentially change this stuff later; currently it just
jurzua
parents:
diff changeset
2760 // points to jQuery.expando
jurzua
parents:
diff changeset
2761 var internalKey = jQuery.expando,
jurzua
parents:
diff changeset
2762 internalCache = this[ internalKey ];
jurzua
parents:
diff changeset
2763 if ( internalCache && internalCache.events && internalCache.events[ type ] ) {
jurzua
parents:
diff changeset
2764 jQuery.event.trigger( event, data, internalCache.handle.elem );
jurzua
parents:
diff changeset
2765 }
jurzua
parents:
diff changeset
2766 });
jurzua
parents:
diff changeset
2767 return;
jurzua
parents:
diff changeset
2768 }
jurzua
parents:
diff changeset
2769
jurzua
parents:
diff changeset
2770 // Don't do events on text and comment nodes
jurzua
parents:
diff changeset
2771 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
jurzua
parents:
diff changeset
2772 return;
jurzua
parents:
diff changeset
2773 }
jurzua
parents:
diff changeset
2774
jurzua
parents:
diff changeset
2775 // Clean up the event in case it is being reused
jurzua
parents:
diff changeset
2776 event.result = undefined;
jurzua
parents:
diff changeset
2777 event.target = elem;
jurzua
parents:
diff changeset
2778
jurzua
parents:
diff changeset
2779 // Clone any incoming data and prepend the event, creating the handler arg list
jurzua
parents:
diff changeset
2780 data = data ? jQuery.makeArray( data ) : [];
jurzua
parents:
diff changeset
2781 data.unshift( event );
jurzua
parents:
diff changeset
2782
jurzua
parents:
diff changeset
2783 var cur = elem,
jurzua
parents:
diff changeset
2784 // IE doesn't like method names with a colon (#3533, #8272)
jurzua
parents:
diff changeset
2785 ontype = type.indexOf(":") < 0 ? "on" + type : "";
jurzua
parents:
diff changeset
2786
jurzua
parents:
diff changeset
2787 // Fire event on the current element, then bubble up the DOM tree
jurzua
parents:
diff changeset
2788 do {
jurzua
parents:
diff changeset
2789 var handle = jQuery._data( cur, "handle" );
jurzua
parents:
diff changeset
2790
jurzua
parents:
diff changeset
2791 event.currentTarget = cur;
jurzua
parents:
diff changeset
2792 if ( handle ) {
jurzua
parents:
diff changeset
2793 handle.apply( cur, data );
jurzua
parents:
diff changeset
2794 }
jurzua
parents:
diff changeset
2795
jurzua
parents:
diff changeset
2796 // Trigger an inline bound script
jurzua
parents:
diff changeset
2797 if ( ontype && jQuery.acceptData( cur ) && cur[ ontype ] && cur[ ontype ].apply( cur, data ) === false ) {
jurzua
parents:
diff changeset
2798 event.result = false;
jurzua
parents:
diff changeset
2799 event.preventDefault();
jurzua
parents:
diff changeset
2800 }
jurzua
parents:
diff changeset
2801
jurzua
parents:
diff changeset
2802 // Bubble up to document, then to window
jurzua
parents:
diff changeset
2803 cur = cur.parentNode || cur.ownerDocument || cur === event.target.ownerDocument && window;
jurzua
parents:
diff changeset
2804 } while ( cur && !event.isPropagationStopped() );
jurzua
parents:
diff changeset
2805
jurzua
parents:
diff changeset
2806 // If nobody prevented the default action, do it now
jurzua
parents:
diff changeset
2807 if ( !event.isDefaultPrevented() ) {
jurzua
parents:
diff changeset
2808 var old,
jurzua
parents:
diff changeset
2809 special = jQuery.event.special[ type ] || {};
jurzua
parents:
diff changeset
2810
jurzua
parents:
diff changeset
2811 if ( (!special._default || special._default.call( elem.ownerDocument, event ) === false) &&
jurzua
parents:
diff changeset
2812 !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
jurzua
parents:
diff changeset
2813
jurzua
parents:
diff changeset
2814 // Call a native DOM method on the target with the same name name as the event.
jurzua
parents:
diff changeset
2815 // Can't use an .isFunction)() check here because IE6/7 fails that test.
jurzua
parents:
diff changeset
2816 // IE<9 dies on focus to hidden element (#1486), may want to revisit a try/catch.
jurzua
parents:
diff changeset
2817 try {
jurzua
parents:
diff changeset
2818 if ( ontype && elem[ type ] ) {
jurzua
parents:
diff changeset
2819 // Don't re-trigger an onFOO event when we call its FOO() method
jurzua
parents:
diff changeset
2820 old = elem[ ontype ];
jurzua
parents:
diff changeset
2821
jurzua
parents:
diff changeset
2822 if ( old ) {
jurzua
parents:
diff changeset
2823 elem[ ontype ] = null;
jurzua
parents:
diff changeset
2824 }
jurzua
parents:
diff changeset
2825
jurzua
parents:
diff changeset
2826 jQuery.event.triggered = type;
jurzua
parents:
diff changeset
2827 elem[ type ]();
jurzua
parents:
diff changeset
2828 }
jurzua
parents:
diff changeset
2829 } catch ( ieError ) {}
jurzua
parents:
diff changeset
2830
jurzua
parents:
diff changeset
2831 if ( old ) {
jurzua
parents:
diff changeset
2832 elem[ ontype ] = old;
jurzua
parents:
diff changeset
2833 }
jurzua
parents:
diff changeset
2834
jurzua
parents:
diff changeset
2835 jQuery.event.triggered = undefined;
jurzua
parents:
diff changeset
2836 }
jurzua
parents:
diff changeset
2837 }
jurzua
parents:
diff changeset
2838
jurzua
parents:
diff changeset
2839 return event.result;
jurzua
parents:
diff changeset
2840 },
jurzua
parents:
diff changeset
2841
jurzua
parents:
diff changeset
2842 handle: function( event ) {
jurzua
parents:
diff changeset
2843 event = jQuery.event.fix( event || window.event );
jurzua
parents:
diff changeset
2844 // Snapshot the handlers list since a called handler may add/remove events.
jurzua
parents:
diff changeset
2845 var handlers = ((jQuery._data( this, "events" ) || {})[ event.type ] || []).slice(0),
jurzua
parents:
diff changeset
2846 run_all = !event.exclusive && !event.namespace,
jurzua
parents:
diff changeset
2847 args = Array.prototype.slice.call( arguments, 0 );
jurzua
parents:
diff changeset
2848
jurzua
parents:
diff changeset
2849 // Use the fix-ed Event rather than the (read-only) native event
jurzua
parents:
diff changeset
2850 args[0] = event;
jurzua
parents:
diff changeset
2851 event.currentTarget = this;
jurzua
parents:
diff changeset
2852
jurzua
parents:
diff changeset
2853 for ( var j = 0, l = handlers.length; j < l; j++ ) {
jurzua
parents:
diff changeset
2854 var handleObj = handlers[ j ];
jurzua
parents:
diff changeset
2855
jurzua
parents:
diff changeset
2856 // Triggered event must 1) be non-exclusive and have no namespace, or
jurzua
parents:
diff changeset
2857 // 2) have namespace(s) a subset or equal to those in the bound event.
jurzua
parents:
diff changeset
2858 if ( run_all || event.namespace_re.test( handleObj.namespace ) ) {
jurzua
parents:
diff changeset
2859 // Pass in a reference to the handler function itself
jurzua
parents:
diff changeset
2860 // So that we can later remove it
jurzua
parents:
diff changeset
2861 event.handler = handleObj.handler;
jurzua
parents:
diff changeset
2862 event.data = handleObj.data;
jurzua
parents:
diff changeset
2863 event.handleObj = handleObj;
jurzua
parents:
diff changeset
2864
jurzua
parents:
diff changeset
2865 var ret = handleObj.handler.apply( this, args );
jurzua
parents:
diff changeset
2866
jurzua
parents:
diff changeset
2867 if ( ret !== undefined ) {
jurzua
parents:
diff changeset
2868 event.result = ret;
jurzua
parents:
diff changeset
2869 if ( ret === false ) {
jurzua
parents:
diff changeset
2870 event.preventDefault();
jurzua
parents:
diff changeset
2871 event.stopPropagation();
jurzua
parents:
diff changeset
2872 }
jurzua
parents:
diff changeset
2873 }
jurzua
parents:
diff changeset
2874
jurzua
parents:
diff changeset
2875 if ( event.isImmediatePropagationStopped() ) {
jurzua
parents:
diff changeset
2876 break;
jurzua
parents:
diff changeset
2877 }
jurzua
parents:
diff changeset
2878 }
jurzua
parents:
diff changeset
2879 }
jurzua
parents:
diff changeset
2880 return event.result;
jurzua
parents:
diff changeset
2881 },
jurzua
parents:
diff changeset
2882
jurzua
parents:
diff changeset
2883 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
2884
jurzua
parents:
diff changeset
2885 fix: function( event ) {
jurzua
parents:
diff changeset
2886 if ( event[ jQuery.expando ] ) {
jurzua
parents:
diff changeset
2887 return event;
jurzua
parents:
diff changeset
2888 }
jurzua
parents:
diff changeset
2889
jurzua
parents:
diff changeset
2890 // store a copy of the original event object
jurzua
parents:
diff changeset
2891 // and "clone" to set read-only properties
jurzua
parents:
diff changeset
2892 var originalEvent = event;
jurzua
parents:
diff changeset
2893 event = jQuery.Event( originalEvent );
jurzua
parents:
diff changeset
2894
jurzua
parents:
diff changeset
2895 for ( var i = this.props.length, prop; i; ) {
jurzua
parents:
diff changeset
2896 prop = this.props[ --i ];
jurzua
parents:
diff changeset
2897 event[ prop ] = originalEvent[ prop ];
jurzua
parents:
diff changeset
2898 }
jurzua
parents:
diff changeset
2899
jurzua
parents:
diff changeset
2900 // Fix target property, if necessary
jurzua
parents:
diff changeset
2901 if ( !event.target ) {
jurzua
parents:
diff changeset
2902 // Fixes #1925 where srcElement might not be defined either
jurzua
parents:
diff changeset
2903 event.target = event.srcElement || document;
jurzua
parents:
diff changeset
2904 }
jurzua
parents:
diff changeset
2905
jurzua
parents:
diff changeset
2906 // check if target is a textnode (safari)
jurzua
parents:
diff changeset
2907 if ( event.target.nodeType === 3 ) {
jurzua
parents:
diff changeset
2908 event.target = event.target.parentNode;
jurzua
parents:
diff changeset
2909 }
jurzua
parents:
diff changeset
2910
jurzua
parents:
diff changeset
2911 // Add relatedTarget, if necessary
jurzua
parents:
diff changeset
2912 if ( !event.relatedTarget && event.fromElement ) {
jurzua
parents:
diff changeset
2913 event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
jurzua
parents:
diff changeset
2914 }
jurzua
parents:
diff changeset
2915
jurzua
parents:
diff changeset
2916 // Calculate pageX/Y if missing and clientX/Y available
jurzua
parents:
diff changeset
2917 if ( event.pageX == null && event.clientX != null ) {
jurzua
parents:
diff changeset
2918 var eventDocument = event.target.ownerDocument || document,
jurzua
parents:
diff changeset
2919 doc = eventDocument.documentElement,
jurzua
parents:
diff changeset
2920 body = eventDocument.body;
jurzua
parents:
diff changeset
2921
jurzua
parents:
diff changeset
2922 event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
jurzua
parents:
diff changeset
2923 event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
jurzua
parents:
diff changeset
2924 }
jurzua
parents:
diff changeset
2925
jurzua
parents:
diff changeset
2926 // Add which for key events
jurzua
parents:
diff changeset
2927 if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
jurzua
parents:
diff changeset
2928 event.which = event.charCode != null ? event.charCode : event.keyCode;
jurzua
parents:
diff changeset
2929 }
jurzua
parents:
diff changeset
2930
jurzua
parents:
diff changeset
2931 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
jurzua
parents:
diff changeset
2932 if ( !event.metaKey && event.ctrlKey ) {
jurzua
parents:
diff changeset
2933 event.metaKey = event.ctrlKey;
jurzua
parents:
diff changeset
2934 }
jurzua
parents:
diff changeset
2935
jurzua
parents:
diff changeset
2936 // Add which for click: 1 === left; 2 === middle; 3 === right
jurzua
parents:
diff changeset
2937 // Note: button is not normalized, so don't use it
jurzua
parents:
diff changeset
2938 if ( !event.which && event.button !== undefined ) {
jurzua
parents:
diff changeset
2939 event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
jurzua
parents:
diff changeset
2940 }
jurzua
parents:
diff changeset
2941
jurzua
parents:
diff changeset
2942 return event;
jurzua
parents:
diff changeset
2943 },
jurzua
parents:
diff changeset
2944
jurzua
parents:
diff changeset
2945 // Deprecated, use jQuery.guid instead
jurzua
parents:
diff changeset
2946 guid: 1E8,
jurzua
parents:
diff changeset
2947
jurzua
parents:
diff changeset
2948 // Deprecated, use jQuery.proxy instead
jurzua
parents:
diff changeset
2949 proxy: jQuery.proxy,
jurzua
parents:
diff changeset
2950
jurzua
parents:
diff changeset
2951 special: {
jurzua
parents:
diff changeset
2952 ready: {
jurzua
parents:
diff changeset
2953 // Make sure the ready event is setup
jurzua
parents:
diff changeset
2954 setup: jQuery.bindReady,
jurzua
parents:
diff changeset
2955 teardown: jQuery.noop
jurzua
parents:
diff changeset
2956 },
jurzua
parents:
diff changeset
2957
jurzua
parents:
diff changeset
2958 live: {
jurzua
parents:
diff changeset
2959 add: function( handleObj ) {
jurzua
parents:
diff changeset
2960 jQuery.event.add( this,
jurzua
parents:
diff changeset
2961 liveConvert( handleObj.origType, handleObj.selector ),
jurzua
parents:
diff changeset
2962 jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
jurzua
parents:
diff changeset
2963 },
jurzua
parents:
diff changeset
2964
jurzua
parents:
diff changeset
2965 remove: function( handleObj ) {
jurzua
parents:
diff changeset
2966 jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
jurzua
parents:
diff changeset
2967 }
jurzua
parents:
diff changeset
2968 },
jurzua
parents:
diff changeset
2969
jurzua
parents:
diff changeset
2970 beforeunload: {
jurzua
parents:
diff changeset
2971 setup: function( data, namespaces, eventHandle ) {
jurzua
parents:
diff changeset
2972 // We only want to do this special case on windows
jurzua
parents:
diff changeset
2973 if ( jQuery.isWindow( this ) ) {
jurzua
parents:
diff changeset
2974 this.onbeforeunload = eventHandle;
jurzua
parents:
diff changeset
2975 }
jurzua
parents:
diff changeset
2976 },
jurzua
parents:
diff changeset
2977
jurzua
parents:
diff changeset
2978 teardown: function( namespaces, eventHandle ) {
jurzua
parents:
diff changeset
2979 if ( this.onbeforeunload === eventHandle ) {
jurzua
parents:
diff changeset
2980 this.onbeforeunload = null;
jurzua
parents:
diff changeset
2981 }
jurzua
parents:
diff changeset
2982 }
jurzua
parents:
diff changeset
2983 }
jurzua
parents:
diff changeset
2984 }
jurzua
parents:
diff changeset
2985 };
jurzua
parents:
diff changeset
2986
jurzua
parents:
diff changeset
2987 jQuery.removeEvent = document.removeEventListener ?
jurzua
parents:
diff changeset
2988 function( elem, type, handle ) {
jurzua
parents:
diff changeset
2989 if ( elem.removeEventListener ) {
jurzua
parents:
diff changeset
2990 elem.removeEventListener( type, handle, false );
jurzua
parents:
diff changeset
2991 }
jurzua
parents:
diff changeset
2992 } :
jurzua
parents:
diff changeset
2993 function( elem, type, handle ) {
jurzua
parents:
diff changeset
2994 if ( elem.detachEvent ) {
jurzua
parents:
diff changeset
2995 elem.detachEvent( "on" + type, handle );
jurzua
parents:
diff changeset
2996 }
jurzua
parents:
diff changeset
2997 };
jurzua
parents:
diff changeset
2998
jurzua
parents:
diff changeset
2999 jQuery.Event = function( src, props ) {
jurzua
parents:
diff changeset
3000 // Allow instantiation without the 'new' keyword
jurzua
parents:
diff changeset
3001 if ( !this.preventDefault ) {
jurzua
parents:
diff changeset
3002 return new jQuery.Event( src, props );
jurzua
parents:
diff changeset
3003 }
jurzua
parents:
diff changeset
3004
jurzua
parents:
diff changeset
3005 // Event object
jurzua
parents:
diff changeset
3006 if ( src && src.type ) {
jurzua
parents:
diff changeset
3007 this.originalEvent = src;
jurzua
parents:
diff changeset
3008 this.type = src.type;
jurzua
parents:
diff changeset
3009
jurzua
parents:
diff changeset
3010 // Events bubbling up the document may have been marked as prevented
jurzua
parents:
diff changeset
3011 // by a handler lower down the tree; reflect the correct value.
jurzua
parents:
diff changeset
3012 this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false ||
jurzua
parents:
diff changeset
3013 src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;
jurzua
parents:
diff changeset
3014
jurzua
parents:
diff changeset
3015 // Event type
jurzua
parents:
diff changeset
3016 } else {
jurzua
parents:
diff changeset
3017 this.type = src;
jurzua
parents:
diff changeset
3018 }
jurzua
parents:
diff changeset
3019
jurzua
parents:
diff changeset
3020 // Put explicitly provided properties onto the event object
jurzua
parents:
diff changeset
3021 if ( props ) {
jurzua
parents:
diff changeset
3022 jQuery.extend( this, props );
jurzua
parents:
diff changeset
3023 }
jurzua
parents:
diff changeset
3024
jurzua
parents:
diff changeset
3025 // timeStamp is buggy for some events on Firefox(#3843)
jurzua
parents:
diff changeset
3026 // So we won't rely on the native value
jurzua
parents:
diff changeset
3027 this.timeStamp = jQuery.now();
jurzua
parents:
diff changeset
3028
jurzua
parents:
diff changeset
3029 // Mark it as fixed
jurzua
parents:
diff changeset
3030 this[ jQuery.expando ] = true;
jurzua
parents:
diff changeset
3031 };
jurzua
parents:
diff changeset
3032
jurzua
parents:
diff changeset
3033 function returnFalse() {
jurzua
parents:
diff changeset
3034 return false;
jurzua
parents:
diff changeset
3035 }
jurzua
parents:
diff changeset
3036 function returnTrue() {
jurzua
parents:
diff changeset
3037 return true;
jurzua
parents:
diff changeset
3038 }
jurzua
parents:
diff changeset
3039
jurzua
parents:
diff changeset
3040 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
jurzua
parents:
diff changeset
3041 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
jurzua
parents:
diff changeset
3042 jQuery.Event.prototype = {
jurzua
parents:
diff changeset
3043 preventDefault: function() {
jurzua
parents:
diff changeset
3044 this.isDefaultPrevented = returnTrue;
jurzua
parents:
diff changeset
3045
jurzua
parents:
diff changeset
3046 var e = this.originalEvent;
jurzua
parents:
diff changeset
3047 if ( !e ) {
jurzua
parents:
diff changeset
3048 return;
jurzua
parents:
diff changeset
3049 }
jurzua
parents:
diff changeset
3050
jurzua
parents:
diff changeset
3051 // if preventDefault exists run it on the original event
jurzua
parents:
diff changeset
3052 if ( e.preventDefault ) {
jurzua
parents:
diff changeset
3053 e.preventDefault();
jurzua
parents:
diff changeset
3054
jurzua
parents:
diff changeset
3055 // otherwise set the returnValue property of the original event to false (IE)
jurzua
parents:
diff changeset
3056 } else {
jurzua
parents:
diff changeset
3057 e.returnValue = false;
jurzua
parents:
diff changeset
3058 }
jurzua
parents:
diff changeset
3059 },
jurzua
parents:
diff changeset
3060 stopPropagation: function() {
jurzua
parents:
diff changeset
3061 this.isPropagationStopped = returnTrue;
jurzua
parents:
diff changeset
3062
jurzua
parents:
diff changeset
3063 var e = this.originalEvent;
jurzua
parents:
diff changeset
3064 if ( !e ) {
jurzua
parents:
diff changeset
3065 return;
jurzua
parents:
diff changeset
3066 }
jurzua
parents:
diff changeset
3067 // if stopPropagation exists run it on the original event
jurzua
parents:
diff changeset
3068 if ( e.stopPropagation ) {
jurzua
parents:
diff changeset
3069 e.stopPropagation();
jurzua
parents:
diff changeset
3070 }
jurzua
parents:
diff changeset
3071 // otherwise set the cancelBubble property of the original event to true (IE)
jurzua
parents:
diff changeset
3072 e.cancelBubble = true;
jurzua
parents:
diff changeset
3073 },
jurzua
parents:
diff changeset
3074 stopImmediatePropagation: function() {
jurzua
parents:
diff changeset
3075 this.isImmediatePropagationStopped = returnTrue;
jurzua
parents:
diff changeset
3076 this.stopPropagation();
jurzua
parents:
diff changeset
3077 },
jurzua
parents:
diff changeset
3078 isDefaultPrevented: returnFalse,
jurzua
parents:
diff changeset
3079 isPropagationStopped: returnFalse,
jurzua
parents:
diff changeset
3080 isImmediatePropagationStopped: returnFalse
jurzua
parents:
diff changeset
3081 };
jurzua
parents:
diff changeset
3082
jurzua
parents:
diff changeset
3083 // Checks if an event happened on an element within another element
jurzua
parents:
diff changeset
3084 // Used in jQuery.event.special.mouseenter and mouseleave handlers
jurzua
parents:
diff changeset
3085 var withinElement = function( event ) {
jurzua
parents:
diff changeset
3086 // Check if mouse(over|out) are still within the same parent element
jurzua
parents:
diff changeset
3087 var parent = event.relatedTarget;
jurzua
parents:
diff changeset
3088
jurzua
parents:
diff changeset
3089 // Firefox sometimes assigns relatedTarget a XUL element
jurzua
parents:
diff changeset
3090 // which we cannot access the parentNode property of
jurzua
parents:
diff changeset
3091 try {
jurzua
parents:
diff changeset
3092
jurzua
parents:
diff changeset
3093 // Chrome does something similar, the parentNode property
jurzua
parents:
diff changeset
3094 // can be accessed but is null.
jurzua
parents:
diff changeset
3095 if ( parent && parent !== document && !parent.parentNode ) {
jurzua
parents:
diff changeset
3096 return;
jurzua
parents:
diff changeset
3097 }
jurzua
parents:
diff changeset
3098 // Traverse up the tree
jurzua
parents:
diff changeset
3099 while ( parent && parent !== this ) {
jurzua
parents:
diff changeset
3100 parent = parent.parentNode;
jurzua
parents:
diff changeset
3101 }
jurzua
parents:
diff changeset
3102
jurzua
parents:
diff changeset
3103 if ( parent !== this ) {
jurzua
parents:
diff changeset
3104 // set the correct event type
jurzua
parents:
diff changeset
3105 event.type = event.data;
jurzua
parents:
diff changeset
3106
jurzua
parents:
diff changeset
3107 // handle event if we actually just moused on to a non sub-element
jurzua
parents:
diff changeset
3108 jQuery.event.handle.apply( this, arguments );
jurzua
parents:
diff changeset
3109 }
jurzua
parents:
diff changeset
3110
jurzua
parents:
diff changeset
3111 // assuming we've left the element since we most likely mousedover a xul element
jurzua
parents:
diff changeset
3112 } catch(e) { }
jurzua
parents:
diff changeset
3113 },
jurzua
parents:
diff changeset
3114
jurzua
parents:
diff changeset
3115 // In case of event delegation, we only need to rename the event.type,
jurzua
parents:
diff changeset
3116 // liveHandler will take care of the rest.
jurzua
parents:
diff changeset
3117 delegate = function( event ) {
jurzua
parents:
diff changeset
3118 event.type = event.data;
jurzua
parents:
diff changeset
3119 jQuery.event.handle.apply( this, arguments );
jurzua
parents:
diff changeset
3120 };
jurzua
parents:
diff changeset
3121
jurzua
parents:
diff changeset
3122 // Create mouseenter and mouseleave events
jurzua
parents:
diff changeset
3123 jQuery.each({
jurzua
parents:
diff changeset
3124 mouseenter: "mouseover",
jurzua
parents:
diff changeset
3125 mouseleave: "mouseout"
jurzua
parents:
diff changeset
3126 }, function( orig, fix ) {
jurzua
parents:
diff changeset
3127 jQuery.event.special[ orig ] = {
jurzua
parents:
diff changeset
3128 setup: function( data ) {
jurzua
parents:
diff changeset
3129 jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
jurzua
parents:
diff changeset
3130 },
jurzua
parents:
diff changeset
3131 teardown: function( data ) {
jurzua
parents:
diff changeset
3132 jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
jurzua
parents:
diff changeset
3133 }
jurzua
parents:
diff changeset
3134 };
jurzua
parents:
diff changeset
3135 });
jurzua
parents:
diff changeset
3136
jurzua
parents:
diff changeset
3137 // submit delegation
jurzua
parents:
diff changeset
3138 if ( !jQuery.support.submitBubbles ) {
jurzua
parents:
diff changeset
3139
jurzua
parents:
diff changeset
3140 jQuery.event.special.submit = {
jurzua
parents:
diff changeset
3141 setup: function( data, namespaces ) {
jurzua
parents:
diff changeset
3142 if ( !jQuery.nodeName( this, "form" ) ) {
jurzua
parents:
diff changeset
3143 jQuery.event.add(this, "click.specialSubmit", function( e ) {
jurzua
parents:
diff changeset
3144 var elem = e.target,
jurzua
parents:
diff changeset
3145 type = elem.type;
jurzua
parents:
diff changeset
3146
jurzua
parents:
diff changeset
3147 if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
jurzua
parents:
diff changeset
3148 trigger( "submit", this, arguments );
jurzua
parents:
diff changeset
3149 }
jurzua
parents:
diff changeset
3150 });
jurzua
parents:
diff changeset
3151
jurzua
parents:
diff changeset
3152 jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
jurzua
parents:
diff changeset
3153 var elem = e.target,
jurzua
parents:
diff changeset
3154 type = elem.type;
jurzua
parents:
diff changeset
3155
jurzua
parents:
diff changeset
3156 if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
jurzua
parents:
diff changeset
3157 trigger( "submit", this, arguments );
jurzua
parents:
diff changeset
3158 }
jurzua
parents:
diff changeset
3159 });
jurzua
parents:
diff changeset
3160
jurzua
parents:
diff changeset
3161 } else {
jurzua
parents:
diff changeset
3162 return false;
jurzua
parents:
diff changeset
3163 }
jurzua
parents:
diff changeset
3164 },
jurzua
parents:
diff changeset
3165
jurzua
parents:
diff changeset
3166 teardown: function( namespaces ) {
jurzua
parents:
diff changeset
3167 jQuery.event.remove( this, ".specialSubmit" );
jurzua
parents:
diff changeset
3168 }
jurzua
parents:
diff changeset
3169 };
jurzua
parents:
diff changeset
3170
jurzua
parents:
diff changeset
3171 }
jurzua
parents:
diff changeset
3172
jurzua
parents:
diff changeset
3173 // change delegation, happens here so we have bind.
jurzua
parents:
diff changeset
3174 if ( !jQuery.support.changeBubbles ) {
jurzua
parents:
diff changeset
3175
jurzua
parents:
diff changeset
3176 var changeFilters,
jurzua
parents:
diff changeset
3177
jurzua
parents:
diff changeset
3178 getVal = function( elem ) {
jurzua
parents:
diff changeset
3179 var type = elem.type, val = elem.value;
jurzua
parents:
diff changeset
3180
jurzua
parents:
diff changeset
3181 if ( type === "radio" || type === "checkbox" ) {
jurzua
parents:
diff changeset
3182 val = elem.checked;
jurzua
parents:
diff changeset
3183
jurzua
parents:
diff changeset
3184 } else if ( type === "select-multiple" ) {
jurzua
parents:
diff changeset
3185 val = elem.selectedIndex > -1 ?
jurzua
parents:
diff changeset
3186 jQuery.map( elem.options, function( elem ) {
jurzua
parents:
diff changeset
3187 return elem.selected;
jurzua
parents:
diff changeset
3188 }).join("-") :
jurzua
parents:
diff changeset
3189 "";
jurzua
parents:
diff changeset
3190
jurzua
parents:
diff changeset
3191 } else if ( jQuery.nodeName( elem, "select" ) ) {
jurzua
parents:
diff changeset
3192 val = elem.selectedIndex;
jurzua
parents:
diff changeset
3193 }
jurzua
parents:
diff changeset
3194
jurzua
parents:
diff changeset
3195 return val;
jurzua
parents:
diff changeset
3196 },
jurzua
parents:
diff changeset
3197
jurzua
parents:
diff changeset
3198 testChange = function testChange( e ) {
jurzua
parents:
diff changeset
3199 var elem = e.target, data, val;
jurzua
parents:
diff changeset
3200
jurzua
parents:
diff changeset
3201 if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) {
jurzua
parents:
diff changeset
3202 return;
jurzua
parents:
diff changeset
3203 }
jurzua
parents:
diff changeset
3204
jurzua
parents:
diff changeset
3205 data = jQuery._data( elem, "_change_data" );
jurzua
parents:
diff changeset
3206 val = getVal(elem);
jurzua
parents:
diff changeset
3207
jurzua
parents:
diff changeset
3208 // the current data will be also retrieved by beforeactivate
jurzua
parents:
diff changeset
3209 if ( e.type !== "focusout" || elem.type !== "radio" ) {
jurzua
parents:
diff changeset
3210 jQuery._data( elem, "_change_data", val );
jurzua
parents:
diff changeset
3211 }
jurzua
parents:
diff changeset
3212
jurzua
parents:
diff changeset
3213 if ( data === undefined || val === data ) {
jurzua
parents:
diff changeset
3214 return;
jurzua
parents:
diff changeset
3215 }
jurzua
parents:
diff changeset
3216
jurzua
parents:
diff changeset
3217 if ( data != null || val ) {
jurzua
parents:
diff changeset
3218 e.type = "change";
jurzua
parents:
diff changeset
3219 e.liveFired = undefined;
jurzua
parents:
diff changeset
3220 jQuery.event.trigger( e, arguments[1], elem );
jurzua
parents:
diff changeset
3221 }
jurzua
parents:
diff changeset
3222 };
jurzua
parents:
diff changeset
3223
jurzua
parents:
diff changeset
3224 jQuery.event.special.change = {
jurzua
parents:
diff changeset
3225 filters: {
jurzua
parents:
diff changeset
3226 focusout: testChange,
jurzua
parents:
diff changeset
3227
jurzua
parents:
diff changeset
3228 beforedeactivate: testChange,
jurzua
parents:
diff changeset
3229
jurzua
parents:
diff changeset
3230 click: function( e ) {
jurzua
parents:
diff changeset
3231 var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
jurzua
parents:
diff changeset
3232
jurzua
parents:
diff changeset
3233 if ( type === "radio" || type === "checkbox" || jQuery.nodeName( elem, "select" ) ) {
jurzua
parents:
diff changeset
3234 testChange.call( this, e );
jurzua
parents:
diff changeset
3235 }
jurzua
parents:
diff changeset
3236 },
jurzua
parents:
diff changeset
3237
jurzua
parents:
diff changeset
3238 // Change has to be called before submit
jurzua
parents:
diff changeset
3239 // Keydown will be called before keypress, which is used in submit-event delegation
jurzua
parents:
diff changeset
3240 keydown: function( e ) {
jurzua
parents:
diff changeset
3241 var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
jurzua
parents:
diff changeset
3242
jurzua
parents:
diff changeset
3243 if ( (e.keyCode === 13 && !jQuery.nodeName( elem, "textarea" ) ) ||
jurzua
parents:
diff changeset
3244 (e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
jurzua
parents:
diff changeset
3245 type === "select-multiple" ) {
jurzua
parents:
diff changeset
3246 testChange.call( this, e );
jurzua
parents:
diff changeset
3247 }
jurzua
parents:
diff changeset
3248 },
jurzua
parents:
diff changeset
3249
jurzua
parents:
diff changeset
3250 // Beforeactivate happens also before the previous element is blurred
jurzua
parents:
diff changeset
3251 // with this event you can't trigger a change event, but you can store
jurzua
parents:
diff changeset
3252 // information
jurzua
parents:
diff changeset
3253 beforeactivate: function( e ) {
jurzua
parents:
diff changeset
3254 var elem = e.target;
jurzua
parents:
diff changeset
3255 jQuery._data( elem, "_change_data", getVal(elem) );
jurzua
parents:
diff changeset
3256 }
jurzua
parents:
diff changeset
3257 },
jurzua
parents:
diff changeset
3258
jurzua
parents:
diff changeset
3259 setup: function( data, namespaces ) {
jurzua
parents:
diff changeset
3260 if ( this.type === "file" ) {
jurzua
parents:
diff changeset
3261 return false;
jurzua
parents:
diff changeset
3262 }
jurzua
parents:
diff changeset
3263
jurzua
parents:
diff changeset
3264 for ( var type in changeFilters ) {
jurzua
parents:
diff changeset
3265 jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
jurzua
parents:
diff changeset
3266 }
jurzua
parents:
diff changeset
3267
jurzua
parents:
diff changeset
3268 return rformElems.test( this.nodeName );
jurzua
parents:
diff changeset
3269 },
jurzua
parents:
diff changeset
3270
jurzua
parents:
diff changeset
3271 teardown: function( namespaces ) {
jurzua
parents:
diff changeset
3272 jQuery.event.remove( this, ".specialChange" );
jurzua
parents:
diff changeset
3273
jurzua
parents:
diff changeset
3274 return rformElems.test( this.nodeName );
jurzua
parents:
diff changeset
3275 }
jurzua
parents:
diff changeset
3276 };
jurzua
parents:
diff changeset
3277
jurzua
parents:
diff changeset
3278 changeFilters = jQuery.event.special.change.filters;
jurzua
parents:
diff changeset
3279
jurzua
parents:
diff changeset
3280 // Handle when the input is .focus()'d
jurzua
parents:
diff changeset
3281 changeFilters.focus = changeFilters.beforeactivate;
jurzua
parents:
diff changeset
3282 }
jurzua
parents:
diff changeset
3283
jurzua
parents:
diff changeset
3284 function trigger( type, elem, args ) {
jurzua
parents:
diff changeset
3285 // Piggyback on a donor event to simulate a different one.
jurzua
parents:
diff changeset
3286 // Fake originalEvent to avoid donor's stopPropagation, but if the
jurzua
parents:
diff changeset
3287 // simulated event prevents default then we do the same on the donor.
jurzua
parents:
diff changeset
3288 // Don't pass args or remember liveFired; they apply to the donor event.
jurzua
parents:
diff changeset
3289 var event = jQuery.extend( {}, args[ 0 ] );
jurzua
parents:
diff changeset
3290 event.type = type;
jurzua
parents:
diff changeset
3291 event.originalEvent = {};
jurzua
parents:
diff changeset
3292 event.liveFired = undefined;
jurzua
parents:
diff changeset
3293 jQuery.event.handle.call( elem, event );
jurzua
parents:
diff changeset
3294 if ( event.isDefaultPrevented() ) {
jurzua
parents:
diff changeset
3295 args[ 0 ].preventDefault();
jurzua
parents:
diff changeset
3296 }
jurzua
parents:
diff changeset
3297 }
jurzua
parents:
diff changeset
3298
jurzua
parents:
diff changeset
3299 // Create "bubbling" focus and blur events
jurzua
parents:
diff changeset
3300 if ( !jQuery.support.focusinBubbles ) {
jurzua
parents:
diff changeset
3301 jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
jurzua
parents:
diff changeset
3302
jurzua
parents:
diff changeset
3303 // Attach a single capturing handler while someone wants focusin/focusout
jurzua
parents:
diff changeset
3304 var attaches = 0;
jurzua
parents:
diff changeset
3305
jurzua
parents:
diff changeset
3306 jQuery.event.special[ fix ] = {
jurzua
parents:
diff changeset
3307 setup: function() {
jurzua
parents:
diff changeset
3308 if ( attaches++ === 0 ) {
jurzua
parents:
diff changeset
3309 document.addEventListener( orig, handler, true );
jurzua
parents:
diff changeset
3310 }
jurzua
parents:
diff changeset
3311 },
jurzua
parents:
diff changeset
3312 teardown: function() {
jurzua
parents:
diff changeset
3313 if ( --attaches === 0 ) {
jurzua
parents:
diff changeset
3314 document.removeEventListener( orig, handler, true );
jurzua
parents:
diff changeset
3315 }
jurzua
parents:
diff changeset
3316 }
jurzua
parents:
diff changeset
3317 };
jurzua
parents:
diff changeset
3318
jurzua
parents:
diff changeset
3319 function handler( donor ) {
jurzua
parents:
diff changeset
3320 // Donor event is always a native one; fix it and switch its type.
jurzua
parents:
diff changeset
3321 // Let focusin/out handler cancel the donor focus/blur event.
jurzua
parents:
diff changeset
3322 var e = jQuery.event.fix( donor );
jurzua
parents:
diff changeset
3323 e.type = fix;
jurzua
parents:
diff changeset
3324 e.originalEvent = {};
jurzua
parents:
diff changeset
3325 jQuery.event.trigger( e, null, e.target );
jurzua
parents:
diff changeset
3326 if ( e.isDefaultPrevented() ) {
jurzua
parents:
diff changeset
3327 donor.preventDefault();
jurzua
parents:
diff changeset
3328 }
jurzua
parents:
diff changeset
3329 }
jurzua
parents:
diff changeset
3330 });
jurzua
parents:
diff changeset
3331 }
jurzua
parents:
diff changeset
3332
jurzua
parents:
diff changeset
3333 jQuery.each(["bind", "one"], function( i, name ) {
jurzua
parents:
diff changeset
3334 jQuery.fn[ name ] = function( type, data, fn ) {
jurzua
parents:
diff changeset
3335 var handler;
jurzua
parents:
diff changeset
3336
jurzua
parents:
diff changeset
3337 // Handle object literals
jurzua
parents:
diff changeset
3338 if ( typeof type === "object" ) {
jurzua
parents:
diff changeset
3339 for ( var key in type ) {
jurzua
parents:
diff changeset
3340 this[ name ](key, data, type[key], fn);
jurzua
parents:
diff changeset
3341 }
jurzua
parents:
diff changeset
3342 return this;
jurzua
parents:
diff changeset
3343 }
jurzua
parents:
diff changeset
3344
jurzua
parents:
diff changeset
3345 if ( arguments.length === 2 || data === false ) {
jurzua
parents:
diff changeset
3346 fn = data;
jurzua
parents:
diff changeset
3347 data = undefined;
jurzua
parents:
diff changeset
3348 }
jurzua
parents:
diff changeset
3349
jurzua
parents:
diff changeset
3350 if ( name === "one" ) {
jurzua
parents:
diff changeset
3351 handler = function( event ) {
jurzua
parents:
diff changeset
3352 jQuery( this ).unbind( event, handler );
jurzua
parents:
diff changeset
3353 return fn.apply( this, arguments );
jurzua
parents:
diff changeset
3354 };
jurzua
parents:
diff changeset
3355 handler.guid = fn.guid || jQuery.guid++;
jurzua
parents:
diff changeset
3356 } else {
jurzua
parents:
diff changeset
3357 handler = fn;
jurzua
parents:
diff changeset
3358 }
jurzua
parents:
diff changeset
3359
jurzua
parents:
diff changeset
3360 if ( type === "unload" && name !== "one" ) {
jurzua
parents:
diff changeset
3361 this.one( type, data, fn );
jurzua
parents:
diff changeset
3362
jurzua
parents:
diff changeset
3363 } else {
jurzua
parents:
diff changeset
3364 for ( var i = 0, l = this.length; i < l; i++ ) {
jurzua
parents:
diff changeset
3365 jQuery.event.add( this[i], type, handler, data );
jurzua
parents:
diff changeset
3366 }
jurzua
parents:
diff changeset
3367 }
jurzua
parents:
diff changeset
3368
jurzua
parents:
diff changeset
3369 return this;
jurzua
parents:
diff changeset
3370 };
jurzua
parents:
diff changeset
3371 });
jurzua
parents:
diff changeset
3372
jurzua
parents:
diff changeset
3373 jQuery.fn.extend({
jurzua
parents:
diff changeset
3374 unbind: function( type, fn ) {
jurzua
parents:
diff changeset
3375 // Handle object literals
jurzua
parents:
diff changeset
3376 if ( typeof type === "object" && !type.preventDefault ) {
jurzua
parents:
diff changeset
3377 for ( var key in type ) {
jurzua
parents:
diff changeset
3378 this.unbind(key, type[key]);
jurzua
parents:
diff changeset
3379 }
jurzua
parents:
diff changeset
3380
jurzua
parents:
diff changeset
3381 } else {
jurzua
parents:
diff changeset
3382 for ( var i = 0, l = this.length; i < l; i++ ) {
jurzua
parents:
diff changeset
3383 jQuery.event.remove( this[i], type, fn );
jurzua
parents:
diff changeset
3384 }
jurzua
parents:
diff changeset
3385 }
jurzua
parents:
diff changeset
3386
jurzua
parents:
diff changeset
3387 return this;
jurzua
parents:
diff changeset
3388 },
jurzua
parents:
diff changeset
3389
jurzua
parents:
diff changeset
3390 delegate: function( selector, types, data, fn ) {
jurzua
parents:
diff changeset
3391 return this.live( types, data, fn, selector );
jurzua
parents:
diff changeset
3392 },
jurzua
parents:
diff changeset
3393
jurzua
parents:
diff changeset
3394 undelegate: function( selector, types, fn ) {
jurzua
parents:
diff changeset
3395 if ( arguments.length === 0 ) {
jurzua
parents:
diff changeset
3396 return this.unbind( "live" );
jurzua
parents:
diff changeset
3397
jurzua
parents:
diff changeset
3398 } else {
jurzua
parents:
diff changeset
3399 return this.die( types, null, fn, selector );
jurzua
parents:
diff changeset
3400 }
jurzua
parents:
diff changeset
3401 },
jurzua
parents:
diff changeset
3402
jurzua
parents:
diff changeset
3403 trigger: function( type, data ) {
jurzua
parents:
diff changeset
3404 return this.each(function() {
jurzua
parents:
diff changeset
3405 jQuery.event.trigger( type, data, this );
jurzua
parents:
diff changeset
3406 });
jurzua
parents:
diff changeset
3407 },
jurzua
parents:
diff changeset
3408
jurzua
parents:
diff changeset
3409 triggerHandler: function( type, data ) {
jurzua
parents:
diff changeset
3410 if ( this[0] ) {
jurzua
parents:
diff changeset
3411 return jQuery.event.trigger( type, data, this[0], true );
jurzua
parents:
diff changeset
3412 }
jurzua
parents:
diff changeset
3413 },
jurzua
parents:
diff changeset
3414
jurzua
parents:
diff changeset
3415 toggle: function( fn ) {
jurzua
parents:
diff changeset
3416 // Save reference to arguments for access in closure
jurzua
parents:
diff changeset
3417 var args = arguments,
jurzua
parents:
diff changeset
3418 guid = fn.guid || jQuery.guid++,
jurzua
parents:
diff changeset
3419 i = 0,
jurzua
parents:
diff changeset
3420 toggler = function( event ) {
jurzua
parents:
diff changeset
3421 // Figure out which function to execute
jurzua
parents:
diff changeset
3422 var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
jurzua
parents:
diff changeset
3423 jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
jurzua
parents:
diff changeset
3424
jurzua
parents:
diff changeset
3425 // Make sure that clicks stop
jurzua
parents:
diff changeset
3426 event.preventDefault();
jurzua
parents:
diff changeset
3427
jurzua
parents:
diff changeset
3428 // and execute the function
jurzua
parents:
diff changeset
3429 return args[ lastToggle ].apply( this, arguments ) || false;
jurzua
parents:
diff changeset
3430 };
jurzua
parents:
diff changeset
3431
jurzua
parents:
diff changeset
3432 // link all the functions, so any of them can unbind this click handler
jurzua
parents:
diff changeset
3433 toggler.guid = guid;
jurzua
parents:
diff changeset
3434 while ( i < args.length ) {
jurzua
parents:
diff changeset
3435 args[ i++ ].guid = guid;
jurzua
parents:
diff changeset
3436 }
jurzua
parents:
diff changeset
3437
jurzua
parents:
diff changeset
3438 return this.click( toggler );
jurzua
parents:
diff changeset
3439 },
jurzua
parents:
diff changeset
3440
jurzua
parents:
diff changeset
3441 hover: function( fnOver, fnOut ) {
jurzua
parents:
diff changeset
3442 return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
jurzua
parents:
diff changeset
3443 }
jurzua
parents:
diff changeset
3444 });
jurzua
parents:
diff changeset
3445
jurzua
parents:
diff changeset
3446 var liveMap = {
jurzua
parents:
diff changeset
3447 focus: "focusin",
jurzua
parents:
diff changeset
3448 blur: "focusout",
jurzua
parents:
diff changeset
3449 mouseenter: "mouseover",
jurzua
parents:
diff changeset
3450 mouseleave: "mouseout"
jurzua
parents:
diff changeset
3451 };
jurzua
parents:
diff changeset
3452
jurzua
parents:
diff changeset
3453 jQuery.each(["live", "die"], function( i, name ) {
jurzua
parents:
diff changeset
3454 jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
jurzua
parents:
diff changeset
3455 var type, i = 0, match, namespaces, preType,
jurzua
parents:
diff changeset
3456 selector = origSelector || this.selector,
jurzua
parents:
diff changeset
3457 context = origSelector ? this : jQuery( this.context );
jurzua
parents:
diff changeset
3458
jurzua
parents:
diff changeset
3459 if ( typeof types === "object" && !types.preventDefault ) {
jurzua
parents:
diff changeset
3460 for ( var key in types ) {
jurzua
parents:
diff changeset
3461 context[ name ]( key, data, types[key], selector );
jurzua
parents:
diff changeset
3462 }
jurzua
parents:
diff changeset
3463
jurzua
parents:
diff changeset
3464 return this;
jurzua
parents:
diff changeset
3465 }
jurzua
parents:
diff changeset
3466
jurzua
parents:
diff changeset
3467 if ( name === "die" && !types &&
jurzua
parents:
diff changeset
3468 origSelector && origSelector.charAt(0) === "." ) {
jurzua
parents:
diff changeset
3469
jurzua
parents:
diff changeset
3470 context.unbind( origSelector );
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 ( data === false || jQuery.isFunction( data ) ) {
jurzua
parents:
diff changeset
3476 fn = data || returnFalse;
jurzua
parents:
diff changeset
3477 data = undefined;
jurzua
parents:
diff changeset
3478 }
jurzua
parents:
diff changeset
3479
jurzua
parents:
diff changeset
3480 types = (types || "").split(" ");
jurzua
parents:
diff changeset
3481
jurzua
parents:
diff changeset
3482 while ( (type = types[ i++ ]) != null ) {
jurzua
parents:
diff changeset
3483 match = rnamespaces.exec( type );
jurzua
parents:
diff changeset
3484 namespaces = "";
jurzua
parents:
diff changeset
3485
jurzua
parents:
diff changeset
3486 if ( match ) {
jurzua
parents:
diff changeset
3487 namespaces = match[0];
jurzua
parents:
diff changeset
3488 type = type.replace( rnamespaces, "" );
jurzua
parents:
diff changeset
3489 }
jurzua
parents:
diff changeset
3490
jurzua
parents:
diff changeset
3491 if ( type === "hover" ) {
jurzua
parents:
diff changeset
3492 types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
jurzua
parents:
diff changeset
3493 continue;
jurzua
parents:
diff changeset
3494 }
jurzua
parents:
diff changeset
3495
jurzua
parents:
diff changeset
3496 preType = type;
jurzua
parents:
diff changeset
3497
jurzua
parents:
diff changeset
3498 if ( liveMap[ type ] ) {
jurzua
parents:
diff changeset
3499 types.push( liveMap[ type ] + namespaces );
jurzua
parents:
diff changeset
3500 type = type + namespaces;
jurzua
parents:
diff changeset
3501
jurzua
parents:
diff changeset
3502 } else {
jurzua
parents:
diff changeset
3503 type = (liveMap[ type ] || type) + namespaces;
jurzua
parents:
diff changeset
3504 }
jurzua
parents:
diff changeset
3505
jurzua
parents:
diff changeset
3506 if ( name === "live" ) {
jurzua
parents:
diff changeset
3507 // bind live handler
jurzua
parents:
diff changeset
3508 for ( var j = 0, l = context.length; j < l; j++ ) {
jurzua
parents:
diff changeset
3509 jQuery.event.add( context[j], "live." + liveConvert( type, selector ),
jurzua
parents:
diff changeset
3510 { data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
jurzua
parents:
diff changeset
3511 }
jurzua
parents:
diff changeset
3512
jurzua
parents:
diff changeset
3513 } else {
jurzua
parents:
diff changeset
3514 // unbind live handler
jurzua
parents:
diff changeset
3515 context.unbind( "live." + liveConvert( type, selector ), fn );
jurzua
parents:
diff changeset
3516 }
jurzua
parents:
diff changeset
3517 }
jurzua
parents:
diff changeset
3518
jurzua
parents:
diff changeset
3519 return this;
jurzua
parents:
diff changeset
3520 };
jurzua
parents:
diff changeset
3521 });
jurzua
parents:
diff changeset
3522
jurzua
parents:
diff changeset
3523 function liveHandler( event ) {
jurzua
parents:
diff changeset
3524 var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret,
jurzua
parents:
diff changeset
3525 elems = [],
jurzua
parents:
diff changeset
3526 selectors = [],
jurzua
parents:
diff changeset
3527 events = jQuery._data( this, "events" );
jurzua
parents:
diff changeset
3528
jurzua
parents:
diff changeset
3529 // Make sure we avoid non-left-click bubbling in Firefox (#3861) and disabled elements in IE (#6911)
jurzua
parents:
diff changeset
3530 if ( event.liveFired === this || !events || !events.live || event.target.disabled || event.button && event.type === "click" ) {
jurzua
parents:
diff changeset
3531 return;
jurzua
parents:
diff changeset
3532 }
jurzua
parents:
diff changeset
3533
jurzua
parents:
diff changeset
3534 if ( event.namespace ) {
jurzua
parents:
diff changeset
3535 namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
jurzua
parents:
diff changeset
3536 }
jurzua
parents:
diff changeset
3537
jurzua
parents:
diff changeset
3538 event.liveFired = this;
jurzua
parents:
diff changeset
3539
jurzua
parents:
diff changeset
3540 var live = events.live.slice(0);
jurzua
parents:
diff changeset
3541
jurzua
parents:
diff changeset
3542 for ( j = 0; j < live.length; j++ ) {
jurzua
parents:
diff changeset
3543 handleObj = live[j];
jurzua
parents:
diff changeset
3544
jurzua
parents:
diff changeset
3545 if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
jurzua
parents:
diff changeset
3546 selectors.push( handleObj.selector );
jurzua
parents:
diff changeset
3547
jurzua
parents:
diff changeset
3548 } else {
jurzua
parents:
diff changeset
3549 live.splice( j--, 1 );
jurzua
parents:
diff changeset
3550 }
jurzua
parents:
diff changeset
3551 }
jurzua
parents:
diff changeset
3552
jurzua
parents:
diff changeset
3553 match = jQuery( event.target ).closest( selectors, event.currentTarget );
jurzua
parents:
diff changeset
3554
jurzua
parents:
diff changeset
3555 for ( i = 0, l = match.length; i < l; i++ ) {
jurzua
parents:
diff changeset
3556 close = match[i];
jurzua
parents:
diff changeset
3557
jurzua
parents:
diff changeset
3558 for ( j = 0; j < live.length; j++ ) {
jurzua
parents:
diff changeset
3559 handleObj = live[j];
jurzua
parents:
diff changeset
3560
jurzua
parents:
diff changeset
3561 if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) && !close.elem.disabled ) {
jurzua
parents:
diff changeset
3562 elem = close.elem;
jurzua
parents:
diff changeset
3563 related = null;
jurzua
parents:
diff changeset
3564
jurzua
parents:
diff changeset
3565 // Those two events require additional checking
jurzua
parents:
diff changeset
3566 if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) {
jurzua
parents:
diff changeset
3567 event.type = handleObj.preType;
jurzua
parents:
diff changeset
3568 related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
jurzua
parents:
diff changeset
3569
jurzua
parents:
diff changeset
3570 // Make sure not to accidentally match a child element with the same selector
jurzua
parents:
diff changeset
3571 if ( related && jQuery.contains( elem, related ) ) {
jurzua
parents:
diff changeset
3572 related = elem;
jurzua
parents:
diff changeset
3573 }
jurzua
parents:
diff changeset
3574 }
jurzua
parents:
diff changeset
3575
jurzua
parents:
diff changeset
3576 if ( !related || related !== elem ) {
jurzua
parents:
diff changeset
3577 elems.push({ elem: elem, handleObj: handleObj, level: close.level });
jurzua
parents:
diff changeset
3578 }
jurzua
parents:
diff changeset
3579 }
jurzua
parents:
diff changeset
3580 }
jurzua
parents:
diff changeset
3581 }
jurzua
parents:
diff changeset
3582
jurzua
parents:
diff changeset
3583 for ( i = 0, l = elems.length; i < l; i++ ) {
jurzua
parents:
diff changeset
3584 match = elems[i];
jurzua
parents:
diff changeset
3585
jurzua
parents:
diff changeset
3586 if ( maxLevel && match.level > maxLevel ) {
jurzua
parents:
diff changeset
3587 break;
jurzua
parents:
diff changeset
3588 }
jurzua
parents:
diff changeset
3589
jurzua
parents:
diff changeset
3590 event.currentTarget = match.elem;
jurzua
parents:
diff changeset
3591 event.data = match.handleObj.data;
jurzua
parents:
diff changeset
3592 event.handleObj = match.handleObj;
jurzua
parents:
diff changeset
3593
jurzua
parents:
diff changeset
3594 ret = match.handleObj.origHandler.apply( match.elem, arguments );
jurzua
parents:
diff changeset
3595
jurzua
parents:
diff changeset
3596 if ( ret === false || event.isPropagationStopped() ) {
jurzua
parents:
diff changeset
3597 maxLevel = match.level;
jurzua
parents:
diff changeset
3598
jurzua
parents:
diff changeset
3599 if ( ret === false ) {
jurzua
parents:
diff changeset
3600 stop = false;
jurzua
parents:
diff changeset
3601 }
jurzua
parents:
diff changeset
3602 if ( event.isImmediatePropagationStopped() ) {
jurzua
parents:
diff changeset
3603 break;
jurzua
parents:
diff changeset
3604 }
jurzua
parents:
diff changeset
3605 }
jurzua
parents:
diff changeset
3606 }
jurzua
parents:
diff changeset
3607
jurzua
parents:
diff changeset
3608 return stop;
jurzua
parents:
diff changeset
3609 }
jurzua
parents:
diff changeset
3610
jurzua
parents:
diff changeset
3611 function liveConvert( type, selector ) {
jurzua
parents:
diff changeset
3612 return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspaces, "&");
jurzua
parents:
diff changeset
3613 }
jurzua
parents:
diff changeset
3614
jurzua
parents:
diff changeset
3615 jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
jurzua
parents:
diff changeset
3616 "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
jurzua
parents:
diff changeset
3617 "change select submit keydown keypress keyup error").split(" "), function( i, name ) {
jurzua
parents:
diff changeset
3618
jurzua
parents:
diff changeset
3619 // Handle event binding
jurzua
parents:
diff changeset
3620 jQuery.fn[ name ] = function( data, fn ) {
jurzua
parents:
diff changeset
3621 if ( fn == null ) {
jurzua
parents:
diff changeset
3622 fn = data;
jurzua
parents:
diff changeset
3623 data = null;
jurzua
parents:
diff changeset
3624 }
jurzua
parents:
diff changeset
3625
jurzua
parents:
diff changeset
3626 return arguments.length > 0 ?
jurzua
parents:
diff changeset
3627 this.bind( name, data, fn ) :
jurzua
parents:
diff changeset
3628 this.trigger( name );
jurzua
parents:
diff changeset
3629 };
jurzua
parents:
diff changeset
3630
jurzua
parents:
diff changeset
3631 if ( jQuery.attrFn ) {
jurzua
parents:
diff changeset
3632 jQuery.attrFn[ name ] = true;
jurzua
parents:
diff changeset
3633 }
jurzua
parents:
diff changeset
3634 });
jurzua
parents:
diff changeset
3635
jurzua
parents:
diff changeset
3636
jurzua
parents:
diff changeset
3637
jurzua
parents:
diff changeset
3638 /*!
jurzua
parents:
diff changeset
3639 * Sizzle CSS Selector Engine
jurzua
parents:
diff changeset
3640 * Copyright 2011, The Dojo Foundation
jurzua
parents:
diff changeset
3641 * Released under the MIT, BSD, and GPL Licenses.
jurzua
parents:
diff changeset
3642 * More information: http://sizzlejs.com/
jurzua
parents:
diff changeset
3643 */
jurzua
parents:
diff changeset
3644 (function(){
jurzua
parents:
diff changeset
3645
jurzua
parents:
diff changeset
3646 var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
jurzua
parents:
diff changeset
3647 done = 0,
jurzua
parents:
diff changeset
3648 toString = Object.prototype.toString,
jurzua
parents:
diff changeset
3649 hasDuplicate = false,
jurzua
parents:
diff changeset
3650 baseHasDuplicate = true,
jurzua
parents:
diff changeset
3651 rBackslash = /\\/g,
jurzua
parents:
diff changeset
3652 rNonWord = /\W/;
jurzua
parents:
diff changeset
3653
jurzua
parents:
diff changeset
3654 // Here we check if the JavaScript engine is using some sort of
jurzua
parents:
diff changeset
3655 // optimization where it does not always call our comparision
jurzua
parents:
diff changeset
3656 // function. If that is the case, discard the hasDuplicate value.
jurzua
parents:
diff changeset
3657 // Thus far that includes Google Chrome.
jurzua
parents:
diff changeset
3658 [0, 0].sort(function() {
jurzua
parents:
diff changeset
3659 baseHasDuplicate = false;
jurzua
parents:
diff changeset
3660 return 0;
jurzua
parents:
diff changeset
3661 });
jurzua
parents:
diff changeset
3662
jurzua
parents:
diff changeset
3663 var Sizzle = function( selector, context, results, seed ) {
jurzua
parents:
diff changeset
3664 results = results || [];
jurzua
parents:
diff changeset
3665 context = context || document;
jurzua
parents:
diff changeset
3666
jurzua
parents:
diff changeset
3667 var origContext = context;
jurzua
parents:
diff changeset
3668
jurzua
parents:
diff changeset
3669 if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
jurzua
parents:
diff changeset
3670 return [];
jurzua
parents:
diff changeset
3671 }
jurzua
parents:
diff changeset
3672
jurzua
parents:
diff changeset
3673 if ( !selector || typeof selector !== "string" ) {
jurzua
parents:
diff changeset
3674 return results;
jurzua
parents:
diff changeset
3675 }
jurzua
parents:
diff changeset
3676
jurzua
parents:
diff changeset
3677 var m, set, checkSet, extra, ret, cur, pop, i,
jurzua
parents:
diff changeset
3678 prune = true,
jurzua
parents:
diff changeset
3679 contextXML = Sizzle.isXML( context ),
jurzua
parents:
diff changeset
3680 parts = [],
jurzua
parents:
diff changeset
3681 soFar = selector;
jurzua
parents:
diff changeset
3682
jurzua
parents:
diff changeset
3683 // Reset the position of the chunker regexp (start from head)
jurzua
parents:
diff changeset
3684 do {
jurzua
parents:
diff changeset
3685 chunker.exec( "" );
jurzua
parents:
diff changeset
3686 m = chunker.exec( soFar );
jurzua
parents:
diff changeset
3687
jurzua
parents:
diff changeset
3688 if ( m ) {
jurzua
parents:
diff changeset
3689 soFar = m[3];
jurzua
parents:
diff changeset
3690
jurzua
parents:
diff changeset
3691 parts.push( m[1] );
jurzua
parents:
diff changeset
3692
jurzua
parents:
diff changeset
3693 if ( m[2] ) {
jurzua
parents:
diff changeset
3694 extra = m[3];
jurzua
parents:
diff changeset
3695 break;
jurzua
parents:
diff changeset
3696 }
jurzua
parents:
diff changeset
3697 }
jurzua
parents:
diff changeset
3698 } while ( m );
jurzua
parents:
diff changeset
3699
jurzua
parents:
diff changeset
3700 if ( parts.length > 1 && origPOS.exec( selector ) ) {
jurzua
parents:
diff changeset
3701
jurzua
parents:
diff changeset
3702 if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
jurzua
parents:
diff changeset
3703 set = posProcess( parts[0] + parts[1], context );
jurzua
parents:
diff changeset
3704
jurzua
parents:
diff changeset
3705 } else {
jurzua
parents:
diff changeset
3706 set = Expr.relative[ parts[0] ] ?
jurzua
parents:
diff changeset
3707 [ context ] :
jurzua
parents:
diff changeset
3708 Sizzle( parts.shift(), context );
jurzua
parents:
diff changeset
3709
jurzua
parents:
diff changeset
3710 while ( parts.length ) {
jurzua
parents:
diff changeset
3711 selector = parts.shift();
jurzua
parents:
diff changeset
3712
jurzua
parents:
diff changeset
3713 if ( Expr.relative[ selector ] ) {
jurzua
parents:
diff changeset
3714 selector += parts.shift();
jurzua
parents:
diff changeset
3715 }
jurzua
parents:
diff changeset
3716
jurzua
parents:
diff changeset
3717 set = posProcess( selector, set );
jurzua
parents:
diff changeset
3718 }
jurzua
parents:
diff changeset
3719 }
jurzua
parents:
diff changeset
3720
jurzua
parents:
diff changeset
3721 } else {
jurzua
parents:
diff changeset
3722 // Take a shortcut and set the context if the root selector is an ID
jurzua
parents:
diff changeset
3723 // (but not if it'll be faster if the inner selector is an ID)
jurzua
parents:
diff changeset
3724 if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
jurzua
parents:
diff changeset
3725 Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
jurzua
parents:
diff changeset
3726
jurzua
parents:
diff changeset
3727 ret = Sizzle.find( parts.shift(), context, contextXML );
jurzua
parents:
diff changeset
3728 context = ret.expr ?
jurzua
parents:
diff changeset
3729 Sizzle.filter( ret.expr, ret.set )[0] :
jurzua
parents:
diff changeset
3730 ret.set[0];
jurzua
parents:
diff changeset
3731 }
jurzua
parents:
diff changeset
3732
jurzua
parents:
diff changeset
3733 if ( context ) {
jurzua
parents:
diff changeset
3734 ret = seed ?
jurzua
parents:
diff changeset
3735 { expr: parts.pop(), set: makeArray(seed) } :
jurzua
parents:
diff changeset
3736 Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
jurzua
parents:
diff changeset
3737
jurzua
parents:
diff changeset
3738 set = ret.expr ?
jurzua
parents:
diff changeset
3739 Sizzle.filter( ret.expr, ret.set ) :
jurzua
parents:
diff changeset
3740 ret.set;
jurzua
parents:
diff changeset
3741
jurzua
parents:
diff changeset
3742 if ( parts.length > 0 ) {
jurzua
parents:
diff changeset
3743 checkSet = makeArray( set );
jurzua
parents:
diff changeset
3744
jurzua
parents:
diff changeset
3745 } else {
jurzua
parents:
diff changeset
3746 prune = false;
jurzua
parents:
diff changeset
3747 }
jurzua
parents:
diff changeset
3748
jurzua
parents:
diff changeset
3749 while ( parts.length ) {
jurzua
parents:
diff changeset
3750 cur = parts.pop();
jurzua
parents:
diff changeset
3751 pop = cur;
jurzua
parents:
diff changeset
3752
jurzua
parents:
diff changeset
3753 if ( !Expr.relative[ cur ] ) {
jurzua
parents:
diff changeset
3754 cur = "";
jurzua
parents:
diff changeset
3755 } else {
jurzua
parents:
diff changeset
3756 pop = parts.pop();
jurzua
parents:
diff changeset
3757 }
jurzua
parents:
diff changeset
3758
jurzua
parents:
diff changeset
3759 if ( pop == null ) {
jurzua
parents:
diff changeset
3760 pop = context;
jurzua
parents:
diff changeset
3761 }
jurzua
parents:
diff changeset
3762
jurzua
parents:
diff changeset
3763 Expr.relative[ cur ]( checkSet, pop, contextXML );
jurzua
parents:
diff changeset
3764 }
jurzua
parents:
diff changeset
3765
jurzua
parents:
diff changeset
3766 } else {
jurzua
parents:
diff changeset
3767 checkSet = parts = [];
jurzua
parents:
diff changeset
3768 }
jurzua
parents:
diff changeset
3769 }
jurzua
parents:
diff changeset
3770
jurzua
parents:
diff changeset
3771 if ( !checkSet ) {
jurzua
parents:
diff changeset
3772 checkSet = set;
jurzua
parents:
diff changeset
3773 }
jurzua
parents:
diff changeset
3774
jurzua
parents:
diff changeset
3775 if ( !checkSet ) {
jurzua
parents:
diff changeset
3776 Sizzle.error( cur || selector );
jurzua
parents:
diff changeset
3777 }
jurzua
parents:
diff changeset
3778
jurzua
parents:
diff changeset
3779 if ( toString.call(checkSet) === "[object Array]" ) {
jurzua
parents:
diff changeset
3780 if ( !prune ) {
jurzua
parents:
diff changeset
3781 results.push.apply( results, checkSet );
jurzua
parents:
diff changeset
3782
jurzua
parents:
diff changeset
3783 } else if ( context && context.nodeType === 1 ) {
jurzua
parents:
diff changeset
3784 for ( i = 0; checkSet[i] != null; i++ ) {
jurzua
parents:
diff changeset
3785 if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
jurzua
parents:
diff changeset
3786 results.push( set[i] );
jurzua
parents:
diff changeset
3787 }
jurzua
parents:
diff changeset
3788 }
jurzua
parents:
diff changeset
3789
jurzua
parents:
diff changeset
3790 } else {
jurzua
parents:
diff changeset
3791 for ( i = 0; checkSet[i] != null; i++ ) {
jurzua
parents:
diff changeset
3792 if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
jurzua
parents:
diff changeset
3793 results.push( set[i] );
jurzua
parents:
diff changeset
3794 }
jurzua
parents:
diff changeset
3795 }
jurzua
parents:
diff changeset
3796 }
jurzua
parents:
diff changeset
3797
jurzua
parents:
diff changeset
3798 } else {
jurzua
parents:
diff changeset
3799 makeArray( checkSet, results );
jurzua
parents:
diff changeset
3800 }
jurzua
parents:
diff changeset
3801
jurzua
parents:
diff changeset
3802 if ( extra ) {
jurzua
parents:
diff changeset
3803 Sizzle( extra, origContext, results, seed );
jurzua
parents:
diff changeset
3804 Sizzle.uniqueSort( results );
jurzua
parents:
diff changeset
3805 }
jurzua
parents:
diff changeset
3806
jurzua
parents:
diff changeset
3807 return results;
jurzua
parents:
diff changeset
3808 };
jurzua
parents:
diff changeset
3809
jurzua
parents:
diff changeset
3810 Sizzle.uniqueSort = function( results ) {
jurzua
parents:
diff changeset
3811 if ( sortOrder ) {
jurzua
parents:
diff changeset
3812 hasDuplicate = baseHasDuplicate;
jurzua
parents:
diff changeset
3813 results.sort( sortOrder );
jurzua
parents:
diff changeset
3814
jurzua
parents:
diff changeset
3815 if ( hasDuplicate ) {
jurzua
parents:
diff changeset
3816 for ( var i = 1; i < results.length; i++ ) {
jurzua
parents:
diff changeset
3817 if ( results[i] === results[ i - 1 ] ) {
jurzua
parents:
diff changeset
3818 results.splice( i--, 1 );
jurzua
parents:
diff changeset
3819 }
jurzua
parents:
diff changeset
3820 }
jurzua
parents:
diff changeset
3821 }
jurzua
parents:
diff changeset
3822 }
jurzua
parents:
diff changeset
3823
jurzua
parents:
diff changeset
3824 return results;
jurzua
parents:
diff changeset
3825 };
jurzua
parents:
diff changeset
3826
jurzua
parents:
diff changeset
3827 Sizzle.matches = function( expr, set ) {
jurzua
parents:
diff changeset
3828 return Sizzle( expr, null, null, set );
jurzua
parents:
diff changeset
3829 };
jurzua
parents:
diff changeset
3830
jurzua
parents:
diff changeset
3831 Sizzle.matchesSelector = function( node, expr ) {
jurzua
parents:
diff changeset
3832 return Sizzle( expr, null, null, [node] ).length > 0;
jurzua
parents:
diff changeset
3833 };
jurzua
parents:
diff changeset
3834
jurzua
parents:
diff changeset
3835 Sizzle.find = function( expr, context, isXML ) {
jurzua
parents:
diff changeset
3836 var set;
jurzua
parents:
diff changeset
3837
jurzua
parents:
diff changeset
3838 if ( !expr ) {
jurzua
parents:
diff changeset
3839 return [];
jurzua
parents:
diff changeset
3840 }
jurzua
parents:
diff changeset
3841
jurzua
parents:
diff changeset
3842 for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
jurzua
parents:
diff changeset
3843 var match,
jurzua
parents:
diff changeset
3844 type = Expr.order[i];
jurzua
parents:
diff changeset
3845
jurzua
parents:
diff changeset
3846 if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
jurzua
parents:
diff changeset
3847 var left = match[1];
jurzua
parents:
diff changeset
3848 match.splice( 1, 1 );
jurzua
parents:
diff changeset
3849
jurzua
parents:
diff changeset
3850 if ( left.substr( left.length - 1 ) !== "\\" ) {
jurzua
parents:
diff changeset
3851 match[1] = (match[1] || "").replace( rBackslash, "" );
jurzua
parents:
diff changeset
3852 set = Expr.find[ type ]( match, context, isXML );
jurzua
parents:
diff changeset
3853
jurzua
parents:
diff changeset
3854 if ( set != null ) {
jurzua
parents:
diff changeset
3855 expr = expr.replace( Expr.match[ type ], "" );
jurzua
parents:
diff changeset
3856 break;
jurzua
parents:
diff changeset
3857 }
jurzua
parents:
diff changeset
3858 }
jurzua
parents:
diff changeset
3859 }
jurzua
parents:
diff changeset
3860 }
jurzua
parents:
diff changeset
3861
jurzua
parents:
diff changeset
3862 if ( !set ) {
jurzua
parents:
diff changeset
3863 set = typeof context.getElementsByTagName !== "undefined" ?
jurzua
parents:
diff changeset
3864 context.getElementsByTagName( "*" ) :
jurzua
parents:
diff changeset
3865 [];
jurzua
parents:
diff changeset
3866 }
jurzua
parents:
diff changeset
3867
jurzua
parents:
diff changeset
3868 return { set: set, expr: expr };
jurzua
parents:
diff changeset
3869 };
jurzua
parents:
diff changeset
3870
jurzua
parents:
diff changeset
3871 Sizzle.filter = function( expr, set, inplace, not ) {
jurzua
parents:
diff changeset
3872 var match, anyFound,
jurzua
parents:
diff changeset
3873 old = expr,
jurzua
parents:
diff changeset
3874 result = [],
jurzua
parents:
diff changeset
3875 curLoop = set,
jurzua
parents:
diff changeset
3876 isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
jurzua
parents:
diff changeset
3877
jurzua
parents:
diff changeset
3878 while ( expr && set.length ) {
jurzua
parents:
diff changeset
3879 for ( var type in Expr.filter ) {
jurzua
parents:
diff changeset
3880 if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
jurzua
parents:
diff changeset
3881 var found, item,
jurzua
parents:
diff changeset
3882 filter = Expr.filter[ type ],
jurzua
parents:
diff changeset
3883 left = match[1];
jurzua
parents:
diff changeset
3884
jurzua
parents:
diff changeset
3885 anyFound = false;
jurzua
parents:
diff changeset
3886
jurzua
parents:
diff changeset
3887 match.splice(1,1);
jurzua
parents:
diff changeset
3888
jurzua
parents:
diff changeset
3889 if ( left.substr( left.length - 1 ) === "\\" ) {
jurzua
parents:
diff changeset
3890 continue;
jurzua
parents:
diff changeset
3891 }
jurzua
parents:
diff changeset
3892
jurzua
parents:
diff changeset
3893 if ( curLoop === result ) {
jurzua
parents:
diff changeset
3894 result = [];
jurzua
parents:
diff changeset
3895 }
jurzua
parents:
diff changeset
3896
jurzua
parents:
diff changeset
3897 if ( Expr.preFilter[ type ] ) {
jurzua
parents:
diff changeset
3898 match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
jurzua
parents:
diff changeset
3899
jurzua
parents:
diff changeset
3900 if ( !match ) {
jurzua
parents:
diff changeset
3901 anyFound = found = true;
jurzua
parents:
diff changeset
3902
jurzua
parents:
diff changeset
3903 } else if ( match === true ) {
jurzua
parents:
diff changeset
3904 continue;
jurzua
parents:
diff changeset
3905 }
jurzua
parents:
diff changeset
3906 }
jurzua
parents:
diff changeset
3907
jurzua
parents:
diff changeset
3908 if ( match ) {
jurzua
parents:
diff changeset
3909 for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
jurzua
parents:
diff changeset
3910 if ( item ) {
jurzua
parents:
diff changeset
3911 found = filter( item, match, i, curLoop );
jurzua
parents:
diff changeset
3912 var pass = not ^ !!found;
jurzua
parents:
diff changeset
3913
jurzua
parents:
diff changeset
3914 if ( inplace && found != null ) {
jurzua
parents:
diff changeset
3915 if ( pass ) {
jurzua
parents:
diff changeset
3916 anyFound = true;
jurzua
parents:
diff changeset
3917
jurzua
parents:
diff changeset
3918 } else {
jurzua
parents:
diff changeset
3919 curLoop[i] = false;
jurzua
parents:
diff changeset
3920 }
jurzua
parents:
diff changeset
3921
jurzua
parents:
diff changeset
3922 } else if ( pass ) {
jurzua
parents:
diff changeset
3923 result.push( item );
jurzua
parents:
diff changeset
3924 anyFound = true;
jurzua
parents:
diff changeset
3925 }
jurzua
parents:
diff changeset
3926 }
jurzua
parents:
diff changeset
3927 }
jurzua
parents:
diff changeset
3928 }
jurzua
parents:
diff changeset
3929
jurzua
parents:
diff changeset
3930 if ( found !== undefined ) {
jurzua
parents:
diff changeset
3931 if ( !inplace ) {
jurzua
parents:
diff changeset
3932 curLoop = result;
jurzua
parents:
diff changeset
3933 }
jurzua
parents:
diff changeset
3934
jurzua
parents:
diff changeset
3935 expr = expr.replace( Expr.match[ type ], "" );
jurzua
parents:
diff changeset
3936
jurzua
parents:
diff changeset
3937 if ( !anyFound ) {
jurzua
parents:
diff changeset
3938 return [];
jurzua
parents:
diff changeset
3939 }
jurzua
parents:
diff changeset
3940
jurzua
parents:
diff changeset
3941 break;
jurzua
parents:
diff changeset
3942 }
jurzua
parents:
diff changeset
3943 }
jurzua
parents:
diff changeset
3944 }
jurzua
parents:
diff changeset
3945
jurzua
parents:
diff changeset
3946 // Improper expression
jurzua
parents:
diff changeset
3947 if ( expr === old ) {
jurzua
parents:
diff changeset
3948 if ( anyFound == null ) {
jurzua
parents:
diff changeset
3949 Sizzle.error( expr );
jurzua
parents:
diff changeset
3950
jurzua
parents:
diff changeset
3951 } else {
jurzua
parents:
diff changeset
3952 break;
jurzua
parents:
diff changeset
3953 }
jurzua
parents:
diff changeset
3954 }
jurzua
parents:
diff changeset
3955
jurzua
parents:
diff changeset
3956 old = expr;
jurzua
parents:
diff changeset
3957 }
jurzua
parents:
diff changeset
3958
jurzua
parents:
diff changeset
3959 return curLoop;
jurzua
parents:
diff changeset
3960 };
jurzua
parents:
diff changeset
3961
jurzua
parents:
diff changeset
3962 Sizzle.error = function( msg ) {
jurzua
parents:
diff changeset
3963 throw "Syntax error, unrecognized expression: " + msg;
jurzua
parents:
diff changeset
3964 };
jurzua
parents:
diff changeset
3965
jurzua
parents:
diff changeset
3966 var Expr = Sizzle.selectors = {
jurzua
parents:
diff changeset
3967 order: [ "ID", "NAME", "TAG" ],
jurzua
parents:
diff changeset
3968
jurzua
parents:
diff changeset
3969 match: {
jurzua
parents:
diff changeset
3970 ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
jurzua
parents:
diff changeset
3971 CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
jurzua
parents:
diff changeset
3972 NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
jurzua
parents:
diff changeset
3973 ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
jurzua
parents:
diff changeset
3974 TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
jurzua
parents:
diff changeset
3975 CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
jurzua
parents:
diff changeset
3976 POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
jurzua
parents:
diff changeset
3977 PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
jurzua
parents:
diff changeset
3978 },
jurzua
parents:
diff changeset
3979
jurzua
parents:
diff changeset
3980 leftMatch: {},
jurzua
parents:
diff changeset
3981
jurzua
parents:
diff changeset
3982 attrMap: {
jurzua
parents:
diff changeset
3983 "class": "className",
jurzua
parents:
diff changeset
3984 "for": "htmlFor"
jurzua
parents:
diff changeset
3985 },
jurzua
parents:
diff changeset
3986
jurzua
parents:
diff changeset
3987 attrHandle: {
jurzua
parents:
diff changeset
3988 href: function( elem ) {
jurzua
parents:
diff changeset
3989 return elem.getAttribute( "href" );
jurzua
parents:
diff changeset
3990 },
jurzua
parents:
diff changeset
3991 type: function( elem ) {
jurzua
parents:
diff changeset
3992 return elem.getAttribute( "type" );
jurzua
parents:
diff changeset
3993 }
jurzua
parents:
diff changeset
3994 },
jurzua
parents:
diff changeset
3995
jurzua
parents:
diff changeset
3996 relative: {
jurzua
parents:
diff changeset
3997 "+": function(checkSet, part){
jurzua
parents:
diff changeset
3998 var isPartStr = typeof part === "string",
jurzua
parents:
diff changeset
3999 isTag = isPartStr && !rNonWord.test( part ),
jurzua
parents:
diff changeset
4000 isPartStrNotTag = isPartStr && !isTag;
jurzua
parents:
diff changeset
4001
jurzua
parents:
diff changeset
4002 if ( isTag ) {
jurzua
parents:
diff changeset
4003 part = part.toLowerCase();
jurzua
parents:
diff changeset
4004 }
jurzua
parents:
diff changeset
4005
jurzua
parents:
diff changeset
4006 for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
jurzua
parents:
diff changeset
4007 if ( (elem = checkSet[i]) ) {
jurzua
parents:
diff changeset
4008 while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
jurzua
parents:
diff changeset
4009
jurzua
parents:
diff changeset
4010 checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
jurzua
parents:
diff changeset
4011 elem || false :
jurzua
parents:
diff changeset
4012 elem === part;
jurzua
parents:
diff changeset
4013 }
jurzua
parents:
diff changeset
4014 }
jurzua
parents:
diff changeset
4015
jurzua
parents:
diff changeset
4016 if ( isPartStrNotTag ) {
jurzua
parents:
diff changeset
4017 Sizzle.filter( part, checkSet, true );
jurzua
parents:
diff changeset
4018 }
jurzua
parents:
diff changeset
4019 },
jurzua
parents:
diff changeset
4020
jurzua
parents:
diff changeset
4021 ">": function( checkSet, part ) {
jurzua
parents:
diff changeset
4022 var elem,
jurzua
parents:
diff changeset
4023 isPartStr = typeof part === "string",
jurzua
parents:
diff changeset
4024 i = 0,
jurzua
parents:
diff changeset
4025 l = checkSet.length;
jurzua
parents:
diff changeset
4026
jurzua
parents:
diff changeset
4027 if ( isPartStr && !rNonWord.test( part ) ) {
jurzua
parents:
diff changeset
4028 part = part.toLowerCase();
jurzua
parents:
diff changeset
4029
jurzua
parents:
diff changeset
4030 for ( ; i < l; i++ ) {
jurzua
parents:
diff changeset
4031 elem = checkSet[i];
jurzua
parents:
diff changeset
4032
jurzua
parents:
diff changeset
4033 if ( elem ) {
jurzua
parents:
diff changeset
4034 var parent = elem.parentNode;
jurzua
parents:
diff changeset
4035 checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
jurzua
parents:
diff changeset
4036 }
jurzua
parents:
diff changeset
4037 }
jurzua
parents:
diff changeset
4038
jurzua
parents:
diff changeset
4039 } else {
jurzua
parents:
diff changeset
4040 for ( ; i < l; i++ ) {
jurzua
parents:
diff changeset
4041 elem = checkSet[i];
jurzua
parents:
diff changeset
4042
jurzua
parents:
diff changeset
4043 if ( elem ) {
jurzua
parents:
diff changeset
4044 checkSet[i] = isPartStr ?
jurzua
parents:
diff changeset
4045 elem.parentNode :
jurzua
parents:
diff changeset
4046 elem.parentNode === part;
jurzua
parents:
diff changeset
4047 }
jurzua
parents:
diff changeset
4048 }
jurzua
parents:
diff changeset
4049
jurzua
parents:
diff changeset
4050 if ( isPartStr ) {
jurzua
parents:
diff changeset
4051 Sizzle.filter( part, checkSet, true );
jurzua
parents:
diff changeset
4052 }
jurzua
parents:
diff changeset
4053 }
jurzua
parents:
diff changeset
4054 },
jurzua
parents:
diff changeset
4055
jurzua
parents:
diff changeset
4056 "": function(checkSet, part, isXML){
jurzua
parents:
diff changeset
4057 var nodeCheck,
jurzua
parents:
diff changeset
4058 doneName = done++,
jurzua
parents:
diff changeset
4059 checkFn = dirCheck;
jurzua
parents:
diff changeset
4060
jurzua
parents:
diff changeset
4061 if ( typeof part === "string" && !rNonWord.test( part ) ) {
jurzua
parents:
diff changeset
4062 part = part.toLowerCase();
jurzua
parents:
diff changeset
4063 nodeCheck = part;
jurzua
parents:
diff changeset
4064 checkFn = dirNodeCheck;
jurzua
parents:
diff changeset
4065 }
jurzua
parents:
diff changeset
4066
jurzua
parents:
diff changeset
4067 checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
jurzua
parents:
diff changeset
4068 },
jurzua
parents:
diff changeset
4069
jurzua
parents:
diff changeset
4070 "~": function( checkSet, part, isXML ) {
jurzua
parents:
diff changeset
4071 var nodeCheck,
jurzua
parents:
diff changeset
4072 doneName = done++,
jurzua
parents:
diff changeset
4073 checkFn = dirCheck;
jurzua
parents:
diff changeset
4074
jurzua
parents:
diff changeset
4075 if ( typeof part === "string" && !rNonWord.test( part ) ) {
jurzua
parents:
diff changeset
4076 part = part.toLowerCase();
jurzua
parents:
diff changeset
4077 nodeCheck = part;
jurzua
parents:
diff changeset
4078 checkFn = dirNodeCheck;
jurzua
parents:
diff changeset
4079 }
jurzua
parents:
diff changeset
4080
jurzua
parents:
diff changeset
4081 checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
jurzua
parents:
diff changeset
4082 }
jurzua
parents:
diff changeset
4083 },
jurzua
parents:
diff changeset
4084
jurzua
parents:
diff changeset
4085 find: {
jurzua
parents:
diff changeset
4086 ID: function( match, context, isXML ) {
jurzua
parents:
diff changeset
4087 if ( typeof context.getElementById !== "undefined" && !isXML ) {
jurzua
parents:
diff changeset
4088 var m = context.getElementById(match[1]);
jurzua
parents:
diff changeset
4089 // Check parentNode to catch when Blackberry 4.6 returns
jurzua
parents:
diff changeset
4090 // nodes that are no longer in the document #6963
jurzua
parents:
diff changeset
4091 return m && m.parentNode ? [m] : [];
jurzua
parents:
diff changeset
4092 }
jurzua
parents:
diff changeset
4093 },
jurzua
parents:
diff changeset
4094
jurzua
parents:
diff changeset
4095 NAME: function( match, context ) {
jurzua
parents:
diff changeset
4096 if ( typeof context.getElementsByName !== "undefined" ) {
jurzua
parents:
diff changeset
4097 var ret = [],
jurzua
parents:
diff changeset
4098 results = context.getElementsByName( match[1] );
jurzua
parents:
diff changeset
4099
jurzua
parents:
diff changeset
4100 for ( var i = 0, l = results.length; i < l; i++ ) {
jurzua
parents:
diff changeset
4101 if ( results[i].getAttribute("name") === match[1] ) {
jurzua
parents:
diff changeset
4102 ret.push( results[i] );
jurzua
parents:
diff changeset
4103 }
jurzua
parents:
diff changeset
4104 }
jurzua
parents:
diff changeset
4105
jurzua
parents:
diff changeset
4106 return ret.length === 0 ? null : ret;
jurzua
parents:
diff changeset
4107 }
jurzua
parents:
diff changeset
4108 },
jurzua
parents:
diff changeset
4109
jurzua
parents:
diff changeset
4110 TAG: function( match, context ) {
jurzua
parents:
diff changeset
4111 if ( typeof context.getElementsByTagName !== "undefined" ) {
jurzua
parents:
diff changeset
4112 return context.getElementsByTagName( match[1] );
jurzua
parents:
diff changeset
4113 }
jurzua
parents:
diff changeset
4114 }
jurzua
parents:
diff changeset
4115 },
jurzua
parents:
diff changeset
4116 preFilter: {
jurzua
parents:
diff changeset
4117 CLASS: function( match, curLoop, inplace, result, not, isXML ) {
jurzua
parents:
diff changeset
4118 match = " " + match[1].replace( rBackslash, "" ) + " ";
jurzua
parents:
diff changeset
4119
jurzua
parents:
diff changeset
4120 if ( isXML ) {
jurzua
parents:
diff changeset
4121 return match;
jurzua
parents:
diff changeset
4122 }
jurzua
parents:
diff changeset
4123
jurzua
parents:
diff changeset
4124 for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
jurzua
parents:
diff changeset
4125 if ( elem ) {
jurzua
parents:
diff changeset
4126 if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
jurzua
parents:
diff changeset
4127 if ( !inplace ) {
jurzua
parents:
diff changeset
4128 result.push( elem );
jurzua
parents:
diff changeset
4129 }
jurzua
parents:
diff changeset
4130
jurzua
parents:
diff changeset
4131 } else if ( inplace ) {
jurzua
parents:
diff changeset
4132 curLoop[i] = false;
jurzua
parents:
diff changeset
4133 }
jurzua
parents:
diff changeset
4134 }
jurzua
parents:
diff changeset
4135 }
jurzua
parents:
diff changeset
4136
jurzua
parents:
diff changeset
4137 return false;
jurzua
parents:
diff changeset
4138 },
jurzua
parents:
diff changeset
4139
jurzua
parents:
diff changeset
4140 ID: function( match ) {
jurzua
parents:
diff changeset
4141 return match[1].replace( rBackslash, "" );
jurzua
parents:
diff changeset
4142 },
jurzua
parents:
diff changeset
4143
jurzua
parents:
diff changeset
4144 TAG: function( match, curLoop ) {
jurzua
parents:
diff changeset
4145 return match[1].replace( rBackslash, "" ).toLowerCase();
jurzua
parents:
diff changeset
4146 },
jurzua
parents:
diff changeset
4147
jurzua
parents:
diff changeset
4148 CHILD: function( match ) {
jurzua
parents:
diff changeset
4149 if ( match[1] === "nth" ) {
jurzua
parents:
diff changeset
4150 if ( !match[2] ) {
jurzua
parents:
diff changeset
4151 Sizzle.error( match[0] );
jurzua
parents:
diff changeset
4152 }
jurzua
parents:
diff changeset
4153
jurzua
parents:
diff changeset
4154 match[2] = match[2].replace(/^\+|\s*/g, '');
jurzua
parents:
diff changeset
4155
jurzua
parents:
diff changeset
4156 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
jurzua
parents:
diff changeset
4157 var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(
jurzua
parents:
diff changeset
4158 match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
jurzua
parents:
diff changeset
4159 !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
jurzua
parents:
diff changeset
4160
jurzua
parents:
diff changeset
4161 // calculate the numbers (first)n+(last) including if they are negative
jurzua
parents:
diff changeset
4162 match[2] = (test[1] + (test[2] || 1)) - 0;
jurzua
parents:
diff changeset
4163 match[3] = test[3] - 0;
jurzua
parents:
diff changeset
4164 }
jurzua
parents:
diff changeset
4165 else if ( match[2] ) {
jurzua
parents:
diff changeset
4166 Sizzle.error( match[0] );
jurzua
parents:
diff changeset
4167 }
jurzua
parents:
diff changeset
4168
jurzua
parents:
diff changeset
4169 // TODO: Move to normal caching system
jurzua
parents:
diff changeset
4170 match[0] = done++;
jurzua
parents:
diff changeset
4171
jurzua
parents:
diff changeset
4172 return match;
jurzua
parents:
diff changeset
4173 },
jurzua
parents:
diff changeset
4174
jurzua
parents:
diff changeset
4175 ATTR: function( match, curLoop, inplace, result, not, isXML ) {
jurzua
parents:
diff changeset
4176 var name = match[1] = match[1].replace( rBackslash, "" );
jurzua
parents:
diff changeset
4177
jurzua
parents:
diff changeset
4178 if ( !isXML && Expr.attrMap[name] ) {
jurzua
parents:
diff changeset
4179 match[1] = Expr.attrMap[name];
jurzua
parents:
diff changeset
4180 }
jurzua
parents:
diff changeset
4181
jurzua
parents:
diff changeset
4182 // Handle if an un-quoted value was used
jurzua
parents:
diff changeset
4183 match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" );
jurzua
parents:
diff changeset
4184
jurzua
parents:
diff changeset
4185 if ( match[2] === "~=" ) {
jurzua
parents:
diff changeset
4186 match[4] = " " + match[4] + " ";
jurzua
parents:
diff changeset
4187 }
jurzua
parents:
diff changeset
4188
jurzua
parents:
diff changeset
4189 return match;
jurzua
parents:
diff changeset
4190 },
jurzua
parents:
diff changeset
4191
jurzua
parents:
diff changeset
4192 PSEUDO: function( match, curLoop, inplace, result, not ) {
jurzua
parents:
diff changeset
4193 if ( match[1] === "not" ) {
jurzua
parents:
diff changeset
4194 // If we're dealing with a complex expression, or a simple one
jurzua
parents:
diff changeset
4195 if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
jurzua
parents:
diff changeset
4196 match[3] = Sizzle(match[3], null, null, curLoop);
jurzua
parents:
diff changeset
4197
jurzua
parents:
diff changeset
4198 } else {
jurzua
parents:
diff changeset
4199 var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
jurzua
parents:
diff changeset
4200
jurzua
parents:
diff changeset
4201 if ( !inplace ) {
jurzua
parents:
diff changeset
4202 result.push.apply( result, ret );
jurzua
parents:
diff changeset
4203 }
jurzua
parents:
diff changeset
4204
jurzua
parents:
diff changeset
4205 return false;
jurzua
parents:
diff changeset
4206 }
jurzua
parents:
diff changeset
4207
jurzua
parents:
diff changeset
4208 } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
jurzua
parents:
diff changeset
4209 return true;
jurzua
parents:
diff changeset
4210 }
jurzua
parents:
diff changeset
4211
jurzua
parents:
diff changeset
4212 return match;
jurzua
parents:
diff changeset
4213 },
jurzua
parents:
diff changeset
4214
jurzua
parents:
diff changeset
4215 POS: function( match ) {
jurzua
parents:
diff changeset
4216 match.unshift( true );
jurzua
parents:
diff changeset
4217
jurzua
parents:
diff changeset
4218 return match;
jurzua
parents:
diff changeset
4219 }
jurzua
parents:
diff changeset
4220 },
jurzua
parents:
diff changeset
4221
jurzua
parents:
diff changeset
4222 filters: {
jurzua
parents:
diff changeset
4223 enabled: function( elem ) {
jurzua
parents:
diff changeset
4224 return elem.disabled === false && elem.type !== "hidden";
jurzua
parents:
diff changeset
4225 },
jurzua
parents:
diff changeset
4226
jurzua
parents:
diff changeset
4227 disabled: function( elem ) {
jurzua
parents:
diff changeset
4228 return elem.disabled === true;
jurzua
parents:
diff changeset
4229 },
jurzua
parents:
diff changeset
4230
jurzua
parents:
diff changeset
4231 checked: function( elem ) {
jurzua
parents:
diff changeset
4232 return elem.checked === true;
jurzua
parents:
diff changeset
4233 },
jurzua
parents:
diff changeset
4234
jurzua
parents:
diff changeset
4235 selected: function( elem ) {
jurzua
parents:
diff changeset
4236 // Accessing this property makes selected-by-default
jurzua
parents:
diff changeset
4237 // options in Safari work properly
jurzua
parents:
diff changeset
4238 if ( elem.parentNode ) {
jurzua
parents:
diff changeset
4239 elem.parentNode.selectedIndex;
jurzua
parents:
diff changeset
4240 }
jurzua
parents:
diff changeset
4241
jurzua
parents:
diff changeset
4242 return elem.selected === true;
jurzua
parents:
diff changeset
4243 },
jurzua
parents:
diff changeset
4244
jurzua
parents:
diff changeset
4245 parent: function( elem ) {
jurzua
parents:
diff changeset
4246 return !!elem.firstChild;
jurzua
parents:
diff changeset
4247 },
jurzua
parents:
diff changeset
4248
jurzua
parents:
diff changeset
4249 empty: function( elem ) {
jurzua
parents:
diff changeset
4250 return !elem.firstChild;
jurzua
parents:
diff changeset
4251 },
jurzua
parents:
diff changeset
4252
jurzua
parents:
diff changeset
4253 has: function( elem, i, match ) {
jurzua
parents:
diff changeset
4254 return !!Sizzle( match[3], elem ).length;
jurzua
parents:
diff changeset
4255 },
jurzua
parents:
diff changeset
4256
jurzua
parents:
diff changeset
4257 header: function( elem ) {
jurzua
parents:
diff changeset
4258 return (/h\d/i).test( elem.nodeName );
jurzua
parents:
diff changeset
4259 },
jurzua
parents:
diff changeset
4260
jurzua
parents:
diff changeset
4261 text: function( elem ) {
jurzua
parents:
diff changeset
4262 var attr = elem.getAttribute( "type" ), type = elem.type;
jurzua
parents:
diff changeset
4263 // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
jurzua
parents:
diff changeset
4264 // use getAttribute instead to test this case
jurzua
parents:
diff changeset
4265 return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null );
jurzua
parents:
diff changeset
4266 },
jurzua
parents:
diff changeset
4267
jurzua
parents:
diff changeset
4268 radio: function( elem ) {
jurzua
parents:
diff changeset
4269 return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type;
jurzua
parents:
diff changeset
4270 },
jurzua
parents:
diff changeset
4271
jurzua
parents:
diff changeset
4272 checkbox: function( elem ) {
jurzua
parents:
diff changeset
4273 return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type;
jurzua
parents:
diff changeset
4274 },
jurzua
parents:
diff changeset
4275
jurzua
parents:
diff changeset
4276 file: function( elem ) {
jurzua
parents:
diff changeset
4277 return elem.nodeName.toLowerCase() === "input" && "file" === elem.type;
jurzua
parents:
diff changeset
4278 },
jurzua
parents:
diff changeset
4279
jurzua
parents:
diff changeset
4280 password: function( elem ) {
jurzua
parents:
diff changeset
4281 return elem.nodeName.toLowerCase() === "input" && "password" === elem.type;
jurzua
parents:
diff changeset
4282 },
jurzua
parents:
diff changeset
4283
jurzua
parents:
diff changeset
4284 submit: function( elem ) {
jurzua
parents:
diff changeset
4285 var name = elem.nodeName.toLowerCase();
jurzua
parents:
diff changeset
4286 return (name === "input" || name === "button") && "submit" === elem.type;
jurzua
parents:
diff changeset
4287 },
jurzua
parents:
diff changeset
4288
jurzua
parents:
diff changeset
4289 image: function( elem ) {
jurzua
parents:
diff changeset
4290 return elem.nodeName.toLowerCase() === "input" && "image" === elem.type;
jurzua
parents:
diff changeset
4291 },
jurzua
parents:
diff changeset
4292
jurzua
parents:
diff changeset
4293 reset: function( elem ) {
jurzua
parents:
diff changeset
4294 return elem.nodeName.toLowerCase() === "input" && "reset" === elem.type;
jurzua
parents:
diff changeset
4295 },
jurzua
parents:
diff changeset
4296
jurzua
parents:
diff changeset
4297 button: function( elem ) {
jurzua
parents:
diff changeset
4298 var name = elem.nodeName.toLowerCase();
jurzua
parents:
diff changeset
4299 return name === "input" && "button" === elem.type || name === "button";
jurzua
parents:
diff changeset
4300 },
jurzua
parents:
diff changeset
4301
jurzua
parents:
diff changeset
4302 input: function( elem ) {
jurzua
parents:
diff changeset
4303 return (/input|select|textarea|button/i).test( elem.nodeName );
jurzua
parents:
diff changeset
4304 },
jurzua
parents:
diff changeset
4305
jurzua
parents:
diff changeset
4306 focus: function( elem ) {
jurzua
parents:
diff changeset
4307 return elem === elem.ownerDocument.activeElement;
jurzua
parents:
diff changeset
4308 }
jurzua
parents:
diff changeset
4309 },
jurzua
parents:
diff changeset
4310 setFilters: {
jurzua
parents:
diff changeset
4311 first: function( elem, i ) {
jurzua
parents:
diff changeset
4312 return i === 0;
jurzua
parents:
diff changeset
4313 },
jurzua
parents:
diff changeset
4314
jurzua
parents:
diff changeset
4315 last: function( elem, i, match, array ) {
jurzua
parents:
diff changeset
4316 return i === array.length - 1;
jurzua
parents:
diff changeset
4317 },
jurzua
parents:
diff changeset
4318
jurzua
parents:
diff changeset
4319 even: function( elem, i ) {
jurzua
parents:
diff changeset
4320 return i % 2 === 0;
jurzua
parents:
diff changeset
4321 },
jurzua
parents:
diff changeset
4322
jurzua
parents:
diff changeset
4323 odd: function( elem, i ) {
jurzua
parents:
diff changeset
4324 return i % 2 === 1;
jurzua
parents:
diff changeset
4325 },
jurzua
parents:
diff changeset
4326
jurzua
parents:
diff changeset
4327 lt: function( elem, i, match ) {
jurzua
parents:
diff changeset
4328 return i < match[3] - 0;
jurzua
parents:
diff changeset
4329 },
jurzua
parents:
diff changeset
4330
jurzua
parents:
diff changeset
4331 gt: function( elem, i, match ) {
jurzua
parents:
diff changeset
4332 return i > match[3] - 0;
jurzua
parents:
diff changeset
4333 },
jurzua
parents:
diff changeset
4334
jurzua
parents:
diff changeset
4335 nth: function( elem, i, match ) {
jurzua
parents:
diff changeset
4336 return match[3] - 0 === i;
jurzua
parents:
diff changeset
4337 },
jurzua
parents:
diff changeset
4338
jurzua
parents:
diff changeset
4339 eq: function( elem, i, match ) {
jurzua
parents:
diff changeset
4340 return match[3] - 0 === i;
jurzua
parents:
diff changeset
4341 }
jurzua
parents:
diff changeset
4342 },
jurzua
parents:
diff changeset
4343 filter: {
jurzua
parents:
diff changeset
4344 PSEUDO: function( elem, match, i, array ) {
jurzua
parents:
diff changeset
4345 var name = match[1],
jurzua
parents:
diff changeset
4346 filter = Expr.filters[ name ];
jurzua
parents:
diff changeset
4347
jurzua
parents:
diff changeset
4348 if ( filter ) {
jurzua
parents:
diff changeset
4349 return filter( elem, i, match, array );
jurzua
parents:
diff changeset
4350
jurzua
parents:
diff changeset
4351 } else if ( name === "contains" ) {
jurzua
parents:
diff changeset
4352 return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0;
jurzua
parents:
diff changeset
4353
jurzua
parents:
diff changeset
4354 } else if ( name === "not" ) {
jurzua
parents:
diff changeset
4355 var not = match[3];
jurzua
parents:
diff changeset
4356
jurzua
parents:
diff changeset
4357 for ( var j = 0, l = not.length; j < l; j++ ) {
jurzua
parents:
diff changeset
4358 if ( not[j] === elem ) {
jurzua
parents:
diff changeset
4359 return false;
jurzua
parents:
diff changeset
4360 }
jurzua
parents:
diff changeset
4361 }
jurzua
parents:
diff changeset
4362
jurzua
parents:
diff changeset
4363 return true;
jurzua
parents:
diff changeset
4364
jurzua
parents:
diff changeset
4365 } else {
jurzua
parents:
diff changeset
4366 Sizzle.error( name );
jurzua
parents:
diff changeset
4367 }
jurzua
parents:
diff changeset
4368 },
jurzua
parents:
diff changeset
4369
jurzua
parents:
diff changeset
4370 CHILD: function( elem, match ) {
jurzua
parents:
diff changeset
4371 var type = match[1],
jurzua
parents:
diff changeset
4372 node = elem;
jurzua
parents:
diff changeset
4373
jurzua
parents:
diff changeset
4374 switch ( type ) {
jurzua
parents:
diff changeset
4375 case "only":
jurzua
parents:
diff changeset
4376 case "first":
jurzua
parents:
diff changeset
4377 while ( (node = node.previousSibling) ) {
jurzua
parents:
diff changeset
4378 if ( node.nodeType === 1 ) {
jurzua
parents:
diff changeset
4379 return false;
jurzua
parents:
diff changeset
4380 }
jurzua
parents:
diff changeset
4381 }
jurzua
parents:
diff changeset
4382
jurzua
parents:
diff changeset
4383 if ( type === "first" ) {
jurzua
parents:
diff changeset
4384 return true;
jurzua
parents:
diff changeset
4385 }
jurzua
parents:
diff changeset
4386
jurzua
parents:
diff changeset
4387 node = elem;
jurzua
parents:
diff changeset
4388
jurzua
parents:
diff changeset
4389 case "last":
jurzua
parents:
diff changeset
4390 while ( (node = node.nextSibling) ) {
jurzua
parents:
diff changeset
4391 if ( node.nodeType === 1 ) {
jurzua
parents:
diff changeset
4392 return false;
jurzua
parents:
diff changeset
4393 }
jurzua
parents:
diff changeset
4394 }
jurzua
parents:
diff changeset
4395
jurzua
parents:
diff changeset
4396 return true;
jurzua
parents:
diff changeset
4397
jurzua
parents:
diff changeset
4398 case "nth":
jurzua
parents:
diff changeset
4399 var first = match[2],
jurzua
parents:
diff changeset
4400 last = match[3];
jurzua
parents:
diff changeset
4401
jurzua
parents:
diff changeset
4402 if ( first === 1 && last === 0 ) {
jurzua
parents:
diff changeset
4403 return true;
jurzua
parents:
diff changeset
4404 }
jurzua
parents:
diff changeset
4405
jurzua
parents:
diff changeset
4406 var doneName = match[0],
jurzua
parents:
diff changeset
4407 parent = elem.parentNode;
jurzua
parents:
diff changeset
4408
jurzua
parents:
diff changeset
4409 if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
jurzua
parents:
diff changeset
4410 var count = 0;
jurzua
parents:
diff changeset
4411
jurzua
parents:
diff changeset
4412 for ( node = parent.firstChild; node; node = node.nextSibling ) {
jurzua
parents:
diff changeset
4413 if ( node.nodeType === 1 ) {
jurzua
parents:
diff changeset
4414 node.nodeIndex = ++count;
jurzua
parents:
diff changeset
4415 }
jurzua
parents:
diff changeset
4416 }
jurzua
parents:
diff changeset
4417
jurzua
parents:
diff changeset
4418 parent.sizcache = doneName;
jurzua
parents:
diff changeset
4419 }
jurzua
parents:
diff changeset
4420
jurzua
parents:
diff changeset
4421 var diff = elem.nodeIndex - last;
jurzua
parents:
diff changeset
4422
jurzua
parents:
diff changeset
4423 if ( first === 0 ) {
jurzua
parents:
diff changeset
4424 return diff === 0;
jurzua
parents:
diff changeset
4425
jurzua
parents:
diff changeset
4426 } else {
jurzua
parents:
diff changeset
4427 return ( diff % first === 0 && diff / first >= 0 );
jurzua
parents:
diff changeset
4428 }
jurzua
parents:
diff changeset
4429 }
jurzua
parents:
diff changeset
4430 },
jurzua
parents:
diff changeset
4431
jurzua
parents:
diff changeset
4432 ID: function( elem, match ) {
jurzua
parents:
diff changeset
4433 return elem.nodeType === 1 && elem.getAttribute("id") === match;
jurzua
parents:
diff changeset
4434 },
jurzua
parents:
diff changeset
4435
jurzua
parents:
diff changeset
4436 TAG: function( elem, match ) {
jurzua
parents:
diff changeset
4437 return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
jurzua
parents:
diff changeset
4438 },
jurzua
parents:
diff changeset
4439
jurzua
parents:
diff changeset
4440 CLASS: function( elem, match ) {
jurzua
parents:
diff changeset
4441 return (" " + (elem.className || elem.getAttribute("class")) + " ")
jurzua
parents:
diff changeset
4442 .indexOf( match ) > -1;
jurzua
parents:
diff changeset
4443 },
jurzua
parents:
diff changeset
4444
jurzua
parents:
diff changeset
4445 ATTR: function( elem, match ) {
jurzua
parents:
diff changeset
4446 var name = match[1],
jurzua
parents:
diff changeset
4447 result = Expr.attrHandle[ name ] ?
jurzua
parents:
diff changeset
4448 Expr.attrHandle[ name ]( elem ) :
jurzua
parents:
diff changeset
4449 elem[ name ] != null ?
jurzua
parents:
diff changeset
4450 elem[ name ] :
jurzua
parents:
diff changeset
4451 elem.getAttribute( name ),
jurzua
parents:
diff changeset
4452 value = result + "",
jurzua
parents:
diff changeset
4453 type = match[2],
jurzua
parents:
diff changeset
4454 check = match[4];
jurzua
parents:
diff changeset
4455
jurzua
parents:
diff changeset
4456 return result == null ?
jurzua
parents:
diff changeset
4457 type === "!=" :
jurzua
parents:
diff changeset
4458 type === "=" ?
jurzua
parents:
diff changeset
4459 value === check :
jurzua
parents:
diff changeset
4460 type === "*=" ?
jurzua
parents:
diff changeset
4461 value.indexOf(check) >= 0 :
jurzua
parents:
diff changeset
4462 type === "~=" ?
jurzua
parents:
diff changeset
4463 (" " + value + " ").indexOf(check) >= 0 :
jurzua
parents:
diff changeset
4464 !check ?
jurzua
parents:
diff changeset
4465 value && result !== false :
jurzua
parents:
diff changeset
4466 type === "!=" ?
jurzua
parents:
diff changeset
4467 value !== check :
jurzua
parents:
diff changeset
4468 type === "^=" ?
jurzua
parents:
diff changeset
4469 value.indexOf(check) === 0 :
jurzua
parents:
diff changeset
4470 type === "$=" ?
jurzua
parents:
diff changeset
4471 value.substr(value.length - check.length) === check :
jurzua
parents:
diff changeset
4472 type === "|=" ?
jurzua
parents:
diff changeset
4473 value === check || value.substr(0, check.length + 1) === check + "-" :
jurzua
parents:
diff changeset
4474 false;
jurzua
parents:
diff changeset
4475 },
jurzua
parents:
diff changeset
4476
jurzua
parents:
diff changeset
4477 POS: function( elem, match, i, array ) {
jurzua
parents:
diff changeset
4478 var name = match[2],
jurzua
parents:
diff changeset
4479 filter = Expr.setFilters[ name ];
jurzua
parents:
diff changeset
4480
jurzua
parents:
diff changeset
4481 if ( filter ) {
jurzua
parents:
diff changeset
4482 return filter( elem, i, match, array );
jurzua
parents:
diff changeset
4483 }
jurzua
parents:
diff changeset
4484 }
jurzua
parents:
diff changeset
4485 }
jurzua
parents:
diff changeset
4486 };
jurzua
parents:
diff changeset
4487
jurzua
parents:
diff changeset
4488 var origPOS = Expr.match.POS,
jurzua
parents:
diff changeset
4489 fescape = function(all, num){
jurzua
parents:
diff changeset
4490 return "\\" + (num - 0 + 1);
jurzua
parents:
diff changeset
4491 };
jurzua
parents:
diff changeset
4492
jurzua
parents:
diff changeset
4493 for ( var type in Expr.match ) {
jurzua
parents:
diff changeset
4494 Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
jurzua
parents:
diff changeset
4495 Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
jurzua
parents:
diff changeset
4496 }
jurzua
parents:
diff changeset
4497
jurzua
parents:
diff changeset
4498 var makeArray = function( array, results ) {
jurzua
parents:
diff changeset
4499 array = Array.prototype.slice.call( array, 0 );
jurzua
parents:
diff changeset
4500
jurzua
parents:
diff changeset
4501 if ( results ) {
jurzua
parents:
diff changeset
4502 results.push.apply( results, array );
jurzua
parents:
diff changeset
4503 return results;
jurzua
parents:
diff changeset
4504 }
jurzua
parents:
diff changeset
4505
jurzua
parents:
diff changeset
4506 return array;
jurzua
parents:
diff changeset
4507 };
jurzua
parents:
diff changeset
4508
jurzua
parents:
diff changeset
4509 // Perform a simple check to determine if the browser is capable of
jurzua
parents:
diff changeset
4510 // converting a NodeList to an array using builtin methods.
jurzua
parents:
diff changeset
4511 // Also verifies that the returned array holds DOM nodes
jurzua
parents:
diff changeset
4512 // (which is not the case in the Blackberry browser)
jurzua
parents:
diff changeset
4513 try {
jurzua
parents:
diff changeset
4514 Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
jurzua
parents:
diff changeset
4515
jurzua
parents:
diff changeset
4516 // Provide a fallback method if it does not work
jurzua
parents:
diff changeset
4517 } catch( e ) {
jurzua
parents:
diff changeset
4518 makeArray = function( array, results ) {
jurzua
parents:
diff changeset
4519 var i = 0,
jurzua
parents:
diff changeset
4520 ret = results || [];
jurzua
parents:
diff changeset
4521
jurzua
parents:
diff changeset
4522 if ( toString.call(array) === "[object Array]" ) {
jurzua
parents:
diff changeset
4523 Array.prototype.push.apply( ret, array );
jurzua
parents:
diff changeset
4524
jurzua
parents:
diff changeset
4525 } else {
jurzua
parents:
diff changeset
4526 if ( typeof array.length === "number" ) {
jurzua
parents:
diff changeset
4527 for ( var l = array.length; i < l; i++ ) {
jurzua
parents:
diff changeset
4528 ret.push( array[i] );
jurzua
parents:
diff changeset
4529 }
jurzua
parents:
diff changeset
4530
jurzua
parents:
diff changeset
4531 } else {
jurzua
parents:
diff changeset
4532 for ( ; array[i]; i++ ) {
jurzua
parents:
diff changeset
4533 ret.push( array[i] );
jurzua
parents:
diff changeset
4534 }
jurzua
parents:
diff changeset
4535 }
jurzua
parents:
diff changeset
4536 }
jurzua
parents:
diff changeset
4537
jurzua
parents:
diff changeset
4538 return ret;
jurzua
parents:
diff changeset
4539 };
jurzua
parents:
diff changeset
4540 }
jurzua
parents:
diff changeset
4541
jurzua
parents:
diff changeset
4542 var sortOrder, siblingCheck;
jurzua
parents:
diff changeset
4543
jurzua
parents:
diff changeset
4544 if ( document.documentElement.compareDocumentPosition ) {
jurzua
parents:
diff changeset
4545 sortOrder = function( a, b ) {
jurzua
parents:
diff changeset
4546 if ( a === b ) {
jurzua
parents:
diff changeset
4547 hasDuplicate = true;
jurzua
parents:
diff changeset
4548 return 0;
jurzua
parents:
diff changeset
4549 }
jurzua
parents:
diff changeset
4550
jurzua
parents:
diff changeset
4551 if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
jurzua
parents:
diff changeset
4552 return a.compareDocumentPosition ? -1 : 1;
jurzua
parents:
diff changeset
4553 }
jurzua
parents:
diff changeset
4554
jurzua
parents:
diff changeset
4555 return a.compareDocumentPosition(b) & 4 ? -1 : 1;
jurzua
parents:
diff changeset
4556 };
jurzua
parents:
diff changeset
4557
jurzua
parents:
diff changeset
4558 } else {
jurzua
parents:
diff changeset
4559 sortOrder = function( a, b ) {
jurzua
parents:
diff changeset
4560 var al, bl,
jurzua
parents:
diff changeset
4561 ap = [],
jurzua
parents:
diff changeset
4562 bp = [],
jurzua
parents:
diff changeset
4563 aup = a.parentNode,
jurzua
parents:
diff changeset
4564 bup = b.parentNode,
jurzua
parents:
diff changeset
4565 cur = aup;
jurzua
parents:
diff changeset
4566
jurzua
parents:
diff changeset
4567 // The nodes are identical, we can exit early
jurzua
parents:
diff changeset
4568 if ( a === b ) {
jurzua
parents:
diff changeset
4569 hasDuplicate = true;
jurzua
parents:
diff changeset
4570 return 0;
jurzua
parents:
diff changeset
4571
jurzua
parents:
diff changeset
4572 // If the nodes are siblings (or identical) we can do a quick check
jurzua
parents:
diff changeset
4573 } else if ( aup === bup ) {
jurzua
parents:
diff changeset
4574 return siblingCheck( a, b );
jurzua
parents:
diff changeset
4575
jurzua
parents:
diff changeset
4576 // If no parents were found then the nodes are disconnected
jurzua
parents:
diff changeset
4577 } else if ( !aup ) {
jurzua
parents:
diff changeset
4578 return -1;
jurzua
parents:
diff changeset
4579
jurzua
parents:
diff changeset
4580 } else if ( !bup ) {
jurzua
parents:
diff changeset
4581 return 1;
jurzua
parents:
diff changeset
4582 }
jurzua
parents:
diff changeset
4583
jurzua
parents:
diff changeset
4584 // Otherwise they're somewhere else in the tree so we need
jurzua
parents:
diff changeset
4585 // to build up a full list of the parentNodes for comparison
jurzua
parents:
diff changeset
4586 while ( cur ) {
jurzua
parents:
diff changeset
4587 ap.unshift( cur );
jurzua
parents:
diff changeset
4588 cur = cur.parentNode;
jurzua
parents:
diff changeset
4589 }
jurzua
parents:
diff changeset
4590
jurzua
parents:
diff changeset
4591 cur = bup;
jurzua
parents:
diff changeset
4592
jurzua
parents:
diff changeset
4593 while ( cur ) {
jurzua
parents:
diff changeset
4594 bp.unshift( cur );
jurzua
parents:
diff changeset
4595 cur = cur.parentNode;
jurzua
parents:
diff changeset
4596 }
jurzua
parents:
diff changeset
4597
jurzua
parents:
diff changeset
4598 al = ap.length;
jurzua
parents:
diff changeset
4599 bl = bp.length;
jurzua
parents:
diff changeset
4600
jurzua
parents:
diff changeset
4601 // Start walking down the tree looking for a discrepancy
jurzua
parents:
diff changeset
4602 for ( var i = 0; i < al && i < bl; i++ ) {
jurzua
parents:
diff changeset
4603 if ( ap[i] !== bp[i] ) {
jurzua
parents:
diff changeset
4604 return siblingCheck( ap[i], bp[i] );
jurzua
parents:
diff changeset
4605 }
jurzua
parents:
diff changeset
4606 }
jurzua
parents:
diff changeset
4607
jurzua
parents:
diff changeset
4608 // We ended someplace up the tree so do a sibling check
jurzua
parents:
diff changeset
4609 return i === al ?
jurzua
parents:
diff changeset
4610 siblingCheck( a, bp[i], -1 ) :
jurzua
parents:
diff changeset
4611 siblingCheck( ap[i], b, 1 );
jurzua
parents:
diff changeset
4612 };
jurzua
parents:
diff changeset
4613
jurzua
parents:
diff changeset
4614 siblingCheck = function( a, b, ret ) {
jurzua
parents:
diff changeset
4615 if ( a === b ) {
jurzua
parents:
diff changeset
4616 return ret;
jurzua
parents:
diff changeset
4617 }
jurzua
parents:
diff changeset
4618
jurzua
parents:
diff changeset
4619 var cur = a.nextSibling;
jurzua
parents:
diff changeset
4620
jurzua
parents:
diff changeset
4621 while ( cur ) {
jurzua
parents:
diff changeset
4622 if ( cur === b ) {
jurzua
parents:
diff changeset
4623 return -1;
jurzua
parents:
diff changeset
4624 }
jurzua
parents:
diff changeset
4625
jurzua
parents:
diff changeset
4626 cur = cur.nextSibling;
jurzua
parents:
diff changeset
4627 }
jurzua
parents:
diff changeset
4628
jurzua
parents:
diff changeset
4629 return 1;
jurzua
parents:
diff changeset
4630 };
jurzua
parents:
diff changeset
4631 }
jurzua
parents:
diff changeset
4632
jurzua
parents:
diff changeset
4633 // Utility function for retreiving the text value of an array of DOM nodes
jurzua
parents:
diff changeset
4634 Sizzle.getText = function( elems ) {
jurzua
parents:
diff changeset
4635 var ret = "", elem;
jurzua
parents:
diff changeset
4636
jurzua
parents:
diff changeset
4637 for ( var i = 0; elems[i]; i++ ) {
jurzua
parents:
diff changeset
4638 elem = elems[i];
jurzua
parents:
diff changeset
4639
jurzua
parents:
diff changeset
4640 // Get the text from text nodes and CDATA nodes
jurzua
parents:
diff changeset
4641 if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
jurzua
parents:
diff changeset
4642 ret += elem.nodeValue;
jurzua
parents:
diff changeset
4643
jurzua
parents:
diff changeset
4644 // Traverse everything else, except comment nodes
jurzua
parents:
diff changeset
4645 } else if ( elem.nodeType !== 8 ) {
jurzua
parents:
diff changeset
4646 ret += Sizzle.getText( elem.childNodes );
jurzua
parents:
diff changeset
4647 }
jurzua
parents:
diff changeset
4648 }
jurzua
parents:
diff changeset
4649
jurzua
parents:
diff changeset
4650 return ret;
jurzua
parents:
diff changeset
4651 };
jurzua
parents:
diff changeset
4652
jurzua
parents:
diff changeset
4653 // Check to see if the browser returns elements by name when
jurzua
parents:
diff changeset
4654 // querying by getElementById (and provide a workaround)
jurzua
parents:
diff changeset
4655 (function(){
jurzua
parents:
diff changeset
4656 // We're going to inject a fake input element with a specified name
jurzua
parents:
diff changeset
4657 var form = document.createElement("div"),
jurzua
parents:
diff changeset
4658 id = "script" + (new Date()).getTime(),
jurzua
parents:
diff changeset
4659 root = document.documentElement;
jurzua
parents:
diff changeset
4660
jurzua
parents:
diff changeset
4661 form.innerHTML = "<a name='" + id + "'/>";
jurzua
parents:
diff changeset
4662
jurzua
parents:
diff changeset
4663 // Inject it into the root element, check its status, and remove it quickly
jurzua
parents:
diff changeset
4664 root.insertBefore( form, root.firstChild );
jurzua
parents:
diff changeset
4665
jurzua
parents:
diff changeset
4666 // The workaround has to do additional checks after a getElementById
jurzua
parents:
diff changeset
4667 // Which slows things down for other browsers (hence the branching)
jurzua
parents:
diff changeset
4668 if ( document.getElementById( id ) ) {
jurzua
parents:
diff changeset
4669 Expr.find.ID = function( match, context, isXML ) {
jurzua
parents:
diff changeset
4670 if ( typeof context.getElementById !== "undefined" && !isXML ) {
jurzua
parents:
diff changeset
4671 var m = context.getElementById(match[1]);
jurzua
parents:
diff changeset
4672
jurzua
parents:
diff changeset
4673 return m ?
jurzua
parents:
diff changeset
4674 m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
jurzua
parents:
diff changeset
4675 [m] :
jurzua
parents:
diff changeset
4676 undefined :
jurzua
parents:
diff changeset
4677 [];
jurzua
parents:
diff changeset
4678 }
jurzua
parents:
diff changeset
4679 };
jurzua
parents:
diff changeset
4680
jurzua
parents:
diff changeset
4681 Expr.filter.ID = function( elem, match ) {
jurzua
parents:
diff changeset
4682 var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
jurzua
parents:
diff changeset
4683
jurzua
parents:
diff changeset
4684 return elem.nodeType === 1 && node && node.nodeValue === match;
jurzua
parents:
diff changeset
4685 };
jurzua
parents:
diff changeset
4686 }
jurzua
parents:
diff changeset
4687
jurzua
parents:
diff changeset
4688 root.removeChild( form );
jurzua
parents:
diff changeset
4689
jurzua
parents:
diff changeset
4690 // release memory in IE
jurzua
parents:
diff changeset
4691 root = form = null;
jurzua
parents:
diff changeset
4692 })();
jurzua
parents:
diff changeset
4693
jurzua
parents:
diff changeset
4694 (function(){
jurzua
parents:
diff changeset
4695 // Check to see if the browser returns only elements
jurzua
parents:
diff changeset
4696 // when doing getElementsByTagName("*")
jurzua
parents:
diff changeset
4697
jurzua
parents:
diff changeset
4698 // Create a fake element
jurzua
parents:
diff changeset
4699 var div = document.createElement("div");
jurzua
parents:
diff changeset
4700 div.appendChild( document.createComment("") );
jurzua
parents:
diff changeset
4701
jurzua
parents:
diff changeset
4702 // Make sure no comments are found
jurzua
parents:
diff changeset
4703 if ( div.getElementsByTagName("*").length > 0 ) {
jurzua
parents:
diff changeset
4704 Expr.find.TAG = function( match, context ) {
jurzua
parents:
diff changeset
4705 var results = context.getElementsByTagName( match[1] );
jurzua
parents:
diff changeset
4706
jurzua
parents:
diff changeset
4707 // Filter out possible comments
jurzua
parents:
diff changeset
4708 if ( match[1] === "*" ) {
jurzua
parents:
diff changeset
4709 var tmp = [];
jurzua
parents:
diff changeset
4710
jurzua
parents:
diff changeset
4711 for ( var i = 0; results[i]; i++ ) {
jurzua
parents:
diff changeset
4712 if ( results[i].nodeType === 1 ) {
jurzua
parents:
diff changeset
4713 tmp.push( results[i] );
jurzua
parents:
diff changeset
4714 }
jurzua
parents:
diff changeset
4715 }
jurzua
parents:
diff changeset
4716
jurzua
parents:
diff changeset
4717 results = tmp;
jurzua
parents:
diff changeset
4718 }
jurzua
parents:
diff changeset
4719
jurzua
parents:
diff changeset
4720 return results;
jurzua
parents:
diff changeset
4721 };
jurzua
parents:
diff changeset
4722 }
jurzua
parents:
diff changeset
4723
jurzua
parents:
diff changeset
4724 // Check to see if an attribute returns normalized href attributes
jurzua
parents:
diff changeset
4725 div.innerHTML = "<a href='#'></a>";
jurzua
parents:
diff changeset
4726
jurzua
parents:
diff changeset
4727 if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
jurzua
parents:
diff changeset
4728 div.firstChild.getAttribute("href") !== "#" ) {
jurzua
parents:
diff changeset
4729
jurzua
parents:
diff changeset
4730 Expr.attrHandle.href = function( elem ) {
jurzua
parents:
diff changeset
4731 return elem.getAttribute( "href", 2 );
jurzua
parents:
diff changeset
4732 };
jurzua
parents:
diff changeset
4733 }
jurzua
parents:
diff changeset
4734
jurzua
parents:
diff changeset
4735 // release memory in IE
jurzua
parents:
diff changeset
4736 div = null;
jurzua
parents:
diff changeset
4737 })();
jurzua
parents:
diff changeset
4738
jurzua
parents:
diff changeset
4739 if ( document.querySelectorAll ) {
jurzua
parents:
diff changeset
4740 (function(){
jurzua
parents:
diff changeset
4741 var oldSizzle = Sizzle,
jurzua
parents:
diff changeset
4742 div = document.createElement("div"),
jurzua
parents:
diff changeset
4743 id = "__sizzle__";
jurzua
parents:
diff changeset
4744
jurzua
parents:
diff changeset
4745 div.innerHTML = "<p class='TEST'></p>";
jurzua
parents:
diff changeset
4746
jurzua
parents:
diff changeset
4747 // Safari can't handle uppercase or unicode characters when
jurzua
parents:
diff changeset
4748 // in quirks mode.
jurzua
parents:
diff changeset
4749 if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
jurzua
parents:
diff changeset
4750 return;
jurzua
parents:
diff changeset
4751 }
jurzua
parents:
diff changeset
4752
jurzua
parents:
diff changeset
4753 Sizzle = function( query, context, extra, seed ) {
jurzua
parents:
diff changeset
4754 context = context || document;
jurzua
parents:
diff changeset
4755
jurzua
parents:
diff changeset
4756 // Only use querySelectorAll on non-XML documents
jurzua
parents:
diff changeset
4757 // (ID selectors don't work in non-HTML documents)
jurzua
parents:
diff changeset
4758 if ( !seed && !Sizzle.isXML(context) ) {
jurzua
parents:
diff changeset
4759 // See if we find a selector to speed up
jurzua
parents:
diff changeset
4760 var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );
jurzua
parents:
diff changeset
4761
jurzua
parents:
diff changeset
4762 if ( match && (context.nodeType === 1 || context.nodeType === 9) ) {
jurzua
parents:
diff changeset
4763 // Speed-up: Sizzle("TAG")
jurzua
parents:
diff changeset
4764 if ( match[1] ) {
jurzua
parents:
diff changeset
4765 return makeArray( context.getElementsByTagName( query ), extra );
jurzua
parents:
diff changeset
4766
jurzua
parents:
diff changeset
4767 // Speed-up: Sizzle(".CLASS")
jurzua
parents:
diff changeset
4768 } else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
jurzua
parents:
diff changeset
4769 return makeArray( context.getElementsByClassName( match[2] ), extra );
jurzua
parents:
diff changeset
4770 }
jurzua
parents:
diff changeset
4771 }
jurzua
parents:
diff changeset
4772
jurzua
parents:
diff changeset
4773 if ( context.nodeType === 9 ) {
jurzua
parents:
diff changeset
4774 // Speed-up: Sizzle("body")
jurzua
parents:
diff changeset
4775 // The body element only exists once, optimize finding it
jurzua
parents:
diff changeset
4776 if ( query === "body" && context.body ) {
jurzua
parents:
diff changeset
4777 return makeArray( [ context.body ], extra );
jurzua
parents:
diff changeset
4778
jurzua
parents:
diff changeset
4779 // Speed-up: Sizzle("#ID")
jurzua
parents:
diff changeset
4780 } else if ( match && match[3] ) {
jurzua
parents:
diff changeset
4781 var elem = context.getElementById( match[3] );
jurzua
parents:
diff changeset
4782
jurzua
parents:
diff changeset
4783 // Check parentNode to catch when Blackberry 4.6 returns
jurzua
parents:
diff changeset
4784 // nodes that are no longer in the document #6963
jurzua
parents:
diff changeset
4785 if ( elem && elem.parentNode ) {
jurzua
parents:
diff changeset
4786 // Handle the case where IE and Opera return items
jurzua
parents:
diff changeset
4787 // by name instead of ID
jurzua
parents:
diff changeset
4788 if ( elem.id === match[3] ) {
jurzua
parents:
diff changeset
4789 return makeArray( [ elem ], extra );
jurzua
parents:
diff changeset
4790 }
jurzua
parents:
diff changeset
4791
jurzua
parents:
diff changeset
4792 } else {
jurzua
parents:
diff changeset
4793 return makeArray( [], extra );
jurzua
parents:
diff changeset
4794 }
jurzua
parents:
diff changeset
4795 }
jurzua
parents:
diff changeset
4796
jurzua
parents:
diff changeset
4797 try {
jurzua
parents:
diff changeset
4798 return makeArray( context.querySelectorAll(query), extra );
jurzua
parents:
diff changeset
4799 } catch(qsaError) {}
jurzua
parents:
diff changeset
4800
jurzua
parents:
diff changeset
4801 // qSA works strangely on Element-rooted queries
jurzua
parents:
diff changeset
4802 // We can work around this by specifying an extra ID on the root
jurzua
parents:
diff changeset
4803 // and working up from there (Thanks to Andrew Dupont for the technique)
jurzua
parents:
diff changeset
4804 // IE 8 doesn't work on object elements
jurzua
parents:
diff changeset
4805 } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
jurzua
parents:
diff changeset
4806 var oldContext = context,
jurzua
parents:
diff changeset
4807 old = context.getAttribute( "id" ),
jurzua
parents:
diff changeset
4808 nid = old || id,
jurzua
parents:
diff changeset
4809 hasParent = context.parentNode,
jurzua
parents:
diff changeset
4810 relativeHierarchySelector = /^\s*[+~]/.test( query );
jurzua
parents:
diff changeset
4811
jurzua
parents:
diff changeset
4812 if ( !old ) {
jurzua
parents:
diff changeset
4813 context.setAttribute( "id", nid );
jurzua
parents:
diff changeset
4814 } else {
jurzua
parents:
diff changeset
4815 nid = nid.replace( /'/g, "\\$&" );
jurzua
parents:
diff changeset
4816 }
jurzua
parents:
diff changeset
4817 if ( relativeHierarchySelector && hasParent ) {
jurzua
parents:
diff changeset
4818 context = context.parentNode;
jurzua
parents:
diff changeset
4819 }
jurzua
parents:
diff changeset
4820
jurzua
parents:
diff changeset
4821 try {
jurzua
parents:
diff changeset
4822 if ( !relativeHierarchySelector || hasParent ) {
jurzua
parents:
diff changeset
4823 return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
jurzua
parents:
diff changeset
4824 }
jurzua
parents:
diff changeset
4825
jurzua
parents:
diff changeset
4826 } catch(pseudoError) {
jurzua
parents:
diff changeset
4827 } finally {
jurzua
parents:
diff changeset
4828 if ( !old ) {
jurzua
parents:
diff changeset
4829 oldContext.removeAttribute( "id" );
jurzua
parents:
diff changeset
4830 }
jurzua
parents:
diff changeset
4831 }
jurzua
parents:
diff changeset
4832 }
jurzua
parents:
diff changeset
4833 }
jurzua
parents:
diff changeset
4834
jurzua
parents:
diff changeset
4835 return oldSizzle(query, context, extra, seed);
jurzua
parents:
diff changeset
4836 };
jurzua
parents:
diff changeset
4837
jurzua
parents:
diff changeset
4838 for ( var prop in oldSizzle ) {
jurzua
parents:
diff changeset
4839 Sizzle[ prop ] = oldSizzle[ prop ];
jurzua
parents:
diff changeset
4840 }
jurzua
parents:
diff changeset
4841
jurzua
parents:
diff changeset
4842 // release memory in IE
jurzua
parents:
diff changeset
4843 div = null;
jurzua
parents:
diff changeset
4844 })();
jurzua
parents:
diff changeset
4845 }
jurzua
parents:
diff changeset
4846
jurzua
parents:
diff changeset
4847 (function(){
jurzua
parents:
diff changeset
4848 var html = document.documentElement,
jurzua
parents:
diff changeset
4849 matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector;
jurzua
parents:
diff changeset
4850
jurzua
parents:
diff changeset
4851 if ( matches ) {
jurzua
parents:
diff changeset
4852 // Check to see if it's possible to do matchesSelector
jurzua
parents:
diff changeset
4853 // on a disconnected node (IE 9 fails this)
jurzua
parents:
diff changeset
4854 var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ),
jurzua
parents:
diff changeset
4855 pseudoWorks = false;
jurzua
parents:
diff changeset
4856
jurzua
parents:
diff changeset
4857 try {
jurzua
parents:
diff changeset
4858 // This should fail with an exception
jurzua
parents:
diff changeset
4859 // Gecko does not error, returns false instead
jurzua
parents:
diff changeset
4860 matches.call( document.documentElement, "[test!='']:sizzle" );
jurzua
parents:
diff changeset
4861
jurzua
parents:
diff changeset
4862 } catch( pseudoError ) {
jurzua
parents:
diff changeset
4863 pseudoWorks = true;
jurzua
parents:
diff changeset
4864 }
jurzua
parents:
diff changeset
4865
jurzua
parents:
diff changeset
4866 Sizzle.matchesSelector = function( node, expr ) {
jurzua
parents:
diff changeset
4867 // Make sure that attribute selectors are quoted
jurzua
parents:
diff changeset
4868 expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
jurzua
parents:
diff changeset
4869
jurzua
parents:
diff changeset
4870 if ( !Sizzle.isXML( node ) ) {
jurzua
parents:
diff changeset
4871 try {
jurzua
parents:
diff changeset
4872 if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
jurzua
parents:
diff changeset
4873 var ret = matches.call( node, expr );
jurzua
parents:
diff changeset
4874
jurzua
parents:
diff changeset
4875 // IE 9's matchesSelector returns false on disconnected nodes
jurzua
parents:
diff changeset
4876 if ( ret || !disconnectedMatch ||
jurzua
parents:
diff changeset
4877 // As well, disconnected nodes are said to be in a document
jurzua
parents:
diff changeset
4878 // fragment in IE 9, so check for that
jurzua
parents:
diff changeset
4879 node.document && node.document.nodeType !== 11 ) {
jurzua
parents:
diff changeset
4880 return ret;
jurzua
parents:
diff changeset
4881 }
jurzua
parents:
diff changeset
4882 }
jurzua
parents:
diff changeset
4883 } catch(e) {}
jurzua
parents:
diff changeset
4884 }
jurzua
parents:
diff changeset
4885
jurzua
parents:
diff changeset
4886 return Sizzle(expr, null, null, [node]).length > 0;
jurzua
parents:
diff changeset
4887 };
jurzua
parents:
diff changeset
4888 }
jurzua
parents:
diff changeset
4889 })();
jurzua
parents:
diff changeset
4890
jurzua
parents:
diff changeset
4891 (function(){
jurzua
parents:
diff changeset
4892 var div = document.createElement("div");
jurzua
parents:
diff changeset
4893
jurzua
parents:
diff changeset
4894 div.innerHTML = "<div class='test e'></div><div class='test'></div>";
jurzua
parents:
diff changeset
4895
jurzua
parents:
diff changeset
4896 // Opera can't find a second classname (in 9.6)
jurzua
parents:
diff changeset
4897 // Also, make sure that getElementsByClassName actually exists
jurzua
parents:
diff changeset
4898 if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
jurzua
parents:
diff changeset
4899 return;
jurzua
parents:
diff changeset
4900 }
jurzua
parents:
diff changeset
4901
jurzua
parents:
diff changeset
4902 // Safari caches class attributes, doesn't catch changes (in 3.2)
jurzua
parents:
diff changeset
4903 div.lastChild.className = "e";
jurzua
parents:
diff changeset
4904
jurzua
parents:
diff changeset
4905 if ( div.getElementsByClassName("e").length === 1 ) {
jurzua
parents:
diff changeset
4906 return;
jurzua
parents:
diff changeset
4907 }
jurzua
parents:
diff changeset
4908
jurzua
parents:
diff changeset
4909 Expr.order.splice(1, 0, "CLASS");
jurzua
parents:
diff changeset
4910 Expr.find.CLASS = function( match, context, isXML ) {
jurzua
parents:
diff changeset
4911 if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
jurzua
parents:
diff changeset
4912 return context.getElementsByClassName(match[1]);
jurzua
parents:
diff changeset
4913 }
jurzua
parents:
diff changeset
4914 };
jurzua
parents:
diff changeset
4915
jurzua
parents:
diff changeset
4916 // release memory in IE
jurzua
parents:
diff changeset
4917 div = null;
jurzua
parents:
diff changeset
4918 })();
jurzua
parents:
diff changeset
4919
jurzua
parents:
diff changeset
4920 function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
jurzua
parents:
diff changeset
4921 for ( var i = 0, l = checkSet.length; i < l; i++ ) {
jurzua
parents:
diff changeset
4922 var elem = checkSet[i];
jurzua
parents:
diff changeset
4923
jurzua
parents:
diff changeset
4924 if ( elem ) {
jurzua
parents:
diff changeset
4925 var match = false;
jurzua
parents:
diff changeset
4926
jurzua
parents:
diff changeset
4927 elem = elem[dir];
jurzua
parents:
diff changeset
4928
jurzua
parents:
diff changeset
4929 while ( elem ) {
jurzua
parents:
diff changeset
4930 if ( elem.sizcache === doneName ) {
jurzua
parents:
diff changeset
4931 match = checkSet[elem.sizset];
jurzua
parents:
diff changeset
4932 break;
jurzua
parents:
diff changeset
4933 }
jurzua
parents:
diff changeset
4934
jurzua
parents:
diff changeset
4935 if ( elem.nodeType === 1 && !isXML ){
jurzua
parents:
diff changeset
4936 elem.sizcache = doneName;
jurzua
parents:
diff changeset
4937 elem.sizset = i;
jurzua
parents:
diff changeset
4938 }
jurzua
parents:
diff changeset
4939
jurzua
parents:
diff changeset
4940 if ( elem.nodeName.toLowerCase() === cur ) {
jurzua
parents:
diff changeset
4941 match = elem;
jurzua
parents:
diff changeset
4942 break;
jurzua
parents:
diff changeset
4943 }
jurzua
parents:
diff changeset
4944
jurzua
parents:
diff changeset
4945 elem = elem[dir];
jurzua
parents:
diff changeset
4946 }
jurzua
parents:
diff changeset
4947
jurzua
parents:
diff changeset
4948 checkSet[i] = match;
jurzua
parents:
diff changeset
4949 }
jurzua
parents:
diff changeset
4950 }
jurzua
parents:
diff changeset
4951 }
jurzua
parents:
diff changeset
4952
jurzua
parents:
diff changeset
4953 function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
jurzua
parents:
diff changeset
4954 for ( var i = 0, l = checkSet.length; i < l; i++ ) {
jurzua
parents:
diff changeset
4955 var elem = checkSet[i];
jurzua
parents:
diff changeset
4956
jurzua
parents:
diff changeset
4957 if ( elem ) {
jurzua
parents:
diff changeset
4958 var match = false;
jurzua
parents:
diff changeset
4959
jurzua
parents:
diff changeset
4960 elem = elem[dir];
jurzua
parents:
diff changeset
4961
jurzua
parents:
diff changeset
4962 while ( elem ) {
jurzua
parents:
diff changeset
4963 if ( elem.sizcache === doneName ) {
jurzua
parents:
diff changeset
4964 match = checkSet[elem.sizset];
jurzua
parents:
diff changeset
4965 break;
jurzua
parents:
diff changeset
4966 }
jurzua
parents:
diff changeset
4967
jurzua
parents:
diff changeset
4968 if ( elem.nodeType === 1 ) {
jurzua
parents:
diff changeset
4969 if ( !isXML ) {
jurzua
parents:
diff changeset
4970 elem.sizcache = doneName;
jurzua
parents:
diff changeset
4971 elem.sizset = i;
jurzua
parents:
diff changeset
4972 }
jurzua
parents:
diff changeset
4973
jurzua
parents:
diff changeset
4974 if ( typeof cur !== "string" ) {
jurzua
parents:
diff changeset
4975 if ( elem === cur ) {
jurzua
parents:
diff changeset
4976 match = true;
jurzua
parents:
diff changeset
4977 break;
jurzua
parents:
diff changeset
4978 }
jurzua
parents:
diff changeset
4979
jurzua
parents:
diff changeset
4980 } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
jurzua
parents:
diff changeset
4981 match = elem;
jurzua
parents:
diff changeset
4982 break;
jurzua
parents:
diff changeset
4983 }
jurzua
parents:
diff changeset
4984 }
jurzua
parents:
diff changeset
4985
jurzua
parents:
diff changeset
4986 elem = elem[dir];
jurzua
parents:
diff changeset
4987 }
jurzua
parents:
diff changeset
4988
jurzua
parents:
diff changeset
4989 checkSet[i] = match;
jurzua
parents:
diff changeset
4990 }
jurzua
parents:
diff changeset
4991 }
jurzua
parents:
diff changeset
4992 }
jurzua
parents:
diff changeset
4993
jurzua
parents:
diff changeset
4994 if ( document.documentElement.contains ) {
jurzua
parents:
diff changeset
4995 Sizzle.contains = function( a, b ) {
jurzua
parents:
diff changeset
4996 return a !== b && (a.contains ? a.contains(b) : true);
jurzua
parents:
diff changeset
4997 };
jurzua
parents:
diff changeset
4998
jurzua
parents:
diff changeset
4999 } else if ( document.documentElement.compareDocumentPosition ) {
jurzua
parents:
diff changeset
5000 Sizzle.contains = function( a, b ) {
jurzua
parents:
diff changeset
5001 return !!(a.compareDocumentPosition(b) & 16);
jurzua
parents:
diff changeset
5002 };
jurzua
parents:
diff changeset
5003
jurzua
parents:
diff changeset
5004 } else {
jurzua
parents:
diff changeset
5005 Sizzle.contains = function() {
jurzua
parents:
diff changeset
5006 return false;
jurzua
parents:
diff changeset
5007 };
jurzua
parents:
diff changeset
5008 }
jurzua
parents:
diff changeset
5009
jurzua
parents:
diff changeset
5010 Sizzle.isXML = function( elem ) {
jurzua
parents:
diff changeset
5011 // documentElement is verified for cases where it doesn't yet exist
jurzua
parents:
diff changeset
5012 // (such as loading iframes in IE - #4833)
jurzua
parents:
diff changeset
5013 var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
jurzua
parents:
diff changeset
5014
jurzua
parents:
diff changeset
5015 return documentElement ? documentElement.nodeName !== "HTML" : false;
jurzua
parents:
diff changeset
5016 };
jurzua
parents:
diff changeset
5017
jurzua
parents:
diff changeset
5018 var posProcess = function( selector, context ) {
jurzua
parents:
diff changeset
5019 var match,
jurzua
parents:
diff changeset
5020 tmpSet = [],
jurzua
parents:
diff changeset
5021 later = "",
jurzua
parents:
diff changeset
5022 root = context.nodeType ? [context] : context;
jurzua
parents:
diff changeset
5023
jurzua
parents:
diff changeset
5024 // Position selectors must be done after the filter
jurzua
parents:
diff changeset
5025 // And so must :not(positional) so we move all PSEUDOs to the end
jurzua
parents:
diff changeset
5026 while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
jurzua
parents:
diff changeset
5027 later += match[0];
jurzua
parents:
diff changeset
5028 selector = selector.replace( Expr.match.PSEUDO, "" );
jurzua
parents:
diff changeset
5029 }
jurzua
parents:
diff changeset
5030
jurzua
parents:
diff changeset
5031 selector = Expr.relative[selector] ? selector + "*" : selector;
jurzua
parents:
diff changeset
5032
jurzua
parents:
diff changeset
5033 for ( var i = 0, l = root.length; i < l; i++ ) {
jurzua
parents:
diff changeset
5034 Sizzle( selector, root[i], tmpSet );
jurzua
parents:
diff changeset
5035 }
jurzua
parents:
diff changeset
5036
jurzua
parents:
diff changeset
5037 return Sizzle.filter( later, tmpSet );
jurzua
parents:
diff changeset
5038 };
jurzua
parents:
diff changeset
5039
jurzua
parents:
diff changeset
5040 // EXPOSE
jurzua
parents:
diff changeset
5041 jQuery.find = Sizzle;
jurzua
parents:
diff changeset
5042 jQuery.expr = Sizzle.selectors;
jurzua
parents:
diff changeset
5043 jQuery.expr[":"] = jQuery.expr.filters;
jurzua
parents:
diff changeset
5044 jQuery.unique = Sizzle.uniqueSort;
jurzua
parents:
diff changeset
5045 jQuery.text = Sizzle.getText;
jurzua
parents:
diff changeset
5046 jQuery.isXMLDoc = Sizzle.isXML;
jurzua
parents:
diff changeset
5047 jQuery.contains = Sizzle.contains;
jurzua
parents:
diff changeset
5048
jurzua
parents:
diff changeset
5049
jurzua
parents:
diff changeset
5050 })();
jurzua
parents:
diff changeset
5051
jurzua
parents:
diff changeset
5052
jurzua
parents:
diff changeset
5053 var runtil = /Until$/,
jurzua
parents:
diff changeset
5054 rparentsprev = /^(?:parents|prevUntil|prevAll)/,
jurzua
parents:
diff changeset
5055 // Note: This RegExp should be improved, or likely pulled from Sizzle
jurzua
parents:
diff changeset
5056 rmultiselector = /,/,
jurzua
parents:
diff changeset
5057 isSimple = /^.[^:#\[\.,]*$/,
jurzua
parents:
diff changeset
5058 slice = Array.prototype.slice,
jurzua
parents:
diff changeset
5059 POS = jQuery.expr.match.POS,
jurzua
parents:
diff changeset
5060 // methods guaranteed to produce a unique set when starting from a unique set
jurzua
parents:
diff changeset
5061 guaranteedUnique = {
jurzua
parents:
diff changeset
5062 children: true,
jurzua
parents:
diff changeset
5063 contents: true,
jurzua
parents:
diff changeset
5064 next: true,
jurzua
parents:
diff changeset
5065 prev: true
jurzua
parents:
diff changeset
5066 };
jurzua
parents:
diff changeset
5067
jurzua
parents:
diff changeset
5068 jQuery.fn.extend({
jurzua
parents:
diff changeset
5069 find: function( selector ) {
jurzua
parents:
diff changeset
5070 var self = this,
jurzua
parents:
diff changeset
5071 i, l;
jurzua
parents:
diff changeset
5072
jurzua
parents:
diff changeset
5073 if ( typeof selector !== "string" ) {
jurzua
parents:
diff changeset
5074 return jQuery( selector ).filter(function() {
jurzua
parents:
diff changeset
5075 for ( i = 0, l = self.length; i < l; i++ ) {
jurzua
parents:
diff changeset
5076 if ( jQuery.contains( self[ i ], this ) ) {
jurzua
parents:
diff changeset
5077 return true;
jurzua
parents:
diff changeset
5078 }
jurzua
parents:
diff changeset
5079 }
jurzua
parents:
diff changeset
5080 });
jurzua
parents:
diff changeset
5081 }
jurzua
parents:
diff changeset
5082
jurzua
parents:
diff changeset
5083 var ret = this.pushStack( "", "find", selector ),
jurzua
parents:
diff changeset
5084 length, n, r;
jurzua
parents:
diff changeset
5085
jurzua
parents:
diff changeset
5086 for ( i = 0, l = this.length; i < l; i++ ) {
jurzua
parents:
diff changeset
5087 length = ret.length;
jurzua
parents:
diff changeset
5088 jQuery.find( selector, this[i], ret );
jurzua
parents:
diff changeset
5089
jurzua
parents:
diff changeset
5090 if ( i > 0 ) {
jurzua
parents:
diff changeset
5091 // Make sure that the results are unique
jurzua
parents:
diff changeset
5092 for ( n = length; n < ret.length; n++ ) {
jurzua
parents:
diff changeset
5093 for ( r = 0; r < length; r++ ) {
jurzua
parents:
diff changeset
5094 if ( ret[r] === ret[n] ) {
jurzua
parents:
diff changeset
5095 ret.splice(n--, 1);
jurzua
parents:
diff changeset
5096 break;
jurzua
parents:
diff changeset
5097 }
jurzua
parents:
diff changeset
5098 }
jurzua
parents:
diff changeset
5099 }
jurzua
parents:
diff changeset
5100 }
jurzua
parents:
diff changeset
5101 }
jurzua
parents:
diff changeset
5102
jurzua
parents:
diff changeset
5103 return ret;
jurzua
parents:
diff changeset
5104 },
jurzua
parents:
diff changeset
5105
jurzua
parents:
diff changeset
5106 has: function( target ) {
jurzua
parents:
diff changeset
5107 var targets = jQuery( target );
jurzua
parents:
diff changeset
5108 return this.filter(function() {
jurzua
parents:
diff changeset
5109 for ( var i = 0, l = targets.length; i < l; i++ ) {
jurzua
parents:
diff changeset
5110 if ( jQuery.contains( this, targets[i] ) ) {
jurzua
parents:
diff changeset
5111 return true;
jurzua
parents:
diff changeset
5112 }
jurzua
parents:
diff changeset
5113 }
jurzua
parents:
diff changeset
5114 });
jurzua
parents:
diff changeset
5115 },
jurzua
parents:
diff changeset
5116
jurzua
parents:
diff changeset
5117 not: function( selector ) {
jurzua
parents:
diff changeset
5118 return this.pushStack( winnow(this, selector, false), "not", selector);
jurzua
parents:
diff changeset
5119 },
jurzua
parents:
diff changeset
5120
jurzua
parents:
diff changeset
5121 filter: function( selector ) {
jurzua
parents:
diff changeset
5122 return this.pushStack( winnow(this, selector, true), "filter", selector );
jurzua
parents:
diff changeset
5123 },
jurzua
parents:
diff changeset
5124
jurzua
parents:
diff changeset
5125 is: function( selector ) {
jurzua
parents:
diff changeset
5126 return !!selector && ( typeof selector === "string" ?
jurzua
parents:
diff changeset
5127 jQuery.filter( selector, this ).length > 0 :
jurzua
parents:
diff changeset
5128 this.filter( selector ).length > 0 );
jurzua
parents:
diff changeset
5129 },
jurzua
parents:
diff changeset
5130
jurzua
parents:
diff changeset
5131 closest: function( selectors, context ) {
jurzua
parents:
diff changeset
5132 var ret = [], i, l, cur = this[0];
jurzua
parents:
diff changeset
5133
jurzua
parents:
diff changeset
5134 // Array
jurzua
parents:
diff changeset
5135 if ( jQuery.isArray( selectors ) ) {
jurzua
parents:
diff changeset
5136 var match, selector,
jurzua
parents:
diff changeset
5137 matches = {},
jurzua
parents:
diff changeset
5138 level = 1;
jurzua
parents:
diff changeset
5139
jurzua
parents:
diff changeset
5140 if ( cur && selectors.length ) {
jurzua
parents:
diff changeset
5141 for ( i = 0, l = selectors.length; i < l; i++ ) {
jurzua
parents:
diff changeset
5142 selector = selectors[i];
jurzua
parents:
diff changeset
5143
jurzua
parents:
diff changeset
5144 if ( !matches[ selector ] ) {
jurzua
parents:
diff changeset
5145 matches[ selector ] = POS.test( selector ) ?
jurzua
parents:
diff changeset
5146 jQuery( selector, context || this.context ) :
jurzua
parents:
diff changeset
5147 selector;
jurzua
parents:
diff changeset
5148 }
jurzua
parents:
diff changeset
5149 }
jurzua
parents:
diff changeset
5150
jurzua
parents:
diff changeset
5151 while ( cur && cur.ownerDocument && cur !== context ) {
jurzua
parents:
diff changeset
5152 for ( selector in matches ) {
jurzua
parents:
diff changeset
5153 match = matches[ selector ];
jurzua
parents:
diff changeset
5154
jurzua
parents:
diff changeset
5155 if ( match.jquery ? match.index( cur ) > -1 : jQuery( cur ).is( match ) ) {
jurzua
parents:
diff changeset
5156 ret.push({ selector: selector, elem: cur, level: level });
jurzua
parents:
diff changeset
5157 }
jurzua
parents:
diff changeset
5158 }
jurzua
parents:
diff changeset
5159
jurzua
parents:
diff changeset
5160 cur = cur.parentNode;
jurzua
parents:
diff changeset
5161 level++;
jurzua
parents:
diff changeset
5162 }
jurzua
parents:
diff changeset
5163 }
jurzua
parents:
diff changeset
5164
jurzua
parents:
diff changeset
5165 return ret;
jurzua
parents:
diff changeset
5166 }
jurzua
parents:
diff changeset
5167
jurzua
parents:
diff changeset
5168 // String
jurzua
parents:
diff changeset
5169 var pos = POS.test( selectors ) || typeof selectors !== "string" ?
jurzua
parents:
diff changeset
5170 jQuery( selectors, context || this.context ) :
jurzua
parents:
diff changeset
5171 0;
jurzua
parents:
diff changeset
5172
jurzua
parents:
diff changeset
5173 for ( i = 0, l = this.length; i < l; i++ ) {
jurzua
parents:
diff changeset
5174 cur = this[i];
jurzua
parents:
diff changeset
5175
jurzua
parents:
diff changeset
5176 while ( cur ) {
jurzua
parents:
diff changeset
5177 if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
jurzua
parents:
diff changeset
5178 ret.push( cur );
jurzua
parents:
diff changeset
5179 break;
jurzua
parents:
diff changeset
5180
jurzua
parents:
diff changeset
5181 } else {
jurzua
parents:
diff changeset
5182 cur = cur.parentNode;
jurzua
parents:
diff changeset
5183 if ( !cur || !cur.ownerDocument || cur === context || cur.nodeType === 11 ) {
jurzua
parents:
diff changeset
5184 break;
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
jurzua
parents:
diff changeset
5190 ret = ret.length > 1 ? jQuery.unique( ret ) : ret;
jurzua
parents:
diff changeset
5191
jurzua
parents:
diff changeset
5192 return this.pushStack( ret, "closest", selectors );
jurzua
parents:
diff changeset
5193 },
jurzua
parents:
diff changeset
5194
jurzua
parents:
diff changeset
5195 // Determine the position of an element within
jurzua
parents:
diff changeset
5196 // the matched set of elements
jurzua
parents:
diff changeset
5197 index: function( elem ) {
jurzua
parents:
diff changeset
5198 if ( !elem || typeof elem === "string" ) {
jurzua
parents:
diff changeset
5199 return jQuery.inArray( this[0],
jurzua
parents:
diff changeset
5200 // If it receives a string, the selector is used
jurzua
parents:
diff changeset
5201 // If it receives nothing, the siblings are used
jurzua
parents:
diff changeset
5202 elem ? jQuery( elem ) : this.parent().children() );
jurzua
parents:
diff changeset
5203 }
jurzua
parents:
diff changeset
5204 // Locate the position of the desired element
jurzua
parents:
diff changeset
5205 return jQuery.inArray(
jurzua
parents:
diff changeset
5206 // If it receives a jQuery object, the first element is used
jurzua
parents:
diff changeset
5207 elem.jquery ? elem[0] : elem, this );
jurzua
parents:
diff changeset
5208 },
jurzua
parents:
diff changeset
5209
jurzua
parents:
diff changeset
5210 add: function( selector, context ) {
jurzua
parents:
diff changeset
5211 var set = typeof selector === "string" ?
jurzua
parents:
diff changeset
5212 jQuery( selector, context ) :
jurzua
parents:
diff changeset
5213 jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
jurzua
parents:
diff changeset
5214 all = jQuery.merge( this.get(), set );
jurzua
parents:
diff changeset
5215
jurzua
parents:
diff changeset
5216 return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
jurzua
parents:
diff changeset
5217 all :
jurzua
parents:
diff changeset
5218 jQuery.unique( all ) );
jurzua
parents:
diff changeset
5219 },
jurzua
parents:
diff changeset
5220
jurzua
parents:
diff changeset
5221 andSelf: function() {
jurzua
parents:
diff changeset
5222 return this.add( this.prevObject );
jurzua
parents:
diff changeset
5223 }
jurzua
parents:
diff changeset
5224 });
jurzua
parents:
diff changeset
5225
jurzua
parents:
diff changeset
5226 // A painfully simple check to see if an element is disconnected
jurzua
parents:
diff changeset
5227 // from a document (should be improved, where feasible).
jurzua
parents:
diff changeset
5228 function isDisconnected( node ) {
jurzua
parents:
diff changeset
5229 return !node || !node.parentNode || node.parentNode.nodeType === 11;
jurzua
parents:
diff changeset
5230 }
jurzua
parents:
diff changeset
5231
jurzua
parents:
diff changeset
5232 jQuery.each({
jurzua
parents:
diff changeset
5233 parent: function( elem ) {
jurzua
parents:
diff changeset
5234 var parent = elem.parentNode;
jurzua
parents:
diff changeset
5235 return parent && parent.nodeType !== 11 ? parent : null;
jurzua
parents:
diff changeset
5236 },
jurzua
parents:
diff changeset
5237 parents: function( elem ) {
jurzua
parents:
diff changeset
5238 return jQuery.dir( elem, "parentNode" );
jurzua
parents:
diff changeset
5239 },
jurzua
parents:
diff changeset
5240 parentsUntil: function( elem, i, until ) {
jurzua
parents:
diff changeset
5241 return jQuery.dir( elem, "parentNode", until );
jurzua
parents:
diff changeset
5242 },
jurzua
parents:
diff changeset
5243 next: function( elem ) {
jurzua
parents:
diff changeset
5244 return jQuery.nth( elem, 2, "nextSibling" );
jurzua
parents:
diff changeset
5245 },
jurzua
parents:
diff changeset
5246 prev: function( elem ) {
jurzua
parents:
diff changeset
5247 return jQuery.nth( elem, 2, "previousSibling" );
jurzua
parents:
diff changeset
5248 },
jurzua
parents:
diff changeset
5249 nextAll: function( elem ) {
jurzua
parents:
diff changeset
5250 return jQuery.dir( elem, "nextSibling" );
jurzua
parents:
diff changeset
5251 },
jurzua
parents:
diff changeset
5252 prevAll: function( elem ) {
jurzua
parents:
diff changeset
5253 return jQuery.dir( elem, "previousSibling" );
jurzua
parents:
diff changeset
5254 },
jurzua
parents:
diff changeset
5255 nextUntil: function( elem, i, until ) {
jurzua
parents:
diff changeset
5256 return jQuery.dir( elem, "nextSibling", until );
jurzua
parents:
diff changeset
5257 },
jurzua
parents:
diff changeset
5258 prevUntil: function( elem, i, until ) {
jurzua
parents:
diff changeset
5259 return jQuery.dir( elem, "previousSibling", until );
jurzua
parents:
diff changeset
5260 },
jurzua
parents:
diff changeset
5261 siblings: function( elem ) {
jurzua
parents:
diff changeset
5262 return jQuery.sibling( elem.parentNode.firstChild, elem );
jurzua
parents:
diff changeset
5263 },
jurzua
parents:
diff changeset
5264 children: function( elem ) {
jurzua
parents:
diff changeset
5265 return jQuery.sibling( elem.firstChild );
jurzua
parents:
diff changeset
5266 },
jurzua
parents:
diff changeset
5267 contents: function( elem ) {
jurzua
parents:
diff changeset
5268 return jQuery.nodeName( elem, "iframe" ) ?
jurzua
parents:
diff changeset
5269 elem.contentDocument || elem.contentWindow.document :
jurzua
parents:
diff changeset
5270 jQuery.makeArray( elem.childNodes );
jurzua
parents:
diff changeset
5271 }
jurzua
parents:
diff changeset
5272 }, function( name, fn ) {
jurzua
parents:
diff changeset
5273 jQuery.fn[ name ] = function( until, selector ) {
jurzua
parents:
diff changeset
5274 var ret = jQuery.map( this, fn, until ),
jurzua
parents:
diff changeset
5275 // The variable 'args' was introduced in
jurzua
parents:
diff changeset
5276 // https://github.com/jquery/jquery/commit/52a0238
jurzua
parents:
diff changeset
5277 // to work around a bug in Chrome 10 (Dev) and should be removed when the bug is fixed.
jurzua
parents:
diff changeset
5278 // http://code.google.com/p/v8/issues/detail?id=1050
jurzua
parents:
diff changeset
5279 args = slice.call(arguments);
jurzua
parents:
diff changeset
5280
jurzua
parents:
diff changeset
5281 if ( !runtil.test( name ) ) {
jurzua
parents:
diff changeset
5282 selector = until;
jurzua
parents:
diff changeset
5283 }
jurzua
parents:
diff changeset
5284
jurzua
parents:
diff changeset
5285 if ( selector && typeof selector === "string" ) {
jurzua
parents:
diff changeset
5286 ret = jQuery.filter( selector, ret );
jurzua
parents:
diff changeset
5287 }
jurzua
parents:
diff changeset
5288
jurzua
parents:
diff changeset
5289 ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
jurzua
parents:
diff changeset
5290
jurzua
parents:
diff changeset
5291 if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
jurzua
parents:
diff changeset
5292 ret = ret.reverse();
jurzua
parents:
diff changeset
5293 }
jurzua
parents:
diff changeset
5294
jurzua
parents:
diff changeset
5295 return this.pushStack( ret, name, args.join(",") );
jurzua
parents:
diff changeset
5296 };
jurzua
parents:
diff changeset
5297 });
jurzua
parents:
diff changeset
5298
jurzua
parents:
diff changeset
5299 jQuery.extend({
jurzua
parents:
diff changeset
5300 filter: function( expr, elems, not ) {
jurzua
parents:
diff changeset
5301 if ( not ) {
jurzua
parents:
diff changeset
5302 expr = ":not(" + expr + ")";
jurzua
parents:
diff changeset
5303 }
jurzua
parents:
diff changeset
5304
jurzua
parents:
diff changeset
5305 return elems.length === 1 ?
jurzua
parents:
diff changeset
5306 jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
jurzua
parents:
diff changeset
5307 jQuery.find.matches(expr, elems);
jurzua
parents:
diff changeset
5308 },
jurzua
parents:
diff changeset
5309
jurzua
parents:
diff changeset
5310 dir: function( elem, dir, until ) {
jurzua
parents:
diff changeset
5311 var matched = [],
jurzua
parents:
diff changeset
5312 cur = elem[ dir ];
jurzua
parents:
diff changeset
5313
jurzua
parents:
diff changeset
5314 while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
jurzua
parents:
diff changeset
5315 if ( cur.nodeType === 1 ) {
jurzua
parents:
diff changeset
5316 matched.push( cur );
jurzua
parents:
diff changeset
5317 }
jurzua
parents:
diff changeset
5318 cur = cur[dir];
jurzua
parents:
diff changeset
5319 }
jurzua
parents:
diff changeset
5320 return matched;
jurzua
parents:
diff changeset
5321 },
jurzua
parents:
diff changeset
5322
jurzua
parents:
diff changeset
5323 nth: function( cur, result, dir, elem ) {
jurzua
parents:
diff changeset
5324 result = result || 1;
jurzua
parents:
diff changeset
5325 var num = 0;
jurzua
parents:
diff changeset
5326
jurzua
parents:
diff changeset
5327 for ( ; cur; cur = cur[dir] ) {
jurzua
parents:
diff changeset
5328 if ( cur.nodeType === 1 && ++num === result ) {
jurzua
parents:
diff changeset
5329 break;
jurzua
parents:
diff changeset
5330 }
jurzua
parents:
diff changeset
5331 }
jurzua
parents:
diff changeset
5332
jurzua
parents:
diff changeset
5333 return cur;
jurzua
parents:
diff changeset
5334 },
jurzua
parents:
diff changeset
5335
jurzua
parents:
diff changeset
5336 sibling: function( n, elem ) {
jurzua
parents:
diff changeset
5337 var r = [];
jurzua
parents:
diff changeset
5338
jurzua
parents:
diff changeset
5339 for ( ; n; n = n.nextSibling ) {
jurzua
parents:
diff changeset
5340 if ( n.nodeType === 1 && n !== elem ) {
jurzua
parents:
diff changeset
5341 r.push( n );
jurzua
parents:
diff changeset
5342 }
jurzua
parents:
diff changeset
5343 }
jurzua
parents:
diff changeset
5344
jurzua
parents:
diff changeset
5345 return r;
jurzua
parents:
diff changeset
5346 }
jurzua
parents:
diff changeset
5347 });
jurzua
parents:
diff changeset
5348
jurzua
parents:
diff changeset
5349 // Implement the identical functionality for filter and not
jurzua
parents:
diff changeset
5350 function winnow( elements, qualifier, keep ) {
jurzua
parents:
diff changeset
5351
jurzua
parents:
diff changeset
5352 // Can't pass null or undefined to indexOf in Firefox 4
jurzua
parents:
diff changeset
5353 // Set to 0 to skip string check
jurzua
parents:
diff changeset
5354 qualifier = qualifier || 0;
jurzua
parents:
diff changeset
5355
jurzua
parents:
diff changeset
5356 if ( jQuery.isFunction( qualifier ) ) {
jurzua
parents:
diff changeset
5357 return jQuery.grep(elements, function( elem, i ) {
jurzua
parents:
diff changeset
5358 var retVal = !!qualifier.call( elem, i, elem );
jurzua
parents:
diff changeset
5359 return retVal === keep;
jurzua
parents:
diff changeset
5360 });
jurzua
parents:
diff changeset
5361
jurzua
parents:
diff changeset
5362 } else if ( qualifier.nodeType ) {
jurzua
parents:
diff changeset
5363 return jQuery.grep(elements, function( elem, i ) {
jurzua
parents:
diff changeset
5364 return (elem === qualifier) === keep;
jurzua
parents:
diff changeset
5365 });
jurzua
parents:
diff changeset
5366
jurzua
parents:
diff changeset
5367 } else if ( typeof qualifier === "string" ) {
jurzua
parents:
diff changeset
5368 var filtered = jQuery.grep(elements, function( elem ) {
jurzua
parents:
diff changeset
5369 return elem.nodeType === 1;
jurzua
parents:
diff changeset
5370 });
jurzua
parents:
diff changeset
5371
jurzua
parents:
diff changeset
5372 if ( isSimple.test( qualifier ) ) {
jurzua
parents:
diff changeset
5373 return jQuery.filter(qualifier, filtered, !keep);
jurzua
parents:
diff changeset
5374 } else {
jurzua
parents:
diff changeset
5375 qualifier = jQuery.filter( qualifier, filtered );
jurzua
parents:
diff changeset
5376 }
jurzua
parents:
diff changeset
5377 }
jurzua
parents:
diff changeset
5378
jurzua
parents:
diff changeset
5379 return jQuery.grep(elements, function( elem, i ) {
jurzua
parents:
diff changeset
5380 return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
jurzua
parents:
diff changeset
5381 });
jurzua
parents:
diff changeset
5382 }
jurzua
parents:
diff changeset
5383
jurzua
parents:
diff changeset
5384
jurzua
parents:
diff changeset
5385
jurzua
parents:
diff changeset
5386
jurzua
parents:
diff changeset
5387 var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
jurzua
parents:
diff changeset
5388 rleadingWhitespace = /^\s+/,
jurzua
parents:
diff changeset
5389 rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
jurzua
parents:
diff changeset
5390 rtagName = /<([\w:]+)/,
jurzua
parents:
diff changeset
5391 rtbody = /<tbody/i,
jurzua
parents:
diff changeset
5392 rhtml = /<|&#?\w+;/,
jurzua
parents:
diff changeset
5393 rnocache = /<(?:script|object|embed|option|style)/i,
jurzua
parents:
diff changeset
5394 // checked="checked" or checked
jurzua
parents:
diff changeset
5395 rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
jurzua
parents:
diff changeset
5396 rscriptType = /\/(java|ecma)script/i,
jurzua
parents:
diff changeset
5397 wrapMap = {
jurzua
parents:
diff changeset
5398 option: [ 1, "<select multiple='multiple'>", "</select>" ],
jurzua
parents:
diff changeset
5399 legend: [ 1, "<fieldset>", "</fieldset>" ],
jurzua
parents:
diff changeset
5400 thead: [ 1, "<table>", "</table>" ],
jurzua
parents:
diff changeset
5401 tr: [ 2, "<table><tbody>", "</tbody></table>" ],
jurzua
parents:
diff changeset
5402 td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
jurzua
parents:
diff changeset
5403 col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
jurzua
parents:
diff changeset
5404 area: [ 1, "<map>", "</map>" ],
jurzua
parents:
diff changeset
5405 _default: [ 0, "", "" ]
jurzua
parents:
diff changeset
5406 };
jurzua
parents:
diff changeset
5407
jurzua
parents:
diff changeset
5408 wrapMap.optgroup = wrapMap.option;
jurzua
parents:
diff changeset
5409 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
jurzua
parents:
diff changeset
5410 wrapMap.th = wrapMap.td;
jurzua
parents:
diff changeset
5411
jurzua
parents:
diff changeset
5412 // IE can't serialize <link> and <script> tags normally
jurzua
parents:
diff changeset
5413 if ( !jQuery.support.htmlSerialize ) {
jurzua
parents:
diff changeset
5414 wrapMap._default = [ 1, "div<div>", "</div>" ];
jurzua
parents:
diff changeset
5415 }
jurzua
parents:
diff changeset
5416
jurzua
parents:
diff changeset
5417 jQuery.fn.extend({
jurzua
parents:
diff changeset
5418 text: function( text ) {
jurzua
parents:
diff changeset
5419 if ( jQuery.isFunction(text) ) {
jurzua
parents:
diff changeset
5420 return this.each(function(i) {
jurzua
parents:
diff changeset
5421 var self = jQuery( this );
jurzua
parents:
diff changeset
5422
jurzua
parents:
diff changeset
5423 self.text( text.call(this, i, self.text()) );
jurzua
parents:
diff changeset
5424 });
jurzua
parents:
diff changeset
5425 }
jurzua
parents:
diff changeset
5426
jurzua
parents:
diff changeset
5427 if ( typeof text !== "object" && text !== undefined ) {
jurzua
parents:
diff changeset
5428 return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
jurzua
parents:
diff changeset
5429 }
jurzua
parents:
diff changeset
5430
jurzua
parents:
diff changeset
5431 return jQuery.text( this );
jurzua
parents:
diff changeset
5432 },
jurzua
parents:
diff changeset
5433
jurzua
parents:
diff changeset
5434 wrapAll: function( html ) {
jurzua
parents:
diff changeset
5435 if ( jQuery.isFunction( html ) ) {
jurzua
parents:
diff changeset
5436 return this.each(function(i) {
jurzua
parents:
diff changeset
5437 jQuery(this).wrapAll( html.call(this, i) );
jurzua
parents:
diff changeset
5438 });
jurzua
parents:
diff changeset
5439 }
jurzua
parents:
diff changeset
5440
jurzua
parents:
diff changeset
5441 if ( this[0] ) {
jurzua
parents:
diff changeset
5442 // The elements to wrap the target around
jurzua
parents:
diff changeset
5443 var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
jurzua
parents:
diff changeset
5444
jurzua
parents:
diff changeset
5445 if ( this[0].parentNode ) {
jurzua
parents:
diff changeset
5446 wrap.insertBefore( this[0] );
jurzua
parents:
diff changeset
5447 }
jurzua
parents:
diff changeset
5448
jurzua
parents:
diff changeset
5449 wrap.map(function() {
jurzua
parents:
diff changeset
5450 var elem = this;
jurzua
parents:
diff changeset
5451
jurzua
parents:
diff changeset
5452 while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
jurzua
parents:
diff changeset
5453 elem = elem.firstChild;
jurzua
parents:
diff changeset
5454 }
jurzua
parents:
diff changeset
5455
jurzua
parents:
diff changeset
5456 return elem;
jurzua
parents:
diff changeset
5457 }).append( this );
jurzua
parents:
diff changeset
5458 }
jurzua
parents:
diff changeset
5459
jurzua
parents:
diff changeset
5460 return this;
jurzua
parents:
diff changeset
5461 },
jurzua
parents:
diff changeset
5462
jurzua
parents:
diff changeset
5463 wrapInner: function( html ) {
jurzua
parents:
diff changeset
5464 if ( jQuery.isFunction( html ) ) {
jurzua
parents:
diff changeset
5465 return this.each(function(i) {
jurzua
parents:
diff changeset
5466 jQuery(this).wrapInner( html.call(this, i) );
jurzua
parents:
diff changeset
5467 });
jurzua
parents:
diff changeset
5468 }
jurzua
parents:
diff changeset
5469
jurzua
parents:
diff changeset
5470 return this.each(function() {
jurzua
parents:
diff changeset
5471 var self = jQuery( this ),
jurzua
parents:
diff changeset
5472 contents = self.contents();
jurzua
parents:
diff changeset
5473
jurzua
parents:
diff changeset
5474 if ( contents.length ) {
jurzua
parents:
diff changeset
5475 contents.wrapAll( html );
jurzua
parents:
diff changeset
5476
jurzua
parents:
diff changeset
5477 } else {
jurzua
parents:
diff changeset
5478 self.append( html );
jurzua
parents:
diff changeset
5479 }
jurzua
parents:
diff changeset
5480 });
jurzua
parents:
diff changeset
5481 },
jurzua
parents:
diff changeset
5482
jurzua
parents:
diff changeset
5483 wrap: function( html ) {
jurzua
parents:
diff changeset
5484 return this.each(function() {
jurzua
parents:
diff changeset
5485 jQuery( this ).wrapAll( html );
jurzua
parents:
diff changeset
5486 });
jurzua
parents:
diff changeset
5487 },
jurzua
parents:
diff changeset
5488
jurzua
parents:
diff changeset
5489 unwrap: function() {
jurzua
parents:
diff changeset
5490 return this.parent().each(function() {
jurzua
parents:
diff changeset
5491 if ( !jQuery.nodeName( this, "body" ) ) {
jurzua
parents:
diff changeset
5492 jQuery( this ).replaceWith( this.childNodes );
jurzua
parents:
diff changeset
5493 }
jurzua
parents:
diff changeset
5494 }).end();
jurzua
parents:
diff changeset
5495 },
jurzua
parents:
diff changeset
5496
jurzua
parents:
diff changeset
5497 append: function() {
jurzua
parents:
diff changeset
5498 return this.domManip(arguments, true, function( elem ) {
jurzua
parents:
diff changeset
5499 if ( this.nodeType === 1 ) {
jurzua
parents:
diff changeset
5500 this.appendChild( elem );
jurzua
parents:
diff changeset
5501 }
jurzua
parents:
diff changeset
5502 });
jurzua
parents:
diff changeset
5503 },
jurzua
parents:
diff changeset
5504
jurzua
parents:
diff changeset
5505 prepend: function() {
jurzua
parents:
diff changeset
5506 return this.domManip(arguments, true, function( elem ) {
jurzua
parents:
diff changeset
5507 if ( this.nodeType === 1 ) {
jurzua
parents:
diff changeset
5508 this.insertBefore( elem, this.firstChild );
jurzua
parents:
diff changeset
5509 }
jurzua
parents:
diff changeset
5510 });
jurzua
parents:
diff changeset
5511 },
jurzua
parents:
diff changeset
5512
jurzua
parents:
diff changeset
5513 before: function() {
jurzua
parents:
diff changeset
5514 if ( this[0] && this[0].parentNode ) {
jurzua
parents:
diff changeset
5515 return this.domManip(arguments, false, function( elem ) {
jurzua
parents:
diff changeset
5516 this.parentNode.insertBefore( elem, this );
jurzua
parents:
diff changeset
5517 });
jurzua
parents:
diff changeset
5518 } else if ( arguments.length ) {
jurzua
parents:
diff changeset
5519 var set = jQuery(arguments[0]);
jurzua
parents:
diff changeset
5520 set.push.apply( set, this.toArray() );
jurzua
parents:
diff changeset
5521 return this.pushStack( set, "before", arguments );
jurzua
parents:
diff changeset
5522 }
jurzua
parents:
diff changeset
5523 },
jurzua
parents:
diff changeset
5524
jurzua
parents:
diff changeset
5525 after: function() {
jurzua
parents:
diff changeset
5526 if ( this[0] && this[0].parentNode ) {
jurzua
parents:
diff changeset
5527 return this.domManip(arguments, false, function( elem ) {
jurzua
parents:
diff changeset
5528 this.parentNode.insertBefore( elem, this.nextSibling );
jurzua
parents:
diff changeset
5529 });
jurzua
parents:
diff changeset
5530 } else if ( arguments.length ) {
jurzua
parents:
diff changeset
5531 var set = this.pushStack( this, "after", arguments );
jurzua
parents:
diff changeset
5532 set.push.apply( set, jQuery(arguments[0]).toArray() );
jurzua
parents:
diff changeset
5533 return set;
jurzua
parents:
diff changeset
5534 }
jurzua
parents:
diff changeset
5535 },
jurzua
parents:
diff changeset
5536
jurzua
parents:
diff changeset
5537 // keepData is for internal use only--do not document
jurzua
parents:
diff changeset
5538 remove: function( selector, keepData ) {
jurzua
parents:
diff changeset
5539 for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
jurzua
parents:
diff changeset
5540 if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
jurzua
parents:
diff changeset
5541 if ( !keepData && elem.nodeType === 1 ) {
jurzua
parents:
diff changeset
5542 jQuery.cleanData( elem.getElementsByTagName("*") );
jurzua
parents:
diff changeset
5543 jQuery.cleanData( [ elem ] );
jurzua
parents:
diff changeset
5544 }
jurzua
parents:
diff changeset
5545
jurzua
parents:
diff changeset
5546 if ( elem.parentNode ) {
jurzua
parents:
diff changeset
5547 elem.parentNode.removeChild( elem );
jurzua
parents:
diff changeset
5548 }
jurzua
parents:
diff changeset
5549 }
jurzua
parents:
diff changeset
5550 }
jurzua
parents:
diff changeset
5551
jurzua
parents:
diff changeset
5552 return this;
jurzua
parents:
diff changeset
5553 },
jurzua
parents:
diff changeset
5554
jurzua
parents:
diff changeset
5555 empty: function() {
jurzua
parents:
diff changeset
5556 for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
jurzua
parents:
diff changeset
5557 // Remove element nodes and prevent memory leaks
jurzua
parents:
diff changeset
5558 if ( elem.nodeType === 1 ) {
jurzua
parents:
diff changeset
5559 jQuery.cleanData( elem.getElementsByTagName("*") );
jurzua
parents:
diff changeset
5560 }
jurzua
parents:
diff changeset
5561
jurzua
parents:
diff changeset
5562 // Remove any remaining nodes
jurzua
parents:
diff changeset
5563 while ( elem.firstChild ) {
jurzua
parents:
diff changeset
5564 elem.removeChild( elem.firstChild );
jurzua
parents:
diff changeset
5565 }
jurzua
parents:
diff changeset
5566 }
jurzua
parents:
diff changeset
5567
jurzua
parents:
diff changeset
5568 return this;
jurzua
parents:
diff changeset
5569 },
jurzua
parents:
diff changeset
5570
jurzua
parents:
diff changeset
5571 clone: function( dataAndEvents, deepDataAndEvents ) {
jurzua
parents:
diff changeset
5572 dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
jurzua
parents:
diff changeset
5573 deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
jurzua
parents:
diff changeset
5574
jurzua
parents:
diff changeset
5575 return this.map( function () {
jurzua
parents:
diff changeset
5576 return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
jurzua
parents:
diff changeset
5577 });
jurzua
parents:
diff changeset
5578 },
jurzua
parents:
diff changeset
5579
jurzua
parents:
diff changeset
5580 html: function( value ) {
jurzua
parents:
diff changeset
5581 if ( value === undefined ) {
jurzua
parents:
diff changeset
5582 return this[0] && this[0].nodeType === 1 ?
jurzua
parents:
diff changeset
5583 this[0].innerHTML.replace(rinlinejQuery, "") :
jurzua
parents:
diff changeset
5584 null;
jurzua
parents:
diff changeset
5585
jurzua
parents:
diff changeset
5586 // See if we can take a shortcut and just use innerHTML
jurzua
parents:
diff changeset
5587 } else if ( typeof value === "string" && !rnocache.test( value ) &&
jurzua
parents:
diff changeset
5588 (jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
jurzua
parents:
diff changeset
5589 !wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
jurzua
parents:
diff changeset
5590
jurzua
parents:
diff changeset
5591 value = value.replace(rxhtmlTag, "<$1></$2>");
jurzua
parents:
diff changeset
5592
jurzua
parents:
diff changeset
5593 try {
jurzua
parents:
diff changeset
5594 for ( var i = 0, l = this.length; i < l; i++ ) {
jurzua
parents:
diff changeset
5595 // Remove element nodes and prevent memory leaks
jurzua
parents:
diff changeset
5596 if ( this[i].nodeType === 1 ) {
jurzua
parents:
diff changeset
5597 jQuery.cleanData( this[i].getElementsByTagName("*") );
jurzua
parents:
diff changeset
5598 this[i].innerHTML = value;
jurzua
parents:
diff changeset
5599 }
jurzua
parents:
diff changeset
5600 }
jurzua
parents:
diff changeset
5601
jurzua
parents:
diff changeset
5602 // If using innerHTML throws an exception, use the fallback method
jurzua
parents:
diff changeset
5603 } catch(e) {
jurzua
parents:
diff changeset
5604 this.empty().append( value );
jurzua
parents:
diff changeset
5605 }
jurzua
parents:
diff changeset
5606
jurzua
parents:
diff changeset
5607 } else if ( jQuery.isFunction( value ) ) {
jurzua
parents:
diff changeset
5608 this.each(function(i){
jurzua
parents:
diff changeset
5609 var self = jQuery( this );
jurzua
parents:
diff changeset
5610
jurzua
parents:
diff changeset
5611 self.html( value.call(this, i, self.html()) );
jurzua
parents:
diff changeset
5612 });
jurzua
parents:
diff changeset
5613
jurzua
parents:
diff changeset
5614 } else {
jurzua
parents:
diff changeset
5615 this.empty().append( value );
jurzua
parents:
diff changeset
5616 }
jurzua
parents:
diff changeset
5617
jurzua
parents:
diff changeset
5618 return this;
jurzua
parents:
diff changeset
5619 },
jurzua
parents:
diff changeset
5620
jurzua
parents:
diff changeset
5621 replaceWith: function( value ) {
jurzua
parents:
diff changeset
5622 if ( this[0] && this[0].parentNode ) {
jurzua
parents:
diff changeset
5623 // Make sure that the elements are removed from the DOM before they are inserted
jurzua
parents:
diff changeset
5624 // this can help fix replacing a parent with child elements
jurzua
parents:
diff changeset
5625 if ( jQuery.isFunction( value ) ) {
jurzua
parents:
diff changeset
5626 return this.each(function(i) {
jurzua
parents:
diff changeset
5627 var self = jQuery(this), old = self.html();
jurzua
parents:
diff changeset
5628 self.replaceWith( value.call( this, i, old ) );
jurzua
parents:
diff changeset
5629 });
jurzua
parents:
diff changeset
5630 }
jurzua
parents:
diff changeset
5631
jurzua
parents:
diff changeset
5632 if ( typeof value !== "string" ) {
jurzua
parents:
diff changeset
5633 value = jQuery( value ).detach();
jurzua
parents:
diff changeset
5634 }
jurzua
parents:
diff changeset
5635
jurzua
parents:
diff changeset
5636 return this.each(function() {
jurzua
parents:
diff changeset
5637 var next = this.nextSibling,
jurzua
parents:
diff changeset
5638 parent = this.parentNode;
jurzua
parents:
diff changeset
5639
jurzua
parents:
diff changeset
5640 jQuery( this ).remove();
jurzua
parents:
diff changeset
5641
jurzua
parents:
diff changeset
5642 if ( next ) {
jurzua
parents:
diff changeset
5643 jQuery(next).before( value );
jurzua
parents:
diff changeset
5644 } else {
jurzua
parents:
diff changeset
5645 jQuery(parent).append( value );
jurzua
parents:
diff changeset
5646 }
jurzua
parents:
diff changeset
5647 });
jurzua
parents:
diff changeset
5648 } else {
jurzua
parents:
diff changeset
5649 return this.length ?
jurzua
parents:
diff changeset
5650 this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) :
jurzua
parents:
diff changeset
5651 this;
jurzua
parents:
diff changeset
5652 }
jurzua
parents:
diff changeset
5653 },
jurzua
parents:
diff changeset
5654
jurzua
parents:
diff changeset
5655 detach: function( selector ) {
jurzua
parents:
diff changeset
5656 return this.remove( selector, true );
jurzua
parents:
diff changeset
5657 },
jurzua
parents:
diff changeset
5658
jurzua
parents:
diff changeset
5659 domManip: function( args, table, callback ) {
jurzua
parents:
diff changeset
5660 var results, first, fragment, parent,
jurzua
parents:
diff changeset
5661 value = args[0],
jurzua
parents:
diff changeset
5662 scripts = [];
jurzua
parents:
diff changeset
5663
jurzua
parents:
diff changeset
5664 // We can't cloneNode fragments that contain checked, in WebKit
jurzua
parents:
diff changeset
5665 if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
jurzua
parents:
diff changeset
5666 return this.each(function() {
jurzua
parents:
diff changeset
5667 jQuery(this).domManip( args, table, callback, true );
jurzua
parents:
diff changeset
5668 });
jurzua
parents:
diff changeset
5669 }
jurzua
parents:
diff changeset
5670
jurzua
parents:
diff changeset
5671 if ( jQuery.isFunction(value) ) {
jurzua
parents:
diff changeset
5672 return this.each(function(i) {
jurzua
parents:
diff changeset
5673 var self = jQuery(this);
jurzua
parents:
diff changeset
5674 args[0] = value.call(this, i, table ? self.html() : undefined);
jurzua
parents:
diff changeset
5675 self.domManip( args, table, callback );
jurzua
parents:
diff changeset
5676 });
jurzua
parents:
diff changeset
5677 }
jurzua
parents:
diff changeset
5678
jurzua
parents:
diff changeset
5679 if ( this[0] ) {
jurzua
parents:
diff changeset
5680 parent = value && value.parentNode;
jurzua
parents:
diff changeset
5681
jurzua
parents:
diff changeset
5682 // If we're in a fragment, just use that instead of building a new one
jurzua
parents:
diff changeset
5683 if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
jurzua
parents:
diff changeset
5684 results = { fragment: parent };
jurzua
parents:
diff changeset
5685
jurzua
parents:
diff changeset
5686 } else {
jurzua
parents:
diff changeset
5687 results = jQuery.buildFragment( args, this, scripts );
jurzua
parents:
diff changeset
5688 }
jurzua
parents:
diff changeset
5689
jurzua
parents:
diff changeset
5690 fragment = results.fragment;
jurzua
parents:
diff changeset
5691
jurzua
parents:
diff changeset
5692 if ( fragment.childNodes.length === 1 ) {
jurzua
parents:
diff changeset
5693 first = fragment = fragment.firstChild;
jurzua
parents:
diff changeset
5694 } else {
jurzua
parents:
diff changeset
5695 first = fragment.firstChild;
jurzua
parents:
diff changeset
5696 }
jurzua
parents:
diff changeset
5697
jurzua
parents:
diff changeset
5698 if ( first ) {
jurzua
parents:
diff changeset
5699 table = table && jQuery.nodeName( first, "tr" );
jurzua
parents:
diff changeset
5700
jurzua
parents:
diff changeset
5701 for ( var i = 0, l = this.length, lastIndex = l - 1; i < l; i++ ) {
jurzua
parents:
diff changeset
5702 callback.call(
jurzua
parents:
diff changeset
5703 table ?
jurzua
parents:
diff changeset
5704 root(this[i], first) :
jurzua
parents:
diff changeset
5705 this[i],
jurzua
parents:
diff changeset
5706 // Make sure that we do not leak memory by inadvertently discarding
jurzua
parents:
diff changeset
5707 // the original fragment (which might have attached data) instead of
jurzua
parents:
diff changeset
5708 // using it; in addition, use the original fragment object for the last
jurzua
parents:
diff changeset
5709 // item instead of first because it can end up being emptied incorrectly
jurzua
parents:
diff changeset
5710 // in certain situations (Bug #8070).
jurzua
parents:
diff changeset
5711 // Fragments from the fragment cache must always be cloned and never used
jurzua
parents:
diff changeset
5712 // in place.
jurzua
parents:
diff changeset
5713 results.cacheable || (l > 1 && i < lastIndex) ?
jurzua
parents:
diff changeset
5714 jQuery.clone( fragment, true, true ) :
jurzua
parents:
diff changeset
5715 fragment
jurzua
parents:
diff changeset
5716 );
jurzua
parents:
diff changeset
5717 }
jurzua
parents:
diff changeset
5718 }
jurzua
parents:
diff changeset
5719
jurzua
parents:
diff changeset
5720 if ( scripts.length ) {
jurzua
parents:
diff changeset
5721 jQuery.each( scripts, evalScript );
jurzua
parents:
diff changeset
5722 }
jurzua
parents:
diff changeset
5723 }
jurzua
parents:
diff changeset
5724
jurzua
parents:
diff changeset
5725 return this;
jurzua
parents:
diff changeset
5726 }
jurzua
parents:
diff changeset
5727 });
jurzua
parents:
diff changeset
5728
jurzua
parents:
diff changeset
5729 function root( elem, cur ) {
jurzua
parents:
diff changeset
5730 return jQuery.nodeName(elem, "table") ?
jurzua
parents:
diff changeset
5731 (elem.getElementsByTagName("tbody")[0] ||
jurzua
parents:
diff changeset
5732 elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
jurzua
parents:
diff changeset
5733 elem;
jurzua
parents:
diff changeset
5734 }
jurzua
parents:
diff changeset
5735
jurzua
parents:
diff changeset
5736 function cloneCopyEvent( src, dest ) {
jurzua
parents:
diff changeset
5737
jurzua
parents:
diff changeset
5738 if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
jurzua
parents:
diff changeset
5739 return;
jurzua
parents:
diff changeset
5740 }
jurzua
parents:
diff changeset
5741
jurzua
parents:
diff changeset
5742 var internalKey = jQuery.expando,
jurzua
parents:
diff changeset
5743 oldData = jQuery.data( src ),
jurzua
parents:
diff changeset
5744 curData = jQuery.data( dest, oldData );
jurzua
parents:
diff changeset
5745
jurzua
parents:
diff changeset
5746 // Switch to use the internal data object, if it exists, for the next
jurzua
parents:
diff changeset
5747 // stage of data copying
jurzua
parents:
diff changeset
5748 if ( (oldData = oldData[ internalKey ]) ) {
jurzua
parents:
diff changeset
5749 var events = oldData.events;
jurzua
parents:
diff changeset
5750 curData = curData[ internalKey ] = jQuery.extend({}, oldData);
jurzua
parents:
diff changeset
5751
jurzua
parents:
diff changeset
5752 if ( events ) {
jurzua
parents:
diff changeset
5753 delete curData.handle;
jurzua
parents:
diff changeset
5754 curData.events = {};
jurzua
parents:
diff changeset
5755
jurzua
parents:
diff changeset
5756 for ( var type in events ) {
jurzua
parents:
diff changeset
5757 for ( var i = 0, l = events[ type ].length; i < l; i++ ) {
jurzua
parents:
diff changeset
5758 jQuery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data );
jurzua
parents:
diff changeset
5759 }
jurzua
parents:
diff changeset
5760 }
jurzua
parents:
diff changeset
5761 }
jurzua
parents:
diff changeset
5762 }
jurzua
parents:
diff changeset
5763 }
jurzua
parents:
diff changeset
5764
jurzua
parents:
diff changeset
5765 function cloneFixAttributes( src, dest ) {
jurzua
parents:
diff changeset
5766 var nodeName;
jurzua
parents:
diff changeset
5767
jurzua
parents:
diff changeset
5768 // We do not need to do anything for non-Elements
jurzua
parents:
diff changeset
5769 if ( dest.nodeType !== 1 ) {
jurzua
parents:
diff changeset
5770 return;
jurzua
parents:
diff changeset
5771 }
jurzua
parents:
diff changeset
5772
jurzua
parents:
diff changeset
5773 // clearAttributes removes the attributes, which we don't want,
jurzua
parents:
diff changeset
5774 // but also removes the attachEvent events, which we *do* want
jurzua
parents:
diff changeset
5775 if ( dest.clearAttributes ) {
jurzua
parents:
diff changeset
5776 dest.clearAttributes();
jurzua
parents:
diff changeset
5777 }
jurzua
parents:
diff changeset
5778
jurzua
parents:
diff changeset
5779 // mergeAttributes, in contrast, only merges back on the
jurzua
parents:
diff changeset
5780 // original attributes, not the events
jurzua
parents:
diff changeset
5781 if ( dest.mergeAttributes ) {
jurzua
parents:
diff changeset
5782 dest.mergeAttributes( src );
jurzua
parents:
diff changeset
5783 }
jurzua
parents:
diff changeset
5784
jurzua
parents:
diff changeset
5785 nodeName = dest.nodeName.toLowerCase();
jurzua
parents:
diff changeset
5786
jurzua
parents:
diff changeset
5787 // IE6-8 fail to clone children inside object elements that use
jurzua
parents:
diff changeset
5788 // the proprietary classid attribute value (rather than the type
jurzua
parents:
diff changeset
5789 // attribute) to identify the type of content to display
jurzua
parents:
diff changeset
5790 if ( nodeName === "object" ) {
jurzua
parents:
diff changeset
5791 dest.outerHTML = src.outerHTML;
jurzua
parents:
diff changeset
5792
jurzua
parents:
diff changeset
5793 } else if ( nodeName === "input" && (src.type === "checkbox" || src.type === "radio") ) {
jurzua
parents:
diff changeset
5794 // IE6-8 fails to persist the checked state of a cloned checkbox
jurzua
parents:
diff changeset
5795 // or radio button. Worse, IE6-7 fail to give the cloned element
jurzua
parents:
diff changeset
5796 // a checked appearance if the defaultChecked value isn't also set
jurzua
parents:
diff changeset
5797 if ( src.checked ) {
jurzua
parents:
diff changeset
5798 dest.defaultChecked = dest.checked = src.checked;
jurzua
parents:
diff changeset
5799 }
jurzua
parents:
diff changeset
5800
jurzua
parents:
diff changeset
5801 // IE6-7 get confused and end up setting the value of a cloned
jurzua
parents:
diff changeset
5802 // checkbox/radio button to an empty string instead of "on"
jurzua
parents:
diff changeset
5803 if ( dest.value !== src.value ) {
jurzua
parents:
diff changeset
5804 dest.value = src.value;
jurzua
parents:
diff changeset
5805 }
jurzua
parents:
diff changeset
5806
jurzua
parents:
diff changeset
5807 // IE6-8 fails to return the selected option to the default selected
jurzua
parents:
diff changeset
5808 // state when cloning options
jurzua
parents:
diff changeset
5809 } else if ( nodeName === "option" ) {
jurzua
parents:
diff changeset
5810 dest.selected = src.defaultSelected;
jurzua
parents:
diff changeset
5811
jurzua
parents:
diff changeset
5812 // IE6-8 fails to set the defaultValue to the correct value when
jurzua
parents:
diff changeset
5813 // cloning other types of input fields
jurzua
parents:
diff changeset
5814 } else if ( nodeName === "input" || nodeName === "textarea" ) {
jurzua
parents:
diff changeset
5815 dest.defaultValue = src.defaultValue;
jurzua
parents:
diff changeset
5816 }
jurzua
parents:
diff changeset
5817
jurzua
parents:
diff changeset
5818 // Event data gets referenced instead of copied if the expando
jurzua
parents:
diff changeset
5819 // gets copied too
jurzua
parents:
diff changeset
5820 dest.removeAttribute( jQuery.expando );
jurzua
parents:
diff changeset
5821 }
jurzua
parents:
diff changeset
5822
jurzua
parents:
diff changeset
5823 jQuery.buildFragment = function( args, nodes, scripts ) {
jurzua
parents:
diff changeset
5824 var fragment, cacheable, cacheresults,
jurzua
parents:
diff changeset
5825 doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document);
jurzua
parents:
diff changeset
5826
jurzua
parents:
diff changeset
5827 // Only cache "small" (1/2 KB) HTML strings that are associated with the main document
jurzua
parents:
diff changeset
5828 // Cloning options loses the selected state, so don't cache them
jurzua
parents:
diff changeset
5829 // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
jurzua
parents:
diff changeset
5830 // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
jurzua
parents:
diff changeset
5831 if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
jurzua
parents:
diff changeset
5832 args[0].charAt(0) === "<" && !rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
jurzua
parents:
diff changeset
5833
jurzua
parents:
diff changeset
5834 cacheable = true;
jurzua
parents:
diff changeset
5835
jurzua
parents:
diff changeset
5836 cacheresults = jQuery.fragments[ args[0] ];
jurzua
parents:
diff changeset
5837 if ( cacheresults && cacheresults !== 1 ) {
jurzua
parents:
diff changeset
5838 fragment = cacheresults;
jurzua
parents:
diff changeset
5839 }
jurzua
parents:
diff changeset
5840 }
jurzua
parents:
diff changeset
5841
jurzua
parents:
diff changeset
5842 if ( !fragment ) {
jurzua
parents:
diff changeset
5843 fragment = doc.createDocumentFragment();
jurzua
parents:
diff changeset
5844 jQuery.clean( args, doc, fragment, scripts );
jurzua
parents:
diff changeset
5845 }
jurzua
parents:
diff changeset
5846
jurzua
parents:
diff changeset
5847 if ( cacheable ) {
jurzua
parents:
diff changeset
5848 jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
jurzua
parents:
diff changeset
5849 }
jurzua
parents:
diff changeset
5850
jurzua
parents:
diff changeset
5851 return { fragment: fragment, cacheable: cacheable };
jurzua
parents:
diff changeset
5852 };
jurzua
parents:
diff changeset
5853
jurzua
parents:
diff changeset
5854 jQuery.fragments = {};
jurzua
parents:
diff changeset
5855
jurzua
parents:
diff changeset
5856 jQuery.each({
jurzua
parents:
diff changeset
5857 appendTo: "append",
jurzua
parents:
diff changeset
5858 prependTo: "prepend",
jurzua
parents:
diff changeset
5859 insertBefore: "before",
jurzua
parents:
diff changeset
5860 insertAfter: "after",
jurzua
parents:
diff changeset
5861 replaceAll: "replaceWith"
jurzua
parents:
diff changeset
5862 }, function( name, original ) {
jurzua
parents:
diff changeset
5863 jQuery.fn[ name ] = function( selector ) {
jurzua
parents:
diff changeset
5864 var ret = [],
jurzua
parents:
diff changeset
5865 insert = jQuery( selector ),
jurzua
parents:
diff changeset
5866 parent = this.length === 1 && this[0].parentNode;
jurzua
parents:
diff changeset
5867
jurzua
parents:
diff changeset
5868 if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
jurzua
parents:
diff changeset
5869 insert[ original ]( this[0] );
jurzua
parents:
diff changeset
5870 return this;
jurzua
parents:
diff changeset
5871
jurzua
parents:
diff changeset
5872 } else {
jurzua
parents:
diff changeset
5873 for ( var i = 0, l = insert.length; i < l; i++ ) {
jurzua
parents:
diff changeset
5874 var elems = (i > 0 ? this.clone(true) : this).get();
jurzua
parents:
diff changeset
5875 jQuery( insert[i] )[ original ]( elems );
jurzua
parents:
diff changeset
5876 ret = ret.concat( elems );
jurzua
parents:
diff changeset
5877 }
jurzua
parents:
diff changeset
5878
jurzua
parents:
diff changeset
5879 return this.pushStack( ret, name, insert.selector );
jurzua
parents:
diff changeset
5880 }
jurzua
parents:
diff changeset
5881 };
jurzua
parents:
diff changeset
5882 });
jurzua
parents:
diff changeset
5883
jurzua
parents:
diff changeset
5884 function getAll( elem ) {
jurzua
parents:
diff changeset
5885 if ( "getElementsByTagName" in elem ) {
jurzua
parents:
diff changeset
5886 return elem.getElementsByTagName( "*" );
jurzua
parents:
diff changeset
5887
jurzua
parents:
diff changeset
5888 } else if ( "querySelectorAll" in elem ) {
jurzua
parents:
diff changeset
5889 return elem.querySelectorAll( "*" );
jurzua
parents:
diff changeset
5890
jurzua
parents:
diff changeset
5891 } else {
jurzua
parents:
diff changeset
5892 return [];
jurzua
parents:
diff changeset
5893 }
jurzua
parents:
diff changeset
5894 }
jurzua
parents:
diff changeset
5895
jurzua
parents:
diff changeset
5896 // Used in clean, fixes the defaultChecked property
jurzua
parents:
diff changeset
5897 function fixDefaultChecked( elem ) {
jurzua
parents:
diff changeset
5898 if ( elem.type === "checkbox" || elem.type === "radio" ) {
jurzua
parents:
diff changeset
5899 elem.defaultChecked = elem.checked;
jurzua
parents:
diff changeset
5900 }
jurzua
parents:
diff changeset
5901 }
jurzua
parents:
diff changeset
5902 // Finds all inputs and passes them to fixDefaultChecked
jurzua
parents:
diff changeset
5903 function findInputs( elem ) {
jurzua
parents:
diff changeset
5904 if ( jQuery.nodeName( elem, "input" ) ) {
jurzua
parents:
diff changeset
5905 fixDefaultChecked( elem );
jurzua
parents:
diff changeset
5906 } else if ( elem.getElementsByTagName ) {
jurzua
parents:
diff changeset
5907 jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked );
jurzua
parents:
diff changeset
5908 }
jurzua
parents:
diff changeset
5909 }
jurzua
parents:
diff changeset
5910
jurzua
parents:
diff changeset
5911 jQuery.extend({
jurzua
parents:
diff changeset
5912 clone: function( elem, dataAndEvents, deepDataAndEvents ) {
jurzua
parents:
diff changeset
5913 var clone = elem.cloneNode(true),
jurzua
parents:
diff changeset
5914 srcElements,
jurzua
parents:
diff changeset
5915 destElements,
jurzua
parents:
diff changeset
5916 i;
jurzua
parents:
diff changeset
5917
jurzua
parents:
diff changeset
5918 if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
jurzua
parents:
diff changeset
5919 (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
jurzua
parents:
diff changeset
5920 // IE copies events bound via attachEvent when using cloneNode.
jurzua
parents:
diff changeset
5921 // Calling detachEvent on the clone will also remove the events
jurzua
parents:
diff changeset
5922 // from the original. In order to get around this, we use some
jurzua
parents:
diff changeset
5923 // proprietary methods to clear the events. Thanks to MooTools
jurzua
parents:
diff changeset
5924 // guys for this hotness.
jurzua
parents:
diff changeset
5925
jurzua
parents:
diff changeset
5926 cloneFixAttributes( elem, clone );
jurzua
parents:
diff changeset
5927
jurzua
parents:
diff changeset
5928 // Using Sizzle here is crazy slow, so we use getElementsByTagName
jurzua
parents:
diff changeset
5929 // instead
jurzua
parents:
diff changeset
5930 srcElements = getAll( elem );
jurzua
parents:
diff changeset
5931 destElements = getAll( clone );
jurzua
parents:
diff changeset
5932
jurzua
parents:
diff changeset
5933 // Weird iteration because IE will replace the length property
jurzua
parents:
diff changeset
5934 // with an element if you are cloning the body and one of the
jurzua
parents:
diff changeset
5935 // elements on the page has a name or id of "length"
jurzua
parents:
diff changeset
5936 for ( i = 0; srcElements[i]; ++i ) {
jurzua
parents:
diff changeset
5937 cloneFixAttributes( srcElements[i], destElements[i] );
jurzua
parents:
diff changeset
5938 }
jurzua
parents:
diff changeset
5939 }
jurzua
parents:
diff changeset
5940
jurzua
parents:
diff changeset
5941 // Copy the events from the original to the clone
jurzua
parents:
diff changeset
5942 if ( dataAndEvents ) {
jurzua
parents:
diff changeset
5943 cloneCopyEvent( elem, clone );
jurzua
parents:
diff changeset
5944
jurzua
parents:
diff changeset
5945 if ( deepDataAndEvents ) {
jurzua
parents:
diff changeset
5946 srcElements = getAll( elem );
jurzua
parents:
diff changeset
5947 destElements = getAll( clone );
jurzua
parents:
diff changeset
5948
jurzua
parents:
diff changeset
5949 for ( i = 0; srcElements[i]; ++i ) {
jurzua
parents:
diff changeset
5950 cloneCopyEvent( srcElements[i], destElements[i] );
jurzua
parents:
diff changeset
5951 }
jurzua
parents:
diff changeset
5952 }
jurzua
parents:
diff changeset
5953 }
jurzua
parents:
diff changeset
5954
jurzua
parents:
diff changeset
5955 // Return the cloned set
jurzua
parents:
diff changeset
5956 return clone;
jurzua
parents:
diff changeset
5957 },
jurzua
parents:
diff changeset
5958
jurzua
parents:
diff changeset
5959 clean: function( elems, context, fragment, scripts ) {
jurzua
parents:
diff changeset
5960 var checkScriptType;
jurzua
parents:
diff changeset
5961
jurzua
parents:
diff changeset
5962 context = context || document;
jurzua
parents:
diff changeset
5963
jurzua
parents:
diff changeset
5964 // !context.createElement fails in IE with an error but returns typeof 'object'
jurzua
parents:
diff changeset
5965 if ( typeof context.createElement === "undefined" ) {
jurzua
parents:
diff changeset
5966 context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
jurzua
parents:
diff changeset
5967 }
jurzua
parents:
diff changeset
5968
jurzua
parents:
diff changeset
5969 var ret = [];
jurzua
parents:
diff changeset
5970
jurzua
parents:
diff changeset
5971 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
jurzua
parents:
diff changeset
5972 if ( typeof elem === "number" ) {
jurzua
parents:
diff changeset
5973 elem += "";
jurzua
parents:
diff changeset
5974 }
jurzua
parents:
diff changeset
5975
jurzua
parents:
diff changeset
5976 if ( !elem ) {
jurzua
parents:
diff changeset
5977 continue;
jurzua
parents:
diff changeset
5978 }
jurzua
parents:
diff changeset
5979
jurzua
parents:
diff changeset
5980 // Convert html string into DOM nodes
jurzua
parents:
diff changeset
5981 if ( typeof elem === "string" ) {
jurzua
parents:
diff changeset
5982 if ( !rhtml.test( elem ) ) {
jurzua
parents:
diff changeset
5983 elem = context.createTextNode( elem );
jurzua
parents:
diff changeset
5984 } else {
jurzua
parents:
diff changeset
5985 // Fix "XHTML"-style tags in all browsers
jurzua
parents:
diff changeset
5986 elem = elem.replace(rxhtmlTag, "<$1></$2>");
jurzua
parents:
diff changeset
5987
jurzua
parents:
diff changeset
5988 // Trim whitespace, otherwise indexOf won't work as expected
jurzua
parents:
diff changeset
5989 var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
jurzua
parents:
diff changeset
5990 wrap = wrapMap[ tag ] || wrapMap._default,
jurzua
parents:
diff changeset
5991 depth = wrap[0],
jurzua
parents:
diff changeset
5992 div = context.createElement("div");
jurzua
parents:
diff changeset
5993
jurzua
parents:
diff changeset
5994 // Go to html and back, then peel off extra wrappers
jurzua
parents:
diff changeset
5995 div.innerHTML = wrap[1] + elem + wrap[2];
jurzua
parents:
diff changeset
5996
jurzua
parents:
diff changeset
5997 // Move to the right depth
jurzua
parents:
diff changeset
5998 while ( depth-- ) {
jurzua
parents:
diff changeset
5999 div = div.lastChild;
jurzua
parents:
diff changeset
6000 }
jurzua
parents:
diff changeset
6001
jurzua
parents:
diff changeset
6002 // Remove IE's autoinserted <tbody> from table fragments
jurzua
parents:
diff changeset
6003 if ( !jQuery.support.tbody ) {
jurzua
parents:
diff changeset
6004
jurzua
parents:
diff changeset
6005 // String was a <table>, *may* have spurious <tbody>
jurzua
parents:
diff changeset
6006 var hasBody = rtbody.test(elem),
jurzua
parents:
diff changeset
6007 tbody = tag === "table" && !hasBody ?
jurzua
parents:
diff changeset
6008 div.firstChild && div.firstChild.childNodes :
jurzua
parents:
diff changeset
6009
jurzua
parents:
diff changeset
6010 // String was a bare <thead> or <tfoot>
jurzua
parents:
diff changeset
6011 wrap[1] === "<table>" && !hasBody ?
jurzua
parents:
diff changeset
6012 div.childNodes :
jurzua
parents:
diff changeset
6013 [];
jurzua
parents:
diff changeset
6014
jurzua
parents:
diff changeset
6015 for ( var j = tbody.length - 1; j >= 0 ; --j ) {
jurzua
parents:
diff changeset
6016 if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
jurzua
parents:
diff changeset
6017 tbody[ j ].parentNode.removeChild( tbody[ j ] );
jurzua
parents:
diff changeset
6018 }
jurzua
parents:
diff changeset
6019 }
jurzua
parents:
diff changeset
6020 }
jurzua
parents:
diff changeset
6021
jurzua
parents:
diff changeset
6022 // IE completely kills leading whitespace when innerHTML is used
jurzua
parents:
diff changeset
6023 if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
jurzua
parents:
diff changeset
6024 div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
jurzua
parents:
diff changeset
6025 }
jurzua
parents:
diff changeset
6026
jurzua
parents:
diff changeset
6027 elem = div.childNodes;
jurzua
parents:
diff changeset
6028 }
jurzua
parents:
diff changeset
6029 }
jurzua
parents:
diff changeset
6030
jurzua
parents:
diff changeset
6031 // Resets defaultChecked for any radios and checkboxes
jurzua
parents:
diff changeset
6032 // about to be appended to the DOM in IE 6/7 (#8060)
jurzua
parents:
diff changeset
6033 var len;
jurzua
parents:
diff changeset
6034 if ( !jQuery.support.appendChecked ) {
jurzua
parents:
diff changeset
6035 if ( elem[0] && typeof (len = elem.length) === "number" ) {
jurzua
parents:
diff changeset
6036 for ( i = 0; i < len; i++ ) {
jurzua
parents:
diff changeset
6037 findInputs( elem[i] );
jurzua
parents:
diff changeset
6038 }
jurzua
parents:
diff changeset
6039 } else {
jurzua
parents:
diff changeset
6040 findInputs( elem );
jurzua
parents:
diff changeset
6041 }
jurzua
parents:
diff changeset
6042 }
jurzua
parents:
diff changeset
6043
jurzua
parents:
diff changeset
6044 if ( elem.nodeType ) {
jurzua
parents:
diff changeset
6045 ret.push( elem );
jurzua
parents:
diff changeset
6046 } else {
jurzua
parents:
diff changeset
6047 ret = jQuery.merge( ret, elem );
jurzua
parents:
diff changeset
6048 }
jurzua
parents:
diff changeset
6049 }
jurzua
parents:
diff changeset
6050
jurzua
parents:
diff changeset
6051 if ( fragment ) {
jurzua
parents:
diff changeset
6052 checkScriptType = function( elem ) {
jurzua
parents:
diff changeset
6053 return !elem.type || rscriptType.test( elem.type );
jurzua
parents:
diff changeset
6054 };
jurzua
parents:
diff changeset
6055 for ( i = 0; ret[i]; i++ ) {
jurzua
parents:
diff changeset
6056 if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
jurzua
parents:
diff changeset
6057 scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
jurzua
parents:
diff changeset
6058
jurzua
parents:
diff changeset
6059 } else {
jurzua
parents:
diff changeset
6060 if ( ret[i].nodeType === 1 ) {
jurzua
parents:
diff changeset
6061 var jsTags = jQuery.grep( ret[i].getElementsByTagName( "script" ), checkScriptType );
jurzua
parents:
diff changeset
6062
jurzua
parents:
diff changeset
6063 ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
jurzua
parents:
diff changeset
6064 }
jurzua
parents:
diff changeset
6065 fragment.appendChild( ret[i] );
jurzua
parents:
diff changeset
6066 }
jurzua
parents:
diff changeset
6067 }
jurzua
parents:
diff changeset
6068 }
jurzua
parents:
diff changeset
6069
jurzua
parents:
diff changeset
6070 return ret;
jurzua
parents:
diff changeset
6071 },
jurzua
parents:
diff changeset
6072
jurzua
parents:
diff changeset
6073 cleanData: function( elems ) {
jurzua
parents:
diff changeset
6074 var data, id, cache = jQuery.cache, internalKey = jQuery.expando, special = jQuery.event.special,
jurzua
parents:
diff changeset
6075 deleteExpando = jQuery.support.deleteExpando;
jurzua
parents:
diff changeset
6076
jurzua
parents:
diff changeset
6077 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
jurzua
parents:
diff changeset
6078 if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
jurzua
parents:
diff changeset
6079 continue;
jurzua
parents:
diff changeset
6080 }
jurzua
parents:
diff changeset
6081
jurzua
parents:
diff changeset
6082 id = elem[ jQuery.expando ];
jurzua
parents:
diff changeset
6083
jurzua
parents:
diff changeset
6084 if ( id ) {
jurzua
parents:
diff changeset
6085 data = cache[ id ] && cache[ id ][ internalKey ];
jurzua
parents:
diff changeset
6086
jurzua
parents:
diff changeset
6087 if ( data && data.events ) {
jurzua
parents:
diff changeset
6088 for ( var type in data.events ) {
jurzua
parents:
diff changeset
6089 if ( special[ type ] ) {
jurzua
parents:
diff changeset
6090 jQuery.event.remove( elem, type );
jurzua
parents:
diff changeset
6091
jurzua
parents:
diff changeset
6092 // This is a shortcut to avoid jQuery.event.remove's overhead
jurzua
parents:
diff changeset
6093 } else {
jurzua
parents:
diff changeset
6094 jQuery.removeEvent( elem, type, data.handle );
jurzua
parents:
diff changeset
6095 }
jurzua
parents:
diff changeset
6096 }
jurzua
parents:
diff changeset
6097
jurzua
parents:
diff changeset
6098 // Null the DOM reference to avoid IE6/7/8 leak (#7054)
jurzua
parents:
diff changeset
6099 if ( data.handle ) {
jurzua
parents:
diff changeset
6100 data.handle.elem = null;
jurzua
parents:
diff changeset
6101 }
jurzua
parents:
diff changeset
6102 }
jurzua
parents:
diff changeset
6103
jurzua
parents:
diff changeset
6104 if ( deleteExpando ) {
jurzua
parents:
diff changeset
6105 delete elem[ jQuery.expando ];
jurzua
parents:
diff changeset
6106
jurzua
parents:
diff changeset
6107 } else if ( elem.removeAttribute ) {
jurzua
parents:
diff changeset
6108 elem.removeAttribute( jQuery.expando );
jurzua
parents:
diff changeset
6109 }
jurzua
parents:
diff changeset
6110
jurzua
parents:
diff changeset
6111 delete cache[ id ];
jurzua
parents:
diff changeset
6112 }
jurzua
parents:
diff changeset
6113 }
jurzua
parents:
diff changeset
6114 }
jurzua
parents:
diff changeset
6115 });
jurzua
parents:
diff changeset
6116
jurzua
parents:
diff changeset
6117 function evalScript( i, elem ) {
jurzua
parents:
diff changeset
6118 if ( elem.src ) {
jurzua
parents:
diff changeset
6119 jQuery.ajax({
jurzua
parents:
diff changeset
6120 url: elem.src,
jurzua
parents:
diff changeset
6121 async: false,
jurzua
parents:
diff changeset
6122 dataType: "script"
jurzua
parents:
diff changeset
6123 });
jurzua
parents:
diff changeset
6124 } else {
jurzua
parents:
diff changeset
6125 jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
jurzua
parents:
diff changeset
6126 }
jurzua
parents:
diff changeset
6127
jurzua
parents:
diff changeset
6128 if ( elem.parentNode ) {
jurzua
parents:
diff changeset
6129 elem.parentNode.removeChild( elem );
jurzua
parents:
diff changeset
6130 }
jurzua
parents:
diff changeset
6131 }
jurzua
parents:
diff changeset
6132
jurzua
parents:
diff changeset
6133
jurzua
parents:
diff changeset
6134
jurzua
parents:
diff changeset
6135
jurzua
parents:
diff changeset
6136 var ralpha = /alpha\([^)]*\)/i,
jurzua
parents:
diff changeset
6137 ropacity = /opacity=([^)]*)/,
jurzua
parents:
diff changeset
6138 rdashAlpha = /-([a-z])/ig,
jurzua
parents:
diff changeset
6139 // fixed for IE9, see #8346
jurzua
parents:
diff changeset
6140 rupper = /([A-Z]|^ms)/g,
jurzua
parents:
diff changeset
6141 rnumpx = /^-?\d+(?:px)?$/i,
jurzua
parents:
diff changeset
6142 rnum = /^-?\d/,
jurzua
parents:
diff changeset
6143 rrelNum = /^[+\-]=/,
jurzua
parents:
diff changeset
6144 rrelNumFilter = /[^+\-\.\de]+/g,
jurzua
parents:
diff changeset
6145
jurzua
parents:
diff changeset
6146 cssShow = { position: "absolute", visibility: "hidden", display: "block" },
jurzua
parents:
diff changeset
6147 cssWidth = [ "Left", "Right" ],
jurzua
parents:
diff changeset
6148 cssHeight = [ "Top", "Bottom" ],
jurzua
parents:
diff changeset
6149 curCSS,
jurzua
parents:
diff changeset
6150
jurzua
parents:
diff changeset
6151 getComputedStyle,
jurzua
parents:
diff changeset
6152 currentStyle,
jurzua
parents:
diff changeset
6153
jurzua
parents:
diff changeset
6154 fcamelCase = function( all, letter ) {
jurzua
parents:
diff changeset
6155 return letter.toUpperCase();
jurzua
parents:
diff changeset
6156 };
jurzua
parents:
diff changeset
6157
jurzua
parents:
diff changeset
6158 jQuery.fn.css = function( name, value ) {
jurzua
parents:
diff changeset
6159 // Setting 'undefined' is a no-op
jurzua
parents:
diff changeset
6160 if ( arguments.length === 2 && value === undefined ) {
jurzua
parents:
diff changeset
6161 return this;
jurzua
parents:
diff changeset
6162 }
jurzua
parents:
diff changeset
6163
jurzua
parents:
diff changeset
6164 return jQuery.access( this, name, value, true, function( elem, name, value ) {
jurzua
parents:
diff changeset
6165 return value !== undefined ?
jurzua
parents:
diff changeset
6166 jQuery.style( elem, name, value ) :
jurzua
parents:
diff changeset
6167 jQuery.css( elem, name );
jurzua
parents:
diff changeset
6168 });
jurzua
parents:
diff changeset
6169 };
jurzua
parents:
diff changeset
6170
jurzua
parents:
diff changeset
6171 jQuery.extend({
jurzua
parents:
diff changeset
6172 // Add in style property hooks for overriding the default
jurzua
parents:
diff changeset
6173 // behavior of getting and setting a style property
jurzua
parents:
diff changeset
6174 cssHooks: {
jurzua
parents:
diff changeset
6175 opacity: {
jurzua
parents:
diff changeset
6176 get: function( elem, computed ) {
jurzua
parents:
diff changeset
6177 if ( computed ) {
jurzua
parents:
diff changeset
6178 // We should always get a number back from opacity
jurzua
parents:
diff changeset
6179 var ret = curCSS( elem, "opacity", "opacity" );
jurzua
parents:
diff changeset
6180 return ret === "" ? "1" : ret;
jurzua
parents:
diff changeset
6181
jurzua
parents:
diff changeset
6182 } else {
jurzua
parents:
diff changeset
6183 return elem.style.opacity;
jurzua
parents:
diff changeset
6184 }
jurzua
parents:
diff changeset
6185 }
jurzua
parents:
diff changeset
6186 }
jurzua
parents:
diff changeset
6187 },
jurzua
parents:
diff changeset
6188
jurzua
parents:
diff changeset
6189 // Exclude the following css properties to add px
jurzua
parents:
diff changeset
6190 cssNumber: {
jurzua
parents:
diff changeset
6191 "zIndex": true,
jurzua
parents:
diff changeset
6192 "fontWeight": true,
jurzua
parents:
diff changeset
6193 "opacity": true,
jurzua
parents:
diff changeset
6194 "zoom": true,
jurzua
parents:
diff changeset
6195 "lineHeight": true,
jurzua
parents:
diff changeset
6196 "widows": true,
jurzua
parents:
diff changeset
6197 "orphans": true
jurzua
parents:
diff changeset
6198 },
jurzua
parents:
diff changeset
6199
jurzua
parents:
diff changeset
6200 // Add in properties whose names you wish to fix before
jurzua
parents:
diff changeset
6201 // setting or getting the value
jurzua
parents:
diff changeset
6202 cssProps: {
jurzua
parents:
diff changeset
6203 // normalize float css property
jurzua
parents:
diff changeset
6204 "float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
jurzua
parents:
diff changeset
6205 },
jurzua
parents:
diff changeset
6206
jurzua
parents:
diff changeset
6207 // Get and set the style property on a DOM Node
jurzua
parents:
diff changeset
6208 style: function( elem, name, value, extra ) {
jurzua
parents:
diff changeset
6209 // Don't set styles on text and comment nodes
jurzua
parents:
diff changeset
6210 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
jurzua
parents:
diff changeset
6211 return;
jurzua
parents:
diff changeset
6212 }
jurzua
parents:
diff changeset
6213
jurzua
parents:
diff changeset
6214 // Make sure that we're working with the right name
jurzua
parents:
diff changeset
6215 var ret, type, origName = jQuery.camelCase( name ),
jurzua
parents:
diff changeset
6216 style = elem.style, hooks = jQuery.cssHooks[ origName ];
jurzua
parents:
diff changeset
6217
jurzua
parents:
diff changeset
6218 name = jQuery.cssProps[ origName ] || origName;
jurzua
parents:
diff changeset
6219
jurzua
parents:
diff changeset
6220 // Check if we're setting a value
jurzua
parents:
diff changeset
6221 if ( value !== undefined ) {
jurzua
parents:
diff changeset
6222 type = typeof value;
jurzua
parents:
diff changeset
6223
jurzua
parents:
diff changeset
6224 // Make sure that NaN and null values aren't set. See: #7116
jurzua
parents:
diff changeset
6225 if ( type === "number" && isNaN( value ) || value == null ) {
jurzua
parents:
diff changeset
6226 return;
jurzua
parents:
diff changeset
6227 }
jurzua
parents:
diff changeset
6228
jurzua
parents:
diff changeset
6229 // convert relative number strings (+= or -=) to relative numbers. #7345
jurzua
parents:
diff changeset
6230 if ( type === "string" && rrelNum.test( value ) ) {
jurzua
parents:
diff changeset
6231 value = +value.replace( rrelNumFilter, "" ) + parseFloat( jQuery.css( elem, name ) );
jurzua
parents:
diff changeset
6232 }
jurzua
parents:
diff changeset
6233
jurzua
parents:
diff changeset
6234 // If a number was passed in, add 'px' to the (except for certain CSS properties)
jurzua
parents:
diff changeset
6235 if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
jurzua
parents:
diff changeset
6236 value += "px";
jurzua
parents:
diff changeset
6237 }
jurzua
parents:
diff changeset
6238
jurzua
parents:
diff changeset
6239 // If a hook was provided, use that value, otherwise just set the specified value
jurzua
parents:
diff changeset
6240 if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
jurzua
parents:
diff changeset
6241 // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
jurzua
parents:
diff changeset
6242 // Fixes bug #5509
jurzua
parents:
diff changeset
6243 try {
jurzua
parents:
diff changeset
6244 style[ name ] = value;
jurzua
parents:
diff changeset
6245 } catch(e) {}
jurzua
parents:
diff changeset
6246 }
jurzua
parents:
diff changeset
6247
jurzua
parents:
diff changeset
6248 } else {
jurzua
parents:
diff changeset
6249 // If a hook was provided get the non-computed value from there
jurzua
parents:
diff changeset
6250 if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
jurzua
parents:
diff changeset
6251 return ret;
jurzua
parents:
diff changeset
6252 }
jurzua
parents:
diff changeset
6253
jurzua
parents:
diff changeset
6254 // Otherwise just get the value from the style object
jurzua
parents:
diff changeset
6255 return style[ name ];
jurzua
parents:
diff changeset
6256 }
jurzua
parents:
diff changeset
6257 },
jurzua
parents:
diff changeset
6258
jurzua
parents:
diff changeset
6259 css: function( elem, name, extra ) {
jurzua
parents:
diff changeset
6260 var ret, hooks;
jurzua
parents:
diff changeset
6261
jurzua
parents:
diff changeset
6262 // Make sure that we're working with the right name
jurzua
parents:
diff changeset
6263 name = jQuery.camelCase( name );
jurzua
parents:
diff changeset
6264 hooks = jQuery.cssHooks[ name ];
jurzua
parents:
diff changeset
6265 name = jQuery.cssProps[ name ] || name;
jurzua
parents:
diff changeset
6266
jurzua
parents:
diff changeset
6267 // cssFloat needs a special treatment
jurzua
parents:
diff changeset
6268 if ( name === "cssFloat" ) {
jurzua
parents:
diff changeset
6269 name = "float";
jurzua
parents:
diff changeset
6270 }
jurzua
parents:
diff changeset
6271
jurzua
parents:
diff changeset
6272 // If a hook was provided get the computed value from there
jurzua
parents:
diff changeset
6273 if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
jurzua
parents:
diff changeset
6274 return ret;
jurzua
parents:
diff changeset
6275
jurzua
parents:
diff changeset
6276 // Otherwise, if a way to get the computed value exists, use that
jurzua
parents:
diff changeset
6277 } else if ( curCSS ) {
jurzua
parents:
diff changeset
6278 return curCSS( elem, name );
jurzua
parents:
diff changeset
6279 }
jurzua
parents:
diff changeset
6280 },
jurzua
parents:
diff changeset
6281
jurzua
parents:
diff changeset
6282 // A method for quickly swapping in/out CSS properties to get correct calculations
jurzua
parents:
diff changeset
6283 swap: function( elem, options, callback ) {
jurzua
parents:
diff changeset
6284 var old = {};
jurzua
parents:
diff changeset
6285
jurzua
parents:
diff changeset
6286 // Remember the old values, and insert the new ones
jurzua
parents:
diff changeset
6287 for ( var name in options ) {
jurzua
parents:
diff changeset
6288 old[ name ] = elem.style[ name ];
jurzua
parents:
diff changeset
6289 elem.style[ name ] = options[ name ];
jurzua
parents:
diff changeset
6290 }
jurzua
parents:
diff changeset
6291
jurzua
parents:
diff changeset
6292 callback.call( elem );
jurzua
parents:
diff changeset
6293
jurzua
parents:
diff changeset
6294 // Revert the old values
jurzua
parents:
diff changeset
6295 for ( name in options ) {
jurzua
parents:
diff changeset
6296 elem.style[ name ] = old[ name ];
jurzua
parents:
diff changeset
6297 }
jurzua
parents:
diff changeset
6298 },
jurzua
parents:
diff changeset
6299
jurzua
parents:
diff changeset
6300 camelCase: function( string ) {
jurzua
parents:
diff changeset
6301 return string.replace( rdashAlpha, fcamelCase );
jurzua
parents:
diff changeset
6302 }
jurzua
parents:
diff changeset
6303 });
jurzua
parents:
diff changeset
6304
jurzua
parents:
diff changeset
6305 // DEPRECATED, Use jQuery.css() instead
jurzua
parents:
diff changeset
6306 jQuery.curCSS = jQuery.css;
jurzua
parents:
diff changeset
6307
jurzua
parents:
diff changeset
6308 jQuery.each(["height", "width"], function( i, name ) {
jurzua
parents:
diff changeset
6309 jQuery.cssHooks[ name ] = {
jurzua
parents:
diff changeset
6310 get: function( elem, computed, extra ) {
jurzua
parents:
diff changeset
6311 var val;
jurzua
parents:
diff changeset
6312
jurzua
parents:
diff changeset
6313 if ( computed ) {
jurzua
parents:
diff changeset
6314 if ( elem.offsetWidth !== 0 ) {
jurzua
parents:
diff changeset
6315 val = getWH( elem, name, extra );
jurzua
parents:
diff changeset
6316
jurzua
parents:
diff changeset
6317 } else {
jurzua
parents:
diff changeset
6318 jQuery.swap( elem, cssShow, function() {
jurzua
parents:
diff changeset
6319 val = getWH( elem, name, extra );
jurzua
parents:
diff changeset
6320 });
jurzua
parents:
diff changeset
6321 }
jurzua
parents:
diff changeset
6322
jurzua
parents:
diff changeset
6323 if ( val <= 0 ) {
jurzua
parents:
diff changeset
6324 val = curCSS( elem, name, name );
jurzua
parents:
diff changeset
6325
jurzua
parents:
diff changeset
6326 if ( val === "0px" && currentStyle ) {
jurzua
parents:
diff changeset
6327 val = currentStyle( elem, name, name );
jurzua
parents:
diff changeset
6328 }
jurzua
parents:
diff changeset
6329
jurzua
parents:
diff changeset
6330 if ( val != null ) {
jurzua
parents:
diff changeset
6331 // Should return "auto" instead of 0, use 0 for
jurzua
parents:
diff changeset
6332 // temporary backwards-compat
jurzua
parents:
diff changeset
6333 return val === "" || val === "auto" ? "0px" : val;
jurzua
parents:
diff changeset
6334 }
jurzua
parents:
diff changeset
6335 }
jurzua
parents:
diff changeset
6336
jurzua
parents:
diff changeset
6337 if ( val < 0 || val == null ) {
jurzua
parents:
diff changeset
6338 val = elem.style[ name ];
jurzua
parents:
diff changeset
6339
jurzua
parents:
diff changeset
6340 // Should return "auto" instead of 0, use 0 for
jurzua
parents:
diff changeset
6341 // temporary backwards-compat
jurzua
parents:
diff changeset
6342 return val === "" || val === "auto" ? "0px" : val;
jurzua
parents:
diff changeset
6343 }
jurzua
parents:
diff changeset
6344
jurzua
parents:
diff changeset
6345 return typeof val === "string" ? val : val + "px";
jurzua
parents:
diff changeset
6346 }
jurzua
parents:
diff changeset
6347 },
jurzua
parents:
diff changeset
6348
jurzua
parents:
diff changeset
6349 set: function( elem, value ) {
jurzua
parents:
diff changeset
6350 if ( rnumpx.test( value ) ) {
jurzua
parents:
diff changeset
6351 // ignore negative width and height values #1599
jurzua
parents:
diff changeset
6352 value = parseFloat(value);
jurzua
parents:
diff changeset
6353
jurzua
parents:
diff changeset
6354 if ( value >= 0 ) {
jurzua
parents:
diff changeset
6355 return value + "px";
jurzua
parents:
diff changeset
6356 }
jurzua
parents:
diff changeset
6357
jurzua
parents:
diff changeset
6358 } else {
jurzua
parents:
diff changeset
6359 return value;
jurzua
parents:
diff changeset
6360 }
jurzua
parents:
diff changeset
6361 }
jurzua
parents:
diff changeset
6362 };
jurzua
parents:
diff changeset
6363 });
jurzua
parents:
diff changeset
6364
jurzua
parents:
diff changeset
6365 if ( !jQuery.support.opacity ) {
jurzua
parents:
diff changeset
6366 jQuery.cssHooks.opacity = {
jurzua
parents:
diff changeset
6367 get: function( elem, computed ) {
jurzua
parents:
diff changeset
6368 // IE uses filters for opacity
jurzua
parents:
diff changeset
6369 return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
jurzua
parents:
diff changeset
6370 ( parseFloat( RegExp.$1 ) / 100 ) + "" :
jurzua
parents:
diff changeset
6371 computed ? "1" : "";
jurzua
parents:
diff changeset
6372 },
jurzua
parents:
diff changeset
6373
jurzua
parents:
diff changeset
6374 set: function( elem, value ) {
jurzua
parents:
diff changeset
6375 var style = elem.style,
jurzua
parents:
diff changeset
6376 currentStyle = elem.currentStyle;
jurzua
parents:
diff changeset
6377
jurzua
parents:
diff changeset
6378 // IE has trouble with opacity if it does not have layout
jurzua
parents:
diff changeset
6379 // Force it by setting the zoom level
jurzua
parents:
diff changeset
6380 style.zoom = 1;
jurzua
parents:
diff changeset
6381
jurzua
parents:
diff changeset
6382 // Set the alpha filter to set the opacity
jurzua
parents:
diff changeset
6383 var opacity = jQuery.isNaN( value ) ?
jurzua
parents:
diff changeset
6384 "" :
jurzua
parents:
diff changeset
6385 "alpha(opacity=" + value * 100 + ")",
jurzua
parents:
diff changeset
6386 filter = currentStyle && currentStyle.filter || style.filter || "";
jurzua
parents:
diff changeset
6387
jurzua
parents:
diff changeset
6388 style.filter = ralpha.test( filter ) ?
jurzua
parents:
diff changeset
6389 filter.replace( ralpha, opacity ) :
jurzua
parents:
diff changeset
6390 filter + " " + opacity;
jurzua
parents:
diff changeset
6391 }
jurzua
parents:
diff changeset
6392 };
jurzua
parents:
diff changeset
6393 }
jurzua
parents:
diff changeset
6394
jurzua
parents:
diff changeset
6395 jQuery(function() {
jurzua
parents:
diff changeset
6396 // This hook cannot be added until DOM ready because the support test
jurzua
parents:
diff changeset
6397 // for it is not run until after DOM ready
jurzua
parents:
diff changeset
6398 if ( !jQuery.support.reliableMarginRight ) {
jurzua
parents:
diff changeset
6399 jQuery.cssHooks.marginRight = {
jurzua
parents:
diff changeset
6400 get: function( elem, computed ) {
jurzua
parents:
diff changeset
6401 // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
jurzua
parents:
diff changeset
6402 // Work around by temporarily setting element display to inline-block
jurzua
parents:
diff changeset
6403 var ret;
jurzua
parents:
diff changeset
6404 jQuery.swap( elem, { "display": "inline-block" }, function() {
jurzua
parents:
diff changeset
6405 if ( computed ) {
jurzua
parents:
diff changeset
6406 ret = curCSS( elem, "margin-right", "marginRight" );
jurzua
parents:
diff changeset
6407 } else {
jurzua
parents:
diff changeset
6408 ret = elem.style.marginRight;
jurzua
parents:
diff changeset
6409 }
jurzua
parents:
diff changeset
6410 });
jurzua
parents:
diff changeset
6411 return ret;
jurzua
parents:
diff changeset
6412 }
jurzua
parents:
diff changeset
6413 };
jurzua
parents:
diff changeset
6414 }
jurzua
parents:
diff changeset
6415 });
jurzua
parents:
diff changeset
6416
jurzua
parents:
diff changeset
6417 if ( document.defaultView && document.defaultView.getComputedStyle ) {
jurzua
parents:
diff changeset
6418 getComputedStyle = function( elem, name ) {
jurzua
parents:
diff changeset
6419 var ret, defaultView, computedStyle;
jurzua
parents:
diff changeset
6420
jurzua
parents:
diff changeset
6421 name = name.replace( rupper, "-$1" ).toLowerCase();
jurzua
parents:
diff changeset
6422
jurzua
parents:
diff changeset
6423 if ( !(defaultView = elem.ownerDocument.defaultView) ) {
jurzua
parents:
diff changeset
6424 return undefined;
jurzua
parents:
diff changeset
6425 }
jurzua
parents:
diff changeset
6426
jurzua
parents:
diff changeset
6427 if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
jurzua
parents:
diff changeset
6428 ret = computedStyle.getPropertyValue( name );
jurzua
parents:
diff changeset
6429 if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
jurzua
parents:
diff changeset
6430 ret = jQuery.style( elem, name );
jurzua
parents:
diff changeset
6431 }
jurzua
parents:
diff changeset
6432 }
jurzua
parents:
diff changeset
6433
jurzua
parents:
diff changeset
6434 return ret;
jurzua
parents:
diff changeset
6435 };
jurzua
parents:
diff changeset
6436 }
jurzua
parents:
diff changeset
6437
jurzua
parents:
diff changeset
6438 if ( document.documentElement.currentStyle ) {
jurzua
parents:
diff changeset
6439 currentStyle = function( elem, name ) {
jurzua
parents:
diff changeset
6440 var left,
jurzua
parents:
diff changeset
6441 ret = elem.currentStyle && elem.currentStyle[ name ],
jurzua
parents:
diff changeset
6442 rsLeft = elem.runtimeStyle && elem.runtimeStyle[ name ],
jurzua
parents:
diff changeset
6443 style = elem.style;
jurzua
parents:
diff changeset
6444
jurzua
parents:
diff changeset
6445 // From the awesome hack by Dean Edwards
jurzua
parents:
diff changeset
6446 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
jurzua
parents:
diff changeset
6447
jurzua
parents:
diff changeset
6448 // If we're not dealing with a regular pixel number
jurzua
parents:
diff changeset
6449 // but a number that has a weird ending, we need to convert it to pixels
jurzua
parents:
diff changeset
6450 if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
jurzua
parents:
diff changeset
6451 // Remember the original values
jurzua
parents:
diff changeset
6452 left = style.left;
jurzua
parents:
diff changeset
6453
jurzua
parents:
diff changeset
6454 // Put in the new values to get a computed value out
jurzua
parents:
diff changeset
6455 if ( rsLeft ) {
jurzua
parents:
diff changeset
6456 elem.runtimeStyle.left = elem.currentStyle.left;
jurzua
parents:
diff changeset
6457 }
jurzua
parents:
diff changeset
6458 style.left = name === "fontSize" ? "1em" : (ret || 0);
jurzua
parents:
diff changeset
6459 ret = style.pixelLeft + "px";
jurzua
parents:
diff changeset
6460
jurzua
parents:
diff changeset
6461 // Revert the changed values
jurzua
parents:
diff changeset
6462 style.left = left;
jurzua
parents:
diff changeset
6463 if ( rsLeft ) {
jurzua
parents:
diff changeset
6464 elem.runtimeStyle.left = rsLeft;
jurzua
parents:
diff changeset
6465 }
jurzua
parents:
diff changeset
6466 }
jurzua
parents:
diff changeset
6467
jurzua
parents:
diff changeset
6468 return ret === "" ? "auto" : ret;
jurzua
parents:
diff changeset
6469 };
jurzua
parents:
diff changeset
6470 }
jurzua
parents:
diff changeset
6471
jurzua
parents:
diff changeset
6472 curCSS = getComputedStyle || currentStyle;
jurzua
parents:
diff changeset
6473
jurzua
parents:
diff changeset
6474 function getWH( elem, name, extra ) {
jurzua
parents:
diff changeset
6475 var which = name === "width" ? cssWidth : cssHeight,
jurzua
parents:
diff changeset
6476 val = name === "width" ? elem.offsetWidth : elem.offsetHeight;
jurzua
parents:
diff changeset
6477
jurzua
parents:
diff changeset
6478 if ( extra === "border" ) {
jurzua
parents:
diff changeset
6479 return val;
jurzua
parents:
diff changeset
6480 }
jurzua
parents:
diff changeset
6481
jurzua
parents:
diff changeset
6482 jQuery.each( which, function() {
jurzua
parents:
diff changeset
6483 if ( !extra ) {
jurzua
parents:
diff changeset
6484 val -= parseFloat(jQuery.css( elem, "padding" + this )) || 0;
jurzua
parents:
diff changeset
6485 }
jurzua
parents:
diff changeset
6486
jurzua
parents:
diff changeset
6487 if ( extra === "margin" ) {
jurzua
parents:
diff changeset
6488 val += parseFloat(jQuery.css( elem, "margin" + this )) || 0;
jurzua
parents:
diff changeset
6489
jurzua
parents:
diff changeset
6490 } else {
jurzua
parents:
diff changeset
6491 val -= parseFloat(jQuery.css( elem, "border" + this + "Width" )) || 0;
jurzua
parents:
diff changeset
6492 }
jurzua
parents:
diff changeset
6493 });
jurzua
parents:
diff changeset
6494
jurzua
parents:
diff changeset
6495 return val;
jurzua
parents:
diff changeset
6496 }
jurzua
parents:
diff changeset
6497
jurzua
parents:
diff changeset
6498 if ( jQuery.expr && jQuery.expr.filters ) {
jurzua
parents:
diff changeset
6499 jQuery.expr.filters.hidden = function( elem ) {
jurzua
parents:
diff changeset
6500 var width = elem.offsetWidth,
jurzua
parents:
diff changeset
6501 height = elem.offsetHeight;
jurzua
parents:
diff changeset
6502
jurzua
parents:
diff changeset
6503 return (width === 0 && height === 0) || (!jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css( elem, "display" )) === "none");
jurzua
parents:
diff changeset
6504 };
jurzua
parents:
diff changeset
6505
jurzua
parents:
diff changeset
6506 jQuery.expr.filters.visible = function( elem ) {
jurzua
parents:
diff changeset
6507 return !jQuery.expr.filters.hidden( elem );
jurzua
parents:
diff changeset
6508 };
jurzua
parents:
diff changeset
6509 }
jurzua
parents:
diff changeset
6510
jurzua
parents:
diff changeset
6511
jurzua
parents:
diff changeset
6512
jurzua
parents:
diff changeset
6513
jurzua
parents:
diff changeset
6514 var r20 = /%20/g,
jurzua
parents:
diff changeset
6515 rbracket = /\[\]$/,
jurzua
parents:
diff changeset
6516 rCRLF = /\r?\n/g,
jurzua
parents:
diff changeset
6517 rhash = /#.*$/,
jurzua
parents:
diff changeset
6518 rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
jurzua
parents:
diff changeset
6519 rinput = /^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
jurzua
parents:
diff changeset
6520 // #7653, #8125, #8152: local protocol detection
jurzua
parents:
diff changeset
6521 rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|widget):$/,
jurzua
parents:
diff changeset
6522 rnoContent = /^(?:GET|HEAD)$/,
jurzua
parents:
diff changeset
6523 rprotocol = /^\/\//,
jurzua
parents:
diff changeset
6524 rquery = /\?/,
jurzua
parents:
diff changeset
6525 rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
jurzua
parents:
diff changeset
6526 rselectTextarea = /^(?:select|textarea)/i,
jurzua
parents:
diff changeset
6527 rspacesAjax = /\s+/,
jurzua
parents:
diff changeset
6528 rts = /([?&])_=[^&]*/,
jurzua
parents:
diff changeset
6529 rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,
jurzua
parents:
diff changeset
6530
jurzua
parents:
diff changeset
6531 // Keep a copy of the old load method
jurzua
parents:
diff changeset
6532 _load = jQuery.fn.load,
jurzua
parents:
diff changeset
6533
jurzua
parents:
diff changeset
6534 /* Prefilters
jurzua
parents:
diff changeset
6535 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
jurzua
parents:
diff changeset
6536 * 2) These are called:
jurzua
parents:
diff changeset
6537 * - BEFORE asking for a transport
jurzua
parents:
diff changeset
6538 * - AFTER param serialization (s.data is a string if s.processData is true)
jurzua
parents:
diff changeset
6539 * 3) key is the dataType
jurzua
parents:
diff changeset
6540 * 4) the catchall symbol "*" can be used
jurzua
parents:
diff changeset
6541 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
jurzua
parents:
diff changeset
6542 */
jurzua
parents:
diff changeset
6543 prefilters = {},
jurzua
parents:
diff changeset
6544
jurzua
parents:
diff changeset
6545 /* Transports bindings
jurzua
parents:
diff changeset
6546 * 1) key is the dataType
jurzua
parents:
diff changeset
6547 * 2) the catchall symbol "*" can be used
jurzua
parents:
diff changeset
6548 * 3) selection will start with transport dataType and THEN go to "*" if needed
jurzua
parents:
diff changeset
6549 */
jurzua
parents:
diff changeset
6550 transports = {},
jurzua
parents:
diff changeset
6551
jurzua
parents:
diff changeset
6552 // Document location
jurzua
parents:
diff changeset
6553 ajaxLocation,
jurzua
parents:
diff changeset
6554
jurzua
parents:
diff changeset
6555 // Document location segments
jurzua
parents:
diff changeset
6556 ajaxLocParts;
jurzua
parents:
diff changeset
6557
jurzua
parents:
diff changeset
6558 // #8138, IE may throw an exception when accessing
jurzua
parents:
diff changeset
6559 // a field from window.location if document.domain has been set
jurzua
parents:
diff changeset
6560 try {
jurzua
parents:
diff changeset
6561 ajaxLocation = location.href;
jurzua
parents:
diff changeset
6562 } catch( e ) {
jurzua
parents:
diff changeset
6563 // Use the href attribute of an A element
jurzua
parents:
diff changeset
6564 // since IE will modify it given document.location
jurzua
parents:
diff changeset
6565 ajaxLocation = document.createElement( "a" );
jurzua
parents:
diff changeset
6566 ajaxLocation.href = "";
jurzua
parents:
diff changeset
6567 ajaxLocation = ajaxLocation.href;
jurzua
parents:
diff changeset
6568 }
jurzua
parents:
diff changeset
6569
jurzua
parents:
diff changeset
6570 // Segment location into parts
jurzua
parents:
diff changeset
6571 ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
jurzua
parents:
diff changeset
6572
jurzua
parents:
diff changeset
6573 // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
jurzua
parents:
diff changeset
6574 function addToPrefiltersOrTransports( structure ) {
jurzua
parents:
diff changeset
6575
jurzua
parents:
diff changeset
6576 // dataTypeExpression is optional and defaults to "*"
jurzua
parents:
diff changeset
6577 return function( dataTypeExpression, func ) {
jurzua
parents:
diff changeset
6578
jurzua
parents:
diff changeset
6579 if ( typeof dataTypeExpression !== "string" ) {
jurzua
parents:
diff changeset
6580 func = dataTypeExpression;
jurzua
parents:
diff changeset
6581 dataTypeExpression = "*";
jurzua
parents:
diff changeset
6582 }
jurzua
parents:
diff changeset
6583
jurzua
parents:
diff changeset
6584 if ( jQuery.isFunction( func ) ) {
jurzua
parents:
diff changeset
6585 var dataTypes = dataTypeExpression.toLowerCase().split( rspacesAjax ),
jurzua
parents:
diff changeset
6586 i = 0,
jurzua
parents:
diff changeset
6587 length = dataTypes.length,
jurzua
parents:
diff changeset
6588 dataType,
jurzua
parents:
diff changeset
6589 list,
jurzua
parents:
diff changeset
6590 placeBefore;
jurzua
parents:
diff changeset
6591
jurzua
parents:
diff changeset
6592 // For each dataType in the dataTypeExpression
jurzua
parents:
diff changeset
6593 for(; i < length; i++ ) {
jurzua
parents:
diff changeset
6594 dataType = dataTypes[ i ];
jurzua
parents:
diff changeset
6595 // We control if we're asked to add before
jurzua
parents:
diff changeset
6596 // any existing element
jurzua
parents:
diff changeset
6597 placeBefore = /^\+/.test( dataType );
jurzua
parents:
diff changeset
6598 if ( placeBefore ) {
jurzua
parents:
diff changeset
6599 dataType = dataType.substr( 1 ) || "*";
jurzua
parents:
diff changeset
6600 }
jurzua
parents:
diff changeset
6601 list = structure[ dataType ] = structure[ dataType ] || [];
jurzua
parents:
diff changeset
6602 // then we add to the structure accordingly
jurzua
parents:
diff changeset
6603 list[ placeBefore ? "unshift" : "push" ]( func );
jurzua
parents:
diff changeset
6604 }
jurzua
parents:
diff changeset
6605 }
jurzua
parents:
diff changeset
6606 };
jurzua
parents:
diff changeset
6607 }
jurzua
parents:
diff changeset
6608
jurzua
parents:
diff changeset
6609 // Base inspection function for prefilters and transports
jurzua
parents:
diff changeset
6610 function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,
jurzua
parents:
diff changeset
6611 dataType /* internal */, inspected /* internal */ ) {
jurzua
parents:
diff changeset
6612
jurzua
parents:
diff changeset
6613 dataType = dataType || options.dataTypes[ 0 ];
jurzua
parents:
diff changeset
6614 inspected = inspected || {};
jurzua
parents:
diff changeset
6615
jurzua
parents:
diff changeset
6616 inspected[ dataType ] = true;
jurzua
parents:
diff changeset
6617
jurzua
parents:
diff changeset
6618 var list = structure[ dataType ],
jurzua
parents:
diff changeset
6619 i = 0,
jurzua
parents:
diff changeset
6620 length = list ? list.length : 0,
jurzua
parents:
diff changeset
6621 executeOnly = ( structure === prefilters ),
jurzua
parents:
diff changeset
6622 selection;
jurzua
parents:
diff changeset
6623
jurzua
parents:
diff changeset
6624 for(; i < length && ( executeOnly || !selection ); i++ ) {
jurzua
parents:
diff changeset
6625 selection = list[ i ]( options, originalOptions, jqXHR );
jurzua
parents:
diff changeset
6626 // If we got redirected to another dataType
jurzua
parents:
diff changeset
6627 // we try there if executing only and not done already
jurzua
parents:
diff changeset
6628 if ( typeof selection === "string" ) {
jurzua
parents:
diff changeset
6629 if ( !executeOnly || inspected[ selection ] ) {
jurzua
parents:
diff changeset
6630 selection = undefined;
jurzua
parents:
diff changeset
6631 } else {
jurzua
parents:
diff changeset
6632 options.dataTypes.unshift( selection );
jurzua
parents:
diff changeset
6633 selection = inspectPrefiltersOrTransports(
jurzua
parents:
diff changeset
6634 structure, options, originalOptions, jqXHR, selection, inspected );
jurzua
parents:
diff changeset
6635 }
jurzua
parents:
diff changeset
6636 }
jurzua
parents:
diff changeset
6637 }
jurzua
parents:
diff changeset
6638 // If we're only executing or nothing was selected
jurzua
parents:
diff changeset
6639 // we try the catchall dataType if not done already
jurzua
parents:
diff changeset
6640 if ( ( executeOnly || !selection ) && !inspected[ "*" ] ) {
jurzua
parents:
diff changeset
6641 selection = inspectPrefiltersOrTransports(
jurzua
parents:
diff changeset
6642 structure, options, originalOptions, jqXHR, "*", inspected );
jurzua
parents:
diff changeset
6643 }
jurzua
parents:
diff changeset
6644 // unnecessary when only executing (prefilters)
jurzua
parents:
diff changeset
6645 // but it'll be ignored by the caller in that case
jurzua
parents:
diff changeset
6646 return selection;
jurzua
parents:
diff changeset
6647 }
jurzua
parents:
diff changeset
6648
jurzua
parents:
diff changeset
6649 jQuery.fn.extend({
jurzua
parents:
diff changeset
6650 load: function( url, params, callback ) {
jurzua
parents:
diff changeset
6651 if ( typeof url !== "string" && _load ) {
jurzua
parents:
diff changeset
6652 return _load.apply( this, arguments );
jurzua
parents:
diff changeset
6653
jurzua
parents:
diff changeset
6654 // Don't do a request if no elements are being requested
jurzua
parents:
diff changeset
6655 } else if ( !this.length ) {
jurzua
parents:
diff changeset
6656 return this;
jurzua
parents:
diff changeset
6657 }
jurzua
parents:
diff changeset
6658
jurzua
parents:
diff changeset
6659 var off = url.indexOf( " " );
jurzua
parents:
diff changeset
6660 if ( off >= 0 ) {
jurzua
parents:
diff changeset
6661 var selector = url.slice( off, url.length );
jurzua
parents:
diff changeset
6662 url = url.slice( 0, off );
jurzua
parents:
diff changeset
6663 }
jurzua
parents:
diff changeset
6664
jurzua
parents:
diff changeset
6665 // Default to a GET request
jurzua
parents:
diff changeset
6666 var type = "GET";
jurzua
parents:
diff changeset
6667
jurzua
parents:
diff changeset
6668 // If the second parameter was provided
jurzua
parents:
diff changeset
6669 if ( params ) {
jurzua
parents:
diff changeset
6670 // If it's a function
jurzua
parents:
diff changeset
6671 if ( jQuery.isFunction( params ) ) {
jurzua
parents:
diff changeset
6672 // We assume that it's the callback
jurzua
parents:
diff changeset
6673 callback = params;
jurzua
parents:
diff changeset
6674 params = undefined;
jurzua
parents:
diff changeset
6675
jurzua
parents:
diff changeset
6676 // Otherwise, build a param string
jurzua
parents:
diff changeset
6677 } else if ( typeof params === "object" ) {
jurzua
parents:
diff changeset
6678 params = jQuery.param( params, jQuery.ajaxSettings.traditional );
jurzua
parents:
diff changeset
6679 type = "POST";
jurzua
parents:
diff changeset
6680 }
jurzua
parents:
diff changeset
6681 }
jurzua
parents:
diff changeset
6682
jurzua
parents:
diff changeset
6683 var self = this;
jurzua
parents:
diff changeset
6684
jurzua
parents:
diff changeset
6685 // Request the remote document
jurzua
parents:
diff changeset
6686 jQuery.ajax({
jurzua
parents:
diff changeset
6687 url: url,
jurzua
parents:
diff changeset
6688 type: type,
jurzua
parents:
diff changeset
6689 dataType: "html",
jurzua
parents:
diff changeset
6690 data: params,
jurzua
parents:
diff changeset
6691 // Complete callback (responseText is used internally)
jurzua
parents:
diff changeset
6692 complete: function( jqXHR, status, responseText ) {
jurzua
parents:
diff changeset
6693 // Store the response as specified by the jqXHR object
jurzua
parents:
diff changeset
6694 responseText = jqXHR.responseText;
jurzua
parents:
diff changeset
6695 // If successful, inject the HTML into all the matched elements
jurzua
parents:
diff changeset
6696 if ( jqXHR.isResolved() ) {
jurzua
parents:
diff changeset
6697 // #4825: Get the actual response in case
jurzua
parents:
diff changeset
6698 // a dataFilter is present in ajaxSettings
jurzua
parents:
diff changeset
6699 jqXHR.done(function( r ) {
jurzua
parents:
diff changeset
6700 responseText = r;
jurzua
parents:
diff changeset
6701 });
jurzua
parents:
diff changeset
6702 // See if a selector was specified
jurzua
parents:
diff changeset
6703 self.html( selector ?
jurzua
parents:
diff changeset
6704 // Create a dummy div to hold the results
jurzua
parents:
diff changeset
6705 jQuery("<div>")
jurzua
parents:
diff changeset
6706 // inject the contents of the document in, removing the scripts
jurzua
parents:
diff changeset
6707 // to avoid any 'Permission Denied' errors in IE
jurzua
parents:
diff changeset
6708 .append(responseText.replace(rscript, ""))
jurzua
parents:
diff changeset
6709
jurzua
parents:
diff changeset
6710 // Locate the specified elements
jurzua
parents:
diff changeset
6711 .find(selector) :
jurzua
parents:
diff changeset
6712
jurzua
parents:
diff changeset
6713 // If not, just inject the full result
jurzua
parents:
diff changeset
6714 responseText );
jurzua
parents:
diff changeset
6715 }
jurzua
parents:
diff changeset
6716
jurzua
parents:
diff changeset
6717 if ( callback ) {
jurzua
parents:
diff changeset
6718 self.each( callback, [ responseText, status, jqXHR ] );
jurzua
parents:
diff changeset
6719 }
jurzua
parents:
diff changeset
6720 }
jurzua
parents:
diff changeset
6721 });
jurzua
parents:
diff changeset
6722
jurzua
parents:
diff changeset
6723 return this;
jurzua
parents:
diff changeset
6724 },
jurzua
parents:
diff changeset
6725
jurzua
parents:
diff changeset
6726 serialize: function() {
jurzua
parents:
diff changeset
6727 return jQuery.param( this.serializeArray() );
jurzua
parents:
diff changeset
6728 },
jurzua
parents:
diff changeset
6729
jurzua
parents:
diff changeset
6730 serializeArray: function() {
jurzua
parents:
diff changeset
6731 return this.map(function(){
jurzua
parents:
diff changeset
6732 return this.elements ? jQuery.makeArray( this.elements ) : this;
jurzua
parents:
diff changeset
6733 })
jurzua
parents:
diff changeset
6734 .filter(function(){
jurzua
parents:
diff changeset
6735 return this.name && !this.disabled &&
jurzua
parents:
diff changeset
6736 ( this.checked || rselectTextarea.test( this.nodeName ) ||
jurzua
parents:
diff changeset
6737 rinput.test( this.type ) );
jurzua
parents:
diff changeset
6738 })
jurzua
parents:
diff changeset
6739 .map(function( i, elem ){
jurzua
parents:
diff changeset
6740 var val = jQuery( this ).val();
jurzua
parents:
diff changeset
6741
jurzua
parents:
diff changeset
6742 return val == null ?
jurzua
parents:
diff changeset
6743 null :
jurzua
parents:
diff changeset
6744 jQuery.isArray( val ) ?
jurzua
parents:
diff changeset
6745 jQuery.map( val, function( val, i ){
jurzua
parents:
diff changeset
6746 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
jurzua
parents:
diff changeset
6747 }) :
jurzua
parents:
diff changeset
6748 { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
jurzua
parents:
diff changeset
6749 }).get();
jurzua
parents:
diff changeset
6750 }
jurzua
parents:
diff changeset
6751 });
jurzua
parents:
diff changeset
6752
jurzua
parents:
diff changeset
6753 // Attach a bunch of functions for handling common AJAX events
jurzua
parents:
diff changeset
6754 jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
jurzua
parents:
diff changeset
6755 jQuery.fn[ o ] = function( f ){
jurzua
parents:
diff changeset
6756 return this.bind( o, f );
jurzua
parents:
diff changeset
6757 };
jurzua
parents:
diff changeset
6758 });
jurzua
parents:
diff changeset
6759
jurzua
parents:
diff changeset
6760 jQuery.each( [ "get", "post" ], function( i, method ) {
jurzua
parents:
diff changeset
6761 jQuery[ method ] = function( url, data, callback, type ) {
jurzua
parents:
diff changeset
6762 // shift arguments if data argument was omitted
jurzua
parents:
diff changeset
6763 if ( jQuery.isFunction( data ) ) {
jurzua
parents:
diff changeset
6764 type = type || callback;
jurzua
parents:
diff changeset
6765 callback = data;
jurzua
parents:
diff changeset
6766 data = undefined;
jurzua
parents:
diff changeset
6767 }
jurzua
parents:
diff changeset
6768
jurzua
parents:
diff changeset
6769 return jQuery.ajax({
jurzua
parents:
diff changeset
6770 type: method,
jurzua
parents:
diff changeset
6771 url: url,
jurzua
parents:
diff changeset
6772 data: data,
jurzua
parents:
diff changeset
6773 success: callback,
jurzua
parents:
diff changeset
6774 dataType: type
jurzua
parents:
diff changeset
6775 });
jurzua
parents:
diff changeset
6776 };
jurzua
parents:
diff changeset
6777 });
jurzua
parents:
diff changeset
6778
jurzua
parents:
diff changeset
6779 jQuery.extend({
jurzua
parents:
diff changeset
6780
jurzua
parents:
diff changeset
6781 getScript: function( url, callback ) {
jurzua
parents:
diff changeset
6782 return jQuery.get( url, undefined, callback, "script" );
jurzua
parents:
diff changeset
6783 },
jurzua
parents:
diff changeset
6784
jurzua
parents:
diff changeset
6785 getJSON: function( url, data, callback ) {
jurzua
parents:
diff changeset
6786 return jQuery.get( url, data, callback, "json" );
jurzua
parents:
diff changeset
6787 },
jurzua
parents:
diff changeset
6788
jurzua
parents:
diff changeset
6789 // Creates a full fledged settings object into target
jurzua
parents:
diff changeset
6790 // with both ajaxSettings and settings fields.
jurzua
parents:
diff changeset
6791 // If target is omitted, writes into ajaxSettings.
jurzua
parents:
diff changeset
6792 ajaxSetup: function ( target, settings ) {
jurzua
parents:
diff changeset
6793 if ( !settings ) {
jurzua
parents:
diff changeset
6794 // Only one parameter, we extend ajaxSettings
jurzua
parents:
diff changeset
6795 settings = target;
jurzua
parents:
diff changeset
6796 target = jQuery.extend( true, jQuery.ajaxSettings, settings );
jurzua
parents:
diff changeset
6797 } else {
jurzua
parents:
diff changeset
6798 // target was provided, we extend into it
jurzua
parents:
diff changeset
6799 jQuery.extend( true, target, jQuery.ajaxSettings, settings );
jurzua
parents:
diff changeset
6800 }
jurzua
parents:
diff changeset
6801 // Flatten fields we don't want deep extended
jurzua
parents:
diff changeset
6802 for( var field in { context: 1, url: 1 } ) {
jurzua
parents:
diff changeset
6803 if ( field in settings ) {
jurzua
parents:
diff changeset
6804 target[ field ] = settings[ field ];
jurzua
parents:
diff changeset
6805 } else if( field in jQuery.ajaxSettings ) {
jurzua
parents:
diff changeset
6806 target[ field ] = jQuery.ajaxSettings[ field ];
jurzua
parents:
diff changeset
6807 }
jurzua
parents:
diff changeset
6808 }
jurzua
parents:
diff changeset
6809 return target;
jurzua
parents:
diff changeset
6810 },
jurzua
parents:
diff changeset
6811
jurzua
parents:
diff changeset
6812 ajaxSettings: {
jurzua
parents:
diff changeset
6813 url: ajaxLocation,
jurzua
parents:
diff changeset
6814 isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
jurzua
parents:
diff changeset
6815 global: true,
jurzua
parents:
diff changeset
6816 type: "GET",
jurzua
parents:
diff changeset
6817 contentType: "application/x-www-form-urlencoded",
jurzua
parents:
diff changeset
6818 processData: true,
jurzua
parents:
diff changeset
6819 async: true,
jurzua
parents:
diff changeset
6820 /*
jurzua
parents:
diff changeset
6821 timeout: 0,
jurzua
parents:
diff changeset
6822 data: null,
jurzua
parents:
diff changeset
6823 dataType: null,
jurzua
parents:
diff changeset
6824 username: null,
jurzua
parents:
diff changeset
6825 password: null,
jurzua
parents:
diff changeset
6826 cache: null,
jurzua
parents:
diff changeset
6827 traditional: false,
jurzua
parents:
diff changeset
6828 headers: {},
jurzua
parents:
diff changeset
6829 */
jurzua
parents:
diff changeset
6830
jurzua
parents:
diff changeset
6831 accepts: {
jurzua
parents:
diff changeset
6832 xml: "application/xml, text/xml",
jurzua
parents:
diff changeset
6833 html: "text/html",
jurzua
parents:
diff changeset
6834 text: "text/plain",
jurzua
parents:
diff changeset
6835 json: "application/json, text/javascript",
jurzua
parents:
diff changeset
6836 "*": "*/*"
jurzua
parents:
diff changeset
6837 },
jurzua
parents:
diff changeset
6838
jurzua
parents:
diff changeset
6839 contents: {
jurzua
parents:
diff changeset
6840 xml: /xml/,
jurzua
parents:
diff changeset
6841 html: /html/,
jurzua
parents:
diff changeset
6842 json: /json/
jurzua
parents:
diff changeset
6843 },
jurzua
parents:
diff changeset
6844
jurzua
parents:
diff changeset
6845 responseFields: {
jurzua
parents:
diff changeset
6846 xml: "responseXML",
jurzua
parents:
diff changeset
6847 text: "responseText"
jurzua
parents:
diff changeset
6848 },
jurzua
parents:
diff changeset
6849
jurzua
parents:
diff changeset
6850 // List of data converters
jurzua
parents:
diff changeset
6851 // 1) key format is "source_type destination_type" (a single space in-between)
jurzua
parents:
diff changeset
6852 // 2) the catchall symbol "*" can be used for source_type
jurzua
parents:
diff changeset
6853 converters: {
jurzua
parents:
diff changeset
6854
jurzua
parents:
diff changeset
6855 // Convert anything to text
jurzua
parents:
diff changeset
6856 "* text": window.String,
jurzua
parents:
diff changeset
6857
jurzua
parents:
diff changeset
6858 // Text to html (true = no transformation)
jurzua
parents:
diff changeset
6859 "text html": true,
jurzua
parents:
diff changeset
6860
jurzua
parents:
diff changeset
6861 // Evaluate text as a json expression
jurzua
parents:
diff changeset
6862 "text json": jQuery.parseJSON,
jurzua
parents:
diff changeset
6863
jurzua
parents:
diff changeset
6864 // Parse text as xml
jurzua
parents:
diff changeset
6865 "text xml": jQuery.parseXML
jurzua
parents:
diff changeset
6866 }
jurzua
parents:
diff changeset
6867 },
jurzua
parents:
diff changeset
6868
jurzua
parents:
diff changeset
6869 ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
jurzua
parents:
diff changeset
6870 ajaxTransport: addToPrefiltersOrTransports( transports ),
jurzua
parents:
diff changeset
6871
jurzua
parents:
diff changeset
6872 // Main method
jurzua
parents:
diff changeset
6873 ajax: function( url, options ) {
jurzua
parents:
diff changeset
6874
jurzua
parents:
diff changeset
6875 // If url is an object, simulate pre-1.5 signature
jurzua
parents:
diff changeset
6876 if ( typeof url === "object" ) {
jurzua
parents:
diff changeset
6877 options = url;
jurzua
parents:
diff changeset
6878 url = undefined;
jurzua
parents:
diff changeset
6879 }
jurzua
parents:
diff changeset
6880
jurzua
parents:
diff changeset
6881 // Force options to be an object
jurzua
parents:
diff changeset
6882 options = options || {};
jurzua
parents:
diff changeset
6883
jurzua
parents:
diff changeset
6884 var // Create the final options object
jurzua
parents:
diff changeset
6885 s = jQuery.ajaxSetup( {}, options ),
jurzua
parents:
diff changeset
6886 // Callbacks context
jurzua
parents:
diff changeset
6887 callbackContext = s.context || s,
jurzua
parents:
diff changeset
6888 // Context for global events
jurzua
parents:
diff changeset
6889 // It's the callbackContext if one was provided in the options
jurzua
parents:
diff changeset
6890 // and if it's a DOM node or a jQuery collection
jurzua
parents:
diff changeset
6891 globalEventContext = callbackContext !== s &&
jurzua
parents:
diff changeset
6892 ( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
jurzua
parents:
diff changeset
6893 jQuery( callbackContext ) : jQuery.event,
jurzua
parents:
diff changeset
6894 // Deferreds
jurzua
parents:
diff changeset
6895 deferred = jQuery.Deferred(),
jurzua
parents:
diff changeset
6896 completeDeferred = jQuery._Deferred(),
jurzua
parents:
diff changeset
6897 // Status-dependent callbacks
jurzua
parents:
diff changeset
6898 statusCode = s.statusCode || {},
jurzua
parents:
diff changeset
6899 // ifModified key
jurzua
parents:
diff changeset
6900 ifModifiedKey,
jurzua
parents:
diff changeset
6901 // Headers (they are sent all at once)
jurzua
parents:
diff changeset
6902 requestHeaders = {},
jurzua
parents:
diff changeset
6903 requestHeadersNames = {},
jurzua
parents:
diff changeset
6904 // Response headers
jurzua
parents:
diff changeset
6905 responseHeadersString,
jurzua
parents:
diff changeset
6906 responseHeaders,
jurzua
parents:
diff changeset
6907 // transport
jurzua
parents:
diff changeset
6908 transport,
jurzua
parents:
diff changeset
6909 // timeout handle
jurzua
parents:
diff changeset
6910 timeoutTimer,
jurzua
parents:
diff changeset
6911 // Cross-domain detection vars
jurzua
parents:
diff changeset
6912 parts,
jurzua
parents:
diff changeset
6913 // The jqXHR state
jurzua
parents:
diff changeset
6914 state = 0,
jurzua
parents:
diff changeset
6915 // To know if global events are to be dispatched
jurzua
parents:
diff changeset
6916 fireGlobals,
jurzua
parents:
diff changeset
6917 // Loop variable
jurzua
parents:
diff changeset
6918 i,
jurzua
parents:
diff changeset
6919 // Fake xhr
jurzua
parents:
diff changeset
6920 jqXHR = {
jurzua
parents:
diff changeset
6921
jurzua
parents:
diff changeset
6922 readyState: 0,
jurzua
parents:
diff changeset
6923
jurzua
parents:
diff changeset
6924 // Caches the header
jurzua
parents:
diff changeset
6925 setRequestHeader: function( name, value ) {
jurzua
parents:
diff changeset
6926 if ( !state ) {
jurzua
parents:
diff changeset
6927 var lname = name.toLowerCase();
jurzua
parents:
diff changeset
6928 name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
jurzua
parents:
diff changeset
6929 requestHeaders[ name ] = value;
jurzua
parents:
diff changeset
6930 }
jurzua
parents:
diff changeset
6931 return this;
jurzua
parents:
diff changeset
6932 },
jurzua
parents:
diff changeset
6933
jurzua
parents:
diff changeset
6934 // Raw string
jurzua
parents:
diff changeset
6935 getAllResponseHeaders: function() {
jurzua
parents:
diff changeset
6936 return state === 2 ? responseHeadersString : null;
jurzua
parents:
diff changeset
6937 },
jurzua
parents:
diff changeset
6938
jurzua
parents:
diff changeset
6939 // Builds headers hashtable if needed
jurzua
parents:
diff changeset
6940 getResponseHeader: function( key ) {
jurzua
parents:
diff changeset
6941 var match;
jurzua
parents:
diff changeset
6942 if ( state === 2 ) {
jurzua
parents:
diff changeset
6943 if ( !responseHeaders ) {
jurzua
parents:
diff changeset
6944 responseHeaders = {};
jurzua
parents:
diff changeset
6945 while( ( match = rheaders.exec( responseHeadersString ) ) ) {
jurzua
parents:
diff changeset
6946 responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
jurzua
parents:
diff changeset
6947 }
jurzua
parents:
diff changeset
6948 }
jurzua
parents:
diff changeset
6949 match = responseHeaders[ key.toLowerCase() ];
jurzua
parents:
diff changeset
6950 }
jurzua
parents:
diff changeset
6951 return match === undefined ? null : match;
jurzua
parents:
diff changeset
6952 },
jurzua
parents:
diff changeset
6953
jurzua
parents:
diff changeset
6954 // Overrides response content-type header
jurzua
parents:
diff changeset
6955 overrideMimeType: function( type ) {
jurzua
parents:
diff changeset
6956 if ( !state ) {
jurzua
parents:
diff changeset
6957 s.mimeType = type;
jurzua
parents:
diff changeset
6958 }
jurzua
parents:
diff changeset
6959 return this;
jurzua
parents:
diff changeset
6960 },
jurzua
parents:
diff changeset
6961
jurzua
parents:
diff changeset
6962 // Cancel the request
jurzua
parents:
diff changeset
6963 abort: function( statusText ) {
jurzua
parents:
diff changeset
6964 statusText = statusText || "abort";
jurzua
parents:
diff changeset
6965 if ( transport ) {
jurzua
parents:
diff changeset
6966 transport.abort( statusText );
jurzua
parents:
diff changeset
6967 }
jurzua
parents:
diff changeset
6968 done( 0, statusText );
jurzua
parents:
diff changeset
6969 return this;
jurzua
parents:
diff changeset
6970 }
jurzua
parents:
diff changeset
6971 };
jurzua
parents:
diff changeset
6972
jurzua
parents:
diff changeset
6973 // Callback for when everything is done
jurzua
parents:
diff changeset
6974 // It is defined here because jslint complains if it is declared
jurzua
parents:
diff changeset
6975 // at the end of the function (which would be more logical and readable)
jurzua
parents:
diff changeset
6976 function done( status, statusText, responses, headers ) {
jurzua
parents:
diff changeset
6977
jurzua
parents:
diff changeset
6978 // Called once
jurzua
parents:
diff changeset
6979 if ( state === 2 ) {
jurzua
parents:
diff changeset
6980 return;
jurzua
parents:
diff changeset
6981 }
jurzua
parents:
diff changeset
6982
jurzua
parents:
diff changeset
6983 // State is "done" now
jurzua
parents:
diff changeset
6984 state = 2;
jurzua
parents:
diff changeset
6985
jurzua
parents:
diff changeset
6986 // Clear timeout if it exists
jurzua
parents:
diff changeset
6987 if ( timeoutTimer ) {
jurzua
parents:
diff changeset
6988 clearTimeout( timeoutTimer );
jurzua
parents:
diff changeset
6989 }
jurzua
parents:
diff changeset
6990
jurzua
parents:
diff changeset
6991 // Dereference transport for early garbage collection
jurzua
parents:
diff changeset
6992 // (no matter how long the jqXHR object will be used)
jurzua
parents:
diff changeset
6993 transport = undefined;
jurzua
parents:
diff changeset
6994
jurzua
parents:
diff changeset
6995 // Cache response headers
jurzua
parents:
diff changeset
6996 responseHeadersString = headers || "";
jurzua
parents:
diff changeset
6997
jurzua
parents:
diff changeset
6998 // Set readyState
jurzua
parents:
diff changeset
6999 jqXHR.readyState = status ? 4 : 0;
jurzua
parents:
diff changeset
7000
jurzua
parents:
diff changeset
7001 var isSuccess,
jurzua
parents:
diff changeset
7002 success,
jurzua
parents:
diff changeset
7003 error,
jurzua
parents:
diff changeset
7004 response = responses ? ajaxHandleResponses( s, jqXHR, responses ) : undefined,
jurzua
parents:
diff changeset
7005 lastModified,
jurzua
parents:
diff changeset
7006 etag;
jurzua
parents:
diff changeset
7007
jurzua
parents:
diff changeset
7008 // If successful, handle type chaining
jurzua
parents:
diff changeset
7009 if ( status >= 200 && status < 300 || status === 304 ) {
jurzua
parents:
diff changeset
7010
jurzua
parents:
diff changeset
7011 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
jurzua
parents:
diff changeset
7012 if ( s.ifModified ) {
jurzua
parents:
diff changeset
7013
jurzua
parents:
diff changeset
7014 if ( ( lastModified = jqXHR.getResponseHeader( "Last-Modified" ) ) ) {
jurzua
parents:
diff changeset
7015 jQuery.lastModified[ ifModifiedKey ] = lastModified;
jurzua
parents:
diff changeset
7016 }
jurzua
parents:
diff changeset
7017 if ( ( etag = jqXHR.getResponseHeader( "Etag" ) ) ) {
jurzua
parents:
diff changeset
7018 jQuery.etag[ ifModifiedKey ] = etag;
jurzua
parents:
diff changeset
7019 }
jurzua
parents:
diff changeset
7020 }
jurzua
parents:
diff changeset
7021
jurzua
parents:
diff changeset
7022 // If not modified
jurzua
parents:
diff changeset
7023 if ( status === 304 ) {
jurzua
parents:
diff changeset
7024
jurzua
parents:
diff changeset
7025 statusText = "notmodified";
jurzua
parents:
diff changeset
7026 isSuccess = true;
jurzua
parents:
diff changeset
7027
jurzua
parents:
diff changeset
7028 // If we have data
jurzua
parents:
diff changeset
7029 } else {
jurzua
parents:
diff changeset
7030
jurzua
parents:
diff changeset
7031 try {
jurzua
parents:
diff changeset
7032 success = ajaxConvert( s, response );
jurzua
parents:
diff changeset
7033 statusText = "success";
jurzua
parents:
diff changeset
7034 isSuccess = true;
jurzua
parents:
diff changeset
7035 } catch(e) {
jurzua
parents:
diff changeset
7036 // We have a parsererror
jurzua
parents:
diff changeset
7037 statusText = "parsererror";
jurzua
parents:
diff changeset
7038 error = e;
jurzua
parents:
diff changeset
7039 }
jurzua
parents:
diff changeset
7040 }
jurzua
parents:
diff changeset
7041 } else {
jurzua
parents:
diff changeset
7042 // We extract error from statusText
jurzua
parents:
diff changeset
7043 // then normalize statusText and status for non-aborts
jurzua
parents:
diff changeset
7044 error = statusText;
jurzua
parents:
diff changeset
7045 if( !statusText || status ) {
jurzua
parents:
diff changeset
7046 statusText = "error";
jurzua
parents:
diff changeset
7047 if ( status < 0 ) {
jurzua
parents:
diff changeset
7048 status = 0;
jurzua
parents:
diff changeset
7049 }
jurzua
parents:
diff changeset
7050 }
jurzua
parents:
diff changeset
7051 }
jurzua
parents:
diff changeset
7052
jurzua
parents:
diff changeset
7053 // Set data for the fake xhr object
jurzua
parents:
diff changeset
7054 jqXHR.status = status;
jurzua
parents:
diff changeset
7055 jqXHR.statusText = statusText;
jurzua
parents:
diff changeset
7056
jurzua
parents:
diff changeset
7057 // Success/Error
jurzua
parents:
diff changeset
7058 if ( isSuccess ) {
jurzua
parents:
diff changeset
7059 deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
jurzua
parents:
diff changeset
7060 } else {
jurzua
parents:
diff changeset
7061 deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
jurzua
parents:
diff changeset
7062 }
jurzua
parents:
diff changeset
7063
jurzua
parents:
diff changeset
7064 // Status-dependent callbacks
jurzua
parents:
diff changeset
7065 jqXHR.statusCode( statusCode );
jurzua
parents:
diff changeset
7066 statusCode = undefined;
jurzua
parents:
diff changeset
7067
jurzua
parents:
diff changeset
7068 if ( fireGlobals ) {
jurzua
parents:
diff changeset
7069 globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
jurzua
parents:
diff changeset
7070 [ jqXHR, s, isSuccess ? success : error ] );
jurzua
parents:
diff changeset
7071 }
jurzua
parents:
diff changeset
7072
jurzua
parents:
diff changeset
7073 // Complete
jurzua
parents:
diff changeset
7074 completeDeferred.resolveWith( callbackContext, [ jqXHR, statusText ] );
jurzua
parents:
diff changeset
7075
jurzua
parents:
diff changeset
7076 if ( fireGlobals ) {
jurzua
parents:
diff changeset
7077 globalEventContext.trigger( "ajaxComplete", [ jqXHR, s] );
jurzua
parents:
diff changeset
7078 // Handle the global AJAX counter
jurzua
parents:
diff changeset
7079 if ( !( --jQuery.active ) ) {
jurzua
parents:
diff changeset
7080 jQuery.event.trigger( "ajaxStop" );
jurzua
parents:
diff changeset
7081 }
jurzua
parents:
diff changeset
7082 }
jurzua
parents:
diff changeset
7083 }
jurzua
parents:
diff changeset
7084
jurzua
parents:
diff changeset
7085 // Attach deferreds
jurzua
parents:
diff changeset
7086 deferred.promise( jqXHR );
jurzua
parents:
diff changeset
7087 jqXHR.success = jqXHR.done;
jurzua
parents:
diff changeset
7088 jqXHR.error = jqXHR.fail;
jurzua
parents:
diff changeset
7089 jqXHR.complete = completeDeferred.done;
jurzua
parents:
diff changeset
7090
jurzua
parents:
diff changeset
7091 // Status-dependent callbacks
jurzua
parents:
diff changeset
7092 jqXHR.statusCode = function( map ) {
jurzua
parents:
diff changeset
7093 if ( map ) {
jurzua
parents:
diff changeset
7094 var tmp;
jurzua
parents:
diff changeset
7095 if ( state < 2 ) {
jurzua
parents:
diff changeset
7096 for( tmp in map ) {
jurzua
parents:
diff changeset
7097 statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
jurzua
parents:
diff changeset
7098 }
jurzua
parents:
diff changeset
7099 } else {
jurzua
parents:
diff changeset
7100 tmp = map[ jqXHR.status ];
jurzua
parents:
diff changeset
7101 jqXHR.then( tmp, tmp );
jurzua
parents:
diff changeset
7102 }
jurzua
parents:
diff changeset
7103 }
jurzua
parents:
diff changeset
7104 return this;
jurzua
parents:
diff changeset
7105 };
jurzua
parents:
diff changeset
7106
jurzua
parents:
diff changeset
7107 // Remove hash character (#7531: and string promotion)
jurzua
parents:
diff changeset
7108 // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
jurzua
parents:
diff changeset
7109 // We also use the url parameter if available
jurzua
parents:
diff changeset
7110 s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
jurzua
parents:
diff changeset
7111
jurzua
parents:
diff changeset
7112 // Extract dataTypes list
jurzua
parents:
diff changeset
7113 s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( rspacesAjax );
jurzua
parents:
diff changeset
7114
jurzua
parents:
diff changeset
7115 // Determine if a cross-domain request is in order
jurzua
parents:
diff changeset
7116 if ( s.crossDomain == null ) {
jurzua
parents:
diff changeset
7117 parts = rurl.exec( s.url.toLowerCase() );
jurzua
parents:
diff changeset
7118 s.crossDomain = !!( parts &&
jurzua
parents:
diff changeset
7119 ( parts[ 1 ] != ajaxLocParts[ 1 ] || parts[ 2 ] != ajaxLocParts[ 2 ] ||
jurzua
parents:
diff changeset
7120 ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
jurzua
parents:
diff changeset
7121 ( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
jurzua
parents:
diff changeset
7122 );
jurzua
parents:
diff changeset
7123 }
jurzua
parents:
diff changeset
7124
jurzua
parents:
diff changeset
7125 // Convert data if not already a string
jurzua
parents:
diff changeset
7126 if ( s.data && s.processData && typeof s.data !== "string" ) {
jurzua
parents:
diff changeset
7127 s.data = jQuery.param( s.data, s.traditional );
jurzua
parents:
diff changeset
7128 }
jurzua
parents:
diff changeset
7129
jurzua
parents:
diff changeset
7130 // Apply prefilters
jurzua
parents:
diff changeset
7131 inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
jurzua
parents:
diff changeset
7132
jurzua
parents:
diff changeset
7133 // If request was aborted inside a prefiler, stop there
jurzua
parents:
diff changeset
7134 if ( state === 2 ) {
jurzua
parents:
diff changeset
7135 return false;
jurzua
parents:
diff changeset
7136 }
jurzua
parents:
diff changeset
7137
jurzua
parents:
diff changeset
7138 // We can fire global events as of now if asked to
jurzua
parents:
diff changeset
7139 fireGlobals = s.global;
jurzua
parents:
diff changeset
7140
jurzua
parents:
diff changeset
7141 // Uppercase the type
jurzua
parents:
diff changeset
7142 s.type = s.type.toUpperCase();
jurzua
parents:
diff changeset
7143
jurzua
parents:
diff changeset
7144 // Determine if request has content
jurzua
parents:
diff changeset
7145 s.hasContent = !rnoContent.test( s.type );
jurzua
parents:
diff changeset
7146
jurzua
parents:
diff changeset
7147 // Watch for a new set of requests
jurzua
parents:
diff changeset
7148 if ( fireGlobals && jQuery.active++ === 0 ) {
jurzua
parents:
diff changeset
7149 jQuery.event.trigger( "ajaxStart" );
jurzua
parents:
diff changeset
7150 }
jurzua
parents:
diff changeset
7151
jurzua
parents:
diff changeset
7152 // More options handling for requests with no content
jurzua
parents:
diff changeset
7153 if ( !s.hasContent ) {
jurzua
parents:
diff changeset
7154
jurzua
parents:
diff changeset
7155 // If data is available, append data to url
jurzua
parents:
diff changeset
7156 if ( s.data ) {
jurzua
parents:
diff changeset
7157 s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
jurzua
parents:
diff changeset
7158 }
jurzua
parents:
diff changeset
7159
jurzua
parents:
diff changeset
7160 // Get ifModifiedKey before adding the anti-cache parameter
jurzua
parents:
diff changeset
7161 ifModifiedKey = s.url;
jurzua
parents:
diff changeset
7162
jurzua
parents:
diff changeset
7163 // Add anti-cache in url if needed
jurzua
parents:
diff changeset
7164 if ( s.cache === false ) {
jurzua
parents:
diff changeset
7165
jurzua
parents:
diff changeset
7166 var ts = jQuery.now(),
jurzua
parents:
diff changeset
7167 // try replacing _= if it is there
jurzua
parents:
diff changeset
7168 ret = s.url.replace( rts, "$1_=" + ts );
jurzua
parents:
diff changeset
7169
jurzua
parents:
diff changeset
7170 // if nothing was replaced, add timestamp to the end
jurzua
parents:
diff changeset
7171 s.url = ret + ( (ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
jurzua
parents:
diff changeset
7172 }
jurzua
parents:
diff changeset
7173 }
jurzua
parents:
diff changeset
7174
jurzua
parents:
diff changeset
7175 // Set the correct header, if data is being sent
jurzua
parents:
diff changeset
7176 if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
jurzua
parents:
diff changeset
7177 jqXHR.setRequestHeader( "Content-Type", s.contentType );
jurzua
parents:
diff changeset
7178 }
jurzua
parents:
diff changeset
7179
jurzua
parents:
diff changeset
7180 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
jurzua
parents:
diff changeset
7181 if ( s.ifModified ) {
jurzua
parents:
diff changeset
7182 ifModifiedKey = ifModifiedKey || s.url;
jurzua
parents:
diff changeset
7183 if ( jQuery.lastModified[ ifModifiedKey ] ) {
jurzua
parents:
diff changeset
7184 jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] );
jurzua
parents:
diff changeset
7185 }
jurzua
parents:
diff changeset
7186 if ( jQuery.etag[ ifModifiedKey ] ) {
jurzua
parents:
diff changeset
7187 jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] );
jurzua
parents:
diff changeset
7188 }
jurzua
parents:
diff changeset
7189 }
jurzua
parents:
diff changeset
7190
jurzua
parents:
diff changeset
7191 // Set the Accepts header for the server, depending on the dataType
jurzua
parents:
diff changeset
7192 jqXHR.setRequestHeader(
jurzua
parents:
diff changeset
7193 "Accept",
jurzua
parents:
diff changeset
7194 s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
jurzua
parents:
diff changeset
7195 s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", */*; q=0.01" : "" ) :
jurzua
parents:
diff changeset
7196 s.accepts[ "*" ]
jurzua
parents:
diff changeset
7197 );
jurzua
parents:
diff changeset
7198
jurzua
parents:
diff changeset
7199 // Check for headers option
jurzua
parents:
diff changeset
7200 for ( i in s.headers ) {
jurzua
parents:
diff changeset
7201 jqXHR.setRequestHeader( i, s.headers[ i ] );
jurzua
parents:
diff changeset
7202 }
jurzua
parents:
diff changeset
7203
jurzua
parents:
diff changeset
7204 // Allow custom headers/mimetypes and early abort
jurzua
parents:
diff changeset
7205 if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
jurzua
parents:
diff changeset
7206 // Abort if not done already
jurzua
parents:
diff changeset
7207 jqXHR.abort();
jurzua
parents:
diff changeset
7208 return false;
jurzua
parents:
diff changeset
7209
jurzua
parents:
diff changeset
7210 }
jurzua
parents:
diff changeset
7211
jurzua
parents:
diff changeset
7212 // Install callbacks on deferreds
jurzua
parents:
diff changeset
7213 for ( i in { success: 1, error: 1, complete: 1 } ) {
jurzua
parents:
diff changeset
7214 jqXHR[ i ]( s[ i ] );
jurzua
parents:
diff changeset
7215 }
jurzua
parents:
diff changeset
7216
jurzua
parents:
diff changeset
7217 // Get transport
jurzua
parents:
diff changeset
7218 transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
jurzua
parents:
diff changeset
7219
jurzua
parents:
diff changeset
7220 // If no transport, we auto-abort
jurzua
parents:
diff changeset
7221 if ( !transport ) {
jurzua
parents:
diff changeset
7222 done( -1, "No Transport" );
jurzua
parents:
diff changeset
7223 } else {
jurzua
parents:
diff changeset
7224 jqXHR.readyState = 1;
jurzua
parents:
diff changeset
7225 // Send global event
jurzua
parents:
diff changeset
7226 if ( fireGlobals ) {
jurzua
parents:
diff changeset
7227 globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
jurzua
parents:
diff changeset
7228 }
jurzua
parents:
diff changeset
7229 // Timeout
jurzua
parents:
diff changeset
7230 if ( s.async && s.timeout > 0 ) {
jurzua
parents:
diff changeset
7231 timeoutTimer = setTimeout( function(){
jurzua
parents:
diff changeset
7232 jqXHR.abort( "timeout" );
jurzua
parents:
diff changeset
7233 }, s.timeout );
jurzua
parents:
diff changeset
7234 }
jurzua
parents:
diff changeset
7235
jurzua
parents:
diff changeset
7236 try {
jurzua
parents:
diff changeset
7237 state = 1;
jurzua
parents:
diff changeset
7238 transport.send( requestHeaders, done );
jurzua
parents:
diff changeset
7239 } catch (e) {
jurzua
parents:
diff changeset
7240 // Propagate exception as error if not done
jurzua
parents:
diff changeset
7241 if ( status < 2 ) {
jurzua
parents:
diff changeset
7242 done( -1, e );
jurzua
parents:
diff changeset
7243 // Simply rethrow otherwise
jurzua
parents:
diff changeset
7244 } else {
jurzua
parents:
diff changeset
7245 jQuery.error( e );
jurzua
parents:
diff changeset
7246 }
jurzua
parents:
diff changeset
7247 }
jurzua
parents:
diff changeset
7248 }
jurzua
parents:
diff changeset
7249
jurzua
parents:
diff changeset
7250 return jqXHR;
jurzua
parents:
diff changeset
7251 },
jurzua
parents:
diff changeset
7252
jurzua
parents:
diff changeset
7253 // Serialize an array of form elements or a set of
jurzua
parents:
diff changeset
7254 // key/values into a query string
jurzua
parents:
diff changeset
7255 param: function( a, traditional ) {
jurzua
parents:
diff changeset
7256 var s = [],
jurzua
parents:
diff changeset
7257 add = function( key, value ) {
jurzua
parents:
diff changeset
7258 // If value is a function, invoke it and return its value
jurzua
parents:
diff changeset
7259 value = jQuery.isFunction( value ) ? value() : value;
jurzua
parents:
diff changeset
7260 s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
jurzua
parents:
diff changeset
7261 };
jurzua
parents:
diff changeset
7262
jurzua
parents:
diff changeset
7263 // Set traditional to true for jQuery <= 1.3.2 behavior.
jurzua
parents:
diff changeset
7264 if ( traditional === undefined ) {
jurzua
parents:
diff changeset
7265 traditional = jQuery.ajaxSettings.traditional;
jurzua
parents:
diff changeset
7266 }
jurzua
parents:
diff changeset
7267
jurzua
parents:
diff changeset
7268 // If an array was passed in, assume that it is an array of form elements.
jurzua
parents:
diff changeset
7269 if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
jurzua
parents:
diff changeset
7270 // Serialize the form elements
jurzua
parents:
diff changeset
7271 jQuery.each( a, function() {
jurzua
parents:
diff changeset
7272 add( this.name, this.value );
jurzua
parents:
diff changeset
7273 });
jurzua
parents:
diff changeset
7274
jurzua
parents:
diff changeset
7275 } else {
jurzua
parents:
diff changeset
7276 // If traditional, encode the "old" way (the way 1.3.2 or older
jurzua
parents:
diff changeset
7277 // did it), otherwise encode params recursively.
jurzua
parents:
diff changeset
7278 for ( var prefix in a ) {
jurzua
parents:
diff changeset
7279 buildParams( prefix, a[ prefix ], traditional, add );
jurzua
parents:
diff changeset
7280 }
jurzua
parents:
diff changeset
7281 }
jurzua
parents:
diff changeset
7282
jurzua
parents:
diff changeset
7283 // Return the resulting serialization
jurzua
parents:
diff changeset
7284 return s.join( "&" ).replace( r20, "+" );
jurzua
parents:
diff changeset
7285 }
jurzua
parents:
diff changeset
7286 });
jurzua
parents:
diff changeset
7287
jurzua
parents:
diff changeset
7288 function buildParams( prefix, obj, traditional, add ) {
jurzua
parents:
diff changeset
7289 if ( jQuery.isArray( obj ) ) {
jurzua
parents:
diff changeset
7290 // Serialize array item.
jurzua
parents:
diff changeset
7291 jQuery.each( obj, function( i, v ) {
jurzua
parents:
diff changeset
7292 if ( traditional || rbracket.test( prefix ) ) {
jurzua
parents:
diff changeset
7293 // Treat each array item as a scalar.
jurzua
parents:
diff changeset
7294 add( prefix, v );
jurzua
parents:
diff changeset
7295
jurzua
parents:
diff changeset
7296 } else {
jurzua
parents:
diff changeset
7297 // If array item is non-scalar (array or object), encode its
jurzua
parents:
diff changeset
7298 // numeric index to resolve deserialization ambiguity issues.
jurzua
parents:
diff changeset
7299 // Note that rack (as of 1.0.0) can't currently deserialize
jurzua
parents:
diff changeset
7300 // nested arrays properly, and attempting to do so may cause
jurzua
parents:
diff changeset
7301 // a server error. Possible fixes are to modify rack's
jurzua
parents:
diff changeset
7302 // deserialization algorithm or to provide an option or flag
jurzua
parents:
diff changeset
7303 // to force array serialization to be shallow.
jurzua
parents:
diff changeset
7304 buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
jurzua
parents:
diff changeset
7305 }
jurzua
parents:
diff changeset
7306 });
jurzua
parents:
diff changeset
7307
jurzua
parents:
diff changeset
7308 } else if ( !traditional && obj != null && typeof obj === "object" ) {
jurzua
parents:
diff changeset
7309 // Serialize object item.
jurzua
parents:
diff changeset
7310 for ( var name in obj ) {
jurzua
parents:
diff changeset
7311 buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
jurzua
parents:
diff changeset
7312 }
jurzua
parents:
diff changeset
7313
jurzua
parents:
diff changeset
7314 } else {
jurzua
parents:
diff changeset
7315 // Serialize scalar item.
jurzua
parents:
diff changeset
7316 add( prefix, obj );
jurzua
parents:
diff changeset
7317 }
jurzua
parents:
diff changeset
7318 }
jurzua
parents:
diff changeset
7319
jurzua
parents:
diff changeset
7320 // This is still on the jQuery object... for now
jurzua
parents:
diff changeset
7321 // Want to move this to jQuery.ajax some day
jurzua
parents:
diff changeset
7322 jQuery.extend({
jurzua
parents:
diff changeset
7323
jurzua
parents:
diff changeset
7324 // Counter for holding the number of active queries
jurzua
parents:
diff changeset
7325 active: 0,
jurzua
parents:
diff changeset
7326
jurzua
parents:
diff changeset
7327 // Last-Modified header cache for next request
jurzua
parents:
diff changeset
7328 lastModified: {},
jurzua
parents:
diff changeset
7329 etag: {}
jurzua
parents:
diff changeset
7330
jurzua
parents:
diff changeset
7331 });
jurzua
parents:
diff changeset
7332
jurzua
parents:
diff changeset
7333 /* Handles responses to an ajax request:
jurzua
parents:
diff changeset
7334 * - sets all responseXXX fields accordingly
jurzua
parents:
diff changeset
7335 * - finds the right dataType (mediates between content-type and expected dataType)
jurzua
parents:
diff changeset
7336 * - returns the corresponding response
jurzua
parents:
diff changeset
7337 */
jurzua
parents:
diff changeset
7338 function ajaxHandleResponses( s, jqXHR, responses ) {
jurzua
parents:
diff changeset
7339
jurzua
parents:
diff changeset
7340 var contents = s.contents,
jurzua
parents:
diff changeset
7341 dataTypes = s.dataTypes,
jurzua
parents:
diff changeset
7342 responseFields = s.responseFields,
jurzua
parents:
diff changeset
7343 ct,
jurzua
parents:
diff changeset
7344 type,
jurzua
parents:
diff changeset
7345 finalDataType,
jurzua
parents:
diff changeset
7346 firstDataType;
jurzua
parents:
diff changeset
7347
jurzua
parents:
diff changeset
7348 // Fill responseXXX fields
jurzua
parents:
diff changeset
7349 for( type in responseFields ) {
jurzua
parents:
diff changeset
7350 if ( type in responses ) {
jurzua
parents:
diff changeset
7351 jqXHR[ responseFields[type] ] = responses[ type ];
jurzua
parents:
diff changeset
7352 }
jurzua
parents:
diff changeset
7353 }
jurzua
parents:
diff changeset
7354
jurzua
parents:
diff changeset
7355 // Remove auto dataType and get content-type in the process
jurzua
parents:
diff changeset
7356 while( dataTypes[ 0 ] === "*" ) {
jurzua
parents:
diff changeset
7357 dataTypes.shift();
jurzua
parents:
diff changeset
7358 if ( ct === undefined ) {
jurzua
parents:
diff changeset
7359 ct = s.mimeType || jqXHR.getResponseHeader( "content-type" );
jurzua
parents:
diff changeset
7360 }
jurzua
parents:
diff changeset
7361 }
jurzua
parents:
diff changeset
7362
jurzua
parents:
diff changeset
7363 // Check if we're dealing with a known content-type
jurzua
parents:
diff changeset
7364 if ( ct ) {
jurzua
parents:
diff changeset
7365 for ( type in contents ) {
jurzua
parents:
diff changeset
7366 if ( contents[ type ] && contents[ type ].test( ct ) ) {
jurzua
parents:
diff changeset
7367 dataTypes.unshift( type );
jurzua
parents:
diff changeset
7368 break;
jurzua
parents:
diff changeset
7369 }
jurzua
parents:
diff changeset
7370 }
jurzua
parents:
diff changeset
7371 }
jurzua
parents:
diff changeset
7372
jurzua
parents:
diff changeset
7373 // Check to see if we have a response for the expected dataType
jurzua
parents:
diff changeset
7374 if ( dataTypes[ 0 ] in responses ) {
jurzua
parents:
diff changeset
7375 finalDataType = dataTypes[ 0 ];
jurzua
parents:
diff changeset
7376 } else {
jurzua
parents:
diff changeset
7377 // Try convertible dataTypes
jurzua
parents:
diff changeset
7378 for ( type in responses ) {
jurzua
parents:
diff changeset
7379 if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
jurzua
parents:
diff changeset
7380 finalDataType = type;
jurzua
parents:
diff changeset
7381 break;
jurzua
parents:
diff changeset
7382 }
jurzua
parents:
diff changeset
7383 if ( !firstDataType ) {
jurzua
parents:
diff changeset
7384 firstDataType = type;
jurzua
parents:
diff changeset
7385 }
jurzua
parents:
diff changeset
7386 }
jurzua
parents:
diff changeset
7387 // Or just use first one
jurzua
parents:
diff changeset
7388 finalDataType = finalDataType || firstDataType;
jurzua
parents:
diff changeset
7389 }
jurzua
parents:
diff changeset
7390
jurzua
parents:
diff changeset
7391 // If we found a dataType
jurzua
parents:
diff changeset
7392 // We add the dataType to the list if needed
jurzua
parents:
diff changeset
7393 // and return the corresponding response
jurzua
parents:
diff changeset
7394 if ( finalDataType ) {
jurzua
parents:
diff changeset
7395 if ( finalDataType !== dataTypes[ 0 ] ) {
jurzua
parents:
diff changeset
7396 dataTypes.unshift( finalDataType );
jurzua
parents:
diff changeset
7397 }
jurzua
parents:
diff changeset
7398 return responses[ finalDataType ];
jurzua
parents:
diff changeset
7399 }
jurzua
parents:
diff changeset
7400 }
jurzua
parents:
diff changeset
7401
jurzua
parents:
diff changeset
7402 // Chain conversions given the request and the original response
jurzua
parents:
diff changeset
7403 function ajaxConvert( s, response ) {
jurzua
parents:
diff changeset
7404
jurzua
parents:
diff changeset
7405 // Apply the dataFilter if provided
jurzua
parents:
diff changeset
7406 if ( s.dataFilter ) {
jurzua
parents:
diff changeset
7407 response = s.dataFilter( response, s.dataType );
jurzua
parents:
diff changeset
7408 }
jurzua
parents:
diff changeset
7409
jurzua
parents:
diff changeset
7410 var dataTypes = s.dataTypes,
jurzua
parents:
diff changeset
7411 converters = {},
jurzua
parents:
diff changeset
7412 i,
jurzua
parents:
diff changeset
7413 key,
jurzua
parents:
diff changeset
7414 length = dataTypes.length,
jurzua
parents:
diff changeset
7415 tmp,
jurzua
parents:
diff changeset
7416 // Current and previous dataTypes
jurzua
parents:
diff changeset
7417 current = dataTypes[ 0 ],
jurzua
parents:
diff changeset
7418 prev,
jurzua
parents:
diff changeset
7419 // Conversion expression
jurzua
parents:
diff changeset
7420 conversion,
jurzua
parents:
diff changeset
7421 // Conversion function
jurzua
parents:
diff changeset
7422 conv,
jurzua
parents:
diff changeset
7423 // Conversion functions (transitive conversion)
jurzua
parents:
diff changeset
7424 conv1,
jurzua
parents:
diff changeset
7425 conv2;
jurzua
parents:
diff changeset
7426
jurzua
parents:
diff changeset
7427 // For each dataType in the chain
jurzua
parents:
diff changeset
7428 for( i = 1; i < length; i++ ) {
jurzua
parents:
diff changeset
7429
jurzua
parents:
diff changeset
7430 // Create converters map
jurzua
parents:
diff changeset
7431 // with lowercased keys
jurzua
parents:
diff changeset
7432 if ( i === 1 ) {
jurzua
parents:
diff changeset
7433 for( key in s.converters ) {
jurzua
parents:
diff changeset
7434 if( typeof key === "string" ) {
jurzua
parents:
diff changeset
7435 converters[ key.toLowerCase() ] = s.converters[ key ];
jurzua
parents:
diff changeset
7436 }
jurzua
parents:
diff changeset
7437 }
jurzua
parents:
diff changeset
7438 }
jurzua
parents:
diff changeset
7439
jurzua
parents:
diff changeset
7440 // Get the dataTypes
jurzua
parents:
diff changeset
7441 prev = current;
jurzua
parents:
diff changeset
7442 current = dataTypes[ i ];
jurzua
parents:
diff changeset
7443
jurzua
parents:
diff changeset
7444 // If current is auto dataType, update it to prev
jurzua
parents:
diff changeset
7445 if( current === "*" ) {
jurzua
parents:
diff changeset
7446 current = prev;
jurzua
parents:
diff changeset
7447 // If no auto and dataTypes are actually different
jurzua
parents:
diff changeset
7448 } else if ( prev !== "*" && prev !== current ) {
jurzua
parents:
diff changeset
7449
jurzua
parents:
diff changeset
7450 // Get the converter
jurzua
parents:
diff changeset
7451 conversion = prev + " " + current;
jurzua
parents:
diff changeset
7452 conv = converters[ conversion ] || converters[ "* " + current ];
jurzua
parents:
diff changeset
7453
jurzua
parents:
diff changeset
7454 // If there is no direct converter, search transitively
jurzua
parents:
diff changeset
7455 if ( !conv ) {
jurzua
parents:
diff changeset
7456 conv2 = undefined;
jurzua
parents:
diff changeset
7457 for( conv1 in converters ) {
jurzua
parents:
diff changeset
7458 tmp = conv1.split( " " );
jurzua
parents:
diff changeset
7459 if ( tmp[ 0 ] === prev || tmp[ 0 ] === "*" ) {
jurzua
parents:
diff changeset
7460 conv2 = converters[ tmp[1] + " " + current ];
jurzua
parents:
diff changeset
7461 if ( conv2 ) {
jurzua
parents:
diff changeset
7462 conv1 = converters[ conv1 ];
jurzua
parents:
diff changeset
7463 if ( conv1 === true ) {
jurzua
parents:
diff changeset
7464 conv = conv2;
jurzua
parents:
diff changeset
7465 } else if ( conv2 === true ) {
jurzua
parents:
diff changeset
7466 conv = conv1;
jurzua
parents:
diff changeset
7467 }
jurzua
parents:
diff changeset
7468 break;
jurzua
parents:
diff changeset
7469 }
jurzua
parents:
diff changeset
7470 }
jurzua
parents:
diff changeset
7471 }
jurzua
parents:
diff changeset
7472 }
jurzua
parents:
diff changeset
7473 // If we found no converter, dispatch an error
jurzua
parents:
diff changeset
7474 if ( !( conv || conv2 ) ) {
jurzua
parents:
diff changeset
7475 jQuery.error( "No conversion from " + conversion.replace(" "," to ") );
jurzua
parents:
diff changeset
7476 }
jurzua
parents:
diff changeset
7477 // If found converter is not an equivalence
jurzua
parents:
diff changeset
7478 if ( conv !== true ) {
jurzua
parents:
diff changeset
7479 // Convert with 1 or 2 converters accordingly
jurzua
parents:
diff changeset
7480 response = conv ? conv( response ) : conv2( conv1(response) );
jurzua
parents:
diff changeset
7481 }
jurzua
parents:
diff changeset
7482 }
jurzua
parents:
diff changeset
7483 }
jurzua
parents:
diff changeset
7484 return response;
jurzua
parents:
diff changeset
7485 }
jurzua
parents:
diff changeset
7486
jurzua
parents:
diff changeset
7487
jurzua
parents:
diff changeset
7488
jurzua
parents:
diff changeset
7489
jurzua
parents:
diff changeset
7490 var jsc = jQuery.now(),
jurzua
parents:
diff changeset
7491 jsre = /(\=)\?(&|$)|\?\?/i;
jurzua
parents:
diff changeset
7492
jurzua
parents:
diff changeset
7493 // Default jsonp settings
jurzua
parents:
diff changeset
7494 jQuery.ajaxSetup({
jurzua
parents:
diff changeset
7495 jsonp: "callback",
jurzua
parents:
diff changeset
7496 jsonpCallback: function() {
jurzua
parents:
diff changeset
7497 return jQuery.expando + "_" + ( jsc++ );
jurzua
parents:
diff changeset
7498 }
jurzua
parents:
diff changeset
7499 });
jurzua
parents:
diff changeset
7500
jurzua
parents:
diff changeset
7501 // Detect, normalize options and install callbacks for jsonp requests
jurzua
parents:
diff changeset
7502 jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
jurzua
parents:
diff changeset
7503
jurzua
parents:
diff changeset
7504 var inspectData = s.contentType === "application/x-www-form-urlencoded" &&
jurzua
parents:
diff changeset
7505 ( typeof s.data === "string" );
jurzua
parents:
diff changeset
7506
jurzua
parents:
diff changeset
7507 if ( s.dataTypes[ 0 ] === "jsonp" ||
jurzua
parents:
diff changeset
7508 s.jsonp !== false && ( jsre.test( s.url ) ||
jurzua
parents:
diff changeset
7509 inspectData && jsre.test( s.data ) ) ) {
jurzua
parents:
diff changeset
7510
jurzua
parents:
diff changeset
7511 var responseContainer,
jurzua
parents:
diff changeset
7512 jsonpCallback = s.jsonpCallback =
jurzua
parents:
diff changeset
7513 jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
jurzua
parents:
diff changeset
7514 previous = window[ jsonpCallback ],
jurzua
parents:
diff changeset
7515 url = s.url,
jurzua
parents:
diff changeset
7516 data = s.data,
jurzua
parents:
diff changeset
7517 replace = "$1" + jsonpCallback + "$2";
jurzua
parents:
diff changeset
7518
jurzua
parents:
diff changeset
7519 if ( s.jsonp !== false ) {
jurzua
parents:
diff changeset
7520 url = url.replace( jsre, replace );
jurzua
parents:
diff changeset
7521 if ( s.url === url ) {
jurzua
parents:
diff changeset
7522 if ( inspectData ) {
jurzua
parents:
diff changeset
7523 data = data.replace( jsre, replace );
jurzua
parents:
diff changeset
7524 }
jurzua
parents:
diff changeset
7525 if ( s.data === data ) {
jurzua
parents:
diff changeset
7526 // Add callback manually
jurzua
parents:
diff changeset
7527 url += (/\?/.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
jurzua
parents:
diff changeset
7528 }
jurzua
parents:
diff changeset
7529 }
jurzua
parents:
diff changeset
7530 }
jurzua
parents:
diff changeset
7531
jurzua
parents:
diff changeset
7532 s.url = url;
jurzua
parents:
diff changeset
7533 s.data = data;
jurzua
parents:
diff changeset
7534
jurzua
parents:
diff changeset
7535 // Install callback
jurzua
parents:
diff changeset
7536 window[ jsonpCallback ] = function( response ) {
jurzua
parents:
diff changeset
7537 responseContainer = [ response ];
jurzua
parents:
diff changeset
7538 };
jurzua
parents:
diff changeset
7539
jurzua
parents:
diff changeset
7540 // Clean-up function
jurzua
parents:
diff changeset
7541 jqXHR.always(function() {
jurzua
parents:
diff changeset
7542 // Set callback back to previous value
jurzua
parents:
diff changeset
7543 window[ jsonpCallback ] = previous;
jurzua
parents:
diff changeset
7544 // Call if it was a function and we have a response
jurzua
parents:
diff changeset
7545 if ( responseContainer && jQuery.isFunction( previous ) ) {
jurzua
parents:
diff changeset
7546 window[ jsonpCallback ]( responseContainer[ 0 ] );
jurzua
parents:
diff changeset
7547 }
jurzua
parents:
diff changeset
7548 });
jurzua
parents:
diff changeset
7549
jurzua
parents:
diff changeset
7550 // Use data converter to retrieve json after script execution
jurzua
parents:
diff changeset
7551 s.converters["script json"] = function() {
jurzua
parents:
diff changeset
7552 if ( !responseContainer ) {
jurzua
parents:
diff changeset
7553 jQuery.error( jsonpCallback + " was not called" );
jurzua
parents:
diff changeset
7554 }
jurzua
parents:
diff changeset
7555 return responseContainer[ 0 ];
jurzua
parents:
diff changeset
7556 };
jurzua
parents:
diff changeset
7557
jurzua
parents:
diff changeset
7558 // force json dataType
jurzua
parents:
diff changeset
7559 s.dataTypes[ 0 ] = "json";
jurzua
parents:
diff changeset
7560
jurzua
parents:
diff changeset
7561 // Delegate to script
jurzua
parents:
diff changeset
7562 return "script";
jurzua
parents:
diff changeset
7563 }
jurzua
parents:
diff changeset
7564 });
jurzua
parents:
diff changeset
7565
jurzua
parents:
diff changeset
7566
jurzua
parents:
diff changeset
7567
jurzua
parents:
diff changeset
7568
jurzua
parents:
diff changeset
7569 // Install script dataType
jurzua
parents:
diff changeset
7570 jQuery.ajaxSetup({
jurzua
parents:
diff changeset
7571 accepts: {
jurzua
parents:
diff changeset
7572 script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
jurzua
parents:
diff changeset
7573 },
jurzua
parents:
diff changeset
7574 contents: {
jurzua
parents:
diff changeset
7575 script: /javascript|ecmascript/
jurzua
parents:
diff changeset
7576 },
jurzua
parents:
diff changeset
7577 converters: {
jurzua
parents:
diff changeset
7578 "text script": function( text ) {
jurzua
parents:
diff changeset
7579 jQuery.globalEval( text );
jurzua
parents:
diff changeset
7580 return text;
jurzua
parents:
diff changeset
7581 }
jurzua
parents:
diff changeset
7582 }
jurzua
parents:
diff changeset
7583 });
jurzua
parents:
diff changeset
7584
jurzua
parents:
diff changeset
7585 // Handle cache's special case and global
jurzua
parents:
diff changeset
7586 jQuery.ajaxPrefilter( "script", function( s ) {
jurzua
parents:
diff changeset
7587 if ( s.cache === undefined ) {
jurzua
parents:
diff changeset
7588 s.cache = false;
jurzua
parents:
diff changeset
7589 }
jurzua
parents:
diff changeset
7590 if ( s.crossDomain ) {
jurzua
parents:
diff changeset
7591 s.type = "GET";
jurzua
parents:
diff changeset
7592 s.global = false;
jurzua
parents:
diff changeset
7593 }
jurzua
parents:
diff changeset
7594 });
jurzua
parents:
diff changeset
7595
jurzua
parents:
diff changeset
7596 // Bind script tag hack transport
jurzua
parents:
diff changeset
7597 jQuery.ajaxTransport( "script", function(s) {
jurzua
parents:
diff changeset
7598
jurzua
parents:
diff changeset
7599 // This transport only deals with cross domain requests
jurzua
parents:
diff changeset
7600 if ( s.crossDomain ) {
jurzua
parents:
diff changeset
7601
jurzua
parents:
diff changeset
7602 var script,
jurzua
parents:
diff changeset
7603 head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement;
jurzua
parents:
diff changeset
7604
jurzua
parents:
diff changeset
7605 return {
jurzua
parents:
diff changeset
7606
jurzua
parents:
diff changeset
7607 send: function( _, callback ) {
jurzua
parents:
diff changeset
7608
jurzua
parents:
diff changeset
7609 script = document.createElement( "script" );
jurzua
parents:
diff changeset
7610
jurzua
parents:
diff changeset
7611 script.async = "async";
jurzua
parents:
diff changeset
7612
jurzua
parents:
diff changeset
7613 if ( s.scriptCharset ) {
jurzua
parents:
diff changeset
7614 script.charset = s.scriptCharset;
jurzua
parents:
diff changeset
7615 }
jurzua
parents:
diff changeset
7616
jurzua
parents:
diff changeset
7617 script.src = s.url;
jurzua
parents:
diff changeset
7618
jurzua
parents:
diff changeset
7619 // Attach handlers for all browsers
jurzua
parents:
diff changeset
7620 script.onload = script.onreadystatechange = function( _, isAbort ) {
jurzua
parents:
diff changeset
7621
jurzua
parents:
diff changeset
7622 if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
jurzua
parents:
diff changeset
7623
jurzua
parents:
diff changeset
7624 // Handle memory leak in IE
jurzua
parents:
diff changeset
7625 script.onload = script.onreadystatechange = null;
jurzua
parents:
diff changeset
7626
jurzua
parents:
diff changeset
7627 // Remove the script
jurzua
parents:
diff changeset
7628 if ( head && script.parentNode ) {
jurzua
parents:
diff changeset
7629 head.removeChild( script );
jurzua
parents:
diff changeset
7630 }
jurzua
parents:
diff changeset
7631
jurzua
parents:
diff changeset
7632 // Dereference the script
jurzua
parents:
diff changeset
7633 script = undefined;
jurzua
parents:
diff changeset
7634
jurzua
parents:
diff changeset
7635 // Callback if not abort
jurzua
parents:
diff changeset
7636 if ( !isAbort ) {
jurzua
parents:
diff changeset
7637 callback( 200, "success" );
jurzua
parents:
diff changeset
7638 }
jurzua
parents:
diff changeset
7639 }
jurzua
parents:
diff changeset
7640 };
jurzua
parents:
diff changeset
7641 // Use insertBefore instead of appendChild to circumvent an IE6 bug.
jurzua
parents:
diff changeset
7642 // This arises when a base node is used (#2709 and #4378).
jurzua
parents:
diff changeset
7643 head.insertBefore( script, head.firstChild );
jurzua
parents:
diff changeset
7644 },
jurzua
parents:
diff changeset
7645
jurzua
parents:
diff changeset
7646 abort: function() {
jurzua
parents:
diff changeset
7647 if ( script ) {
jurzua
parents:
diff changeset
7648 script.onload( 0, 1 );
jurzua
parents:
diff changeset
7649 }
jurzua
parents:
diff changeset
7650 }
jurzua
parents:
diff changeset
7651 };
jurzua
parents:
diff changeset
7652 }
jurzua
parents:
diff changeset
7653 });
jurzua
parents:
diff changeset
7654
jurzua
parents:
diff changeset
7655
jurzua
parents:
diff changeset
7656
jurzua
parents:
diff changeset
7657
jurzua
parents:
diff changeset
7658 var // #5280: Internet Explorer will keep connections alive if we don't abort on unload
jurzua
parents:
diff changeset
7659 xhrOnUnloadAbort = window.ActiveXObject ? function() {
jurzua
parents:
diff changeset
7660 // Abort all pending requests
jurzua
parents:
diff changeset
7661 for ( var key in xhrCallbacks ) {
jurzua
parents:
diff changeset
7662 xhrCallbacks[ key ]( 0, 1 );
jurzua
parents:
diff changeset
7663 }
jurzua
parents:
diff changeset
7664 } : false,
jurzua
parents:
diff changeset
7665 xhrId = 0,
jurzua
parents:
diff changeset
7666 xhrCallbacks;
jurzua
parents:
diff changeset
7667
jurzua
parents:
diff changeset
7668 // Functions to create xhrs
jurzua
parents:
diff changeset
7669 function createStandardXHR() {
jurzua
parents:
diff changeset
7670 try {
jurzua
parents:
diff changeset
7671 return new window.XMLHttpRequest();
jurzua
parents:
diff changeset
7672 } catch( e ) {}
jurzua
parents:
diff changeset
7673 }
jurzua
parents:
diff changeset
7674
jurzua
parents:
diff changeset
7675 function createActiveXHR() {
jurzua
parents:
diff changeset
7676 try {
jurzua
parents:
diff changeset
7677 return new window.ActiveXObject( "Microsoft.XMLHTTP" );
jurzua
parents:
diff changeset
7678 } catch( e ) {}
jurzua
parents:
diff changeset
7679 }
jurzua
parents:
diff changeset
7680
jurzua
parents:
diff changeset
7681 // Create the request object
jurzua
parents:
diff changeset
7682 // (This is still attached to ajaxSettings for backward compatibility)
jurzua
parents:
diff changeset
7683 jQuery.ajaxSettings.xhr = window.ActiveXObject ?
jurzua
parents:
diff changeset
7684 /* Microsoft failed to properly
jurzua
parents:
diff changeset
7685 * implement the XMLHttpRequest in IE7 (can't request local files),
jurzua
parents:
diff changeset
7686 * so we use the ActiveXObject when it is available
jurzua
parents:
diff changeset
7687 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
jurzua
parents:
diff changeset
7688 * we need a fallback.
jurzua
parents:
diff changeset
7689 */
jurzua
parents:
diff changeset
7690 function() {
jurzua
parents:
diff changeset
7691 return !this.isLocal && createStandardXHR() || createActiveXHR();
jurzua
parents:
diff changeset
7692 } :
jurzua
parents:
diff changeset
7693 // For all other browsers, use the standard XMLHttpRequest object
jurzua
parents:
diff changeset
7694 createStandardXHR;
jurzua
parents:
diff changeset
7695
jurzua
parents:
diff changeset
7696 // Determine support properties
jurzua
parents:
diff changeset
7697 (function( xhr ) {
jurzua
parents:
diff changeset
7698 jQuery.extend( jQuery.support, {
jurzua
parents:
diff changeset
7699 ajax: !!xhr,
jurzua
parents:
diff changeset
7700 cors: !!xhr && ( "withCredentials" in xhr )
jurzua
parents:
diff changeset
7701 });
jurzua
parents:
diff changeset
7702 })( jQuery.ajaxSettings.xhr() );
jurzua
parents:
diff changeset
7703
jurzua
parents:
diff changeset
7704 // Create transport if the browser can provide an xhr
jurzua
parents:
diff changeset
7705 if ( jQuery.support.ajax ) {
jurzua
parents:
diff changeset
7706
jurzua
parents:
diff changeset
7707 jQuery.ajaxTransport(function( s ) {
jurzua
parents:
diff changeset
7708 // Cross domain only allowed if supported through XMLHttpRequest
jurzua
parents:
diff changeset
7709 if ( !s.crossDomain || jQuery.support.cors ) {
jurzua
parents:
diff changeset
7710
jurzua
parents:
diff changeset
7711 var callback;
jurzua
parents:
diff changeset
7712
jurzua
parents:
diff changeset
7713 return {
jurzua
parents:
diff changeset
7714 send: function( headers, complete ) {
jurzua
parents:
diff changeset
7715
jurzua
parents:
diff changeset
7716 // Get a new xhr
jurzua
parents:
diff changeset
7717 var xhr = s.xhr(),
jurzua
parents:
diff changeset
7718 handle,
jurzua
parents:
diff changeset
7719 i;
jurzua
parents:
diff changeset
7720
jurzua
parents:
diff changeset
7721 // Open the socket
jurzua
parents:
diff changeset
7722 // Passing null username, generates a login popup on Opera (#2865)
jurzua
parents:
diff changeset
7723 if ( s.username ) {
jurzua
parents:
diff changeset
7724 xhr.open( s.type, s.url, s.async, s.username, s.password );
jurzua
parents:
diff changeset
7725 } else {
jurzua
parents:
diff changeset
7726 xhr.open( s.type, s.url, s.async );
jurzua
parents:
diff changeset
7727 }
jurzua
parents:
diff changeset
7728
jurzua
parents:
diff changeset
7729 // Apply custom fields if provided
jurzua
parents:
diff changeset
7730 if ( s.xhrFields ) {
jurzua
parents:
diff changeset
7731 for ( i in s.xhrFields ) {
jurzua
parents:
diff changeset
7732 xhr[ i ] = s.xhrFields[ i ];
jurzua
parents:
diff changeset
7733 }
jurzua
parents:
diff changeset
7734 }
jurzua
parents:
diff changeset
7735
jurzua
parents:
diff changeset
7736 // Override mime type if needed
jurzua
parents:
diff changeset
7737 if ( s.mimeType && xhr.overrideMimeType ) {
jurzua
parents:
diff changeset
7738 xhr.overrideMimeType( s.mimeType );
jurzua
parents:
diff changeset
7739 }
jurzua
parents:
diff changeset
7740
jurzua
parents:
diff changeset
7741 // X-Requested-With header
jurzua
parents:
diff changeset
7742 // For cross-domain requests, seeing as conditions for a preflight are
jurzua
parents:
diff changeset
7743 // akin to a jigsaw puzzle, we simply never set it to be sure.
jurzua
parents:
diff changeset
7744 // (it can always be set on a per-request basis or even using ajaxSetup)
jurzua
parents:
diff changeset
7745 // For same-domain requests, won't change header if already provided.
jurzua
parents:
diff changeset
7746 if ( !s.crossDomain && !headers["X-Requested-With"] ) {
jurzua
parents:
diff changeset
7747 headers[ "X-Requested-With" ] = "XMLHttpRequest";
jurzua
parents:
diff changeset
7748 }
jurzua
parents:
diff changeset
7749
jurzua
parents:
diff changeset
7750 // Need an extra try/catch for cross domain requests in Firefox 3
jurzua
parents:
diff changeset
7751 try {
jurzua
parents:
diff changeset
7752 for ( i in headers ) {
jurzua
parents:
diff changeset
7753 xhr.setRequestHeader( i, headers[ i ] );
jurzua
parents:
diff changeset
7754 }
jurzua
parents:
diff changeset
7755 } catch( _ ) {}
jurzua
parents:
diff changeset
7756
jurzua
parents:
diff changeset
7757 // Do send the request
jurzua
parents:
diff changeset
7758 // This may raise an exception which is actually
jurzua
parents:
diff changeset
7759 // handled in jQuery.ajax (so no try/catch here)
jurzua
parents:
diff changeset
7760 xhr.send( ( s.hasContent && s.data ) || null );
jurzua
parents:
diff changeset
7761
jurzua
parents:
diff changeset
7762 // Listener
jurzua
parents:
diff changeset
7763 callback = function( _, isAbort ) {
jurzua
parents:
diff changeset
7764
jurzua
parents:
diff changeset
7765 var status,
jurzua
parents:
diff changeset
7766 statusText,
jurzua
parents:
diff changeset
7767 responseHeaders,
jurzua
parents:
diff changeset
7768 responses,
jurzua
parents:
diff changeset
7769 xml;
jurzua
parents:
diff changeset
7770
jurzua
parents:
diff changeset
7771 // Firefox throws exceptions when accessing properties
jurzua
parents:
diff changeset
7772 // of an xhr when a network error occured
jurzua
parents:
diff changeset
7773 // http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
jurzua
parents:
diff changeset
7774 try {
jurzua
parents:
diff changeset
7775
jurzua
parents:
diff changeset
7776 // Was never called and is aborted or complete
jurzua
parents:
diff changeset
7777 if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
jurzua
parents:
diff changeset
7778
jurzua
parents:
diff changeset
7779 // Only called once
jurzua
parents:
diff changeset
7780 callback = undefined;
jurzua
parents:
diff changeset
7781
jurzua
parents:
diff changeset
7782 // Do not keep as active anymore
jurzua
parents:
diff changeset
7783 if ( handle ) {
jurzua
parents:
diff changeset
7784 xhr.onreadystatechange = jQuery.noop;
jurzua
parents:
diff changeset
7785 if ( xhrOnUnloadAbort ) {
jurzua
parents:
diff changeset
7786 delete xhrCallbacks[ handle ];
jurzua
parents:
diff changeset
7787 }
jurzua
parents:
diff changeset
7788 }
jurzua
parents:
diff changeset
7789
jurzua
parents:
diff changeset
7790 // If it's an abort
jurzua
parents:
diff changeset
7791 if ( isAbort ) {
jurzua
parents:
diff changeset
7792 // Abort it manually if needed
jurzua
parents:
diff changeset
7793 if ( xhr.readyState !== 4 ) {
jurzua
parents:
diff changeset
7794 xhr.abort();
jurzua
parents:
diff changeset
7795 }
jurzua
parents:
diff changeset
7796 } else {
jurzua
parents:
diff changeset
7797 status = xhr.status;
jurzua
parents:
diff changeset
7798 responseHeaders = xhr.getAllResponseHeaders();
jurzua
parents:
diff changeset
7799 responses = {};
jurzua
parents:
diff changeset
7800 xml = xhr.responseXML;
jurzua
parents:
diff changeset
7801
jurzua
parents:
diff changeset
7802 // Construct response list
jurzua
parents:
diff changeset
7803 if ( xml && xml.documentElement /* #4958 */ ) {
jurzua
parents:
diff changeset
7804 responses.xml = xml;
jurzua
parents:
diff changeset
7805 }
jurzua
parents:
diff changeset
7806 responses.text = xhr.responseText;
jurzua
parents:
diff changeset
7807
jurzua
parents:
diff changeset
7808 // Firefox throws an exception when accessing
jurzua
parents:
diff changeset
7809 // statusText for faulty cross-domain requests
jurzua
parents:
diff changeset
7810 try {
jurzua
parents:
diff changeset
7811 statusText = xhr.statusText;
jurzua
parents:
diff changeset
7812 } catch( e ) {
jurzua
parents:
diff changeset
7813 // We normalize with Webkit giving an empty statusText
jurzua
parents:
diff changeset
7814 statusText = "";
jurzua
parents:
diff changeset
7815 }
jurzua
parents:
diff changeset
7816
jurzua
parents:
diff changeset
7817 // Filter status for non standard behaviors
jurzua
parents:
diff changeset
7818
jurzua
parents:
diff changeset
7819 // If the request is local and we have data: assume a success
jurzua
parents:
diff changeset
7820 // (success with no data won't get notified, that's the best we
jurzua
parents:
diff changeset
7821 // can do given current implementations)
jurzua
parents:
diff changeset
7822 if ( !status && s.isLocal && !s.crossDomain ) {
jurzua
parents:
diff changeset
7823 status = responses.text ? 200 : 404;
jurzua
parents:
diff changeset
7824 // IE - #1450: sometimes returns 1223 when it should be 204
jurzua
parents:
diff changeset
7825 } else if ( status === 1223 ) {
jurzua
parents:
diff changeset
7826 status = 204;
jurzua
parents:
diff changeset
7827 }
jurzua
parents:
diff changeset
7828 }
jurzua
parents:
diff changeset
7829 }
jurzua
parents:
diff changeset
7830 } catch( firefoxAccessException ) {
jurzua
parents:
diff changeset
7831 if ( !isAbort ) {
jurzua
parents:
diff changeset
7832 complete( -1, firefoxAccessException );
jurzua
parents:
diff changeset
7833 }
jurzua
parents:
diff changeset
7834 }
jurzua
parents:
diff changeset
7835
jurzua
parents:
diff changeset
7836 // Call complete if needed
jurzua
parents:
diff changeset
7837 if ( responses ) {
jurzua
parents:
diff changeset
7838 complete( status, statusText, responses, responseHeaders );
jurzua
parents:
diff changeset
7839 }
jurzua
parents:
diff changeset
7840 };
jurzua
parents:
diff changeset
7841
jurzua
parents:
diff changeset
7842 // if we're in sync mode or it's in cache
jurzua
parents:
diff changeset
7843 // and has been retrieved directly (IE6 & IE7)
jurzua
parents:
diff changeset
7844 // we need to manually fire the callback
jurzua
parents:
diff changeset
7845 if ( !s.async || xhr.readyState === 4 ) {
jurzua
parents:
diff changeset
7846 callback();
jurzua
parents:
diff changeset
7847 } else {
jurzua
parents:
diff changeset
7848 handle = ++xhrId;
jurzua
parents:
diff changeset
7849 if ( xhrOnUnloadAbort ) {
jurzua
parents:
diff changeset
7850 // Create the active xhrs callbacks list if needed
jurzua
parents:
diff changeset
7851 // and attach the unload handler
jurzua
parents:
diff changeset
7852 if ( !xhrCallbacks ) {
jurzua
parents:
diff changeset
7853 xhrCallbacks = {};
jurzua
parents:
diff changeset
7854 jQuery( window ).unload( xhrOnUnloadAbort );
jurzua
parents:
diff changeset
7855 }
jurzua
parents:
diff changeset
7856 // Add to list of active xhrs callbacks
jurzua
parents:
diff changeset
7857 xhrCallbacks[ handle ] = callback;
jurzua
parents:
diff changeset
7858 }
jurzua
parents:
diff changeset
7859 xhr.onreadystatechange = callback;
jurzua
parents:
diff changeset
7860 }
jurzua
parents:
diff changeset
7861 },
jurzua
parents:
diff changeset
7862
jurzua
parents:
diff changeset
7863 abort: function() {
jurzua
parents:
diff changeset
7864 if ( callback ) {
jurzua
parents:
diff changeset
7865 callback(0,1);
jurzua
parents:
diff changeset
7866 }
jurzua
parents:
diff changeset
7867 }
jurzua
parents:
diff changeset
7868 };
jurzua
parents:
diff changeset
7869 }
jurzua
parents:
diff changeset
7870 });
jurzua
parents:
diff changeset
7871 }
jurzua
parents:
diff changeset
7872
jurzua
parents:
diff changeset
7873
jurzua
parents:
diff changeset
7874
jurzua
parents:
diff changeset
7875
jurzua
parents:
diff changeset
7876 var elemdisplay = {},
jurzua
parents:
diff changeset
7877 iframe, iframeDoc,
jurzua
parents:
diff changeset
7878 rfxtypes = /^(?:toggle|show|hide)$/,
jurzua
parents:
diff changeset
7879 rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
jurzua
parents:
diff changeset
7880 timerId,
jurzua
parents:
diff changeset
7881 fxAttrs = [
jurzua
parents:
diff changeset
7882 // height animations
jurzua
parents:
diff changeset
7883 [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
jurzua
parents:
diff changeset
7884 // width animations
jurzua
parents:
diff changeset
7885 [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
jurzua
parents:
diff changeset
7886 // opacity animations
jurzua
parents:
diff changeset
7887 [ "opacity" ]
jurzua
parents:
diff changeset
7888 ],
jurzua
parents:
diff changeset
7889 fxNow,
jurzua
parents:
diff changeset
7890 requestAnimationFrame = window.webkitRequestAnimationFrame ||
jurzua
parents:
diff changeset
7891 window.mozRequestAnimationFrame ||
jurzua
parents:
diff changeset
7892 window.oRequestAnimationFrame;
jurzua
parents:
diff changeset
7893
jurzua
parents:
diff changeset
7894 jQuery.fn.extend({
jurzua
parents:
diff changeset
7895 show: function( speed, easing, callback ) {
jurzua
parents:
diff changeset
7896 var elem, display;
jurzua
parents:
diff changeset
7897
jurzua
parents:
diff changeset
7898 if ( speed || speed === 0 ) {
jurzua
parents:
diff changeset
7899 return this.animate( genFx("show", 3), speed, easing, callback);
jurzua
parents:
diff changeset
7900
jurzua
parents:
diff changeset
7901 } else {
jurzua
parents:
diff changeset
7902 for ( var i = 0, j = this.length; i < j; i++ ) {
jurzua
parents:
diff changeset
7903 elem = this[i];
jurzua
parents:
diff changeset
7904
jurzua
parents:
diff changeset
7905 if ( elem.style ) {
jurzua
parents:
diff changeset
7906 display = elem.style.display;
jurzua
parents:
diff changeset
7907
jurzua
parents:
diff changeset
7908 // Reset the inline display of this element to learn if it is
jurzua
parents:
diff changeset
7909 // being hidden by cascaded rules or not
jurzua
parents:
diff changeset
7910 if ( !jQuery._data(elem, "olddisplay") && display === "none" ) {
jurzua
parents:
diff changeset
7911 display = elem.style.display = "";
jurzua
parents:
diff changeset
7912 }
jurzua
parents:
diff changeset
7913
jurzua
parents:
diff changeset
7914 // Set elements which have been overridden with display: none
jurzua
parents:
diff changeset
7915 // in a stylesheet to whatever the default browser style is
jurzua
parents:
diff changeset
7916 // for such an element
jurzua
parents:
diff changeset
7917 if ( display === "" && jQuery.css( elem, "display" ) === "none" ) {
jurzua
parents:
diff changeset
7918 jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName));
jurzua
parents:
diff changeset
7919 }
jurzua
parents:
diff changeset
7920 }
jurzua
parents:
diff changeset
7921 }
jurzua
parents:
diff changeset
7922
jurzua
parents:
diff changeset
7923 // Set the display of most of the elements in a second loop
jurzua
parents:
diff changeset
7924 // to avoid the constant reflow
jurzua
parents:
diff changeset
7925 for ( i = 0; i < j; i++ ) {
jurzua
parents:
diff changeset
7926 elem = this[i];
jurzua
parents:
diff changeset
7927
jurzua
parents:
diff changeset
7928 if ( elem.style ) {
jurzua
parents:
diff changeset
7929 display = elem.style.display;
jurzua
parents:
diff changeset
7930
jurzua
parents:
diff changeset
7931 if ( display === "" || display === "none" ) {
jurzua
parents:
diff changeset
7932 elem.style.display = jQuery._data(elem, "olddisplay") || "";
jurzua
parents:
diff changeset
7933 }
jurzua
parents:
diff changeset
7934 }
jurzua
parents:
diff changeset
7935 }
jurzua
parents:
diff changeset
7936
jurzua
parents:
diff changeset
7937 return this;
jurzua
parents:
diff changeset
7938 }
jurzua
parents:
diff changeset
7939 },
jurzua
parents:
diff changeset
7940
jurzua
parents:
diff changeset
7941 hide: function( speed, easing, callback ) {
jurzua
parents:
diff changeset
7942 if ( speed || speed === 0 ) {
jurzua
parents:
diff changeset
7943 return this.animate( genFx("hide", 3), speed, easing, callback);
jurzua
parents:
diff changeset
7944
jurzua
parents:
diff changeset
7945 } else {
jurzua
parents:
diff changeset
7946 for ( var i = 0, j = this.length; i < j; i++ ) {
jurzua
parents:
diff changeset
7947 if ( this[i].style ) {
jurzua
parents:
diff changeset
7948 var display = jQuery.css( this[i], "display" );
jurzua
parents:
diff changeset
7949
jurzua
parents:
diff changeset
7950 if ( display !== "none" && !jQuery._data( this[i], "olddisplay" ) ) {
jurzua
parents:
diff changeset
7951 jQuery._data( this[i], "olddisplay", display );
jurzua
parents:
diff changeset
7952 }
jurzua
parents:
diff changeset
7953 }
jurzua
parents:
diff changeset
7954 }
jurzua
parents:
diff changeset
7955
jurzua
parents:
diff changeset
7956 // Set the display of the elements in a second loop
jurzua
parents:
diff changeset
7957 // to avoid the constant reflow
jurzua
parents:
diff changeset
7958 for ( i = 0; i < j; i++ ) {
jurzua
parents:
diff changeset
7959 if ( this[i].style ) {
jurzua
parents:
diff changeset
7960 this[i].style.display = "none";
jurzua
parents:
diff changeset
7961 }
jurzua
parents:
diff changeset
7962 }
jurzua
parents:
diff changeset
7963
jurzua
parents:
diff changeset
7964 return this;
jurzua
parents:
diff changeset
7965 }
jurzua
parents:
diff changeset
7966 },
jurzua
parents:
diff changeset
7967
jurzua
parents:
diff changeset
7968 // Save the old toggle function
jurzua
parents:
diff changeset
7969 _toggle: jQuery.fn.toggle,
jurzua
parents:
diff changeset
7970
jurzua
parents:
diff changeset
7971 toggle: function( fn, fn2, callback ) {
jurzua
parents:
diff changeset
7972 var bool = typeof fn === "boolean";
jurzua
parents:
diff changeset
7973
jurzua
parents:
diff changeset
7974 if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
jurzua
parents:
diff changeset
7975 this._toggle.apply( this, arguments );
jurzua
parents:
diff changeset
7976
jurzua
parents:
diff changeset
7977 } else if ( fn == null || bool ) {
jurzua
parents:
diff changeset
7978 this.each(function() {
jurzua
parents:
diff changeset
7979 var state = bool ? fn : jQuery(this).is(":hidden");
jurzua
parents:
diff changeset
7980 jQuery(this)[ state ? "show" : "hide" ]();
jurzua
parents:
diff changeset
7981 });
jurzua
parents:
diff changeset
7982
jurzua
parents:
diff changeset
7983 } else {
jurzua
parents:
diff changeset
7984 this.animate(genFx("toggle", 3), fn, fn2, callback);
jurzua
parents:
diff changeset
7985 }
jurzua
parents:
diff changeset
7986
jurzua
parents:
diff changeset
7987 return this;
jurzua
parents:
diff changeset
7988 },
jurzua
parents:
diff changeset
7989
jurzua
parents:
diff changeset
7990 fadeTo: function( speed, to, easing, callback ) {
jurzua
parents:
diff changeset
7991 return this.filter(":hidden").css("opacity", 0).show().end()
jurzua
parents:
diff changeset
7992 .animate({opacity: to}, speed, easing, callback);
jurzua
parents:
diff changeset
7993 },
jurzua
parents:
diff changeset
7994
jurzua
parents:
diff changeset
7995 animate: function( prop, speed, easing, callback ) {
jurzua
parents:
diff changeset
7996 var optall = jQuery.speed(speed, easing, callback);
jurzua
parents:
diff changeset
7997
jurzua
parents:
diff changeset
7998 if ( jQuery.isEmptyObject( prop ) ) {
jurzua
parents:
diff changeset
7999 return this.each( optall.complete, [ false ] );
jurzua
parents:
diff changeset
8000 }
jurzua
parents:
diff changeset
8001
jurzua
parents:
diff changeset
8002 return this[ optall.queue === false ? "each" : "queue" ](function() {
jurzua
parents:
diff changeset
8003 // XXX 'this' does not always have a nodeName when running the
jurzua
parents:
diff changeset
8004 // test suite
jurzua
parents:
diff changeset
8005
jurzua
parents:
diff changeset
8006 if ( optall.queue === false ) {
jurzua
parents:
diff changeset
8007 jQuery._mark( this );
jurzua
parents:
diff changeset
8008 }
jurzua
parents:
diff changeset
8009
jurzua
parents:
diff changeset
8010 var opt = jQuery.extend({}, optall),
jurzua
parents:
diff changeset
8011 isElement = this.nodeType === 1,
jurzua
parents:
diff changeset
8012 hidden = isElement && jQuery(this).is(":hidden"),
jurzua
parents:
diff changeset
8013 name, val, p,
jurzua
parents:
diff changeset
8014 display, e,
jurzua
parents:
diff changeset
8015 parts, start, end, unit;
jurzua
parents:
diff changeset
8016
jurzua
parents:
diff changeset
8017 // will store per property easing and be used to determine when an animation is complete
jurzua
parents:
diff changeset
8018 opt.animatedProperties = {};
jurzua
parents:
diff changeset
8019
jurzua
parents:
diff changeset
8020 for ( p in prop ) {
jurzua
parents:
diff changeset
8021
jurzua
parents:
diff changeset
8022 // property name normalization
jurzua
parents:
diff changeset
8023 name = jQuery.camelCase( p );
jurzua
parents:
diff changeset
8024 if ( p !== name ) {
jurzua
parents:
diff changeset
8025 prop[ name ] = prop[ p ];
jurzua
parents:
diff changeset
8026 delete prop[ p ];
jurzua
parents:
diff changeset
8027 }
jurzua
parents:
diff changeset
8028
jurzua
parents:
diff changeset
8029 val = prop[name];
jurzua
parents:
diff changeset
8030
jurzua
parents:
diff changeset
8031 if ( val === "hide" && hidden || val === "show" && !hidden ) {
jurzua
parents:
diff changeset
8032 return opt.complete.call(this);
jurzua
parents:
diff changeset
8033 }
jurzua
parents:
diff changeset
8034
jurzua
parents:
diff changeset
8035 if ( isElement && ( name === "height" || name === "width" ) ) {
jurzua
parents:
diff changeset
8036 // Make sure that nothing sneaks out
jurzua
parents:
diff changeset
8037 // Record all 3 overflow attributes because IE does not
jurzua
parents:
diff changeset
8038 // change the overflow attribute when overflowX and
jurzua
parents:
diff changeset
8039 // overflowY are set to the same value
jurzua
parents:
diff changeset
8040 opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
jurzua
parents:
diff changeset
8041
jurzua
parents:
diff changeset
8042 // Set display property to inline-block for height/width
jurzua
parents:
diff changeset
8043 // animations on inline elements that are having width/height
jurzua
parents:
diff changeset
8044 // animated
jurzua
parents:
diff changeset
8045 if ( jQuery.css( this, "display" ) === "inline" &&
jurzua
parents:
diff changeset
8046 jQuery.css( this, "float" ) === "none" ) {
jurzua
parents:
diff changeset
8047 if ( !jQuery.support.inlineBlockNeedsLayout ) {
jurzua
parents:
diff changeset
8048 this.style.display = "inline-block";
jurzua
parents:
diff changeset
8049
jurzua
parents:
diff changeset
8050 } else {
jurzua
parents:
diff changeset
8051 display = defaultDisplay(this.nodeName);
jurzua
parents:
diff changeset
8052
jurzua
parents:
diff changeset
8053 // inline-level elements accept inline-block;
jurzua
parents:
diff changeset
8054 // block-level elements need to be inline with layout
jurzua
parents:
diff changeset
8055 if ( display === "inline" ) {
jurzua
parents:
diff changeset
8056 this.style.display = "inline-block";
jurzua
parents:
diff changeset
8057
jurzua
parents:
diff changeset
8058 } else {
jurzua
parents:
diff changeset
8059 this.style.display = "inline";
jurzua
parents:
diff changeset
8060 this.style.zoom = 1;
jurzua
parents:
diff changeset
8061 }
jurzua
parents:
diff changeset
8062 }
jurzua
parents:
diff changeset
8063 }
jurzua
parents:
diff changeset
8064 }
jurzua
parents:
diff changeset
8065
jurzua
parents:
diff changeset
8066 // easing resolution: per property > opt.specialEasing > opt.easing > 'swing' (default)
jurzua
parents:
diff changeset
8067 opt.animatedProperties[name] = jQuery.isArray( val ) ?
jurzua
parents:
diff changeset
8068 val[1]:
jurzua
parents:
diff changeset
8069 opt.specialEasing && opt.specialEasing[name] || opt.easing || 'swing';
jurzua
parents:
diff changeset
8070 }
jurzua
parents:
diff changeset
8071
jurzua
parents:
diff changeset
8072 if ( opt.overflow != null ) {
jurzua
parents:
diff changeset
8073 this.style.overflow = "hidden";
jurzua
parents:
diff changeset
8074 }
jurzua
parents:
diff changeset
8075
jurzua
parents:
diff changeset
8076 for ( p in prop ) {
jurzua
parents:
diff changeset
8077 e = new jQuery.fx( this, opt, p );
jurzua
parents:
diff changeset
8078
jurzua
parents:
diff changeset
8079 val = prop[p];
jurzua
parents:
diff changeset
8080
jurzua
parents:
diff changeset
8081 if ( rfxtypes.test(val) ) {
jurzua
parents:
diff changeset
8082 e[ val === "toggle" ? hidden ? "show" : "hide" : val ]();
jurzua
parents:
diff changeset
8083
jurzua
parents:
diff changeset
8084 } else {
jurzua
parents:
diff changeset
8085 parts = rfxnum.exec(val);
jurzua
parents:
diff changeset
8086 start = e.cur();
jurzua
parents:
diff changeset
8087
jurzua
parents:
diff changeset
8088 if ( parts ) {
jurzua
parents:
diff changeset
8089 end = parseFloat( parts[2] );
jurzua
parents:
diff changeset
8090 unit = parts[3] || ( jQuery.cssNumber[ name ] ? "" : "px" );
jurzua
parents:
diff changeset
8091
jurzua
parents:
diff changeset
8092 // We need to compute starting value
jurzua
parents:
diff changeset
8093 if ( unit !== "px" ) {
jurzua
parents:
diff changeset
8094 jQuery.style( this, p, (end || 1) + unit);
jurzua
parents:
diff changeset
8095 start = ((end || 1) / e.cur()) * start;
jurzua
parents:
diff changeset
8096 jQuery.style( this, p, start + unit);
jurzua
parents:
diff changeset
8097 }
jurzua
parents:
diff changeset
8098
jurzua
parents:
diff changeset
8099 // If a +=/-= token was provided, we're doing a relative animation
jurzua
parents:
diff changeset
8100 if ( parts[1] ) {
jurzua
parents:
diff changeset
8101 end = ((parts[1] === "-=" ? -1 : 1) * end) + start;
jurzua
parents:
diff changeset
8102 }
jurzua
parents:
diff changeset
8103
jurzua
parents:
diff changeset
8104 e.custom( start, end, unit );
jurzua
parents:
diff changeset
8105
jurzua
parents:
diff changeset
8106 } else {
jurzua
parents:
diff changeset
8107 e.custom( start, val, "" );
jurzua
parents:
diff changeset
8108 }
jurzua
parents:
diff changeset
8109 }
jurzua
parents:
diff changeset
8110 }
jurzua
parents:
diff changeset
8111
jurzua
parents:
diff changeset
8112 // For JS strict compliance
jurzua
parents:
diff changeset
8113 return true;
jurzua
parents:
diff changeset
8114 });
jurzua
parents:
diff changeset
8115 },
jurzua
parents:
diff changeset
8116
jurzua
parents:
diff changeset
8117 stop: function( clearQueue, gotoEnd ) {
jurzua
parents:
diff changeset
8118 if ( clearQueue ) {
jurzua
parents:
diff changeset
8119 this.queue([]);
jurzua
parents:
diff changeset
8120 }
jurzua
parents:
diff changeset
8121
jurzua
parents:
diff changeset
8122 this.each(function() {
jurzua
parents:
diff changeset
8123 var timers = jQuery.timers,
jurzua
parents:
diff changeset
8124 i = timers.length;
jurzua
parents:
diff changeset
8125 // clear marker counters if we know they won't be
jurzua
parents:
diff changeset
8126 if ( !gotoEnd ) {
jurzua
parents:
diff changeset
8127 jQuery._unmark( true, this );
jurzua
parents:
diff changeset
8128 }
jurzua
parents:
diff changeset
8129 // go in reverse order so anything added to the queue during the loop is ignored
jurzua
parents:
diff changeset
8130 while ( i-- ) {
jurzua
parents:
diff changeset
8131 if ( timers[i].elem === this ) {
jurzua
parents:
diff changeset
8132 if (gotoEnd) {
jurzua
parents:
diff changeset
8133 // force the next step to be the last
jurzua
parents:
diff changeset
8134 timers[i](true);
jurzua
parents:
diff changeset
8135 }
jurzua
parents:
diff changeset
8136
jurzua
parents:
diff changeset
8137 timers.splice(i, 1);
jurzua
parents:
diff changeset
8138 }
jurzua
parents:
diff changeset
8139 }
jurzua
parents:
diff changeset
8140 });
jurzua
parents:
diff changeset
8141
jurzua
parents:
diff changeset
8142 // start the next in the queue if the last step wasn't forced
jurzua
parents:
diff changeset
8143 if ( !gotoEnd ) {
jurzua
parents:
diff changeset
8144 this.dequeue();
jurzua
parents:
diff changeset
8145 }
jurzua
parents:
diff changeset
8146
jurzua
parents:
diff changeset
8147 return this;
jurzua
parents:
diff changeset
8148 }
jurzua
parents:
diff changeset
8149
jurzua
parents:
diff changeset
8150 });
jurzua
parents:
diff changeset
8151
jurzua
parents:
diff changeset
8152 // Animations created synchronously will run synchronously
jurzua
parents:
diff changeset
8153 function createFxNow() {
jurzua
parents:
diff changeset
8154 setTimeout( clearFxNow, 0 );
jurzua
parents:
diff changeset
8155 return ( fxNow = jQuery.now() );
jurzua
parents:
diff changeset
8156 }
jurzua
parents:
diff changeset
8157
jurzua
parents:
diff changeset
8158 function clearFxNow() {
jurzua
parents:
diff changeset
8159 fxNow = undefined;
jurzua
parents:
diff changeset
8160 }
jurzua
parents:
diff changeset
8161
jurzua
parents:
diff changeset
8162 // Generate parameters to create a standard animation
jurzua
parents:
diff changeset
8163 function genFx( type, num ) {
jurzua
parents:
diff changeset
8164 var obj = {};
jurzua
parents:
diff changeset
8165
jurzua
parents:
diff changeset
8166 jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
jurzua
parents:
diff changeset
8167 obj[ this ] = type;
jurzua
parents:
diff changeset
8168 });
jurzua
parents:
diff changeset
8169
jurzua
parents:
diff changeset
8170 return obj;
jurzua
parents:
diff changeset
8171 }
jurzua
parents:
diff changeset
8172
jurzua
parents:
diff changeset
8173 // Generate shortcuts for custom animations
jurzua
parents:
diff changeset
8174 jQuery.each({
jurzua
parents:
diff changeset
8175 slideDown: genFx("show", 1),
jurzua
parents:
diff changeset
8176 slideUp: genFx("hide", 1),
jurzua
parents:
diff changeset
8177 slideToggle: genFx("toggle", 1),
jurzua
parents:
diff changeset
8178 fadeIn: { opacity: "show" },
jurzua
parents:
diff changeset
8179 fadeOut: { opacity: "hide" },
jurzua
parents:
diff changeset
8180 fadeToggle: { opacity: "toggle" }
jurzua
parents:
diff changeset
8181 }, function( name, props ) {
jurzua
parents:
diff changeset
8182 jQuery.fn[ name ] = function( speed, easing, callback ) {
jurzua
parents:
diff changeset
8183 return this.animate( props, speed, easing, callback );
jurzua
parents:
diff changeset
8184 };
jurzua
parents:
diff changeset
8185 });
jurzua
parents:
diff changeset
8186
jurzua
parents:
diff changeset
8187 jQuery.extend({
jurzua
parents:
diff changeset
8188 speed: function( speed, easing, fn ) {
jurzua
parents:
diff changeset
8189 var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
jurzua
parents:
diff changeset
8190 complete: fn || !fn && easing ||
jurzua
parents:
diff changeset
8191 jQuery.isFunction( speed ) && speed,
jurzua
parents:
diff changeset
8192 duration: speed,
jurzua
parents:
diff changeset
8193 easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
jurzua
parents:
diff changeset
8194 };
jurzua
parents:
diff changeset
8195
jurzua
parents:
diff changeset
8196 opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
jurzua
parents:
diff changeset
8197 opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
jurzua
parents:
diff changeset
8198
jurzua
parents:
diff changeset
8199 // Queueing
jurzua
parents:
diff changeset
8200 opt.old = opt.complete;
jurzua
parents:
diff changeset
8201 opt.complete = function( noUnmark ) {
jurzua
parents:
diff changeset
8202 if ( opt.queue !== false ) {
jurzua
parents:
diff changeset
8203 jQuery.dequeue( this );
jurzua
parents:
diff changeset
8204 } else if ( noUnmark !== false ) {
jurzua
parents:
diff changeset
8205 jQuery._unmark( this );
jurzua
parents:
diff changeset
8206 }
jurzua
parents:
diff changeset
8207
jurzua
parents:
diff changeset
8208 if ( jQuery.isFunction( opt.old ) ) {
jurzua
parents:
diff changeset
8209 opt.old.call( this );
jurzua
parents:
diff changeset
8210 }
jurzua
parents:
diff changeset
8211 };
jurzua
parents:
diff changeset
8212
jurzua
parents:
diff changeset
8213 return opt;
jurzua
parents:
diff changeset
8214 },
jurzua
parents:
diff changeset
8215
jurzua
parents:
diff changeset
8216 easing: {
jurzua
parents:
diff changeset
8217 linear: function( p, n, firstNum, diff ) {
jurzua
parents:
diff changeset
8218 return firstNum + diff * p;
jurzua
parents:
diff changeset
8219 },
jurzua
parents:
diff changeset
8220 swing: function( p, n, firstNum, diff ) {
jurzua
parents:
diff changeset
8221 return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
jurzua
parents:
diff changeset
8222 }
jurzua
parents:
diff changeset
8223 },
jurzua
parents:
diff changeset
8224
jurzua
parents:
diff changeset
8225 timers: [],
jurzua
parents:
diff changeset
8226
jurzua
parents:
diff changeset
8227 fx: function( elem, options, prop ) {
jurzua
parents:
diff changeset
8228 this.options = options;
jurzua
parents:
diff changeset
8229 this.elem = elem;
jurzua
parents:
diff changeset
8230 this.prop = prop;
jurzua
parents:
diff changeset
8231
jurzua
parents:
diff changeset
8232 options.orig = options.orig || {};
jurzua
parents:
diff changeset
8233 }
jurzua
parents:
diff changeset
8234
jurzua
parents:
diff changeset
8235 });
jurzua
parents:
diff changeset
8236
jurzua
parents:
diff changeset
8237 jQuery.fx.prototype = {
jurzua
parents:
diff changeset
8238 // Simple function for setting a style value
jurzua
parents:
diff changeset
8239 update: function() {
jurzua
parents:
diff changeset
8240 if ( this.options.step ) {
jurzua
parents:
diff changeset
8241 this.options.step.call( this.elem, this.now, this );
jurzua
parents:
diff changeset
8242 }
jurzua
parents:
diff changeset
8243
jurzua
parents:
diff changeset
8244 (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
jurzua
parents:
diff changeset
8245 },
jurzua
parents:
diff changeset
8246
jurzua
parents:
diff changeset
8247 // Get the current size
jurzua
parents:
diff changeset
8248 cur: function() {
jurzua
parents:
diff changeset
8249 if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
jurzua
parents:
diff changeset
8250 return this.elem[ this.prop ];
jurzua
parents:
diff changeset
8251 }
jurzua
parents:
diff changeset
8252
jurzua
parents:
diff changeset
8253 var parsed,
jurzua
parents:
diff changeset
8254 r = jQuery.css( this.elem, this.prop );
jurzua
parents:
diff changeset
8255 // Empty strings, null, undefined and "auto" are converted to 0,
jurzua
parents:
diff changeset
8256 // complex values such as "rotate(1rad)" are returned as is,
jurzua
parents:
diff changeset
8257 // simple values such as "10px" are parsed to Float.
jurzua
parents:
diff changeset
8258 return isNaN( parsed = parseFloat( r ) ) ? !r || r === "auto" ? 0 : r : parsed;
jurzua
parents:
diff changeset
8259 },
jurzua
parents:
diff changeset
8260
jurzua
parents:
diff changeset
8261 // Start an animation from one number to another
jurzua
parents:
diff changeset
8262 custom: function( from, to, unit ) {
jurzua
parents:
diff changeset
8263 var self = this,
jurzua
parents:
diff changeset
8264 fx = jQuery.fx,
jurzua
parents:
diff changeset
8265 raf;
jurzua
parents:
diff changeset
8266
jurzua
parents:
diff changeset
8267 this.startTime = fxNow || createFxNow();
jurzua
parents:
diff changeset
8268 this.start = from;
jurzua
parents:
diff changeset
8269 this.end = to;
jurzua
parents:
diff changeset
8270 this.unit = unit || this.unit || ( jQuery.cssNumber[ this.prop ] ? "" : "px" );
jurzua
parents:
diff changeset
8271 this.now = this.start;
jurzua
parents:
diff changeset
8272 this.pos = this.state = 0;
jurzua
parents:
diff changeset
8273
jurzua
parents:
diff changeset
8274 function t( gotoEnd ) {
jurzua
parents:
diff changeset
8275 return self.step(gotoEnd);
jurzua
parents:
diff changeset
8276 }
jurzua
parents:
diff changeset
8277
jurzua
parents:
diff changeset
8278 t.elem = this.elem;
jurzua
parents:
diff changeset
8279
jurzua
parents:
diff changeset
8280 if ( t() && jQuery.timers.push(t) && !timerId ) {
jurzua
parents:
diff changeset
8281 // Use requestAnimationFrame instead of setInterval if available
jurzua
parents:
diff changeset
8282 if ( requestAnimationFrame ) {
jurzua
parents:
diff changeset
8283 timerId = 1;
jurzua
parents:
diff changeset
8284 raf = function() {
jurzua
parents:
diff changeset
8285 // When timerId gets set to null at any point, this stops
jurzua
parents:
diff changeset
8286 if ( timerId ) {
jurzua
parents:
diff changeset
8287 requestAnimationFrame( raf );
jurzua
parents:
diff changeset
8288 fx.tick();
jurzua
parents:
diff changeset
8289 }
jurzua
parents:
diff changeset
8290 };
jurzua
parents:
diff changeset
8291 requestAnimationFrame( raf );
jurzua
parents:
diff changeset
8292 } else {
jurzua
parents:
diff changeset
8293 timerId = setInterval( fx.tick, fx.interval );
jurzua
parents:
diff changeset
8294 }
jurzua
parents:
diff changeset
8295 }
jurzua
parents:
diff changeset
8296 },
jurzua
parents:
diff changeset
8297
jurzua
parents:
diff changeset
8298 // Simple 'show' function
jurzua
parents:
diff changeset
8299 show: function() {
jurzua
parents:
diff changeset
8300 // Remember where we started, so that we can go back to it later
jurzua
parents:
diff changeset
8301 this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
jurzua
parents:
diff changeset
8302 this.options.show = true;
jurzua
parents:
diff changeset
8303
jurzua
parents:
diff changeset
8304 // Begin the animation
jurzua
parents:
diff changeset
8305 // Make sure that we start at a small width/height to avoid any
jurzua
parents:
diff changeset
8306 // flash of content
jurzua
parents:
diff changeset
8307 this.custom(this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur());
jurzua
parents:
diff changeset
8308
jurzua
parents:
diff changeset
8309 // Start by showing the element
jurzua
parents:
diff changeset
8310 jQuery( this.elem ).show();
jurzua
parents:
diff changeset
8311 },
jurzua
parents:
diff changeset
8312
jurzua
parents:
diff changeset
8313 // Simple 'hide' function
jurzua
parents:
diff changeset
8314 hide: function() {
jurzua
parents:
diff changeset
8315 // Remember where we started, so that we can go back to it later
jurzua
parents:
diff changeset
8316 this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
jurzua
parents:
diff changeset
8317 this.options.hide = true;
jurzua
parents:
diff changeset
8318
jurzua
parents:
diff changeset
8319 // Begin the animation
jurzua
parents:
diff changeset
8320 this.custom(this.cur(), 0);
jurzua
parents:
diff changeset
8321 },
jurzua
parents:
diff changeset
8322
jurzua
parents:
diff changeset
8323 // Each step of an animation
jurzua
parents:
diff changeset
8324 step: function( gotoEnd ) {
jurzua
parents:
diff changeset
8325 var t = fxNow || createFxNow(),
jurzua
parents:
diff changeset
8326 done = true,
jurzua
parents:
diff changeset
8327 elem = this.elem,
jurzua
parents:
diff changeset
8328 options = this.options,
jurzua
parents:
diff changeset
8329 i, n;
jurzua
parents:
diff changeset
8330
jurzua
parents:
diff changeset
8331 if ( gotoEnd || t >= options.duration + this.startTime ) {
jurzua
parents:
diff changeset
8332 this.now = this.end;
jurzua
parents:
diff changeset
8333 this.pos = this.state = 1;
jurzua
parents:
diff changeset
8334 this.update();
jurzua
parents:
diff changeset
8335
jurzua
parents:
diff changeset
8336 options.animatedProperties[ this.prop ] = true;
jurzua
parents:
diff changeset
8337
jurzua
parents:
diff changeset
8338 for ( i in options.animatedProperties ) {
jurzua
parents:
diff changeset
8339 if ( options.animatedProperties[i] !== true ) {
jurzua
parents:
diff changeset
8340 done = false;
jurzua
parents:
diff changeset
8341 }
jurzua
parents:
diff changeset
8342 }
jurzua
parents:
diff changeset
8343
jurzua
parents:
diff changeset
8344 if ( done ) {
jurzua
parents:
diff changeset
8345 // Reset the overflow
jurzua
parents:
diff changeset
8346 if ( options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
jurzua
parents:
diff changeset
8347
jurzua
parents:
diff changeset
8348 jQuery.each( [ "", "X", "Y" ], function (index, value) {
jurzua
parents:
diff changeset
8349 elem.style[ "overflow" + value ] = options.overflow[index];
jurzua
parents:
diff changeset
8350 });
jurzua
parents:
diff changeset
8351 }
jurzua
parents:
diff changeset
8352
jurzua
parents:
diff changeset
8353 // Hide the element if the "hide" operation was done
jurzua
parents:
diff changeset
8354 if ( options.hide ) {
jurzua
parents:
diff changeset
8355 jQuery(elem).hide();
jurzua
parents:
diff changeset
8356 }
jurzua
parents:
diff changeset
8357
jurzua
parents:
diff changeset
8358 // Reset the properties, if the item has been hidden or shown
jurzua
parents:
diff changeset
8359 if ( options.hide || options.show ) {
jurzua
parents:
diff changeset
8360 for ( var p in options.animatedProperties ) {
jurzua
parents:
diff changeset
8361 jQuery.style( elem, p, options.orig[p] );
jurzua
parents:
diff changeset
8362 }
jurzua
parents:
diff changeset
8363 }
jurzua
parents:
diff changeset
8364
jurzua
parents:
diff changeset
8365 // Execute the complete function
jurzua
parents:
diff changeset
8366 options.complete.call( elem );
jurzua
parents:
diff changeset
8367 }
jurzua
parents:
diff changeset
8368
jurzua
parents:
diff changeset
8369 return false;
jurzua
parents:
diff changeset
8370
jurzua
parents:
diff changeset
8371 } else {
jurzua
parents:
diff changeset
8372 // classical easing cannot be used with an Infinity duration
jurzua
parents:
diff changeset
8373 if ( options.duration == Infinity ) {
jurzua
parents:
diff changeset
8374 this.now = t;
jurzua
parents:
diff changeset
8375 } else {
jurzua
parents:
diff changeset
8376 n = t - this.startTime;
jurzua
parents:
diff changeset
8377
jurzua
parents:
diff changeset
8378 this.state = n / options.duration;
jurzua
parents:
diff changeset
8379 // Perform the easing function, defaults to swing
jurzua
parents:
diff changeset
8380 this.pos = jQuery.easing[options.animatedProperties[this.prop]](this.state, n, 0, 1, options.duration);
jurzua
parents:
diff changeset
8381 this.now = this.start + ((this.end - this.start) * this.pos);
jurzua
parents:
diff changeset
8382 }
jurzua
parents:
diff changeset
8383 // Perform the next step of the animation
jurzua
parents:
diff changeset
8384 this.update();
jurzua
parents:
diff changeset
8385 }
jurzua
parents:
diff changeset
8386
jurzua
parents:
diff changeset
8387 return true;
jurzua
parents:
diff changeset
8388 }
jurzua
parents:
diff changeset
8389 };
jurzua
parents:
diff changeset
8390
jurzua
parents:
diff changeset
8391 jQuery.extend( jQuery.fx, {
jurzua
parents:
diff changeset
8392 tick: function() {
jurzua
parents:
diff changeset
8393 var timers = jQuery.timers,
jurzua
parents:
diff changeset
8394 i = timers.length;
jurzua
parents:
diff changeset
8395 while ( i-- ) {
jurzua
parents:
diff changeset
8396 if ( !timers[i]() ) {
jurzua
parents:
diff changeset
8397 timers.splice(i, 1);
jurzua
parents:
diff changeset
8398 }
jurzua
parents:
diff changeset
8399 }
jurzua
parents:
diff changeset
8400
jurzua
parents:
diff changeset
8401 if ( !timers.length ) {
jurzua
parents:
diff changeset
8402 jQuery.fx.stop();
jurzua
parents:
diff changeset
8403 }
jurzua
parents:
diff changeset
8404 },
jurzua
parents:
diff changeset
8405
jurzua
parents:
diff changeset
8406 interval: 13,
jurzua
parents:
diff changeset
8407
jurzua
parents:
diff changeset
8408 stop: function() {
jurzua
parents:
diff changeset
8409 clearInterval( timerId );
jurzua
parents:
diff changeset
8410 timerId = null;
jurzua
parents:
diff changeset
8411 },
jurzua
parents:
diff changeset
8412
jurzua
parents:
diff changeset
8413 speeds: {
jurzua
parents:
diff changeset
8414 slow: 600,
jurzua
parents:
diff changeset
8415 fast: 200,
jurzua
parents:
diff changeset
8416 // Default speed
jurzua
parents:
diff changeset
8417 _default: 400
jurzua
parents:
diff changeset
8418 },
jurzua
parents:
diff changeset
8419
jurzua
parents:
diff changeset
8420 step: {
jurzua
parents:
diff changeset
8421 opacity: function( fx ) {
jurzua
parents:
diff changeset
8422 jQuery.style( fx.elem, "opacity", fx.now );
jurzua
parents:
diff changeset
8423 },
jurzua
parents:
diff changeset
8424
jurzua
parents:
diff changeset
8425 _default: function( fx ) {
jurzua
parents:
diff changeset
8426 if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
jurzua
parents:
diff changeset
8427 fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
jurzua
parents:
diff changeset
8428 } else {
jurzua
parents:
diff changeset
8429 fx.elem[ fx.prop ] = fx.now;
jurzua
parents:
diff changeset
8430 }
jurzua
parents:
diff changeset
8431 }
jurzua
parents:
diff changeset
8432 }
jurzua
parents:
diff changeset
8433 });
jurzua
parents:
diff changeset
8434
jurzua
parents:
diff changeset
8435 if ( jQuery.expr && jQuery.expr.filters ) {
jurzua
parents:
diff changeset
8436 jQuery.expr.filters.animated = function( elem ) {
jurzua
parents:
diff changeset
8437 return jQuery.grep(jQuery.timers, function( fn ) {
jurzua
parents:
diff changeset
8438 return elem === fn.elem;
jurzua
parents:
diff changeset
8439 }).length;
jurzua
parents:
diff changeset
8440 };
jurzua
parents:
diff changeset
8441 }
jurzua
parents:
diff changeset
8442
jurzua
parents:
diff changeset
8443 // Try to restore the default display value of an element
jurzua
parents:
diff changeset
8444 function defaultDisplay( nodeName ) {
jurzua
parents:
diff changeset
8445
jurzua
parents:
diff changeset
8446 if ( !elemdisplay[ nodeName ] ) {
jurzua
parents:
diff changeset
8447
jurzua
parents:
diff changeset
8448 var elem = jQuery( "<" + nodeName + ">" ).appendTo( "body" ),
jurzua
parents:
diff changeset
8449 display = elem.css( "display" );
jurzua
parents:
diff changeset
8450
jurzua
parents:
diff changeset
8451 elem.remove();
jurzua
parents:
diff changeset
8452
jurzua
parents:
diff changeset
8453 // If the simple way fails,
jurzua
parents:
diff changeset
8454 // get element's real default display by attaching it to a temp iframe
jurzua
parents:
diff changeset
8455 if ( display === "none" || display === "" ) {
jurzua
parents:
diff changeset
8456 // No iframe to use yet, so create it
jurzua
parents:
diff changeset
8457 if ( !iframe ) {
jurzua
parents:
diff changeset
8458 iframe = document.createElement( "iframe" );
jurzua
parents:
diff changeset
8459 iframe.frameBorder = iframe.width = iframe.height = 0;
jurzua
parents:
diff changeset
8460 }
jurzua
parents:
diff changeset
8461
jurzua
parents:
diff changeset
8462 document.body.appendChild( iframe );
jurzua
parents:
diff changeset
8463
jurzua
parents:
diff changeset
8464 // Create a cacheable copy of the iframe document on first call.
jurzua
parents:
diff changeset
8465 // IE and Opera will allow us to reuse the iframeDoc without re-writing the fake html
jurzua
parents:
diff changeset
8466 // document to it, Webkit & Firefox won't allow reusing the iframe document
jurzua
parents:
diff changeset
8467 if ( !iframeDoc || !iframe.createElement ) {
jurzua
parents:
diff changeset
8468 iframeDoc = ( iframe.contentWindow || iframe.contentDocument ).document;
jurzua
parents:
diff changeset
8469 iframeDoc.write( "<!doctype><html><body></body></html>" );
jurzua
parents:
diff changeset
8470 }
jurzua
parents:
diff changeset
8471
jurzua
parents:
diff changeset
8472 elem = iframeDoc.createElement( nodeName );
jurzua
parents:
diff changeset
8473
jurzua
parents:
diff changeset
8474 iframeDoc.body.appendChild( elem );
jurzua
parents:
diff changeset
8475
jurzua
parents:
diff changeset
8476 display = jQuery.css( elem, "display" );
jurzua
parents:
diff changeset
8477
jurzua
parents:
diff changeset
8478 document.body.removeChild( iframe );
jurzua
parents:
diff changeset
8479 }
jurzua
parents:
diff changeset
8480
jurzua
parents:
diff changeset
8481 // Store the correct default display
jurzua
parents:
diff changeset
8482 elemdisplay[ nodeName ] = display;
jurzua
parents:
diff changeset
8483 }
jurzua
parents:
diff changeset
8484
jurzua
parents:
diff changeset
8485 return elemdisplay[ nodeName ];
jurzua
parents:
diff changeset
8486 }
jurzua
parents:
diff changeset
8487
jurzua
parents:
diff changeset
8488
jurzua
parents:
diff changeset
8489
jurzua
parents:
diff changeset
8490
jurzua
parents:
diff changeset
8491 var rtable = /^t(?:able|d|h)$/i,
jurzua
parents:
diff changeset
8492 rroot = /^(?:body|html)$/i;
jurzua
parents:
diff changeset
8493
jurzua
parents:
diff changeset
8494 if ( "getBoundingClientRect" in document.documentElement ) {
jurzua
parents:
diff changeset
8495 jQuery.fn.offset = function( options ) {
jurzua
parents:
diff changeset
8496 var elem = this[0], box;
jurzua
parents:
diff changeset
8497
jurzua
parents:
diff changeset
8498 if ( options ) {
jurzua
parents:
diff changeset
8499 return this.each(function( i ) {
jurzua
parents:
diff changeset
8500 jQuery.offset.setOffset( this, options, i );
jurzua
parents:
diff changeset
8501 });
jurzua
parents:
diff changeset
8502 }
jurzua
parents:
diff changeset
8503
jurzua
parents:
diff changeset
8504 if ( !elem || !elem.ownerDocument ) {
jurzua
parents:
diff changeset
8505 return null;
jurzua
parents:
diff changeset
8506 }
jurzua
parents:
diff changeset
8507
jurzua
parents:
diff changeset
8508 if ( elem === elem.ownerDocument.body ) {
jurzua
parents:
diff changeset
8509 return jQuery.offset.bodyOffset( elem );
jurzua
parents:
diff changeset
8510 }
jurzua
parents:
diff changeset
8511
jurzua
parents:
diff changeset
8512 try {
jurzua
parents:
diff changeset
8513 box = elem.getBoundingClientRect();
jurzua
parents:
diff changeset
8514 } catch(e) {}
jurzua
parents:
diff changeset
8515
jurzua
parents:
diff changeset
8516 var doc = elem.ownerDocument,
jurzua
parents:
diff changeset
8517 docElem = doc.documentElement;
jurzua
parents:
diff changeset
8518
jurzua
parents:
diff changeset
8519 // Make sure we're not dealing with a disconnected DOM node
jurzua
parents:
diff changeset
8520 if ( !box || !jQuery.contains( docElem, elem ) ) {
jurzua
parents:
diff changeset
8521 return box ? { top: box.top, left: box.left } : { top: 0, left: 0 };
jurzua
parents:
diff changeset
8522 }
jurzua
parents:
diff changeset
8523
jurzua
parents:
diff changeset
8524 var body = doc.body,
jurzua
parents:
diff changeset
8525 win = getWindow(doc),
jurzua
parents:
diff changeset
8526 clientTop = docElem.clientTop || body.clientTop || 0,
jurzua
parents:
diff changeset
8527 clientLeft = docElem.clientLeft || body.clientLeft || 0,
jurzua
parents:
diff changeset
8528 scrollTop = win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop || body.scrollTop,
jurzua
parents:
diff changeset
8529 scrollLeft = win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft,
jurzua
parents:
diff changeset
8530 top = box.top + scrollTop - clientTop,
jurzua
parents:
diff changeset
8531 left = box.left + scrollLeft - clientLeft;
jurzua
parents:
diff changeset
8532
jurzua
parents:
diff changeset
8533 return { top: top, left: left };
jurzua
parents:
diff changeset
8534 };
jurzua
parents:
diff changeset
8535
jurzua
parents:
diff changeset
8536 } else {
jurzua
parents:
diff changeset
8537 jQuery.fn.offset = function( options ) {
jurzua
parents:
diff changeset
8538 var elem = this[0];
jurzua
parents:
diff changeset
8539
jurzua
parents:
diff changeset
8540 if ( options ) {
jurzua
parents:
diff changeset
8541 return this.each(function( i ) {
jurzua
parents:
diff changeset
8542 jQuery.offset.setOffset( this, options, i );
jurzua
parents:
diff changeset
8543 });
jurzua
parents:
diff changeset
8544 }
jurzua
parents:
diff changeset
8545
jurzua
parents:
diff changeset
8546 if ( !elem || !elem.ownerDocument ) {
jurzua
parents:
diff changeset
8547 return null;
jurzua
parents:
diff changeset
8548 }
jurzua
parents:
diff changeset
8549
jurzua
parents:
diff changeset
8550 if ( elem === elem.ownerDocument.body ) {
jurzua
parents:
diff changeset
8551 return jQuery.offset.bodyOffset( elem );
jurzua
parents:
diff changeset
8552 }
jurzua
parents:
diff changeset
8553
jurzua
parents:
diff changeset
8554 jQuery.offset.initialize();
jurzua
parents:
diff changeset
8555
jurzua
parents:
diff changeset
8556 var computedStyle,
jurzua
parents:
diff changeset
8557 offsetParent = elem.offsetParent,
jurzua
parents:
diff changeset
8558 prevOffsetParent = elem,
jurzua
parents:
diff changeset
8559 doc = elem.ownerDocument,
jurzua
parents:
diff changeset
8560 docElem = doc.documentElement,
jurzua
parents:
diff changeset
8561 body = doc.body,
jurzua
parents:
diff changeset
8562 defaultView = doc.defaultView,
jurzua
parents:
diff changeset
8563 prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
jurzua
parents:
diff changeset
8564 top = elem.offsetTop,
jurzua
parents:
diff changeset
8565 left = elem.offsetLeft;
jurzua
parents:
diff changeset
8566
jurzua
parents:
diff changeset
8567 while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
jurzua
parents:
diff changeset
8568 if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
jurzua
parents:
diff changeset
8569 break;
jurzua
parents:
diff changeset
8570 }
jurzua
parents:
diff changeset
8571
jurzua
parents:
diff changeset
8572 computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
jurzua
parents:
diff changeset
8573 top -= elem.scrollTop;
jurzua
parents:
diff changeset
8574 left -= elem.scrollLeft;
jurzua
parents:
diff changeset
8575
jurzua
parents:
diff changeset
8576 if ( elem === offsetParent ) {
jurzua
parents:
diff changeset
8577 top += elem.offsetTop;
jurzua
parents:
diff changeset
8578 left += elem.offsetLeft;
jurzua
parents:
diff changeset
8579
jurzua
parents:
diff changeset
8580 if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
jurzua
parents:
diff changeset
8581 top += parseFloat( computedStyle.borderTopWidth ) || 0;
jurzua
parents:
diff changeset
8582 left += parseFloat( computedStyle.borderLeftWidth ) || 0;
jurzua
parents:
diff changeset
8583 }
jurzua
parents:
diff changeset
8584
jurzua
parents:
diff changeset
8585 prevOffsetParent = offsetParent;
jurzua
parents:
diff changeset
8586 offsetParent = elem.offsetParent;
jurzua
parents:
diff changeset
8587 }
jurzua
parents:
diff changeset
8588
jurzua
parents:
diff changeset
8589 if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
jurzua
parents:
diff changeset
8590 top += parseFloat( computedStyle.borderTopWidth ) || 0;
jurzua
parents:
diff changeset
8591 left += parseFloat( computedStyle.borderLeftWidth ) || 0;
jurzua
parents:
diff changeset
8592 }
jurzua
parents:
diff changeset
8593
jurzua
parents:
diff changeset
8594 prevComputedStyle = computedStyle;
jurzua
parents:
diff changeset
8595 }
jurzua
parents:
diff changeset
8596
jurzua
parents:
diff changeset
8597 if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
jurzua
parents:
diff changeset
8598 top += body.offsetTop;
jurzua
parents:
diff changeset
8599 left += body.offsetLeft;
jurzua
parents:
diff changeset
8600 }
jurzua
parents:
diff changeset
8601
jurzua
parents:
diff changeset
8602 if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
jurzua
parents:
diff changeset
8603 top += Math.max( docElem.scrollTop, body.scrollTop );
jurzua
parents:
diff changeset
8604 left += Math.max( docElem.scrollLeft, body.scrollLeft );
jurzua
parents:
diff changeset
8605 }
jurzua
parents:
diff changeset
8606
jurzua
parents:
diff changeset
8607 return { top: top, left: left };
jurzua
parents:
diff changeset
8608 };
jurzua
parents:
diff changeset
8609 }
jurzua
parents:
diff changeset
8610
jurzua
parents:
diff changeset
8611 jQuery.offset = {
jurzua
parents:
diff changeset
8612 initialize: function() {
jurzua
parents:
diff changeset
8613 var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.css(body, "marginTop") ) || 0,
jurzua
parents:
diff changeset
8614 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
8615
jurzua
parents:
diff changeset
8616 jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
jurzua
parents:
diff changeset
8617
jurzua
parents:
diff changeset
8618 container.innerHTML = html;
jurzua
parents:
diff changeset
8619 body.insertBefore( container, body.firstChild );
jurzua
parents:
diff changeset
8620 innerDiv = container.firstChild;
jurzua
parents:
diff changeset
8621 checkDiv = innerDiv.firstChild;
jurzua
parents:
diff changeset
8622 td = innerDiv.nextSibling.firstChild.firstChild;
jurzua
parents:
diff changeset
8623
jurzua
parents:
diff changeset
8624 this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
jurzua
parents:
diff changeset
8625 this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
jurzua
parents:
diff changeset
8626
jurzua
parents:
diff changeset
8627 checkDiv.style.position = "fixed";
jurzua
parents:
diff changeset
8628 checkDiv.style.top = "20px";
jurzua
parents:
diff changeset
8629
jurzua
parents:
diff changeset
8630 // safari subtracts parent border width here which is 5px
jurzua
parents:
diff changeset
8631 this.supportsFixedPosition = (checkDiv.offsetTop === 20 || checkDiv.offsetTop === 15);
jurzua
parents:
diff changeset
8632 checkDiv.style.position = checkDiv.style.top = "";
jurzua
parents:
diff changeset
8633
jurzua
parents:
diff changeset
8634 innerDiv.style.overflow = "hidden";
jurzua
parents:
diff changeset
8635 innerDiv.style.position = "relative";
jurzua
parents:
diff changeset
8636
jurzua
parents:
diff changeset
8637 this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
jurzua
parents:
diff changeset
8638
jurzua
parents:
diff changeset
8639 this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);
jurzua
parents:
diff changeset
8640
jurzua
parents:
diff changeset
8641 body.removeChild( container );
jurzua
parents:
diff changeset
8642 jQuery.offset.initialize = jQuery.noop;
jurzua
parents:
diff changeset
8643 },
jurzua
parents:
diff changeset
8644
jurzua
parents:
diff changeset
8645 bodyOffset: function( body ) {
jurzua
parents:
diff changeset
8646 var top = body.offsetTop,
jurzua
parents:
diff changeset
8647 left = body.offsetLeft;
jurzua
parents:
diff changeset
8648
jurzua
parents:
diff changeset
8649 jQuery.offset.initialize();
jurzua
parents:
diff changeset
8650
jurzua
parents:
diff changeset
8651 if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
jurzua
parents:
diff changeset
8652 top += parseFloat( jQuery.css(body, "marginTop") ) || 0;
jurzua
parents:
diff changeset
8653 left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
jurzua
parents:
diff changeset
8654 }
jurzua
parents:
diff changeset
8655
jurzua
parents:
diff changeset
8656 return { top: top, left: left };
jurzua
parents:
diff changeset
8657 },
jurzua
parents:
diff changeset
8658
jurzua
parents:
diff changeset
8659 setOffset: function( elem, options, i ) {
jurzua
parents:
diff changeset
8660 var position = jQuery.css( elem, "position" );
jurzua
parents:
diff changeset
8661
jurzua
parents:
diff changeset
8662 // set position first, in-case top/left are set even on static elem
jurzua
parents:
diff changeset
8663 if ( position === "static" ) {
jurzua
parents:
diff changeset
8664 elem.style.position = "relative";
jurzua
parents:
diff changeset
8665 }
jurzua
parents:
diff changeset
8666
jurzua
parents:
diff changeset
8667 var curElem = jQuery( elem ),
jurzua
parents:
diff changeset
8668 curOffset = curElem.offset(),
jurzua
parents:
diff changeset
8669 curCSSTop = jQuery.css( elem, "top" ),
jurzua
parents:
diff changeset
8670 curCSSLeft = jQuery.css( elem, "left" ),
jurzua
parents:
diff changeset
8671 calculatePosition = (position === "absolute" || position === "fixed") && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
jurzua
parents:
diff changeset
8672 props = {}, curPosition = {}, curTop, curLeft;
jurzua
parents:
diff changeset
8673
jurzua
parents:
diff changeset
8674 // 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
8675 if ( calculatePosition ) {
jurzua
parents:
diff changeset
8676 curPosition = curElem.position();
jurzua
parents:
diff changeset
8677 curTop = curPosition.top;
jurzua
parents:
diff changeset
8678 curLeft = curPosition.left;
jurzua
parents:
diff changeset
8679 } else {
jurzua
parents:
diff changeset
8680 curTop = parseFloat( curCSSTop ) || 0;
jurzua
parents:
diff changeset
8681 curLeft = parseFloat( curCSSLeft ) || 0;
jurzua
parents:
diff changeset
8682 }
jurzua
parents:
diff changeset
8683
jurzua
parents:
diff changeset
8684 if ( jQuery.isFunction( options ) ) {
jurzua
parents:
diff changeset
8685 options = options.call( elem, i, curOffset );
jurzua
parents:
diff changeset
8686 }
jurzua
parents:
diff changeset
8687
jurzua
parents:
diff changeset
8688 if (options.top != null) {
jurzua
parents:
diff changeset
8689 props.top = (options.top - curOffset.top) + curTop;
jurzua
parents:
diff changeset
8690 }
jurzua
parents:
diff changeset
8691 if (options.left != null) {
jurzua
parents:
diff changeset
8692 props.left = (options.left - curOffset.left) + curLeft;
jurzua
parents:
diff changeset
8693 }
jurzua
parents:
diff changeset
8694
jurzua
parents:
diff changeset
8695 if ( "using" in options ) {
jurzua
parents:
diff changeset
8696 options.using.call( elem, props );
jurzua
parents:
diff changeset
8697 } else {
jurzua
parents:
diff changeset
8698 curElem.css( props );
jurzua
parents:
diff changeset
8699 }
jurzua
parents:
diff changeset
8700 }
jurzua
parents:
diff changeset
8701 };
jurzua
parents:
diff changeset
8702
jurzua
parents:
diff changeset
8703
jurzua
parents:
diff changeset
8704 jQuery.fn.extend({
jurzua
parents:
diff changeset
8705 position: function() {
jurzua
parents:
diff changeset
8706 if ( !this[0] ) {
jurzua
parents:
diff changeset
8707 return null;
jurzua
parents:
diff changeset
8708 }
jurzua
parents:
diff changeset
8709
jurzua
parents:
diff changeset
8710 var elem = this[0],
jurzua
parents:
diff changeset
8711
jurzua
parents:
diff changeset
8712 // Get *real* offsetParent
jurzua
parents:
diff changeset
8713 offsetParent = this.offsetParent(),
jurzua
parents:
diff changeset
8714
jurzua
parents:
diff changeset
8715 // Get correct offsets
jurzua
parents:
diff changeset
8716 offset = this.offset(),
jurzua
parents:
diff changeset
8717 parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
jurzua
parents:
diff changeset
8718
jurzua
parents:
diff changeset
8719 // Subtract element margins
jurzua
parents:
diff changeset
8720 // note: when an element has margin: auto the offsetLeft and marginLeft
jurzua
parents:
diff changeset
8721 // are the same in Safari causing offset.left to incorrectly be 0
jurzua
parents:
diff changeset
8722 offset.top -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
jurzua
parents:
diff changeset
8723 offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;
jurzua
parents:
diff changeset
8724
jurzua
parents:
diff changeset
8725 // Add offsetParent borders
jurzua
parents:
diff changeset
8726 parentOffset.top += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
jurzua
parents:
diff changeset
8727 parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;
jurzua
parents:
diff changeset
8728
jurzua
parents:
diff changeset
8729 // Subtract the two offsets
jurzua
parents:
diff changeset
8730 return {
jurzua
parents:
diff changeset
8731 top: offset.top - parentOffset.top,
jurzua
parents:
diff changeset
8732 left: offset.left - parentOffset.left
jurzua
parents:
diff changeset
8733 };
jurzua
parents:
diff changeset
8734 },
jurzua
parents:
diff changeset
8735
jurzua
parents:
diff changeset
8736 offsetParent: function() {
jurzua
parents:
diff changeset
8737 return this.map(function() {
jurzua
parents:
diff changeset
8738 var offsetParent = this.offsetParent || document.body;
jurzua
parents:
diff changeset
8739 while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
jurzua
parents:
diff changeset
8740 offsetParent = offsetParent.offsetParent;
jurzua
parents:
diff changeset
8741 }
jurzua
parents:
diff changeset
8742 return offsetParent;
jurzua
parents:
diff changeset
8743 });
jurzua
parents:
diff changeset
8744 }
jurzua
parents:
diff changeset
8745 });
jurzua
parents:
diff changeset
8746
jurzua
parents:
diff changeset
8747
jurzua
parents:
diff changeset
8748 // Create scrollLeft and scrollTop methods
jurzua
parents:
diff changeset
8749 jQuery.each( ["Left", "Top"], function( i, name ) {
jurzua
parents:
diff changeset
8750 var method = "scroll" + name;
jurzua
parents:
diff changeset
8751
jurzua
parents:
diff changeset
8752 jQuery.fn[ method ] = function( val ) {
jurzua
parents:
diff changeset
8753 var elem, win;
jurzua
parents:
diff changeset
8754
jurzua
parents:
diff changeset
8755 if ( val === undefined ) {
jurzua
parents:
diff changeset
8756 elem = this[ 0 ];
jurzua
parents:
diff changeset
8757
jurzua
parents:
diff changeset
8758 if ( !elem ) {
jurzua
parents:
diff changeset
8759 return null;
jurzua
parents:
diff changeset
8760 }
jurzua
parents:
diff changeset
8761
jurzua
parents:
diff changeset
8762 win = getWindow( elem );
jurzua
parents:
diff changeset
8763
jurzua
parents:
diff changeset
8764 // Return the scroll offset
jurzua
parents:
diff changeset
8765 return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
jurzua
parents:
diff changeset
8766 jQuery.support.boxModel && win.document.documentElement[ method ] ||
jurzua
parents:
diff changeset
8767 win.document.body[ method ] :
jurzua
parents:
diff changeset
8768 elem[ method ];
jurzua
parents:
diff changeset
8769 }
jurzua
parents:
diff changeset
8770
jurzua
parents:
diff changeset
8771 // Set the scroll offset
jurzua
parents:
diff changeset
8772 return this.each(function() {
jurzua
parents:
diff changeset
8773 win = getWindow( this );
jurzua
parents:
diff changeset
8774
jurzua
parents:
diff changeset
8775 if ( win ) {
jurzua
parents:
diff changeset
8776 win.scrollTo(
jurzua
parents:
diff changeset
8777 !i ? val : jQuery( win ).scrollLeft(),
jurzua
parents:
diff changeset
8778 i ? val : jQuery( win ).scrollTop()
jurzua
parents:
diff changeset
8779 );
jurzua
parents:
diff changeset
8780
jurzua
parents:
diff changeset
8781 } else {
jurzua
parents:
diff changeset
8782 this[ method ] = val;
jurzua
parents:
diff changeset
8783 }
jurzua
parents:
diff changeset
8784 });
jurzua
parents:
diff changeset
8785 };
jurzua
parents:
diff changeset
8786 });
jurzua
parents:
diff changeset
8787
jurzua
parents:
diff changeset
8788 function getWindow( elem ) {
jurzua
parents:
diff changeset
8789 return jQuery.isWindow( elem ) ?
jurzua
parents:
diff changeset
8790 elem :
jurzua
parents:
diff changeset
8791 elem.nodeType === 9 ?
jurzua
parents:
diff changeset
8792 elem.defaultView || elem.parentWindow :
jurzua
parents:
diff changeset
8793 false;
jurzua
parents:
diff changeset
8794 }
jurzua
parents:
diff changeset
8795
jurzua
parents:
diff changeset
8796
jurzua
parents:
diff changeset
8797
jurzua
parents:
diff changeset
8798
jurzua
parents:
diff changeset
8799 // Create innerHeight, innerWidth, outerHeight and outerWidth methods
jurzua
parents:
diff changeset
8800 jQuery.each([ "Height", "Width" ], function( i, name ) {
jurzua
parents:
diff changeset
8801
jurzua
parents:
diff changeset
8802 var type = name.toLowerCase();
jurzua
parents:
diff changeset
8803
jurzua
parents:
diff changeset
8804 // innerHeight and innerWidth
jurzua
parents:
diff changeset
8805 jQuery.fn["inner" + name] = function() {
jurzua
parents:
diff changeset
8806 return this[0] ?
jurzua
parents:
diff changeset
8807 parseFloat( jQuery.css( this[0], type, "padding" ) ) :
jurzua
parents:
diff changeset
8808 null;
jurzua
parents:
diff changeset
8809 };
jurzua
parents:
diff changeset
8810
jurzua
parents:
diff changeset
8811 // outerHeight and outerWidth
jurzua
parents:
diff changeset
8812 jQuery.fn["outer" + name] = function( margin ) {
jurzua
parents:
diff changeset
8813 return this[0] ?
jurzua
parents:
diff changeset
8814 parseFloat( jQuery.css( this[0], type, margin ? "margin" : "border" ) ) :
jurzua
parents:
diff changeset
8815 null;
jurzua
parents:
diff changeset
8816 };
jurzua
parents:
diff changeset
8817
jurzua
parents:
diff changeset
8818 jQuery.fn[ type ] = function( size ) {
jurzua
parents:
diff changeset
8819 // Get window width or height
jurzua
parents:
diff changeset
8820 var elem = this[0];
jurzua
parents:
diff changeset
8821 if ( !elem ) {
jurzua
parents:
diff changeset
8822 return size == null ? null : this;
jurzua
parents:
diff changeset
8823 }
jurzua
parents:
diff changeset
8824
jurzua
parents:
diff changeset
8825 if ( jQuery.isFunction( size ) ) {
jurzua
parents:
diff changeset
8826 return this.each(function( i ) {
jurzua
parents:
diff changeset
8827 var self = jQuery( this );
jurzua
parents:
diff changeset
8828 self[ type ]( size.call( this, i, self[ type ]() ) );
jurzua
parents:
diff changeset
8829 });
jurzua
parents:
diff changeset
8830 }
jurzua
parents:
diff changeset
8831
jurzua
parents:
diff changeset
8832 if ( jQuery.isWindow( elem ) ) {
jurzua
parents:
diff changeset
8833 // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
jurzua
parents:
diff changeset
8834 // 3rd condition allows Nokia support, as it supports the docElem prop but not CSS1Compat
jurzua
parents:
diff changeset
8835 var docElemProp = elem.document.documentElement[ "client" + name ];
jurzua
parents:
diff changeset
8836 return elem.document.compatMode === "CSS1Compat" && docElemProp ||
jurzua
parents:
diff changeset
8837 elem.document.body[ "client" + name ] || docElemProp;
jurzua
parents:
diff changeset
8838
jurzua
parents:
diff changeset
8839 // Get document width or height
jurzua
parents:
diff changeset
8840 } else if ( elem.nodeType === 9 ) {
jurzua
parents:
diff changeset
8841 // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
jurzua
parents:
diff changeset
8842 return Math.max(
jurzua
parents:
diff changeset
8843 elem.documentElement["client" + name],
jurzua
parents:
diff changeset
8844 elem.body["scroll" + name], elem.documentElement["scroll" + name],
jurzua
parents:
diff changeset
8845 elem.body["offset" + name], elem.documentElement["offset" + name]
jurzua
parents:
diff changeset
8846 );
jurzua
parents:
diff changeset
8847
jurzua
parents:
diff changeset
8848 // Get or set width or height on the element
jurzua
parents:
diff changeset
8849 } else if ( size === undefined ) {
jurzua
parents:
diff changeset
8850 var orig = jQuery.css( elem, type ),
jurzua
parents:
diff changeset
8851 ret = parseFloat( orig );
jurzua
parents:
diff changeset
8852
jurzua
parents:
diff changeset
8853 return jQuery.isNaN( ret ) ? orig : ret;
jurzua
parents:
diff changeset
8854
jurzua
parents:
diff changeset
8855 // Set the width or height on the element (default to pixels if value is unitless)
jurzua
parents:
diff changeset
8856 } else {
jurzua
parents:
diff changeset
8857 return this.css( type, typeof size === "string" ? size : size + "px" );
jurzua
parents:
diff changeset
8858 }
jurzua
parents:
diff changeset
8859 };
jurzua
parents:
diff changeset
8860
jurzua
parents:
diff changeset
8861 });
jurzua
parents:
diff changeset
8862
jurzua
parents:
diff changeset
8863
jurzua
parents:
diff changeset
8864 window.jQuery = window.$ = jQuery;
jurzua
parents:
diff changeset
8865 })(window);