« back to all changes in this revision
Viewing changes to src/sizzle/speed/frameworks/jquery.js
- browse files at revision 14
- compare with another revision
- download diff
- download tarball
- view history from revision 14
- Committer: Bazaar Package Importer
- Author(s): Marcelo Jorge Vieira (metal)
- Date: 2011-05-29 20:21:27 UTC
- mfrom: (0.1.8 upstream)
- Revision ID: james.westby@ubuntu.com-20110529202127-yo710urpsj87oqnh
Tags: 1.6.1-1
New upstream release (Closes: #628052)
- files added:
- src/deferred.js
- files removed:
- src/selector.js
- src/sizzle/.git
- src/sizzle/.git/branches
- src/sizzle/.git/hooks
- src/sizzle/.git/info
- src/sizzle/.git/logs
- src/sizzle/.git/logs/refs
- src/sizzle/.git/logs/refs/heads
- src/sizzle/.git/objects
- src/sizzle/.git/objects/info
- src/sizzle/.git/objects/pack
- src/sizzle/.git/refs
- src/sizzle/.git/refs/heads
- src/sizzle/.git/refs/remotes
- src/sizzle/.git/refs/remotes/origin
- src/sizzle/.git/refs/tags
- src/sizzle/speed
- src/sizzle/speed/frameworks
- src/sizzle/speed/system
- src/sizzle/test
- src/sizzle/test/data
- src/sizzle/test/unit
- files modified:
- README.md
added
removed
src/sizzle/speed/frameworks/jquery.js
1
(function(){
2
/*
3
* jQuery 1.2.6 - New Wave Javascript
4
*
5
* Copyright (c) 2008 John Resig (jquery.com)
6
* Dual licensed under the MIT (MIT-LICENSE.txt)
7
* and GPL (GPL-LICENSE.txt) licenses.
8
*
9
* $Date: 2008-05-24 14:22:17 -0400 (Sat, 24 May 2008) $
10
* $Rev: 5685 $
11
*/
12
13
// Map over jQuery in case of overwrite
14
var _jQuery = window.jQuery,
15
// Map over the $ in case of overwrite
16
_$ = window.$;
17
18
var jQuery = window.jQuery = window.$ = function( selector, context ) {
19
// The jQuery object is actually just the init constructor 'enhanced'
20
return new jQuery.fn.init( selector, context );
21
};
22
23
// A simple way to check for HTML strings or ID strings
24
// (both of which we optimize for)
25
var quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#(\w+)$/,
26
27
// Is it a simple selector
28
isSimple = /^.[^:#\[\.]*$/,
29
30
// Will speed up references to undefined, and allows munging its name.
31
undefined;
32
33
jQuery.fn = jQuery.prototype = {
34
init: function( selector, context ) {
35
// Make sure that a selection was provided
36
selector = selector || document;
37
38
// Handle $(DOMElement)
39
if ( selector.nodeType ) {
40
this[0] = selector;
41
this.length = 1;
42
return this;
43
}
44
// Handle HTML strings
45
if ( typeof selector == "string" ) {
46
// Are we dealing with HTML string or an ID?
47
var match = quickExpr.exec( selector );
48
49
// Verify a match, and that no context was specified for #id
50
if ( match && (match[1] || !context) ) {
51
52
// HANDLE: $(html) -> $(array)
53
if ( match[1] )
54
selector = jQuery.clean( [ match[1] ], context );
55
56
// HANDLE: $("#id")
57
else {
58
var elem = document.getElementById( match[3] );
59
60
// Make sure an element was located
61
if ( elem ){
62
// Handle the case where IE and Opera return items
63
// by name instead of ID
64
if ( elem.id != match[3] )
65
return jQuery().find( selector );
66
67
// Otherwise, we inject the element directly into the jQuery object
68
return jQuery( elem );
69
}
70
selector = [];
71
}
72
73
// HANDLE: $(expr, [context])
74
// (which is just equivalent to: $(content).find(expr)
75
} else
76
return jQuery( context ).find( selector );
77
78
// HANDLE: $(function)
79
// Shortcut for document ready
80
} else if ( jQuery.isFunction( selector ) )
81
return jQuery( document )[ jQuery.fn.ready ? "ready" : "load" ]( selector );
82
83
return this.setArray(jQuery.makeArray(selector));
84
},
85
86
// The current version of jQuery being used
87
jquery: "1.2.6",
88
89
// The number of elements contained in the matched element set
90
size: function() {
91
return this.length;
92
},
93
94
// The number of elements contained in the matched element set
95
length: 0,
96
97
// Get the Nth element in the matched element set OR
98
// Get the whole matched element set as a clean array
99
get: function( num ) {
100
return num == undefined ?
101
102
// Return a 'clean' array
103
jQuery.makeArray( this ) :
104
105
// Return just the object
106
this[ num ];
107
},
108
109
// Take an array of elements and push it onto the stack
110
// (returning the new matched element set)
111
pushStack: function( elems ) {
112
// Build a new jQuery matched element set
113
var ret = jQuery( elems );
114
115
// Add the old object onto the stack (as a reference)
116
ret.prevObject = this;
117
118
// Return the newly-formed element set
119
return ret;
120
},
121
122
// Force the current matched set of elements to become
123
// the specified array of elements (destroying the stack in the process)
124
// You should use pushStack() in order to do this, but maintain the stack
125
setArray: function( elems ) {
126
// Resetting the length to 0, then using the native Array push
127
// is a super-fast way to populate an object with array-like properties
128
this.length = 0;
129
Array.prototype.push.apply( this, elems );
130
131
return this;
132
},
133
134
// Execute a callback for every element in the matched set.
135
// (You can seed the arguments with an array of args, but this is
136
// only used internally.)
137
each: function( callback, args ) {
138
return jQuery.each( this, callback, args );
139
},
140
141
// Determine the position of an element within
142
// the matched set of elements
143
index: function( elem ) {
144
var ret = -1;
145
146
// Locate the position of the desired element
147
return jQuery.inArray(
148
// If it receives a jQuery object, the first element is used
149
elem && elem.jquery ? elem[0] : elem
150
, this );
151
},
152
153
attr: function( name, value, type ) {
154
var options = name;
155
156
// Look for the case where we're accessing a style value
157
if ( name.constructor == String )
158
if ( value === undefined )
159
return this[0] && jQuery[ type || "attr" ]( this[0], name );
160
161
else {
162
options = {};
163
options[ name ] = value;
164
}
165
166
// Check to see if we're setting style values
167
return this.each(function(i){
168
// Set all the styles
169
for ( name in options )
170
jQuery.attr(
171
type ?
172
this.style :
173
this,
174
name, jQuery.prop( this, options[ name ], type, i, name )
175
);
176
});
177
},
178
179
css: function( key, value ) {
180
// ignore negative width and height values
181
if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )
182
value = undefined;
183
return this.attr( key, value, "curCSS" );
184
},
185
186
text: function( text ) {
187
if ( typeof text != "object" && text != null )
188
return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
189
190
var ret = "";
191
192
jQuery.each( text || this, function(){
193
jQuery.each( this.childNodes, function(){
194
if ( this.nodeType != 8 )
195
ret += this.nodeType != 1 ?
196
this.nodeValue :
197
jQuery.fn.text( [ this ] );
198
});
199
});
200
201
return ret;
202
},
203
204
wrapAll: function( html ) {
205
if ( this[0] )
206
// The elements to wrap the target around
207
jQuery( html, this[0].ownerDocument )
208
.clone()
209
.insertBefore( this[0] )
210
.map(function(){
211
var elem = this;
212
213
while ( elem.firstChild )
214
elem = elem.firstChild;
215
216
return elem;
217
})
218
.append(this);
219
220
return this;
221
},
222
223
wrapInner: function( html ) {
224
return this.each(function(){
225
jQuery( this ).contents().wrapAll( html );
226
});
227
},
228
229
wrap: function( html ) {
230
return this.each(function(){
231
jQuery( this ).wrapAll( html );
232
});
233
},
234
235
append: function() {
236
return this.domManip(arguments, true, false, function(elem){
237
if (this.nodeType == 1)
238
this.appendChild( elem );
239
});
240
},
241
242
prepend: function() {
243
return this.domManip(arguments, true, true, function(elem){
244
if (this.nodeType == 1)
245
this.insertBefore( elem, this.firstChild );
246
});
247
},
248
249
before: function() {
250
return this.domManip(arguments, false, false, function(elem){
251
this.parentNode.insertBefore( elem, this );
252
});
253
},
254
255
after: function() {
256
return this.domManip(arguments, false, true, function(elem){
257
this.parentNode.insertBefore( elem, this.nextSibling );
258
});
259
},
260
261
end: function() {
262
return this.prevObject || jQuery( [] );
263
},
264
265
find: function( selector ) {
266
var elems = jQuery.map(this, function(elem){
267
return jQuery.find( selector, elem );
268
});
269
270
return this.pushStack( /[^+>] [^+>]/.test( selector ) || selector.indexOf("..") > -1 ?
271
jQuery.unique( elems ) :
272
elems );
273
},
274
275
clone: function( events ) {
276
// Do the clone
277
var ret = this.map(function(){
278
if ( jQuery.browser.msie && !jQuery.isXMLDoc(this) ) {
279
// IE copies events bound via attachEvent when
280
// using cloneNode. Calling detachEvent on the
281
// clone will also remove the events from the orignal
282
// In order to get around this, we use innerHTML.
283
// Unfortunately, this means some modifications to
284
// attributes in IE that are actually only stored
285
// as properties will not be copied (such as the
286
// the name attribute on an input).
287
var clone = this.cloneNode(true),
288
container = document.createElement("div");
289
container.appendChild(clone);
290
return jQuery.clean([container.innerHTML])[0];
291
} else
292
return this.cloneNode(true);
293
});
294
295
// Need to set the expando to null on the cloned set if it exists
296
// removeData doesn't work here, IE removes it from the original as well
297
// this is primarily for IE but the data expando shouldn't be copied over in any browser
298
var clone = ret.find("*").andSelf().each(function(){
299
if ( this[ expando ] != undefined )
300
this[ expando ] = null;
301
});
302
303
// Copy the events from the original to the clone
304
if ( events === true )
305
this.find("*").andSelf().each(function(i){
306
if (this.nodeType == 3)
307
return;
308
var events = jQuery.data( this, "events" );
309
310
for ( var type in events )
311
for ( var handler in events[ type ] )
312
jQuery.event.add( clone[ i ], type, events[ type ][ handler ], events[ type ][ handler ].data );
313
});
314
315
// Return the cloned set
316
return ret;
317
},
318
319
filter: function( selector ) {
320
return this.pushStack(
321
jQuery.isFunction( selector ) &&
322
jQuery.grep(this, function(elem, i){
323
return selector.call( elem, i );
324
}) ||
325
326
jQuery.multiFilter( selector, this ) );
327
},
328
329
not: function( selector ) {
330
if ( selector.constructor == String )
331
// test special case where just one selector is passed in
332
if ( isSimple.test( selector ) )
333
return this.pushStack( jQuery.multiFilter( selector, this, true ) );
334
else
335
selector = jQuery.multiFilter( selector, this );
336
337
var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
338
return this.filter(function() {
339
return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;
340
});
341
},
342
343
add: function( selector ) {
344
return this.pushStack( jQuery.unique( jQuery.merge(
345
this.get(),
346
typeof selector == 'string' ?
347
jQuery( selector ) :
348
jQuery.makeArray( selector )
349
)));
350
},
351
352
is: function( selector ) {
353
return !!selector && jQuery.multiFilter( selector, this ).length > 0;
354
},
355
356
hasClass: function( selector ) {
357
return this.is( "." + selector );
358
},
359
360
val: function( value ) {
361
if ( value == undefined ) {
362
363
if ( this.length ) {
364
var elem = this[0];
365
366
// We need to handle select boxes special
367
if ( jQuery.nodeName( elem, "select" ) ) {
368
var index = elem.selectedIndex,
369
values = [],
370
options = elem.options,
371
one = elem.type == "select-one";
372
373
// Nothing was selected
374
if ( index < 0 )
375
return null;
376
377
// Loop through all the selected options
378
for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
379
var option = options[ i ];
380
381
if ( option.selected ) {
382
// Get the specifc value for the option
383
value = jQuery.browser.msie && !option.attributes.value.specified ? option.text : option.value;
384
385
// We don't need an array for one selects
386
if ( one )
387
return value;
388
389
// Multi-Selects return an array
390
values.push( value );
391
}
392
}
393
394
return values;
395
396
// Everything else, we just grab the value
397
} else
398
return (this[0].value || "").replace(/\r/g, "");
399
400
}
401
402
return undefined;
403
}
404
405
if( value.constructor == Number )
406
value += '';
407
408
return this.each(function(){
409
if ( this.nodeType != 1 )
410
return;
411
412
if ( value.constructor == Array && /radio|checkbox/.test( this.type ) )
413
this.checked = (jQuery.inArray(this.value, value) >= 0 ||
414
jQuery.inArray(this.name, value) >= 0);
415
416
else if ( jQuery.nodeName( this, "select" ) ) {
417
var values = jQuery.makeArray(value);
418
419
jQuery( "option", this ).each(function(){
420
this.selected = (jQuery.inArray( this.value, values ) >= 0 ||
421
jQuery.inArray( this.text, values ) >= 0);
422
});
423
424
if ( !values.length )
425
this.selectedIndex = -1;
426
427
} else
428
this.value = value;
429
});
430
},
431
432
html: function( value ) {
433
return value == undefined ?
434
(this[0] ?
435
this[0].innerHTML :
436
null) :
437
this.empty().append( value );
438
},
439
440
replaceWith: function( value ) {
441
return this.after( value ).remove();
442
},
443
444
eq: function( i ) {
445
return this.slice( i, i + 1 );
446
},
447
448
slice: function() {
449
return this.pushStack( Array.prototype.slice.apply( this, arguments ) );
450
},
451
452
map: function( callback ) {
453
return this.pushStack( jQuery.map(this, function(elem, i){
454
return callback.call( elem, i, elem );
455
}));
456
},
457
458
andSelf: function() {
459
return this.add( this.prevObject );
460
},
461
462
data: function( key, value ){
463
var parts = key.split(".");
464
parts[1] = parts[1] ? "." + parts[1] : "";
465
466
if ( value === undefined ) {
467
var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
468
469
if ( data === undefined && this.length )
470
data = jQuery.data( this[0], key );
471
472
return data === undefined && parts[1] ?
473
this.data( parts[0] ) :
474
data;
475
} else
476
return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){
477
jQuery.data( this, key, value );
478
});
479
},
480
481
removeData: function( key ){
482
return this.each(function(){
483
jQuery.removeData( this, key );
484
});
485
},
486
487
domManip: function( args, table, reverse, callback ) {
488
var clone = this.length > 1, elems;
489
490
return this.each(function(){
491
if ( !elems ) {
492
elems = jQuery.clean( args, this.ownerDocument );
493
494
if ( reverse )
495
elems.reverse();
496
}
497
498
var obj = this;
499
500
if ( table && jQuery.nodeName( this, "table" ) && jQuery.nodeName( elems[0], "tr" ) )
501
obj = this.getElementsByTagName("tbody")[0] || this.appendChild( this.ownerDocument.createElement("tbody") );
502
503
var scripts = jQuery( [] );
504
505
jQuery.each(elems, function(){
506
var elem = clone ?
507
jQuery( this ).clone( true )[0] :
508
this;
509
510
// execute all scripts after the elements have been injected
511
if ( jQuery.nodeName( elem, "script" ) )
512
scripts = scripts.add( elem );
513
else {
514
// Remove any inner scripts for later evaluation
515
if ( elem.nodeType == 1 )
516
scripts = scripts.add( jQuery( "script", elem ).remove() );
517
518
// Inject the elements into the document
519
callback.call( obj, elem );
520
}
521
});
522
523
scripts.each( evalScript );
524
});
525
}
526
};
527
528
// Give the init function the jQuery prototype for later instantiation
529
jQuery.fn.init.prototype = jQuery.fn;
530
531
function evalScript( i, elem ) {
532
if ( elem.src )
533
jQuery.ajax({
534
url: elem.src,
535
async: false,
536
dataType: "script"
537
});
538
539
else
540
jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
541
542
if ( elem.parentNode )
543
elem.parentNode.removeChild( elem );
544
}
545
546
function now(){
547
return +new Date;
548
}
549
550
jQuery.extend = jQuery.fn.extend = function() {
551
// copy reference to target object
552
var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;
553
554
// Handle a deep copy situation
555
if ( target.constructor == Boolean ) {
556
deep = target;
557
target = arguments[1] || {};
558
// skip the boolean and the target
559
i = 2;
560
}
561
562
// Handle case when target is a string or something (possible in deep copy)
563
if ( typeof target != "object" && typeof target != "function" )
564
target = {};
565
566
// extend jQuery itself if only one argument is passed
567
if ( length == i ) {
568
target = this;
569
--i;
570
}
571
572
for ( ; i < length; i++ )
573
// Only deal with non-null/undefined values
574
if ( (options = arguments[ i ]) != null )
575
// Extend the base object
576
for ( var name in options ) {
577
var src = target[ name ], copy = options[ name ];
578
579
// Prevent never-ending loop
580
if ( target === copy )
581
continue;
582
583
// Recurse if we're merging object values
584
if ( deep && copy && typeof copy == "object" && !copy.nodeType )
585
target[ name ] = jQuery.extend( deep,
586
// Never move original objects, clone them
587
src || ( copy.length != null ? [ ] : { } )
588
, copy );
589
590
// Don't bring in undefined values
591
else if ( copy !== undefined )
592
target[ name ] = copy;
593
594
}
595
596
// Return the modified object
597
return target;
598
};
599
600
var expando = "jQuery" + now(), uuid = 0, windowData = {},
601
// exclude the following css properties to add px
602
exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
603
// cache defaultView
604
defaultView = document.defaultView || {};
605
606
jQuery.extend({
607
noConflict: function( deep ) {
608
window.$ = _$;
609
610
if ( deep )
611
window.jQuery = _jQuery;
612
613
return jQuery;
614
},
615
616
// See test/unit/core.js for details concerning this function.
617
isFunction: function( fn ) {
618
return !!fn && typeof fn != "string" && !fn.nodeName &&
619
fn.constructor != Array && /^[\s[]?function/.test( fn + "" );
620
},
621
622
// check if an element is in a (or is an) XML document
623
isXMLDoc: function( elem ) {
624
return elem.documentElement && !elem.body ||
625
elem.tagName && elem.ownerDocument && !elem.ownerDocument.body;
626
},
627
628
// Evalulates a script in a global context
629
globalEval: function( data ) {
630
data = jQuery.trim( data );
631
632
if ( data ) {
633
// Inspired by code by Andrea Giammarchi
634
// http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
635
var head = document.getElementsByTagName("head")[0] || document.documentElement,
636
script = document.createElement("script");
637
638
script.type = "text/javascript";
639
if ( jQuery.browser.msie )
640
script.text = data;
641
else
642
script.appendChild( document.createTextNode( data ) );
643
644
// Use insertBefore instead of appendChild to circumvent an IE6 bug.
645
// This arises when a base node is used (#2709).
646
head.insertBefore( script, head.firstChild );
647
head.removeChild( script );
648
}
649
},
650
651
nodeName: function( elem, name ) {
652
return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
653
},
654
655
cache: {},
656
657
data: function( elem, name, data ) {
658
elem = elem == window ?
659
windowData :
660
elem;
661
662
var id = elem[ expando ];
663
664
// Compute a unique ID for the element
665
if ( !id )
666
id = elem[ expando ] = ++uuid;
667
668
// Only generate the data cache if we're
669
// trying to access or manipulate it
670
if ( name && !jQuery.cache[ id ] )
671
jQuery.cache[ id ] = {};
672
673
// Prevent overriding the named cache with undefined values
674
if ( data !== undefined )
675
jQuery.cache[ id ][ name ] = data;
676
677
// Return the named cache data, or the ID for the element
678
return name ?
679
jQuery.cache[ id ][ name ] :
680
id;
681
},
682
683
removeData: function( elem, name ) {
684
elem = elem == window ?
685
windowData :
686
elem;
687
688
var id = elem[ expando ];
689
690
// If we want to remove a specific section of the element's data
691
if ( name ) {
692
if ( jQuery.cache[ id ] ) {
693
// Remove the section of cache data
694
delete jQuery.cache[ id ][ name ];
695
696
// If we've removed all the data, remove the element's cache
697
name = "";
698
699
for ( name in jQuery.cache[ id ] )
700
break;
701
702
if ( !name )
703
jQuery.removeData( elem );
704
}
705
706
// Otherwise, we want to remove all of the element's data
707
} else {
708
// Clean up the element expando
709
try {
710
delete elem[ expando ];
711
} catch(e){
712
// IE has trouble directly removing the expando
713
// but it's ok with using removeAttribute
714
if ( elem.removeAttribute )
715
elem.removeAttribute( expando );
716
}
717
718
// Completely remove the data cache
719
delete jQuery.cache[ id ];
720
}
721
},
722
723
// args is for internal usage only
724
each: function( object, callback, args ) {
725
var name, i = 0, length = object.length;
726
727
if ( args ) {
728
if ( length == undefined ) {
729
for ( name in object )
730
if ( callback.apply( object[ name ], args ) === false )
731
break;
732
} else
733
for ( ; i < length; )
734
if ( callback.apply( object[ i++ ], args ) === false )
735
break;
736
737
// A special, fast, case for the most common use of each
738
} else {
739
if ( length == undefined ) {
740
for ( name in object )
741
if ( callback.call( object[ name ], name, object[ name ] ) === false )
742
break;
743
} else
744
for ( var value = object[0];
745
i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
746
}
747
748
return object;
749
},
750
751
prop: function( elem, value, type, i, name ) {
752
// Handle executable functions
753
if ( jQuery.isFunction( value ) )
754
value = value.call( elem, i );
755
756
// Handle passing in a number to a CSS property
757
return value && value.constructor == Number && type == "curCSS" && !exclude.test( name ) ?
758
value + "px" :
759
value;
760
},
761
762
className: {
763
// internal only, use addClass("class")
764
add: function( elem, classNames ) {
765
jQuery.each((classNames || "").split(/\s+/), function(i, className){
766
if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
767
elem.className += (elem.className ? " " : "") + className;
768
});
769
},
770
771
// internal only, use removeClass("class")
772
remove: function( elem, classNames ) {
773
if (elem.nodeType == 1)
774
elem.className = classNames != undefined ?
775
jQuery.grep(elem.className.split(/\s+/), function(className){
776
return !jQuery.className.has( classNames, className );
777
}).join(" ") :
778
"";
779
},
780
781
// internal only, use hasClass("class")
782
has: function( elem, className ) {
783
return jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
784
}
785
},
786
787
// A method for quickly swapping in/out CSS properties to get correct calculations
788
swap: function( elem, options, callback ) {
789
var old = {};
790
// Remember the old values, and insert the new ones
791
for ( var name in options ) {
792
old[ name ] = elem.style[ name ];
793
elem.style[ name ] = options[ name ];
794
}
795
796
callback.call( elem );
797
798
// Revert the old values
799
for ( var name in options )
800
elem.style[ name ] = old[ name ];
801
},
802
803
css: function( elem, name, force ) {
804
if ( name == "width" || name == "height" ) {
805
var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];
806
807
function getWH() {
808
val = name == "width" ? elem.offsetWidth : elem.offsetHeight;
809
var padding = 0, border = 0;
810
jQuery.each( which, function() {
811
padding += parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
812
border += parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
813
});
814
val -= Math.round(padding + border);
815
}
816
817
if ( jQuery(elem).is(":visible") )
818
getWH();
819
else
820
jQuery.swap( elem, props, getWH );
821
822
return Math.max(0, val);
823
}
824
825
return jQuery.curCSS( elem, name, force );
826
},
827
828
curCSS: function( elem, name, force ) {
829
var ret, style = elem.style;
830
831
// A helper method for determining if an element's values are broken
832
function color( elem ) {
833
if ( !jQuery.browser.safari )
834
return false;
835
836
// defaultView is cached
837
var ret = defaultView.getComputedStyle( elem, null );
838
return !ret || ret.getPropertyValue("color") == "";
839
}
840
841
// We need to handle opacity special in IE
842
if ( name == "opacity" && jQuery.browser.msie ) {
843
ret = jQuery.attr( style, "opacity" );
844
845
return ret == "" ?
846
"1" :
847
ret;
848
}
849
// Opera sometimes will give the wrong display answer, this fixes it, see #2037
850
if ( jQuery.browser.opera && name == "display" ) {
851
var save = style.outline;
852
style.outline = "0 solid black";
853
style.outline = save;
854
}
855
856
// Make sure we're using the right name for getting the float value
857
if ( name.match( /float/i ) )
858
name = styleFloat;
859
860
if ( !force && style && style[ name ] )
861
ret = style[ name ];
862
863
else if ( defaultView.getComputedStyle ) {
864
865
// Only "float" is needed here
866
if ( name.match( /float/i ) )
867
name = "float";
868
869
name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();
870
871
var computedStyle = defaultView.getComputedStyle( elem, null );
872
873
if ( computedStyle && !color( elem ) )
874
ret = computedStyle.getPropertyValue( name );
875
876
// If the element isn't reporting its values properly in Safari
877
// then some display: none elements are involved
878
else {
879
var swap = [], stack = [], a = elem, i = 0;
880
881
// Locate all of the parent display: none elements
882
for ( ; a && color(a); a = a.parentNode )
883
stack.unshift(a);
884
885
// Go through and make them visible, but in reverse
886
// (It would be better if we knew the exact display type that they had)
887
for ( ; i < stack.length; i++ )
888
if ( color( stack[ i ] ) ) {
889
swap[ i ] = stack[ i ].style.display;
890
stack[ i ].style.display = "block";
891
}
892
893
// Since we flip the display style, we have to handle that
894
// one special, otherwise get the value
895
ret = name == "display" && swap[ stack.length - 1 ] != null ?
896
"none" :
897
( computedStyle && computedStyle.getPropertyValue( name ) ) || "";
898
899
// Finally, revert the display styles back
900
for ( i = 0; i < swap.length; i++ )
901
if ( swap[ i ] != null )
902
stack[ i ].style.display = swap[ i ];
903
}
904
905
// We should always get a number back from opacity
906
if ( name == "opacity" && ret == "" )
907
ret = "1";
908
909
} else if ( elem.currentStyle ) {
910
var camelCase = name.replace(/\-(\w)/g, function(all, letter){
911
return letter.toUpperCase();
912
});
913
914
ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];
915
916
// From the awesome hack by Dean Edwards
917
// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
918
919
// If we're not dealing with a regular pixel number
920
// but a number that has a weird ending, we need to convert it to pixels
921
if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) {
922
// Remember the original values
923
var left = style.left, rsLeft = elem.runtimeStyle.left;
924
925
// Put in the new values to get a computed value out
926
elem.runtimeStyle.left = elem.currentStyle.left;
927
style.left = ret || 0;
928
ret = style.pixelLeft + "px";
929
930
// Revert the changed values
931
style.left = left;
932
elem.runtimeStyle.left = rsLeft;
933
}
934
}
935
936
return ret;
937
},
938
939
clean: function( elems, context ) {
940
var ret = [];
941
context = context || document;
942
// !context.createElement fails in IE with an error but returns typeof 'object'
943
if (typeof context.createElement == 'undefined')
944
context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
945
946
jQuery.each(elems, function(i, elem){
947
if ( !elem )
948
return;
949
950
if ( elem.constructor == Number )
951
elem += '';
952
953
// Convert html string into DOM nodes
954
if ( typeof elem == "string" ) {
955
// Fix "XHTML"-style tags in all browsers
956
elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){
957
return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
958
all :
959
front + "></" + tag + ">";
960
});
961
962
// Trim whitespace, otherwise indexOf won't work as expected
963
var tags = jQuery.trim( elem ).toLowerCase(), div = context.createElement("div");
964
965
var wrap =
966
// option or optgroup
967
!tags.indexOf("<opt") &&
968
[ 1, "<select multiple='multiple'>", "</select>" ] ||
969
970
!tags.indexOf("<leg") &&
971
[ 1, "<fieldset>", "</fieldset>" ] ||
972
973
tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&
974
[ 1, "<table>", "</table>" ] ||
975
976
!tags.indexOf("<tr") &&
977
[ 2, "<table><tbody>", "</tbody></table>" ] ||
978
979
// <thead> matched above
980
(!tags.indexOf("<td") || !tags.indexOf("<th")) &&
981
[ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] ||
982
983
!tags.indexOf("<col") &&
984
[ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] ||
985
986
// IE can't serialize <link> and <script> tags normally
987
jQuery.browser.msie &&
988
[ 1, "div<div>", "</div>" ] ||
989
990
[ 0, "", "" ];
991
992
// Go to html and back, then peel off extra wrappers
993
div.innerHTML = wrap[1] + elem + wrap[2];
994
995
// Move to the right depth
996
while ( wrap[0]-- )
997
div = div.lastChild;
998
999
// Remove IE's autoinserted <tbody> from table fragments
1000
if ( jQuery.browser.msie ) {
1001
1002
// String was a <table>, *may* have spurious <tbody>
1003
var tbody = !tags.indexOf("<table") && tags.indexOf("<tbody") < 0 ?
1004
div.firstChild && div.firstChild.childNodes :
1005
1006
// String was a bare <thead> or <tfoot>
1007
wrap[1] == "<table>" && tags.indexOf("<tbody") < 0 ?
1008
div.childNodes :
1009
[];
1010
1011
for ( var j = tbody.length - 1; j >= 0 ; --j )
1012
if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length )
1013
tbody[ j ].parentNode.removeChild( tbody[ j ] );
1014
1015
// IE completely kills leading whitespace when innerHTML is used
1016
if ( /^\s/.test( elem ) )
1017
div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild );
1018
1019
}
1020
1021
elem = jQuery.makeArray( div.childNodes );
1022
}
1023
1024
if ( elem.length === 0 && (!jQuery.nodeName( elem, "form" ) && !jQuery.nodeName( elem, "select" )) )
1025
return;
1026
1027
if ( elem[0] == undefined || jQuery.nodeName( elem, "form" ) || elem.options )
1028
ret.push( elem );
1029
1030
else
1031
ret = jQuery.merge( ret, elem );
1032
1033
});
1034
1035
return ret;
1036
},
1037
1038
attr: function( elem, name, value ) {
1039
// don't set attributes on text and comment nodes
1040
if (!elem || elem.nodeType == 3 || elem.nodeType == 8)
1041
return undefined;
1042
1043
var notxml = !jQuery.isXMLDoc( elem ),
1044
// Whether we are setting (or getting)
1045
set = value !== undefined,
1046
msie = jQuery.browser.msie;
1047
1048
// Try to normalize/fix the name
1049
name = notxml && jQuery.props[ name ] || name;
1050
1051
// Only do all the following if this is a node (faster for style)
1052
// IE elem.getAttribute passes even for style
1053
if ( elem.tagName ) {
1054
1055
// These attributes require special treatment
1056
var special = /href|src|style/.test( name );
1057
1058
// Safari mis-reports the default selected property of a hidden option
1059
// Accessing the parent's selectedIndex property fixes it
1060
if ( name == "selected" && jQuery.browser.safari )
1061
elem.parentNode.selectedIndex;
1062
1063
// If applicable, access the attribute via the DOM 0 way
1064
if ( name in elem && notxml && !special ) {
1065
if ( set ){
1066
// We can't allow the type property to be changed (since it causes problems in IE)
1067
if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode )
1068
throw "type property can't be changed";
1069
1070
elem[ name ] = value;
1071
}
1072
1073
// browsers index elements by id/name on forms, give priority to attributes.
1074
if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) )
1075
return elem.getAttributeNode( name ).nodeValue;
1076
1077
return elem[ name ];
1078
}
1079
1080
if ( msie && notxml && name == "style" )
1081
return jQuery.attr( elem.style, "cssText", value );
1082
1083
if ( set )
1084
// convert the value to a string (all browsers do this but IE) see #1070
1085
elem.setAttribute( name, "" + value );
1086
1087
var attr = msie && notxml && special
1088
// Some attributes require a special call on IE
1089
? elem.getAttribute( name, 2 )
1090
: elem.getAttribute( name );
1091
1092
// Non-existent attributes return null, we normalize to undefined
1093
return attr === null ? undefined : attr;
1094
}
1095
1096
// elem is actually elem.style ... set the style
1097
1098
// IE uses filters for opacity
1099
if ( msie && name == "opacity" ) {
1100
if ( set ) {
1101
// IE has trouble with opacity if it does not have layout
1102
// Force it by setting the zoom level
1103
elem.zoom = 1;
1104
1105
// Set the alpha filter to set the opacity
1106
elem.filter = (elem.filter || "").replace( /alpha\([^)]*\)/, "" ) +
1107
(parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
1108
}
1109
1110
return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
1111
(parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '':
1112
"";
1113
}
1114
1115
name = name.replace(/-([a-z])/ig, function(all, letter){
1116
return letter.toUpperCase();
1117
});
1118
1119
if ( set )
1120
elem[ name ] = value;
1121
1122
return elem[ name ];
1123
},
1124
1125
trim: function( text ) {
1126
return (text || "").replace( /^\s+|\s+$/g, "" );
1127
},
1128
1129
makeArray: function( array ) {
1130
var ret = [];
1131
1132
if( array != null ){
1133
var i = array.length;
1134
//the window, strings and functions also have 'length'
1135
if( i == null || array.split || array.setInterval || array.call )
1136
ret[0] = array;
1137
else
1138
while( i )
1139
ret[--i] = array[i];
1140
}
1141
1142
return ret;
1143
},
1144
1145
inArray: function( elem, array ) {
1146
for ( var i = 0, length = array.length; i < length; i++ )
1147
// Use === because on IE, window == document
1148
if ( array[ i ] === elem )
1149
return i;
1150
1151
return -1;
1152
},
1153
1154
merge: function( first, second ) {
1155
// We have to loop this way because IE & Opera overwrite the length
1156
// expando of getElementsByTagName
1157
var i = 0, elem, pos = first.length;
1158
// Also, we need to make sure that the correct elements are being returned
1159
// (IE returns comment nodes in a '*' query)
1160
if ( jQuery.browser.msie ) {
1161
while ( elem = second[ i++ ] )
1162
if ( elem.nodeType != 8 )
1163
first[ pos++ ] = elem;
1164
1165
} else
1166
while ( elem = second[ i++ ] )
1167
first[ pos++ ] = elem;
1168
1169
return first;
1170
},
1171
1172
unique: function( array ) {
1173
var ret = [], done = {};
1174
1175
try {
1176
1177
for ( var i = 0, length = array.length; i < length; i++ ) {
1178
var id = jQuery.data( array[ i ] );
1179
1180
if ( !done[ id ] ) {
1181
done[ id ] = true;
1182
ret.push( array[ i ] );
1183
}
1184
}
1185
1186
} catch( e ) {
1187
ret = array;
1188
}
1189
1190
return ret;
1191
},
1192
1193
grep: function( elems, callback, inv ) {
1194
var ret = [];
1195
1196
// Go through the array, only saving the items
1197
// that pass the validator function
1198
for ( var i = 0, length = elems.length; i < length; i++ )
1199
if ( !inv != !callback( elems[ i ], i ) )
1200
ret.push( elems[ i ] );
1201
1202
return ret;
1203
},
1204
1205
map: function( elems, callback ) {
1206
var ret = [];
1207
1208
// Go through the array, translating each of the items to their
1209
// new value (or values).
1210
for ( var i = 0, length = elems.length; i < length; i++ ) {
1211
var value = callback( elems[ i ], i );
1212
1213
if ( value != null )
1214
ret[ ret.length ] = value;
1215
}
1216
1217
return ret.concat.apply( [], ret );
1218
}
1219
});
1220
1221
var userAgent = navigator.userAgent.toLowerCase();
1222
1223
// Figure out what browser is being used
1224
jQuery.browser = {
1225
version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [])[1],
1226
safari: /webkit/.test( userAgent ),
1227
opera: /opera/.test( userAgent ),
1228
msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
1229
mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )
1230
};
1231
1232
var styleFloat = jQuery.browser.msie ?
1233
"styleFloat" :
1234
"cssFloat";
1235
1236
jQuery.extend({
1237
// Check to see if the W3C box model is being used
1238
boxModel: !jQuery.browser.msie || document.compatMode == "CSS1Compat",
1239
1240
props: {
1241
"for": "htmlFor",
1242
"class": "className",
1243
"float": styleFloat,
1244
cssFloat: styleFloat,
1245
styleFloat: styleFloat,
1246
readonly: "readOnly",
1247
maxlength: "maxLength",
1248
cellspacing: "cellSpacing"
1249
}
1250
});
1251
1252
jQuery.each({
1253
parent: function(elem){return elem.parentNode;},
1254
parents: function(elem){return jQuery.dir(elem,"parentNode");},
1255
next: function(elem){return jQuery.nth(elem,2,"nextSibling");},
1256
prev: function(elem){return jQuery.nth(elem,2,"previousSibling");},
1257
nextAll: function(elem){return jQuery.dir(elem,"nextSibling");},
1258
prevAll: function(elem){return jQuery.dir(elem,"previousSibling");},
1259
siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);},
1260
children: function(elem){return jQuery.sibling(elem.firstChild);},
1261
contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
1262
}, function(name, fn){
1263
jQuery.fn[ name ] = function( selector ) {
1264
var ret = jQuery.map( this, fn );
1265
1266
if ( selector && typeof selector == "string" )
1267
ret = jQuery.multiFilter( selector, ret );
1268
1269
return this.pushStack( jQuery.unique( ret ) );
1270
};
1271
});
1272
1273
jQuery.each({
1274
appendTo: "append",
1275
prependTo: "prepend",
1276
insertBefore: "before",
1277
insertAfter: "after",
1278
replaceAll: "replaceWith"
1279
}, function(name, original){
1280
jQuery.fn[ name ] = function() {
1281
var args = arguments;
1282
1283
return this.each(function(){
1284
for ( var i = 0, length = args.length; i < length; i++ )
1285
jQuery( args[ i ] )[ original ]( this );
1286
});
1287
};
1288
});
1289
1290
jQuery.each({
1291
removeAttr: function( name ) {
1292
jQuery.attr( this, name, "" );
1293
if (this.nodeType == 1)
1294
this.removeAttribute( name );
1295
},
1296
1297
addClass: function( classNames ) {
1298
jQuery.className.add( this, classNames );
1299
},
1300
1301
removeClass: function( classNames ) {
1302
jQuery.className.remove( this, classNames );
1303
},
1304
1305
toggleClass: function( classNames ) {
1306
jQuery.className[ jQuery.className.has( this, classNames ) ? "remove" : "add" ]( this, classNames );
1307
},
1308
1309
remove: function( selector ) {
1310
if ( !selector || jQuery.filter( selector, [ this ] ).r.length ) {
1311
// Prevent memory leaks
1312
jQuery( "*", this ).add(this).each(function(){
1313
jQuery.event.remove(this);
1314
jQuery.removeData(this);
1315
});
1316
if (this.parentNode)
1317
this.parentNode.removeChild( this );
1318
}
1319
},
1320
1321
empty: function() {
1322
// Remove element nodes and prevent memory leaks
1323
jQuery( ">*", this ).remove();
1324
1325
// Remove any remaining nodes
1326
while ( this.firstChild )
1327
this.removeChild( this.firstChild );
1328
}
1329
}, function(name, fn){
1330
jQuery.fn[ name ] = function(){
1331
return this.each( fn, arguments );
1332
};
1333
});
1334
1335
jQuery.each([ "Height", "Width" ], function(i, name){
1336
var type = name.toLowerCase();
1337
1338
jQuery.fn[ type ] = function( size ) {
1339
// Get window width or height
1340
return this[0] == window ?
1341
// Opera reports document.body.client[Width/Height] properly in both quirks and standards
1342
jQuery.browser.opera && document.body[ "client" + name ] ||
1343
1344
// Safari reports inner[Width/Height] just fine (Mozilla and Opera include scroll bar widths)
1345
jQuery.browser.safari && window[ "inner" + name ] ||
1346
1347
// Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
1348
document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] || document.body[ "client" + name ] :
1349
1350
// Get document width or height
1351
this[0] == document ?
1352
// Either scroll[Width/Height] or offset[Width/Height], whichever is greater
1353
Math.max(
1354
Math.max(document.body["scroll" + name], document.documentElement["scroll" + name]),
1355
Math.max(document.body["offset" + name], document.documentElement["offset" + name])
1356
) :
1357
1358
// Get or set width or height on the element
1359
size == undefined ?
1360
// Get width or height on the element
1361
(this.length ? jQuery.css( this[0], type ) : null) :
1362
1363
// Set the width or height on the element (default to pixels if value is unitless)
1364
this.css( type, size.constructor == String ? size : size + "px" );
1365
};
1366
});
1367
1368
// Helper function used by the dimensions and offset modules
1369
function num(elem, prop) {
1370
return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) || 0;
1371
}var chars = jQuery.browser.safari && parseInt(jQuery.browser.version) < 417 ?
1372
"(?:[\\w*_-]|\\\\.)" :
1373
"(?:[\\w\u0128-\uFFFF*_-]|\\\\.)",
1374
quickChild = new RegExp("^>\\s*(" + chars + "+)"),
1375
quickID = new RegExp("^(" + chars + "+)(#)(" + chars + "+)"),
1376
quickClass = new RegExp("^([#.]?)(" + chars + "*)");
1377
1378
jQuery.extend({
1379
expr: {
1380
"": function(a,i,m){return m[2]=="*"||jQuery.nodeName(a,m[2]);},
1381
"#": function(a,i,m){return a.getAttribute("id")==m[2];},
1382
":": {
1383
// Position Checks
1384
lt: function(a,i,m){return i<m[3]-0;},
1385
gt: function(a,i,m){return i>m[3]-0;},
1386
nth: function(a,i,m){return m[3]-0==i;},
1387
eq: function(a,i,m){return m[3]-0==i;},
1388
first: function(a,i){return i==0;},
1389
last: function(a,i,m,r){return i==r.length-1;},
1390
even: function(a,i){return i%2==0;},
1391
odd: function(a,i){return i%2;},
1392
1393
// Child Checks
1394
"first-child": function(a){return a.parentNode.getElementsByTagName("*")[0]==a;},
1395
"last-child": function(a){return jQuery.nth(a.parentNode.lastChild,1,"previousSibling")==a;},
1396
"only-child": function(a){return !jQuery.nth(a.parentNode.lastChild,2,"previousSibling");},
1397
1398
// Parent Checks
1399
parent: function(a){return a.firstChild;},
1400
empty: function(a){return !a.firstChild;},
1401
1402
// Text Check
1403
contains: function(a,i,m){return (a.textContent||a.innerText||jQuery(a).text()||"").indexOf(m[3])>=0;},
1404
1405
// Visibility
1406
visible: function(a){return "hidden"!=a.type&&jQuery.css(a,"display")!="none"&&jQuery.css(a,"visibility")!="hidden";},
1407
hidden: function(a){return "hidden"==a.type||jQuery.css(a,"display")=="none"||jQuery.css(a,"visibility")=="hidden";},
1408
1409
// Form attributes
1410
enabled: function(a){return !a.disabled;},
1411
disabled: function(a){return a.disabled;},
1412
checked: function(a){return a.checked;},
1413
selected: function(a){return a.selected||jQuery.attr(a,"selected");},
1414
1415
// Form elements
1416
text: function(a){return "text"==a.type;},
1417
radio: function(a){return "radio"==a.type;},
1418
checkbox: function(a){return "checkbox"==a.type;},
1419
file: function(a){return "file"==a.type;},
1420
password: function(a){return "password"==a.type;},
1421
submit: function(a){return "submit"==a.type;},
1422
image: function(a){return "image"==a.type;},
1423
reset: function(a){return "reset"==a.type;},
1424
button: function(a){return "button"==a.type||jQuery.nodeName(a,"button");},
1425
input: function(a){return /input|select|textarea|button/i.test(a.nodeName);},
1426
1427
// :has()
1428
has: function(a,i,m){return jQuery.find(m[3],a).length;},
1429
1430
// :header
1431
header: function(a){return /h\d/i.test(a.nodeName);},
1432
1433
// :animated
1434
animated: function(a){return jQuery.grep(jQuery.timers,function(fn){return a==fn.elem;}).length;}
1435
}
1436
},
1437
1438
// The regular expressions that power the parsing engine
1439
parse: [
1440
// Match: [@value='test'], [@foo]
1441
/^(\[) *@?([\w-]+) *([!*$^~=]*) *('?"?)(.*?)\4 *\]/,
1442
1443
// Match: :contains('foo')
1444
/^(:)([\w-]+)\("?'?(.*?(\(.*?\))?[^(]*?)"?'?\)/,
1445
1446
// Match: :even, :last-child, #id, .class
1447
new RegExp("^([:.#]*)(" + chars + "+)")
1448
],
1449
1450
multiFilter: function( expr, elems, not ) {
1451
var old, cur = [];
1452
1453
while ( expr && expr != old ) {
1454
old = expr;
1455
var f = jQuery.filter( expr, elems, not );
1456
expr = f.t.replace(/^\s*,\s*/, "" );
1457
cur = not ? elems = f.r : jQuery.merge( cur, f.r );
1458
}
1459
1460
return cur;
1461
},
1462
1463
find: function( t, context ) {
1464
// Quickly handle non-string expressions
1465
if ( typeof t != "string" )
1466
return [ t ];
1467
1468
// check to make sure context is a DOM element or a document
1469
if ( context && context.nodeType != 1 && context.nodeType != 9)
1470
return [ ];
1471
1472
// Set the correct context (if none is provided)
1473
context = context || document;
1474
1475
// Initialize the search
1476
var ret = [context], done = [], last, nodeName;
1477
1478
// Continue while a selector expression exists, and while
1479
// we're no longer looping upon ourselves
1480
while ( t && last != t ) {
1481
var r = [];
1482
last = t;
1483
1484
t = jQuery.trim(t);
1485
1486
var foundToken = false,
1487
1488
// An attempt at speeding up child selectors that
1489
// point to a specific element tag
1490
re = quickChild,
1491
1492
m = re.exec(t);
1493
1494
if ( m ) {
1495
nodeName = m[1].toUpperCase();
1496
1497
// Perform our own iteration and filter
1498
for ( var i = 0; ret[i]; i++ )
1499
for ( var c = ret[i].firstChild; c; c = c.nextSibling )
1500
if ( c.nodeType == 1 && (nodeName == "*" || c.nodeName.toUpperCase() == nodeName) )
1501
r.push( c );
1502
1503
ret = r;
1504
t = t.replace( re, "" );
1505
if ( t.indexOf(" ") == 0 ) continue;
1506
foundToken = true;
1507
} else {
1508
re = /^([>+~])\s*(\w*)/i;
1509
1510
if ( (m = re.exec(t)) != null ) {
1511
r = [];
1512
1513
var merge = {};
1514
nodeName = m[2].toUpperCase();
1515
m = m[1];
1516
1517
for ( var j = 0, rl = ret.length; j < rl; j++ ) {
1518
var n = m == "~" || m == "+" ? ret[j].nextSibling : ret[j].firstChild;
1519
for ( ; n; n = n.nextSibling )
1520
if ( n.nodeType == 1 ) {
1521
var id = jQuery.data(n);
1522
1523
if ( m == "~" && merge[id] ) break;
1524
1525
if (!nodeName || n.nodeName.toUpperCase() == nodeName ) {
1526
if ( m == "~" ) merge[id] = true;
1527
r.push( n );
1528
}
1529
1530
if ( m == "+" ) break;
1531
}
1532
}
1533
1534
ret = r;
1535
1536
// And remove the token
1537
t = jQuery.trim( t.replace( re, "" ) );
1538
foundToken = true;
1539
}
1540
}
1541
1542
// See if there's still an expression, and that we haven't already
1543
// matched a token
1544
if ( t && !foundToken ) {
1545
// Handle multiple expressions
1546
if ( !t.indexOf(",") ) {
1547
// Clean the result set
1548
if ( context == ret[0] ) ret.shift();
1549
1550
// Merge the result sets
1551
done = jQuery.merge( done, ret );
1552
1553
// Reset the context
1554
r = ret = [context];
1555
1556
// Touch up the selector string
1557
t = " " + t.substr(1,t.length);
1558
1559
} else {
1560
// Optimize for the case nodeName#idName
1561
var re2 = quickID;
1562
var m = re2.exec(t);
1563
1564
// Re-organize the results, so that they're consistent
1565
if ( m ) {
1566
m = [ 0, m[2], m[3], m[1] ];
1567
1568
} else {
1569
// Otherwise, do a traditional filter check for
1570
// ID, class, and element selectors
1571
re2 = quickClass;
1572
m = re2.exec(t);
1573
}
1574
1575
m[2] = m[2].replace(/\\/g, "");
1576
1577
var elem = ret[ret.length-1];
1578
1579
// Try to do a global search by ID, where we can
1580
if ( m[1] == "#" && elem && elem.getElementById && !jQuery.isXMLDoc(elem) ) {
1581
// Optimization for HTML document case
1582
var oid = elem.getElementById(m[2]);
1583
1584
// Do a quick check for the existence of the actual ID attribute
1585
// to avoid selecting by the name attribute in IE
1586
// also check to insure id is a string to avoid selecting an element with the name of 'id' inside a form
1587
if ( (jQuery.browser.msie||jQuery.browser.opera) && oid && typeof oid.id == "string" && oid.id != m[2] )
1588
oid = jQuery('[@id="'+m[2]+'"]', elem)[0];
1589
1590
// Do a quick check for node name (where applicable) so
1591
// that div#foo searches will be really fast
1592
ret = r = oid && (!m[3] || jQuery.nodeName(oid, m[3])) ? [oid] : [];
1593
} else {
1594
// We need to find all descendant elements
1595
for ( var i = 0; ret[i]; i++ ) {
1596
// Grab the tag name being searched for
1597
var tag = m[1] == "#" && m[3] ? m[3] : m[1] != "" || m[0] == "" ? "*" : m[2];
1598
1599
// Handle IE7 being really dumb about <object>s
1600
if ( tag == "*" && ret[i].nodeName.toLowerCase() == "object" )
1601
tag = "param";
1602
1603
r = jQuery.merge( r, ret[i].getElementsByTagName( tag ));
1604
}
1605
1606
// It's faster to filter by class and be done with it
1607
if ( m[1] == "." )
1608
r = jQuery.classFilter( r, m[2] );
1609
1610
// Same with ID filtering
1611
if ( m[1] == "#" ) {
1612
var tmp = [];
1613
1614
// Try to find the element with the ID
1615
for ( var i = 0; r[i]; i++ )
1616
if ( r[i].getAttribute("id") == m[2] ) {
1617
tmp = [ r[i] ];
1618
break;
1619
}
1620
1621
r = tmp;
1622
}
1623
1624
ret = r;
1625
}
1626
1627
t = t.replace( re2, "" );
1628
}
1629
1630
}
1631
1632
// If a selector string still exists
1633
if ( t ) {
1634
// Attempt to filter it
1635
var val = jQuery.filter(t,r);
1636
ret = r = val.r;
1637
t = jQuery.trim(val.t);
1638
}
1639
}
1640
1641
// An error occurred with the selector;
1642
// just return an empty set instead
1643
if ( t )
1644
ret = [];
1645
1646
// Remove the root context
1647
if ( ret && context == ret[0] )
1648
ret.shift();
1649
1650
// And combine the results
1651
done = jQuery.merge( done, ret );
1652
1653
return done;
1654
},
1655
1656
classFilter: function(r,m,not){
1657
m = " " + m + " ";
1658
var tmp = [];
1659
for ( var i = 0; r[i]; i++ ) {
1660
var pass = (" " + r[i].className + " ").indexOf( m ) >= 0;
1661
if ( !not && pass || not && !pass )
1662
tmp.push( r[i] );
1663
}
1664
return tmp;
1665
},
1666
1667
filter: function(t,r,not) {
1668
var last;
1669
1670
// Look for common filter expressions
1671
while ( t && t != last ) {
1672
last = t;
1673
1674
var p = jQuery.parse, m;
1675
1676
for ( var i = 0; p[i]; i++ ) {
1677
m = p[i].exec( t );
1678
1679
if ( m ) {
1680
// Remove what we just matched
1681
t = t.substring( m[0].length );
1682
1683
m[2] = m[2].replace(/\\/g, "");
1684
break;
1685
}
1686
}
1687
1688
if ( !m )
1689
break;
1690
1691
// :not() is a special case that can be optimized by
1692
// keeping it out of the expression list
1693
if ( m[1] == ":" && m[2] == "not" )
1694
// optimize if only one selector found (most common case)
1695
r = isSimple.test( m[3] ) ?
1696
jQuery.filter(m[3], r, true).r :
1697
jQuery( r ).not( m[3] );
1698
1699
// We can get a big speed boost by filtering by class here
1700
else if ( m[1] == "." )
1701
r = jQuery.classFilter(r, m[2], not);
1702
1703
else if ( m[1] == "[" ) {
1704
var tmp = [], type = m[3];
1705
1706
for ( var i = 0, rl = r.length; i < rl; i++ ) {
1707
var a = r[i], z = a[ jQuery.props[m[2]] || m[2] ];
1708
1709
if ( z == null || /href|src|selected/.test(m[2]) )
1710
z = jQuery.attr(a,m[2]) || '';
1711
1712
if ( (type == "" && !!z ||
1713
type == "=" && z == m[5] ||
1714
type == "!=" && z != m[5] ||
1715
type == "^=" && z && !z.indexOf(m[5]) ||
1716
type == "$=" && z.substr(z.length - m[5].length) == m[5] ||
1717
(type == "*=" || type == "~=") && z.indexOf(m[5]) >= 0) ^ not )
1718
tmp.push( a );
1719
}
1720
1721
r = tmp;
1722
1723
// We can get a speed boost by handling nth-child here
1724
} else if ( m[1] == ":" && m[2] == "nth-child" ) {
1725
var merge = {}, tmp = [],
1726
// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
1727
test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
1728
m[3] == "even" && "2n" || m[3] == "odd" && "2n+1" ||
1729
!/\D/.test(m[3]) && "0n+" + m[3] || m[3]),
1730
// calculate the numbers (first)n+(last) including if they are negative
1731
first = (test[1] + (test[2] || 1)) - 0, last = test[3] - 0;
1732
1733
// loop through all the elements left in the jQuery object
1734
for ( var i = 0, rl = r.length; i < rl; i++ ) {
1735
var node = r[i], parentNode = node.parentNode, id = jQuery.data(parentNode);
1736
1737
if ( !merge[id] ) {
1738
var c = 1;
1739
1740
for ( var n = parentNode.firstChild; n; n = n.nextSibling )
1741
if ( n.nodeType == 1 )
1742
n.nodeIndex = c++;
1743
1744
merge[id] = true;
1745
}
1746
1747
var add = false;
1748
1749
if ( first == 0 ) {
1750
if ( node.nodeIndex == last )
1751
add = true;
1752
} else if ( (node.nodeIndex - last) % first == 0 && (node.nodeIndex - last) / first >= 0 )
1753
add = true;
1754
1755
if ( add ^ not )
1756
tmp.push( node );
1757
}
1758
1759
r = tmp;
1760
1761
// Otherwise, find the expression to execute
1762
} else {
1763
var fn = jQuery.expr[ m[1] ];
1764
if ( typeof fn == "object" )
1765
fn = fn[ m[2] ];
1766
1767
if ( typeof fn == "string" )
1768
fn = eval("false||function(a,i){return " + fn + ";}");
1769
1770
// Execute it against the current filter
1771
r = jQuery.grep( r, function(elem, i){
1772
return fn(elem, i, m, r);
1773
}, not );
1774
}
1775
}
1776
1777
// Return an array of filtered elements (r)
1778
// and the modified expression string (t)
1779
return { r: r, t: t };
1780
},
1781
1782
dir: function( elem, dir ){
1783
var matched = [],
1784
cur = elem[dir];
1785
while ( cur && cur != document ) {
1786
if ( cur.nodeType == 1 )
1787
matched.push( cur );
1788
cur = cur[dir];
1789
}
1790
return matched;
1791
},
1792
1793
nth: function(cur,result,dir,elem){
1794
result = result || 1;
1795
var num = 0;
1796
1797
for ( ; cur; cur = cur[dir] )
1798
if ( cur.nodeType == 1 && ++num == result )
1799
break;
1800
1801
return cur;
1802
},
1803
1804
sibling: function( n, elem ) {
1805
var r = [];
1806
1807
for ( ; n; n = n.nextSibling ) {
1808
if ( n.nodeType == 1 && n != elem )
1809
r.push( n );
1810
}
1811
1812
return r;
1813
}
1814
});
1815
/*
1816
* A number of helper functions used for managing events.
1817
* Many of the ideas behind this code orignated from
1818
* Dean Edwards' addEvent library.
1819
*/
1820
jQuery.event = {
1821
1822
// Bind an event to an element
1823
// Original by Dean Edwards
1824
add: function(elem, types, handler, data) {
1825
if ( elem.nodeType == 3 || elem.nodeType == 8 )
1826
return;
1827
1828
// For whatever reason, IE has trouble passing the window object
1829
// around, causing it to be cloned in the process
1830
if ( jQuery.browser.msie && elem.setInterval )
1831
elem = window;
1832
1833
// Make sure that the function being executed has a unique ID
1834
if ( !handler.guid )
1835
handler.guid = this.guid++;
1836
1837
// if data is passed, bind to handler
1838
if( data != undefined ) {
1839
// Create temporary function pointer to original handler
1840
var fn = handler;
1841
1842
// Create unique handler function, wrapped around original handler
1843
handler = this.proxy( fn, function() {
1844
// Pass arguments and context to original handler
1845
return fn.apply(this, arguments);
1846
});
1847
1848
// Store data in unique handler
1849
handler.data = data;
1850
}
1851
1852
// Init the element's event structure
1853
var events = jQuery.data(elem, "events") || jQuery.data(elem, "events", {}),
1854
handle = jQuery.data(elem, "handle") || jQuery.data(elem, "handle", function(){
1855
// Handle the second event of a trigger and when
1856
// an event is called after a page has unloaded
1857
if ( typeof jQuery != "undefined" && !jQuery.event.triggered )
1858
return jQuery.event.handle.apply(arguments.callee.elem, arguments);
1859
});
1860
// Add elem as a property of the handle function
1861
// This is to prevent a memory leak with non-native
1862
// event in IE.
1863
handle.elem = elem;
1864
1865
// Handle multiple events separated by a space
1866
// jQuery(...).bind("mouseover mouseout", fn);
1867
jQuery.each(types.split(/\s+/), function(index, type) {
1868
// Namespaced event handlers
1869
var parts = type.split(".");
1870
type = parts[0];
1871
handler.type = parts[1];
1872
1873
// Get the current list of functions bound to this event
1874
var handlers = events[type];
1875
1876
// Init the event handler queue
1877
if (!handlers) {
1878
handlers = events[type] = {};
1879
1880
// Check for a special event handler
1881
// Only use addEventListener/attachEvent if the special
1882
// events handler returns false
1883
if ( !jQuery.event.special[type] || jQuery.event.special[type].setup.call(elem) === false ) {
1884
// Bind the global event handler to the element
1885
if (elem.addEventListener)
1886
elem.addEventListener(type, handle, false);
1887
else if (elem.attachEvent)
1888
elem.attachEvent("on" + type, handle);
1889
}
1890
}
1891
1892
// Add the function to the element's handler list
1893
handlers[handler.guid] = handler;
1894
1895
// Keep track of which events have been used, for global triggering
1896
jQuery.event.global[type] = true;
1897
});
1898
1899
// Nullify elem to prevent memory leaks in IE
1900
elem = null;
1901
},
1902
1903
guid: 1,
1904
global: {},
1905
1906
// Detach an event or set of events from an element
1907
remove: function(elem, types, handler) {
1908
// don't do events on text and comment nodes
1909
if ( elem.nodeType == 3 || elem.nodeType == 8 )
1910
return;
1911
1912
var events = jQuery.data(elem, "events"), ret, index;
1913
1914
if ( events ) {
1915
// Unbind all events for the element
1916
if ( types == undefined || (typeof types == "string" && types.charAt(0) == ".") )
1917
for ( var type in events )
1918
this.remove( elem, type + (types || "") );
1919
else {
1920
// types is actually an event object here
1921
if ( types.type ) {
1922
handler = types.handler;
1923
types = types.type;
1924
}
1925
1926
// Handle multiple events seperated by a space
1927
// jQuery(...).unbind("mouseover mouseout", fn);
1928
jQuery.each(types.split(/\s+/), function(index, type){
1929
// Namespaced event handlers
1930
var parts = type.split(".");
1931
type = parts[0];
1932
1933
if ( events[type] ) {
1934
// remove the given handler for the given type
1935
if ( handler )
1936
delete events[type][handler.guid];
1937
1938
// remove all handlers for the given type
1939
else
1940
for ( handler in events[type] )
1941
// Handle the removal of namespaced events
1942
if ( !parts[1] || events[type][handler].type == parts[1] )
1943
delete events[type][handler];
1944
1945
// remove generic event handler if no more handlers exist
1946
for ( ret in events[type] ) break;
1947
if ( !ret ) {
1948
if ( !jQuery.event.special[type] || jQuery.event.special[type].teardown.call(elem) === false ) {
1949
if (elem.removeEventListener)
1950
elem.removeEventListener(type, jQuery.data(elem, "handle"), false);
1951
else if (elem.detachEvent)
1952
elem.detachEvent("on" + type, jQuery.data(elem, "handle"));
1953
}
1954
ret = null;
1955
delete events[type];
1956
}
1957
}
1958
});
1959
}
1960
1961
// Remove the expando if it's no longer used
1962
for ( ret in events ) break;
1963
if ( !ret ) {
1964
var handle = jQuery.data( elem, "handle" );
1965
if ( handle ) handle.elem = null;
1966
jQuery.removeData( elem, "events" );
1967
jQuery.removeData( elem, "handle" );
1968
}
1969
}
1970
},
1971
1972
trigger: function(type, data, elem, donative, extra) {
1973
// Clone the incoming data, if any
1974
data = jQuery.makeArray(data);
1975
1976
if ( type.indexOf("!") >= 0 ) {
1977
type = type.slice(0, -1);
1978
var exclusive = true;
1979
}
1980
1981
// Handle a global trigger
1982
if ( !elem ) {
1983
// Only trigger if we've ever bound an event for it
1984
if ( this.global[type] )
1985
jQuery("*").add([window, document]).trigger(type, data);
1986
1987
// Handle triggering a single element
1988
} else {
1989
// don't do events on text and comment nodes
1990
if ( elem.nodeType == 3 || elem.nodeType == 8 )
1991
return undefined;
1992
1993
var val, ret, fn = jQuery.isFunction( elem[ type ] || null ),
1994
// Check to see if we need to provide a fake event, or not
1995
event = !data[0] || !data[0].preventDefault;
1996
1997
// Pass along a fake event
1998
if ( event ) {
1999
data.unshift({
2000
type: type,
2001
target: elem,
2002
preventDefault: function(){},
2003
stopPropagation: function(){},
2004
timeStamp: now()
2005
});
2006
data[0][expando] = true; // no need to fix fake event
2007
}
2008
2009
// Enforce the right trigger type
2010
data[0].type = type;
2011
if ( exclusive )
2012
data[0].exclusive = true;
2013
2014
// Trigger the event, it is assumed that "handle" is a function
2015
var handle = jQuery.data(elem, "handle");
2016
if ( handle )
2017
val = handle.apply( elem, data );
2018
2019
// Handle triggering native .onfoo handlers (and on links since we don't call .click() for links)
2020
if ( (!fn || (jQuery.nodeName(elem, 'a') && type == "click")) && elem["on"+type] && elem["on"+type].apply( elem, data ) === false )
2021
val = false;
2022
2023
// Extra functions don't get the custom event object
2024
if ( event )
2025
data.shift();
2026
2027
// Handle triggering of extra function
2028
if ( extra && jQuery.isFunction( extra ) ) {
2029
// call the extra function and tack the current return value on the end for possible inspection
2030
ret = extra.apply( elem, val == null ? data : data.concat( val ) );
2031
// if anything is returned, give it precedence and have it overwrite the previous value
2032
if (ret !== undefined)
2033
val = ret;
2034
}
2035
2036
// Trigger the native events (except for clicks on links)
2037
if ( fn && donative !== false && val !== false && !(jQuery.nodeName(elem, 'a') && type == "click") ) {
2038
this.triggered = true;
2039
try {
2040
elem[ type ]();
2041
// prevent IE from throwing an error for some hidden elements
2042
} catch (e) {}
2043
}
2044
2045
this.triggered = false;
2046
}
2047
2048
return val;
2049
},
2050
2051
handle: function(event) {
2052
// returned undefined or false
2053
var val, ret, namespace, all, handlers;
2054
2055
event = arguments[0] = jQuery.event.fix( event || window.event );
2056
2057
// Namespaced event handlers
2058
namespace = event.type.split(".");
2059
event.type = namespace[0];
2060
namespace = namespace[1];
2061
// Cache this now, all = true means, any handler
2062
all = !namespace && !event.exclusive;
2063
2064
handlers = ( jQuery.data(this, "events") || {} )[event.type];
2065
2066
for ( var j in handlers ) {
2067
var handler = handlers[j];
2068
2069
// Filter the functions by class
2070
if ( all || handler.type == namespace ) {
2071
// Pass in a reference to the handler function itself
2072
// So that we can later remove it
2073
event.handler = handler;
2074
event.data = handler.data;
2075
2076
ret = handler.apply( this, arguments );
2077
2078
if ( val !== false )
2079
val = ret;
2080
2081
if ( ret === false ) {
2082
event.preventDefault();
2083
event.stopPropagation();
2084
}
2085
}
2086
}
2087
2088
return val;
2089
},
2090
2091
fix: function(event) {
2092
if ( event[expando] == true )
2093
return event;
2094
2095
// store a copy of the original event object
2096
// and "clone" to set read-only properties
2097
var originalEvent = event;
2098
event = { originalEvent: originalEvent };
2099
var props = "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode metaKey newValue originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target timeStamp toElement type view wheelDelta which".split(" ");
2100
for ( var i=props.length; i; i-- )
2101
event[ props[i] ] = originalEvent[ props[i] ];
2102
2103
// Mark it as fixed
2104
event[expando] = true;
2105
2106
// add preventDefault and stopPropagation since
2107
// they will not work on the clone
2108
event.preventDefault = function() {
2109
// if preventDefault exists run it on the original event
2110
if (originalEvent.preventDefault)
2111
originalEvent.preventDefault();
2112
// otherwise set the returnValue property of the original event to false (IE)
2113
originalEvent.returnValue = false;
2114
};
2115
event.stopPropagation = function() {
2116
// if stopPropagation exists run it on the original event
2117
if (originalEvent.stopPropagation)
2118
originalEvent.stopPropagation();
2119
// otherwise set the cancelBubble property of the original event to true (IE)
2120
originalEvent.cancelBubble = true;
2121
};
2122
2123
// Fix timeStamp
2124
event.timeStamp = event.timeStamp || now();
2125
2126
// Fix target property, if necessary
2127
if ( !event.target )
2128
event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
2129
2130
// check if target is a textnode (safari)
2131
if ( event.target.nodeType == 3 )
2132
event.target = event.target.parentNode;
2133
2134
// Add relatedTarget, if necessary
2135
if ( !event.relatedTarget && event.fromElement )
2136
event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
2137
2138
// Calculate pageX/Y if missing and clientX/Y available
2139
if ( event.pageX == null && event.clientX != null ) {
2140
var doc = document.documentElement, body = document.body;
2141
event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
2142
event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
2143
}
2144
2145
// Add which for key events
2146
if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
2147
event.which = event.charCode || event.keyCode;
2148
2149
// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2150
if ( !event.metaKey && event.ctrlKey )
2151
event.metaKey = event.ctrlKey;
2152
2153
// Add which for click: 1 == left; 2 == middle; 3 == right
2154
// Note: button is not normalized, so don't use it
2155
if ( !event.which && event.button )
2156
event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
2157
2158
return event;
2159
},
2160
2161
proxy: function( fn, proxy ){
2162
// Set the guid of unique handler to the same of original handler, so it can be removed
2163
proxy.guid = fn.guid = fn.guid || proxy.guid || this.guid++;
2164
// So proxy can be declared as an argument
2165
return proxy;
2166
},
2167
2168
special: {
2169
ready: {
2170
setup: function() {
2171
// Make sure the ready event is setup
2172
bindReady();
2173
return;
2174
},
2175
2176
teardown: function() { return; }
2177
},
2178
2179
mouseenter: {
2180
setup: function() {
2181
if ( jQuery.browser.msie ) return false;
2182
jQuery(this).bind("mouseover", jQuery.event.special.mouseenter.handler);
2183
return true;
2184
},
2185
2186
teardown: function() {
2187
if ( jQuery.browser.msie ) return false;
2188
jQuery(this).unbind("mouseover", jQuery.event.special.mouseenter.handler);
2189
return true;
2190
},
2191
2192
handler: function(event) {
2193
// If we actually just moused on to a sub-element, ignore it
2194
if ( withinElement(event, this) ) return true;
2195
// Execute the right handlers by setting the event type to mouseenter
2196
event.type = "mouseenter";
2197
return jQuery.event.handle.apply(this, arguments);
2198
}
2199
},
2200
2201
mouseleave: {
2202
setup: function() {
2203
if ( jQuery.browser.msie ) return false;
2204
jQuery(this).bind("mouseout", jQuery.event.special.mouseleave.handler);
2205
return true;
2206
},
2207
2208
teardown: function() {
2209
if ( jQuery.browser.msie ) return false;
2210
jQuery(this).unbind("mouseout", jQuery.event.special.mouseleave.handler);
2211
return true;
2212
},
2213
2214
handler: function(event) {
2215
// If we actually just moused on to a sub-element, ignore it
2216
if ( withinElement(event, this) ) return true;
2217
// Execute the right handlers by setting the event type to mouseleave
2218
event.type = "mouseleave";
2219
return jQuery.event.handle.apply(this, arguments);
2220
}
2221
}
2222
}
2223
};
2224
2225
jQuery.fn.extend({
2226
bind: function( type, data, fn ) {
2227
return type == "unload" ? this.one(type, data, fn) : this.each(function(){
2228
jQuery.event.add( this, type, fn || data, fn && data );
2229
});
2230
},
2231
2232
one: function( type, data, fn ) {
2233
var one = jQuery.event.proxy( fn || data, function(event) {
2234
jQuery(this).unbind(event, one);
2235
return (fn || data).apply( this, arguments );
2236
});
2237
return this.each(function(){
2238
jQuery.event.add( this, type, one, fn && data);
2239
});
2240
},
2241
2242
unbind: function( type, fn ) {
2243
return this.each(function(){
2244
jQuery.event.remove( this, type, fn );
2245
});
2246
},
2247
2248
trigger: function( type, data, fn ) {
2249
return this.each(function(){
2250
jQuery.event.trigger( type, data, this, true, fn );
2251
});
2252
},
2253
2254
triggerHandler: function( type, data, fn ) {
2255
return this[0] && jQuery.event.trigger( type, data, this[0], false, fn );
2256
},
2257
2258
toggle: function( fn ) {
2259
// Save reference to arguments for access in closure
2260
var args = arguments, i = 1;
2261
2262
// link all the functions, so any of them can unbind this click handler
2263
while( i < args.length )
2264
jQuery.event.proxy( fn, args[i++] );
2265
2266
return this.click( jQuery.event.proxy( fn, function(event) {
2267
// Figure out which function to execute
2268
this.lastToggle = ( this.lastToggle || 0 ) % i;
2269
2270
// Make sure that clicks stop
2271
event.preventDefault();
2272
2273
// and execute the function
2274
return args[ this.lastToggle++ ].apply( this, arguments ) || false;
2275
}));
2276
},
2277
2278
hover: function(fnOver, fnOut) {
2279
return this.bind('mouseenter', fnOver).bind('mouseleave', fnOut);
2280
},
2281
2282
ready: function(fn) {
2283
// Attach the listeners
2284
bindReady();
2285
2286
// If the DOM is already ready
2287
if ( jQuery.isReady )
2288
// Execute the function immediately
2289
fn.call( document, jQuery );
2290
2291
// Otherwise, remember the function for later
2292
else
2293
// Add the function to the wait list
2294
jQuery.readyList.push( function() { return fn.call(this, jQuery); } );
2295
2296
return this;
2297
}
2298
});
2299
2300
jQuery.extend({
2301
isReady: false,
2302
readyList: [],
2303
// Handle when the DOM is ready
2304
ready: function() {
2305
// Make sure that the DOM is not already loaded
2306
if ( !jQuery.isReady ) {
2307
// Remember that the DOM is ready
2308
jQuery.isReady = true;
2309
2310
// If there are functions bound, to execute
2311
if ( jQuery.readyList ) {
2312
// Execute all of them
2313
jQuery.each( jQuery.readyList, function(){
2314
this.call( document );
2315
});
2316
2317
// Reset the list of functions
2318
jQuery.readyList = null;
2319
}
2320
2321
// Trigger any bound ready events
2322
jQuery(document).triggerHandler("ready");
2323
}
2324
}
2325
});
2326
2327
var readyBound = false;
2328
2329
function bindReady(){
2330
if ( readyBound ) return;
2331
readyBound = true;
2332
2333
// Mozilla, Opera (see further below for it) and webkit nightlies currently support this event
2334
if ( document.addEventListener && !jQuery.browser.opera)
2335
// Use the handy event callback
2336
document.addEventListener( "DOMContentLoaded", jQuery.ready, false );
2337
2338
// If IE is used and is not in a frame
2339
// Continually check to see if the document is ready
2340
if ( jQuery.browser.msie && window == top ) (function(){
2341
if (jQuery.isReady) return;
2342
try {
2343
// If IE is used, use the trick by Diego Perini
2344
// http://javascript.nwbox.com/IEContentLoaded/
2345
document.documentElement.doScroll("left");
2346
} catch( error ) {
2347
setTimeout( arguments.callee, 0 );
2348
return;
2349
}
2350
// and execute any waiting functions
2351
jQuery.ready();
2352
})();
2353
2354
if ( jQuery.browser.opera )
2355
document.addEventListener( "DOMContentLoaded", function () {
2356
if (jQuery.isReady) return;
2357
for (var i = 0; i < document.styleSheets.length; i++)
2358
if (document.styleSheets[i].disabled) {
2359
setTimeout( arguments.callee, 0 );
2360
return;
2361
}
2362
// and execute any waiting functions
2363
jQuery.ready();
2364
}, false);
2365
2366
if ( jQuery.browser.safari ) {
2367
var numStyles;
2368
(function(){
2369
if (jQuery.isReady) return;
2370
if ( document.readyState != "loaded" && document.readyState != "complete" ) {
2371
setTimeout( arguments.callee, 0 );
2372
return;
2373
}
2374
if ( numStyles === undefined )
2375
numStyles = jQuery("style, link[rel=stylesheet]").length;
2376
if ( document.styleSheets.length != numStyles ) {
2377
setTimeout( arguments.callee, 0 );
2378
return;
2379
}
2380
// and execute any waiting functions
2381
jQuery.ready();
2382
})();
2383
}
2384
2385
// A fallback to window.onload, that will always work
2386
jQuery.event.add( window, "load", jQuery.ready );
2387
}
2388
2389
jQuery.each( ("blur,focus,load,resize,scroll,unload,click,dblclick," +
2390
"mousedown,mouseup,mousemove,mouseover,mouseout,change,select," +
2391
"submit,keydown,keypress,keyup,error").split(","), function(i, name){
2392
2393
// Handle event binding
2394
jQuery.fn[name] = function(fn){
2395
return fn ? this.bind(name, fn) : this.trigger(name);
2396
};
2397
});
2398
2399
// Checks if an event happened on an element within another element
2400
// Used in jQuery.event.special.mouseenter and mouseleave handlers
2401
var withinElement = function(event, elem) {
2402
// Check if mouse(over|out) are still within the same parent element
2403
var parent = event.relatedTarget;
2404
// Traverse up the tree
2405
while ( parent && parent != elem ) try { parent = parent.parentNode; } catch(error) { parent = elem; }
2406
// Return true if we actually just moused on to a sub-element
2407
return parent == elem;
2408
};
2409
2410
// Prevent memory leaks in IE
2411
// And prevent errors on refresh with events like mouseover in other browsers
2412
// Window isn't included so as not to unbind existing unload events
2413
jQuery(window).bind("unload", function() {
2414
jQuery("*").add(document).unbind();
2415
});
2416
jQuery.fn.extend({
2417
// Keep a copy of the old load
2418
_load: jQuery.fn.load,
2419
2420
load: function( url, params, callback ) {
2421
if ( typeof url != 'string' )
2422
return this._load( url );
2423
2424
var off = url.indexOf(" ");
2425
if ( off >= 0 ) {
2426
var selector = url.slice(off, url.length);
2427
url = url.slice(0, off);
2428
}
2429
2430
callback = callback || function(){};
2431
2432
// Default to a GET request
2433
var type = "GET";
2434
2435
// If the second parameter was provided
2436
if ( params )
2437
// If it's a function
2438
if ( jQuery.isFunction( params ) ) {
2439
// We assume that it's the callback
2440
callback = params;
2441
params = null;
2442
2443
// Otherwise, build a param string
2444
} else {
2445
params = jQuery.param( params );
2446
type = "POST";
2447
}
2448
2449
var self = this;
2450
2451
// Request the remote document
2452
jQuery.ajax({
2453
url: url,
2454
type: type,
2455
dataType: "html",
2456
data: params,
2457
complete: function(res, status){
2458
// If successful, inject the HTML into all the matched elements
2459
if ( status == "success" || status == "notmodified" )
2460
// See if a selector was specified
2461
self.html( selector ?
2462
// Create a dummy div to hold the results
2463
jQuery("<div/>")
2464
// inject the contents of the document in, removing the scripts
2465
// to avoid any 'Permission Denied' errors in IE
2466
.append(res.responseText.replace(/<script(.|\s)*?\/script>/g, ""))
2467
2468
// Locate the specified elements
2469
.find(selector) :
2470
2471
// If not, just inject the full result
2472
res.responseText );
2473
2474
self.each( callback, [res.responseText, status, res] );
2475
}
2476
});
2477
return this;
2478
},
2479
2480
serialize: function() {
2481
return jQuery.param(this.serializeArray());
2482
},
2483
serializeArray: function() {
2484
return this.map(function(){
2485
return jQuery.nodeName(this, "form") ?
2486
jQuery.makeArray(this.elements) : this;
2487
})
2488
.filter(function(){
2489
return this.name && !this.disabled &&
2490
(this.checked || /select|textarea/i.test(this.nodeName) ||
2491
/text|hidden|password/i.test(this.type));
2492
})
2493
.map(function(i, elem){
2494
var val = jQuery(this).val();
2495
return val == null ? null :
2496
val.constructor == Array ?
2497
jQuery.map( val, function(val, i){
2498
return {name: elem.name, value: val};
2499
}) :
2500
{name: elem.name, value: val};
2501
}).get();
2502
}
2503
});
2504
2505
// Attach a bunch of functions for handling common AJAX events
2506
jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){
2507
jQuery.fn[o] = function(f){
2508
return this.bind(o, f);
2509
};
2510
});
2511
2512
var jsc = now();
2513
2514
jQuery.extend({
2515
get: function( url, data, callback, type ) {
2516
// shift arguments if data argument was ommited
2517
if ( jQuery.isFunction( data ) ) {
2518
callback = data;
2519
data = null;
2520
}
2521
2522
return jQuery.ajax({
2523
type: "GET",
2524
url: url,
2525
data: data,
2526
success: callback,
2527
dataType: type
2528
});
2529
},
2530
2531
getScript: function( url, callback ) {
2532
return jQuery.get(url, null, callback, "script");
2533
},
2534
2535
getJSON: function( url, data, callback ) {
2536
return jQuery.get(url, data, callback, "json");
2537
},
2538
2539
post: function( url, data, callback, type ) {
2540
if ( jQuery.isFunction( data ) ) {
2541
callback = data;
2542
data = {};
2543
}
2544
2545
return jQuery.ajax({
2546
type: "POST",
2547
url: url,
2548
data: data,
2549
success: callback,
2550
dataType: type
2551
});
2552
},
2553
2554
ajaxSetup: function( settings ) {
2555
jQuery.extend( jQuery.ajaxSettings, settings );
2556
},
2557
2558
ajaxSettings: {
2559
url: location.href,
2560
global: true,
2561
type: "GET",
2562
timeout: 0,
2563
contentType: "application/x-www-form-urlencoded",
2564
processData: true,
2565
async: true,
2566
data: null,
2567
username: null,
2568
password: null,
2569
accepts: {
2570
xml: "application/xml, text/xml",
2571
html: "text/html",
2572
script: "text/javascript, application/javascript",
2573
json: "application/json, text/javascript",
2574
text: "text/plain",
2575
_default: "*/*"
2576
}
2577
},
2578
2579
// Last-Modified header cache for next request
2580
lastModified: {},
2581
2582
ajax: function( s ) {
2583
// Extend the settings, but re-extend 's' so that it can be
2584
// checked again later (in the test suite, specifically)
2585
s = jQuery.extend(true, s, jQuery.extend(true, {}, jQuery.ajaxSettings, s));
2586
2587
var jsonp, jsre = /=\?(&|$)/g, status, data,
2588
type = s.type.toUpperCase();
2589
2590
// convert data if not already a string
2591
if ( s.data && s.processData && typeof s.data != "string" )
2592
s.data = jQuery.param(s.data);
2593
2594
// Handle JSONP Parameter Callbacks
2595
if ( s.dataType == "jsonp" ) {
2596
if ( type == "GET" ) {
2597
if ( !s.url.match(jsre) )
2598
s.url += (s.url.match(/\?/) ? "&" : "?") + (s.jsonp || "callback") + "=?";
2599
} else if ( !s.data || !s.data.match(jsre) )
2600
s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
2601
s.dataType = "json";
2602
}
2603
2604
// Build temporary JSONP function
2605
if ( s.dataType == "json" && (s.data && s.data.match(jsre) || s.url.match(jsre)) ) {
2606
jsonp = "jsonp" + jsc++;
2607
2608
// Replace the =? sequence both in the query string and the data
2609
if ( s.data )
2610
s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
2611
s.url = s.url.replace(jsre, "=" + jsonp + "$1");
2612
2613
// We need to make sure
2614
// that a JSONP style response is executed properly
2615
s.dataType = "script";
2616
2617
// Handle JSONP-style loading
2618
window[ jsonp ] = function(tmp){
2619
data = tmp;
2620
success();
2621
complete();
2622
// Garbage collect
2623
window[ jsonp ] = undefined;
2624
try{ delete window[ jsonp ]; } catch(e){}
2625
if ( head )
2626
head.removeChild( script );
2627
};
2628
}
2629
2630
if ( s.dataType == "script" && s.cache == null )
2631
s.cache = false;
2632
2633
if ( s.cache === false && type == "GET" ) {
2634
var ts = now();
2635
// try replacing _= if it is there
2636
var ret = s.url.replace(/(\?|&)_=.*?(&|$)/, "$1_=" + ts + "$2");
2637
// if nothing was replaced, add timestamp to the end
2638
s.url = ret + ((ret == s.url) ? (s.url.match(/\?/) ? "&" : "?") + "_=" + ts : "");
2639
}
2640
2641
// If data is available, append data to url for get requests
2642
if ( s.data && type == "GET" ) {
2643
s.url += (s.url.match(/\?/) ? "&" : "?") + s.data;
2644
2645
// IE likes to send both get and post data, prevent this
2646
s.data = null;
2647
}
2648
2649
// Watch for a new set of requests
2650
if ( s.global && ! jQuery.active++ )
2651
jQuery.event.trigger( "ajaxStart" );
2652
2653
// Matches an absolute URL, and saves the domain
2654
var remote = /^(?:\w+:)?\/\/([^\/?#]+)/;
2655
2656
// If we're requesting a remote document
2657
// and trying to load JSON or Script with a GET
2658
if ( s.dataType == "script" && type == "GET"
2659
&& remote.test(s.url) && remote.exec(s.url)[1] != location.host ){
2660
var head = document.getElementsByTagName("head")[0];
2661
var script = document.createElement("script");
2662
script.src = s.url;
2663
if (s.scriptCharset)
2664
script.charset = s.scriptCharset;
2665
2666
// Handle Script loading
2667
if ( !jsonp ) {
2668
var done = false;
2669
2670
// Attach handlers for all browsers
2671
script.onload = script.onreadystatechange = function(){
2672
if ( !done && (!this.readyState ||
2673
this.readyState == "loaded" || this.readyState == "complete") ) {
2674
done = true;
2675
success();
2676
complete();
2677
head.removeChild( script );
2678
}
2679
};
2680
}
2681
2682
head.appendChild(script);
2683
2684
// We handle everything using the script element injection
2685
return undefined;
2686
}
2687
2688
var requestDone = false;
2689
2690
// Create the request object; Microsoft failed to properly
2691
// implement the XMLHttpRequest in IE7, so we use the ActiveXObject when it is available
2692
var xhr = window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
2693
2694
// Open the socket
2695
// Passing null username, generates a login popup on Opera (#2865)
2696
if( s.username )
2697
xhr.open(type, s.url, s.async, s.username, s.password);
2698
else
2699
xhr.open(type, s.url, s.async);
2700
2701
// Need an extra try/catch for cross domain requests in Firefox 3
2702
try {
2703
// Set the correct header, if data is being sent
2704
if ( s.data )
2705
xhr.setRequestHeader("Content-Type", s.contentType);
2706
2707
// Set the If-Modified-Since header, if ifModified mode.
2708
if ( s.ifModified )
2709
xhr.setRequestHeader("If-Modified-Since",
2710
jQuery.lastModified[s.url] || "Thu, 01 Jan 1970 00:00:00 GMT" );
2711
2712
// Set header so the called script knows that it's an XMLHttpRequest
2713
xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
2714
2715
// Set the Accepts header for the server, depending on the dataType
2716
xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
2717
s.accepts[ s.dataType ] + ", */*" :
2718
s.accepts._default );
2719
} catch(e){}
2720
2721
// Allow custom headers/mimetypes
2722
if ( s.beforeSend && s.beforeSend(xhr, s) === false ) {
2723
// cleanup active request counter
2724
s.global && jQuery.active--;
2725
// close opended socket
2726
xhr.abort();
2727
return false;
2728
}
2729
2730
if ( s.global )
2731
jQuery.event.trigger("ajaxSend", [xhr, s]);
2732
2733
// Wait for a response to come back
2734
var onreadystatechange = function(isTimeout){
2735
// The transfer is complete and the data is available, or the request timed out
2736
if ( !requestDone && xhr && (xhr.readyState == 4 || isTimeout == "timeout") ) {
2737
requestDone = true;
2738
2739
// clear poll interval
2740
if (ival) {
2741
clearInterval(ival);
2742
ival = null;
2743
}
2744
2745
status = isTimeout == "timeout" && "timeout" ||
2746
!jQuery.httpSuccess( xhr ) && "error" ||
2747
s.ifModified && jQuery.httpNotModified( xhr, s.url ) && "notmodified" ||
2748
"success";
2749
2750
if ( status == "success" ) {
2751
// Watch for, and catch, XML document parse errors
2752
try {
2753
// process the data (runs the xml through httpData regardless of callback)
2754
data = jQuery.httpData( xhr, s.dataType, s.dataFilter );
2755
} catch(e) {
2756
status = "parsererror";
2757
}
2758
}
2759
2760
// Make sure that the request was successful or notmodified
2761
if ( status == "success" ) {
2762
// Cache Last-Modified header, if ifModified mode.
2763
var modRes;
2764
try {
2765
modRes = xhr.getResponseHeader("Last-Modified");
2766
} catch(e) {} // swallow exception thrown by FF if header is not available
2767
2768
if ( s.ifModified && modRes )
2769
jQuery.lastModified[s.url] = modRes;
2770
2771
// JSONP handles its own success callback
2772
if ( !jsonp )
2773
success();
2774
} else
2775
jQuery.handleError(s, xhr, status);
2776
2777
// Fire the complete handlers
2778
complete();
2779
2780
// Stop memory leaks
2781
if ( s.async )
2782
xhr = null;
2783
}
2784
};
2785
2786
if ( s.async ) {
2787
// don't attach the handler to the request, just poll it instead
2788
var ival = setInterval(onreadystatechange, 13);
2789
2790
// Timeout checker
2791
if ( s.timeout > 0 )
2792
setTimeout(function(){
2793
// Check to see if the request is still happening
2794
if ( xhr ) {
2795
// Cancel the request
2796
xhr.abort();
2797
2798
if( !requestDone )
2799
onreadystatechange( "timeout" );
2800
}
2801
}, s.timeout);
2802
}
2803
2804
// Send the data
2805
try {
2806
xhr.send(s.data);
2807
} catch(e) {
2808
jQuery.handleError(s, xhr, null, e);
2809
}
2810
2811
// firefox 1.5 doesn't fire statechange for sync requests
2812
if ( !s.async )
2813
onreadystatechange();
2814
2815
function success(){
2816
// If a local callback was specified, fire it and pass it the data
2817
if ( s.success )
2818
s.success( data, status );
2819
2820
// Fire the global callback
2821
if ( s.global )
2822
jQuery.event.trigger( "ajaxSuccess", [xhr, s] );
2823
}
2824
2825
function complete(){
2826
// Process result
2827
if ( s.complete )
2828
s.complete(xhr, status);
2829
2830
// The request was completed
2831
if ( s.global )
2832
jQuery.event.trigger( "ajaxComplete", [xhr, s] );
2833
2834
// Handle the global AJAX counter
2835
if ( s.global && ! --jQuery.active )
2836
jQuery.event.trigger( "ajaxStop" );
2837
}
2838
2839
// return XMLHttpRequest to allow aborting the request etc.
2840
return xhr;
2841
},
2842
2843
handleError: function( s, xhr, status, e ) {
2844
// If a local callback was specified, fire it
2845
if ( s.error ) s.error( xhr, status, e );
2846
2847
// Fire the global callback
2848
if ( s.global )
2849
jQuery.event.trigger( "ajaxError", [xhr, s, e] );
2850
},
2851
2852
// Counter for holding the number of active queries
2853
active: 0,
2854
2855
// Determines if an XMLHttpRequest was successful or not
2856
httpSuccess: function( xhr ) {
2857
try {
2858
// IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
2859
return !xhr.status && location.protocol == "file:" ||
2860
( xhr.status >= 200 && xhr.status < 300 ) || xhr.status == 304 || xhr.status == 1223 ||
2861
jQuery.browser.safari && xhr.status == undefined;
2862
} catch(e){}
2863
return false;
2864
},
2865
2866
// Determines if an XMLHttpRequest returns NotModified
2867
httpNotModified: function( xhr, url ) {
2868
try {
2869
var xhrRes = xhr.getResponseHeader("Last-Modified");
2870
2871
// Firefox always returns 200. check Last-Modified date
2872
return xhr.status == 304 || xhrRes == jQuery.lastModified[url] ||
2873
jQuery.browser.safari && xhr.status == undefined;
2874
} catch(e){}
2875
return false;
2876
},
2877
2878
httpData: function( xhr, type, filter ) {
2879
var ct = xhr.getResponseHeader("content-type"),
2880
xml = type == "xml" || !type && ct && ct.indexOf("xml") >= 0,
2881
data = xml ? xhr.responseXML : xhr.responseText;
2882
2883
if ( xml && data.documentElement.tagName == "parsererror" )
2884
throw "parsererror";
2885
2886
// Allow a pre-filtering function to sanitize the response
2887
if( filter )
2888
data = filter( data, type );
2889
2890
// If the type is "script", eval it in global context
2891
if ( type == "script" )
2892
jQuery.globalEval( data );
2893
2894
// Get the JavaScript object, if JSON is used.
2895
if ( type == "json" )
2896
data = eval("(" + data + ")");
2897
2898
return data;
2899
},
2900
2901
// Serialize an array of form elements or a set of
2902
// key/values into a query string
2903
param: function( a ) {
2904
var s = [];
2905
2906
// If an array was passed in, assume that it is an array
2907
// of form elements
2908
if ( a.constructor == Array || a.jquery )
2909
// Serialize the form elements
2910
jQuery.each( a, function(){
2911
s.push( encodeURIComponent(this.name) + "=" + encodeURIComponent( this.value ) );
2912
});
2913
2914
// Otherwise, assume that it's an object of key/value pairs
2915
else
2916
// Serialize the key/values
2917
for ( var j in a )
2918
// If the value is an array then the key names need to be repeated
2919
if ( a[j] && a[j].constructor == Array )
2920
jQuery.each( a[j], function(){
2921
s.push( encodeURIComponent(j) + "=" + encodeURIComponent( this ) );
2922
});
2923
else
2924
s.push( encodeURIComponent(j) + "=" + encodeURIComponent( jQuery.isFunction(a[j]) ? a[j]() : a[j] ) );
2925
2926
// Return the resulting serialization
2927
return s.join("&").replace(/%20/g, "+");
2928
}
2929
2930
});
2931
jQuery.fn.extend({
2932
show: function(speed,callback){
2933
return speed ?
2934
this.animate({
2935
height: "show", width: "show", opacity: "show"
2936
}, speed, callback) :
2937
2938
this.filter(":hidden").each(function(){
2939
this.style.display = this.oldblock || "";
2940
if ( jQuery.css(this,"display") == "none" ) {
2941
var elem = jQuery("<" + this.tagName + " />").appendTo("body");
2942
this.style.display = elem.css("display");
2943
// handle an edge condition where css is - div { display:none; } or similar
2944
if (this.style.display == "none")
2945
this.style.display = "block";
2946
elem.remove();
2947
}
2948
}).end();
2949
},
2950
2951
hide: function(speed,callback){
2952
return speed ?
2953
this.animate({
2954
height: "hide", width: "hide", opacity: "hide"
2955
}, speed, callback) :
2956
2957
this.filter(":visible").each(function(){
2958
this.oldblock = this.oldblock || jQuery.css(this,"display");
2959
this.style.display = "none";
2960
}).end();
2961
},
2962
2963
// Save the old toggle function
2964
_toggle: jQuery.fn.toggle,
2965
2966
toggle: function( fn, fn2 ){
2967
return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ?
2968
this._toggle.apply( this, arguments ) :
2969
fn ?
2970
this.animate({
2971
height: "toggle", width: "toggle", opacity: "toggle"
2972
}, fn, fn2) :
2973
this.each(function(){
2974
jQuery(this)[ jQuery(this).is(":hidden") ? "show" : "hide" ]();
2975
});
2976
},
2977
2978
slideDown: function(speed,callback){
2979
return this.animate({height: "show"}, speed, callback);
2980
},
2981
2982
slideUp: function(speed,callback){
2983
return this.animate({height: "hide"}, speed, callback);
2984
},
2985
2986
slideToggle: function(speed, callback){
2987
return this.animate({height: "toggle"}, speed, callback);
2988
},
2989
2990
fadeIn: function(speed, callback){
2991
return this.animate({opacity: "show"}, speed, callback);
2992
},
2993
2994
fadeOut: function(speed, callback){
2995
return this.animate({opacity: "hide"}, speed, callback);
2996
},
2997
2998
fadeTo: function(speed,to,callback){
2999
return this.animate({opacity: to}, speed, callback);
3000
},
3001
3002
animate: function( prop, speed, easing, callback ) {
3003
var optall = jQuery.speed(speed, easing, callback);
3004
3005
return this[ optall.queue === false ? "each" : "queue" ](function(){
3006
if ( this.nodeType != 1)
3007
return false;
3008
3009
var opt = jQuery.extend({}, optall), p,
3010
hidden = jQuery(this).is(":hidden"), self = this;
3011
3012
for ( p in prop ) {
3013
if ( prop[p] == "hide" && hidden || prop[p] == "show" && !hidden )
3014
return opt.complete.call(this);
3015
3016
if ( p == "height" || p == "width" ) {
3017
// Store display property
3018
opt.display = jQuery.css(this, "display");
3019
3020
// Make sure that nothing sneaks out
3021
opt.overflow = this.style.overflow;
3022
}
3023
}
3024
3025
if ( opt.overflow != null )
3026
this.style.overflow = "hidden";
3027
3028
opt.curAnim = jQuery.extend({}, prop);
3029
3030
jQuery.each( prop, function(name, val){
3031
var e = new jQuery.fx( self, opt, name );
3032
3033
if ( /toggle|show|hide/.test(val) )
3034
e[ val == "toggle" ? hidden ? "show" : "hide" : val ]( prop );
3035
else {
3036
var parts = val.toString().match(/^([+-]=)?([\d+-.]+)(.*)$/),
3037
start = e.cur(true) || 0;
3038
3039
if ( parts ) {
3040
var end = parseFloat(parts[2]),
3041
unit = parts[3] || "px";
3042
3043
// We need to compute starting value
3044
if ( unit != "px" ) {
3045
self.style[ name ] = (end || 1) + unit;
3046
start = ((end || 1) / e.cur(true)) * start;
3047
self.style[ name ] = start + unit;
3048
}
3049
3050
// If a +=/-= token was provided, we're doing a relative animation
3051
if ( parts[1] )
3052
end = ((parts[1] == "-=" ? -1 : 1) * end) + start;
3053
3054
e.custom( start, end, unit );
3055
} else
3056
e.custom( start, val, "" );
3057
}
3058
});
3059
3060
// For JS strict compliance
3061
return true;
3062
});
3063
},
3064
3065
queue: function(type, fn){
3066
if ( jQuery.isFunction(type) || ( type && type.constructor == Array )) {
3067
fn = type;
3068
type = "fx";
3069
}
3070
3071
if ( !type || (typeof type == "string" && !fn) )
3072
return queue( this[0], type );
3073
3074
return this.each(function(){
3075
if ( fn.constructor == Array )
3076
queue(this, type, fn);
3077
else {
3078
queue(this, type).push( fn );
3079
3080
if ( queue(this, type).length == 1 )
3081
fn.call(this);
3082
}
3083
});
3084
},
3085
3086
stop: function(clearQueue, gotoEnd){
3087
var timers = jQuery.timers;
3088
3089
if (clearQueue)
3090
this.queue([]);
3091
3092
this.each(function(){
3093
// go in reverse order so anything added to the queue during the loop is ignored
3094
for ( var i = timers.length - 1; i >= 0; i-- )
3095
if ( timers[i].elem == this ) {
3096
if (gotoEnd)
3097
// force the next step to be the last
3098
timers[i](true);
3099
timers.splice(i, 1);
3100
}
3101
});
3102
3103
// start the next in the queue if the last step wasn't forced
3104
if (!gotoEnd)
3105
this.dequeue();
3106
3107
return this;
3108
}
3109
3110
});
3111
3112
var queue = function( elem, type, array ) {
3113
if ( elem ){
3114
3115
type = type || "fx";
3116
3117
var q = jQuery.data( elem, type + "queue" );
3118
3119
if ( !q || array )
3120
q = jQuery.data( elem, type + "queue", jQuery.makeArray(array) );
3121
3122
}
3123
return q;
3124
};
3125
3126
jQuery.fn.dequeue = function(type){
3127
type = type || "fx";
3128
3129
return this.each(function(){
3130
var q = queue(this, type);
3131
3132
q.shift();
3133
3134
if ( q.length )
3135
q[0].call( this );
3136
});
3137
};
3138
3139
jQuery.extend({
3140
3141
speed: function(speed, easing, fn) {
3142
var opt = speed && speed.constructor == Object ? speed : {
3143
complete: fn || !fn && easing ||
3144
jQuery.isFunction( speed ) && speed,
3145
duration: speed,
3146
easing: fn && easing || easing && easing.constructor != Function && easing
3147
};
3148
3149
opt.duration = (opt.duration && opt.duration.constructor == Number ?
3150
opt.duration :
3151
jQuery.fx.speeds[opt.duration]) || jQuery.fx.speeds.def;
3152
3153
// Queueing
3154
opt.old = opt.complete;
3155
opt.complete = function(){
3156
if ( opt.queue !== false )
3157
jQuery(this).dequeue();
3158
if ( jQuery.isFunction( opt.old ) )
3159
opt.old.call( this );
3160
};
3161
3162
return opt;
3163
},
3164
3165
easing: {
3166
linear: function( p, n, firstNum, diff ) {
3167
return firstNum + diff * p;
3168
},
3169
swing: function( p, n, firstNum, diff ) {
3170
return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
3171
}
3172
},
3173
3174
timers: [],
3175
timerId: null,
3176
3177
fx: function( elem, options, prop ){
3178
this.options = options;
3179
this.elem = elem;
3180
this.prop = prop;
3181
3182
if ( !options.orig )
3183
options.orig = {};
3184
}
3185
3186
});
3187
3188
jQuery.fx.prototype = {
3189
3190
// Simple function for setting a style value
3191
update: function(){
3192
if ( this.options.step )
3193
this.options.step.call( this.elem, this.now, this );
3194
3195
(jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
3196
3197
// Set display property to block for height/width animations
3198
if ( this.prop == "height" || this.prop == "width" )
3199
this.elem.style.display = "block";
3200
},
3201
3202
// Get the current size
3203
cur: function(force){
3204
if ( this.elem[this.prop] != null && this.elem.style[this.prop] == null )
3205
return this.elem[ this.prop ];
3206
3207
var r = parseFloat(jQuery.css(this.elem, this.prop, force));
3208
return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) || 0;
3209
},
3210
3211
// Start an animation from one number to another
3212
custom: function(from, to, unit){
3213
this.startTime = now();
3214
this.start = from;
3215
this.end = to;
3216
this.unit = unit || this.unit || "px";
3217
this.now = this.start;
3218
this.pos = this.state = 0;
3219
this.update();
3220
3221
var self = this;
3222
function t(gotoEnd){
3223
return self.step(gotoEnd);
3224
}
3225
3226
t.elem = this.elem;
3227
3228
jQuery.timers.push(t);
3229
3230
if ( jQuery.timerId == null ) {
3231
jQuery.timerId = setInterval(function(){
3232
var timers = jQuery.timers;
3233
3234
for ( var i = 0; i < timers.length; i++ )
3235
if ( !timers[i]() )
3236
timers.splice(i--, 1);
3237
3238
if ( !timers.length ) {
3239
clearInterval( jQuery.timerId );
3240
jQuery.timerId = null;
3241
}
3242
}, 13);
3243
}
3244
},
3245
3246
// Simple 'show' function
3247
show: function(){
3248
// Remember where we started, so that we can go back to it later
3249
this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
3250
this.options.show = true;
3251
3252
// Begin the animation
3253
this.custom(0, this.cur());
3254
3255
// Make sure that we start at a small width/height to avoid any
3256
// flash of content
3257
if ( this.prop == "width" || this.prop == "height" )
3258
this.elem.style[this.prop] = "1px";
3259
3260
// Start by showing the element
3261
jQuery(this.elem).show();
3262
},
3263
3264
// Simple 'hide' function
3265
hide: function(){
3266
// Remember where we started, so that we can go back to it later
3267
this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
3268
this.options.hide = true;
3269
3270
// Begin the animation
3271
this.custom(this.cur(), 0);
3272
},
3273
3274
// Each step of an animation
3275
step: function(gotoEnd){
3276
var t = now();
3277
3278
if ( gotoEnd || t > this.options.duration + this.startTime ) {
3279
this.now = this.end;
3280
this.pos = this.state = 1;
3281
this.update();
3282
3283
this.options.curAnim[ this.prop ] = true;
3284
3285
var done = true;
3286
for ( var i in this.options.curAnim )
3287
if ( this.options.curAnim[i] !== true )
3288
done = false;
3289
3290
if ( done ) {
3291
if ( this.options.display != null ) {
3292
// Reset the overflow
3293
this.elem.style.overflow = this.options.overflow;
3294
3295
// Reset the display
3296
this.elem.style.display = this.options.display;
3297
if ( jQuery.css(this.elem, "display") == "none" )
3298
this.elem.style.display = "block";
3299
}
3300
3301
// Hide the element if the "hide" operation was done
3302
if ( this.options.hide )
3303
this.elem.style.display = "none";
3304
3305
// Reset the properties, if the item has been hidden or shown
3306
if ( this.options.hide || this.options.show )
3307
for ( var p in this.options.curAnim )
3308
jQuery.attr(this.elem.style, p, this.options.orig[p]);
3309
}
3310
3311
if ( done )
3312
// Execute the complete function
3313
this.options.complete.call( this.elem );
3314
3315
return false;
3316
} else {
3317
var n = t - this.startTime;
3318
this.state = n / this.options.duration;
3319
3320
// Perform the easing function, defaults to swing
3321
this.pos = jQuery.easing[this.options.easing || (jQuery.easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration);
3322
this.now = this.start + ((this.end - this.start) * this.pos);
3323
3324
// Perform the next step of the animation
3325
this.update();
3326
}
3327
3328
return true;
3329
}
3330
3331
};
3332
3333
jQuery.extend( jQuery.fx, {
3334
speeds:{
3335
slow: 600,
3336
fast: 200,
3337
// Default speed
3338
def: 400
3339
},
3340
step: {
3341
scrollLeft: function(fx){
3342
fx.elem.scrollLeft = fx.now;
3343
},
3344
3345
scrollTop: function(fx){
3346
fx.elem.scrollTop = fx.now;
3347
},
3348
3349
opacity: function(fx){
3350
jQuery.attr(fx.elem.style, "opacity", fx.now);
3351
},
3352
3353
_default: function(fx){
3354
fx.elem.style[ fx.prop ] = fx.now + fx.unit;
3355
}
3356
}
3357
});
3358
// The Offset Method
3359
// Originally By Brandon Aaron, part of the Dimension Plugin
3360
// http://jquery.com/plugins/project/dimensions
3361
jQuery.fn.offset = function() {
3362
var left = 0, top = 0, elem = this[0], results;
3363
3364
if ( elem ) with ( jQuery.browser ) {
3365
var parent = elem.parentNode,
3366
offsetChild = elem,
3367
offsetParent = elem.offsetParent,
3368
doc = elem.ownerDocument,
3369
safari2 = safari && parseInt(version) < 522 && !/adobeair/i.test(userAgent),
3370
css = jQuery.curCSS,
3371
fixed = css(elem, "position") == "fixed";
3372
3373
// Use getBoundingClientRect if available
3374
if ( elem.getBoundingClientRect ) {
3375
var box = elem.getBoundingClientRect();
3376
3377
// Add the document scroll offsets
3378
add(box.left + Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft),
3379
box.top + Math.max(doc.documentElement.scrollTop, doc.body.scrollTop));
3380
3381
// IE adds the HTML element's border, by default it is medium which is 2px
3382
// IE 6 and 7 quirks mode the border width is overwritable by the following css html { border: 0; }
3383
// IE 7 standards mode, the border is always 2px
3384
// This border/offset is typically represented by the clientLeft and clientTop properties
3385
// However, in IE6 and 7 quirks mode the clientLeft and clientTop properties are not updated when overwriting it via CSS
3386
// Therefore this method will be off by 2px in IE while in quirksmode
3387
add( -doc.documentElement.clientLeft, -doc.documentElement.clientTop );
3388
3389
// Otherwise loop through the offsetParents and parentNodes
3390
} else {
3391
3392
// Initial element offsets
3393
add( elem.offsetLeft, elem.offsetTop );
3394
3395
// Get parent offsets
3396
while ( offsetParent ) {
3397
// Add offsetParent offsets
3398
add( offsetParent.offsetLeft, offsetParent.offsetTop );
3399
3400
// Mozilla and Safari > 2 does not include the border on offset parents
3401
// However Mozilla adds the border for table or table cells
3402
if ( mozilla && !/^t(able|d|h)$/i.test(offsetParent.tagName) || safari && !safari2 )
3403
border( offsetParent );
3404
3405
// Add the document scroll offsets if position is fixed on any offsetParent
3406
if ( !fixed && css(offsetParent, "position") == "fixed" )
3407
fixed = true;
3408
3409
// Set offsetChild to previous offsetParent unless it is the body element
3410
offsetChild = /^body$/i.test(offsetParent.tagName) ? offsetChild : offsetParent;
3411
// Get next offsetParent
3412
offsetParent = offsetParent.offsetParent;
3413
}
3414
3415
// Get parent scroll offsets
3416
while ( parent && parent.tagName && !/^body|html$/i.test(parent.tagName) ) {
3417
// Remove parent scroll UNLESS that parent is inline or a table to work around Opera inline/table scrollLeft/Top bug
3418
if ( !/^inline|table.*$/i.test(css(parent, "display")) )
3419
// Subtract parent scroll offsets
3420
add( -parent.scrollLeft, -parent.scrollTop );
3421
3422
// Mozilla does not add the border for a parent that has overflow != visible
3423
if ( mozilla && css(parent, "overflow") != "visible" )
3424
border( parent );
3425
3426
// Get next parent
3427
parent = parent.parentNode;
3428
}
3429
3430
// Safari <= 2 doubles body offsets with a fixed position element/offsetParent or absolutely positioned offsetChild
3431
// Mozilla doubles body offsets with a non-absolutely positioned offsetChild
3432
if ( (safari2 && (fixed || css(offsetChild, "position") == "absolute")) ||
3433
(mozilla && css(offsetChild, "position") != "absolute") )
3434
add( -doc.body.offsetLeft, -doc.body.offsetTop );
3435
3436
// Add the document scroll offsets if position is fixed
3437
if ( fixed )
3438
add(Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft),
3439
Math.max(doc.documentElement.scrollTop, doc.body.scrollTop));
3440
}
3441
3442
// Return an object with top and left properties
3443
results = { top: top, left: left };
3444
}
3445
3446
function border(elem) {
3447
add( jQuery.curCSS(elem, "borderLeftWidth", true), jQuery.curCSS(elem, "borderTopWidth", true) );
3448
}
3449
3450
function add(l, t) {
3451
left += parseInt(l, 10) || 0;
3452
top += parseInt(t, 10) || 0;
3453
}
3454
3455
return results;
3456
};
3457
3458
3459
jQuery.fn.extend({
3460
position: function() {
3461
var left = 0, top = 0, results;
3462
3463
if ( this[0] ) {
3464
// Get *real* offsetParent
3465
var offsetParent = this.offsetParent(),
3466
3467
// Get correct offsets
3468
offset = this.offset(),
3469
parentOffset = /^body|html$/i.test(offsetParent[0].tagName) ? { top: 0, left: 0 } : offsetParent.offset();
3470
3471
// Subtract element margins
3472
// note: when an element has margin: auto the offsetLeft and marginLeft
3473
// are the same in Safari causing offset.left to incorrectly be 0
3474
offset.top -= num( this, 'marginTop' );
3475
offset.left -= num( this, 'marginLeft' );
3476
3477
// Add offsetParent borders
3478
parentOffset.top += num( offsetParent, 'borderTopWidth' );
3479
parentOffset.left += num( offsetParent, 'borderLeftWidth' );
3480
3481
// Subtract the two offsets
3482
results = {
3483
top: offset.top - parentOffset.top,
3484
left: offset.left - parentOffset.left
3485
};
3486
}
3487
3488
return results;
3489
},
3490
3491
offsetParent: function() {
3492
var offsetParent = this[0].offsetParent;
3493
while ( offsetParent && (!/^body|html$/i.test(offsetParent.tagName) && jQuery.css(offsetParent, 'position') == 'static') )
3494
offsetParent = offsetParent.offsetParent;
3495
return jQuery(offsetParent);
3496
}
3497
});
3498
3499
3500
// Create scrollLeft and scrollTop methods
3501
jQuery.each( ['Left', 'Top'], function(i, name) {
3502
var method = 'scroll' + name;
3503
3504
jQuery.fn[ method ] = function(val) {
3505
if (!this[0]) return;
3506
3507
return val != undefined ?
3508
3509
// Set the scroll offset
3510
this.each(function() {
3511
this == window || this == document ?
3512
window.scrollTo(
3513
!i ? val : jQuery(window).scrollLeft(),
3514
i ? val : jQuery(window).scrollTop()
3515
) :
3516
this[ method ] = val;
3517
}) :
3518
3519
// Return the scroll offset
3520
this[0] == window || this[0] == document ?
3521
self[ i ? 'pageYOffset' : 'pageXOffset' ] ||
3522
jQuery.boxModel && document.documentElement[ method ] ||
3523
document.body[ method ] :
3524
this[0][ method ];
3525
};
3526
});
3527
// Create innerHeight, innerWidth, outerHeight and outerWidth methods
3528
jQuery.each([ "Height", "Width" ], function(i, name){
3529
3530
var tl = i ? "Left" : "Top", // top or left
3531
br = i ? "Right" : "Bottom"; // bottom or right
3532
3533
// innerHeight and innerWidth
3534
jQuery.fn["inner" + name] = function(){
3535
return this[ name.toLowerCase() ]() +
3536
num(this, "padding" + tl) +
3537
num(this, "padding" + br);
3538
};
3539
3540
// outerHeight and outerWidth
3541
jQuery.fn["outer" + name] = function(margin) {
3542
return this["inner" + name]() +
3543
num(this, "border" + tl + "Width") +
3544
num(this, "border" + br + "Width") +
3545
(margin ?
3546
num(this, "margin" + tl) + num(this, "margin" + br) : 0);
3547
};
3548
3549
});})();
Loggerhead is a web-based interface for Breezy
Version: 2.0.1