mirror of
https://github.com/jquery/jquery.git
synced 2024-11-23 02:54:22 +00:00
2246 lines
58 KiB
JavaScript
2246 lines
58 KiB
JavaScript
/* prevent execution of jQOld if included more than once */
|
|
if(typeof window.jQOld == "undefined") {
|
|
/*
|
|
* jQOld 1.1.2 - New Wave Javascript
|
|
*
|
|
* Copyright (c) 2007 John Resig (jquery.com)
|
|
* Dual licensed under the MIT (MIT-LICENSE.txt)
|
|
* and GPL (GPL-LICENSE.txt) licenses.
|
|
*
|
|
* $Date: 2007-02-28 12:03:00 -0500 (Wed, 28 Feb 2007) $
|
|
* $Rev: 1465 $
|
|
*/
|
|
|
|
// Global undefined variable
|
|
window.undefined = window.undefined;
|
|
var jQOld = function(a,c) {
|
|
// If the context is global, return a new object
|
|
if ( window == this )
|
|
return new jQOld(a,c);
|
|
|
|
// Make sure that a selection was provided
|
|
a = a || document;
|
|
|
|
// HANDLE: $(function)
|
|
// Shortcut for document ready
|
|
if ( jQOld.isFunction(a) )
|
|
return new jQOld(document)[ jQOld.fn.ready ? "ready" : "load" ]( a );
|
|
|
|
// Handle HTML strings
|
|
if ( typeof a == "string" ) {
|
|
// HANDLE: $(html) -> $(array)
|
|
var m = /^[^<]*(<(.|\s)+>)[^>]*$/.exec(a);
|
|
if ( m )
|
|
a = jQOld.clean( [ m[1] ] );
|
|
|
|
// HANDLE: $(expr)
|
|
else
|
|
return new jQOld( c ).find( a );
|
|
}
|
|
|
|
return this.setArray(
|
|
// HANDLE: $(array)
|
|
a.constructor == Array && a ||
|
|
|
|
// HANDLE: $(arraylike)
|
|
// Watch for when an array-like object is passed as the selector
|
|
(a.jquery || a.length && a != window && !a.nodeType && a[0] != undefined && a[0].nodeType) && jQOld.makeArray( a ) ||
|
|
|
|
// HANDLE: $(*)
|
|
[ a ] );
|
|
};
|
|
|
|
// Map over the $ in case of overwrite
|
|
if ( typeof $ != "undefined" )
|
|
jQOld._$ = $;
|
|
|
|
// Map the jQOld namespace to the '$' one
|
|
var $ = jQOld;
|
|
|
|
jQOld.fn = jQOld.prototype = {
|
|
jquery: "1.1.2",
|
|
|
|
size: function() {
|
|
return this.length;
|
|
},
|
|
|
|
length: 0,
|
|
|
|
get: function( num ) {
|
|
return num == undefined ?
|
|
|
|
// Return a 'clean' array
|
|
jQOld.makeArray( this ) :
|
|
|
|
// Return just the object
|
|
this[num];
|
|
},
|
|
pushStack: function( a ) {
|
|
var ret = jQOld(a);
|
|
ret.prevObject = this;
|
|
return ret;
|
|
},
|
|
setArray: function( a ) {
|
|
this.length = 0;
|
|
[].push.apply( this, a );
|
|
return this;
|
|
},
|
|
each: function( fn, args ) {
|
|
return jQOld.each( this, fn, args );
|
|
},
|
|
index: function( obj ) {
|
|
var pos = -1;
|
|
this.each(function(i){
|
|
if ( this == obj ) pos = i;
|
|
});
|
|
return pos;
|
|
},
|
|
|
|
attr: function( key, value, type ) {
|
|
var obj = key;
|
|
|
|
// Look for the case where we're accessing a style value
|
|
if ( key.constructor == String )
|
|
if ( value == undefined )
|
|
return this.length && jQOld[ type || "attr" ]( this[0], key ) || undefined;
|
|
else {
|
|
obj = {};
|
|
obj[ key ] = value;
|
|
}
|
|
|
|
// Check to see if we're setting style values
|
|
return this.each(function(index){
|
|
// Set all the styles
|
|
for ( var prop in obj )
|
|
jQOld.attr(
|
|
type ? this.style : this,
|
|
prop, jQOld.prop(this, obj[prop], type, index, prop)
|
|
);
|
|
});
|
|
},
|
|
|
|
css: function( key, value ) {
|
|
return this.attr( key, value, "curCSS" );
|
|
},
|
|
|
|
text: function(e) {
|
|
if ( typeof e == "string" )
|
|
return this.empty().append( document.createTextNode( e ) );
|
|
|
|
var t = "";
|
|
jQOld.each( e || this, function(){
|
|
jQOld.each( this.childNodes, function(){
|
|
if ( this.nodeType != 8 )
|
|
t += this.nodeType != 1 ?
|
|
this.nodeValue : jQOld.fn.text([ this ]);
|
|
});
|
|
});
|
|
return t;
|
|
},
|
|
|
|
wrap: function() {
|
|
// The elements to wrap the target around
|
|
var a = jQOld.clean(arguments);
|
|
|
|
// Wrap each of the matched elements individually
|
|
return this.each(function(){
|
|
// Clone the structure that we're using to wrap
|
|
var b = a[0].cloneNode(true);
|
|
|
|
// Insert it before the element to be wrapped
|
|
this.parentNode.insertBefore( b, this );
|
|
|
|
// Find the deepest point in the wrap structure
|
|
while ( b.firstChild )
|
|
b = b.firstChild;
|
|
|
|
// Move the matched element to within the wrap structure
|
|
b.appendChild( this );
|
|
});
|
|
},
|
|
append: function() {
|
|
return this.domManip(arguments, true, 1, function(a){
|
|
this.appendChild( a );
|
|
});
|
|
},
|
|
prepend: function() {
|
|
return this.domManip(arguments, true, -1, function(a){
|
|
this.insertBefore( a, this.firstChild );
|
|
});
|
|
},
|
|
before: function() {
|
|
return this.domManip(arguments, false, 1, function(a){
|
|
this.parentNode.insertBefore( a, this );
|
|
});
|
|
},
|
|
after: function() {
|
|
return this.domManip(arguments, false, -1, function(a){
|
|
this.parentNode.insertBefore( a, this.nextSibling );
|
|
});
|
|
},
|
|
end: function() {
|
|
return this.prevObject || jQOld([]);
|
|
},
|
|
find: function(t) {
|
|
return this.pushStack( jQOld.map( this, function(a){
|
|
return jQOld.find(t,a);
|
|
}), t );
|
|
},
|
|
clone: function(deep) {
|
|
return this.pushStack( jQOld.map( this, function(a){
|
|
var a = a.cloneNode( deep != undefined ? deep : true );
|
|
a.$events = null; // drop $events expando to avoid firing incorrect events
|
|
return a;
|
|
}) );
|
|
},
|
|
|
|
filter: function(t) {
|
|
return this.pushStack(
|
|
jQOld.isFunction( t ) &&
|
|
jQOld.grep(this, function(el, index){
|
|
return t.apply(el, [index])
|
|
}) ||
|
|
|
|
jQOld.multiFilter(t,this) );
|
|
},
|
|
|
|
not: function(t) {
|
|
return this.pushStack(
|
|
t.constructor == String &&
|
|
jQOld.multiFilter(t, this, true) ||
|
|
|
|
jQOld.grep(this, function(a) {
|
|
return ( t.constructor == Array || t.jquery )
|
|
? jQOld.inArray( a, t ) < 0
|
|
: a != t;
|
|
})
|
|
);
|
|
},
|
|
|
|
add: function(t) {
|
|
return this.pushStack( jQOld.merge(
|
|
this.get(),
|
|
t.constructor == String ?
|
|
jQOld(t).get() :
|
|
t.length != undefined && (!t.nodeName || t.nodeName == "FORM") ?
|
|
t : [t] )
|
|
);
|
|
},
|
|
is: function(expr) {
|
|
return expr ? jQOld.filter(expr,this).r.length > 0 : false;
|
|
},
|
|
|
|
val: function( val ) {
|
|
return val == undefined ?
|
|
( this.length ? this[0].value : null ) :
|
|
this.attr( "value", val );
|
|
},
|
|
|
|
html: function( val ) {
|
|
return val == undefined ?
|
|
( this.length ? this[0].innerHTML : null ) :
|
|
this.empty().append( val );
|
|
},
|
|
domManip: function(args, table, dir, fn){
|
|
var clone = this.length > 1;
|
|
var a = jQOld.clean(args);
|
|
if ( dir < 0 )
|
|
a.reverse();
|
|
|
|
return this.each(function(){
|
|
var obj = this;
|
|
|
|
if ( table && jQOld.nodeName(this, "table") && jQOld.nodeName(a[0], "tr") )
|
|
obj = this.getElementsByTagName("tbody")[0] || this.appendChild(document.createElement("tbody"));
|
|
|
|
jQOld.each( a, function(){
|
|
fn.apply( obj, [ clone ? this.cloneNode(true) : this ] );
|
|
});
|
|
|
|
});
|
|
}
|
|
};
|
|
|
|
jQOld.extend = jQOld.fn.extend = function() {
|
|
// copy reference to target object
|
|
var target = arguments[0],
|
|
a = 1;
|
|
|
|
// extend jQOld itself if only one argument is passed
|
|
if ( arguments.length == 1 ) {
|
|
target = this;
|
|
a = 0;
|
|
}
|
|
var prop;
|
|
while (prop = arguments[a++])
|
|
// Extend the base object
|
|
for ( var i in prop ) target[i] = prop[i];
|
|
|
|
// Return the modified object
|
|
return target;
|
|
};
|
|
|
|
jQOld.extend({
|
|
noConflict: function() {
|
|
if ( jQOld._$ )
|
|
$ = jQOld._$;
|
|
return jQOld;
|
|
},
|
|
|
|
// This may seem like some crazy code, but trust me when I say that this
|
|
// is the only cross-browser way to do this. --John
|
|
isFunction: function( fn ) {
|
|
return !!fn && typeof fn != "string" && !fn.nodeName &&
|
|
typeof fn[0] == "undefined" && /function/i.test( fn + "" );
|
|
},
|
|
|
|
// check if an element is in a XML document
|
|
isXMLDoc: function(elem) {
|
|
return elem.tagName && elem.ownerDocument && !elem.ownerDocument.body;
|
|
},
|
|
|
|
nodeName: function( elem, name ) {
|
|
return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
|
|
},
|
|
// args is for internal usage only
|
|
each: function( obj, fn, args ) {
|
|
if ( obj.length == undefined )
|
|
for ( var i in obj )
|
|
fn.apply( obj[i], args || [i, obj[i]] );
|
|
else
|
|
for ( var i = 0, ol = obj.length; i < ol; i++ )
|
|
if ( fn.apply( obj[i], args || [i, obj[i]] ) === false ) break;
|
|
return obj;
|
|
},
|
|
|
|
prop: function(elem, value, type, index, prop){
|
|
// Handle executable functions
|
|
if ( jQOld.isFunction( value ) )
|
|
value = value.call( elem, [index] );
|
|
|
|
// exclude the following css properties to add px
|
|
var exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i;
|
|
|
|
// Handle passing in a number to a CSS property
|
|
return value && value.constructor == Number && type == "curCSS" && !exclude.test(prop) ?
|
|
value + "px" :
|
|
value;
|
|
},
|
|
|
|
className: {
|
|
// internal only, use addClass("class")
|
|
add: function( elem, c ){
|
|
jQOld.each( c.split(/\s+/), function(i, cur){
|
|
if ( !jQOld.className.has( elem.className, cur ) )
|
|
elem.className += ( elem.className ? " " : "" ) + cur;
|
|
});
|
|
},
|
|
|
|
// internal only, use removeClass("class")
|
|
remove: function( elem, c ){
|
|
elem.className = c ?
|
|
jQOld.grep( elem.className.split(/\s+/), function(cur){
|
|
return !jQOld.className.has( c, cur );
|
|
}).join(" ") : "";
|
|
},
|
|
|
|
// internal only, use is(".class")
|
|
has: function( t, c ) {
|
|
t = t.className || t;
|
|
// escape regex characters
|
|
c = c.replace(/([\.\\\+\*\?\[\^\]\$\(\)\{\}\=\!\<\>\|\:])/g, "\\$1");
|
|
return t && new RegExp("(^|\\s)" + c + "(\\s|$)").test( t );
|
|
}
|
|
},
|
|
swap: function(e,o,f) {
|
|
for ( var i in o ) {
|
|
e.style["old"+i] = e.style[i];
|
|
e.style[i] = o[i];
|
|
}
|
|
f.apply( e, [] );
|
|
for ( var i in o )
|
|
e.style[i] = e.style["old"+i];
|
|
},
|
|
|
|
css: function(e,p) {
|
|
if ( p == "height" || p == "width" ) {
|
|
var old = {}, oHeight, oWidth, d = ["Top","Bottom","Right","Left"];
|
|
|
|
jQOld.each( d, function(){
|
|
old["padding" + this] = 0;
|
|
old["border" + this + "Width"] = 0;
|
|
});
|
|
|
|
jQOld.swap( e, old, function() {
|
|
if (jQOld.css(e,"display") != "none") {
|
|
oHeight = e.offsetHeight;
|
|
oWidth = e.offsetWidth;
|
|
} else {
|
|
e = jQOld(e.cloneNode(true))
|
|
.find(":radio").removeAttr("checked").end()
|
|
.css({
|
|
visibility: "hidden", position: "absolute", display: "block", right: "0", left: "0"
|
|
}).appendTo(e.parentNode)[0];
|
|
|
|
var parPos = jQOld.css(e.parentNode,"position");
|
|
if ( parPos == "" || parPos == "static" )
|
|
e.parentNode.style.position = "relative";
|
|
|
|
oHeight = e.clientHeight;
|
|
oWidth = e.clientWidth;
|
|
|
|
if ( parPos == "" || parPos == "static" )
|
|
e.parentNode.style.position = "static";
|
|
|
|
e.parentNode.removeChild(e);
|
|
}
|
|
});
|
|
|
|
return p == "height" ? oHeight : oWidth;
|
|
}
|
|
|
|
return jQOld.curCSS( e, p );
|
|
},
|
|
|
|
curCSS: function(elem, prop, force) {
|
|
var ret;
|
|
|
|
if (prop == "opacity" && jQOld.browser.msie)
|
|
return jQOld.attr(elem.style, "opacity");
|
|
|
|
if (prop == "float" || prop == "cssFloat")
|
|
prop = jQOld.browser.msie ? "styleFloat" : "cssFloat";
|
|
|
|
if (!force && elem.style[prop])
|
|
ret = elem.style[prop];
|
|
|
|
else if (document.defaultView && document.defaultView.getComputedStyle) {
|
|
|
|
if (prop == "cssFloat" || prop == "styleFloat")
|
|
prop = "float";
|
|
|
|
prop = prop.replace(/([A-Z])/g,"-$1").toLowerCase();
|
|
var cur = document.defaultView.getComputedStyle(elem, null);
|
|
|
|
if ( cur )
|
|
ret = cur.getPropertyValue(prop);
|
|
else if ( prop == "display" )
|
|
ret = "none";
|
|
else
|
|
jQOld.swap(elem, { display: "block" }, function() {
|
|
var c = document.defaultView.getComputedStyle(this, "");
|
|
ret = c && c.getPropertyValue(prop) || "";
|
|
});
|
|
|
|
} else if (elem.currentStyle) {
|
|
|
|
var newProp = prop.replace(/\-(\w)/g,function(m,c){return c.toUpperCase();});
|
|
ret = elem.currentStyle[prop] || elem.currentStyle[newProp];
|
|
|
|
}
|
|
|
|
return ret;
|
|
},
|
|
|
|
clean: function(a) {
|
|
var r = [];
|
|
|
|
jQOld.each( a, function(i,arg){
|
|
if ( !arg ) return;
|
|
|
|
if ( arg.constructor == Number )
|
|
arg = arg.toString();
|
|
|
|
// Convert html string into DOM nodes
|
|
if ( typeof arg == "string" ) {
|
|
// Trim whitespace, otherwise indexOf won't work as expected
|
|
var s = jQOld.trim(arg), div = document.createElement("div"), tb = [];
|
|
|
|
var wrap =
|
|
// option or optgroup
|
|
!s.indexOf("<opt") &&
|
|
[1, "<select>", "</select>"] ||
|
|
|
|
(!s.indexOf("<thead") || !s.indexOf("<tbody") || !s.indexOf("<tfoot")) &&
|
|
[1, "<table>", "</table>"] ||
|
|
|
|
!s.indexOf("<tr") &&
|
|
[2, "<table><tbody>", "</tbody></table>"] ||
|
|
|
|
// <thead> matched above
|
|
(!s.indexOf("<td") || !s.indexOf("<th")) &&
|
|
[3, "<table><tbody><tr>", "</tr></tbody></table>"] ||
|
|
|
|
[0,"",""];
|
|
|
|
// Go to html and back, then peel off extra wrappers
|
|
div.innerHTML = wrap[1] + s + wrap[2];
|
|
|
|
// Move to the right depth
|
|
while ( wrap[0]-- )
|
|
div = div.firstChild;
|
|
|
|
// Remove IE's autoinserted <tbody> from table fragments
|
|
if ( jQOld.browser.msie ) {
|
|
|
|
// String was a <table>, *may* have spurious <tbody>
|
|
if ( !s.indexOf("<table") && s.indexOf("<tbody") < 0 )
|
|
tb = div.firstChild && div.firstChild.childNodes;
|
|
|
|
// String was a bare <thead> or <tfoot>
|
|
else if ( wrap[1] == "<table>" && s.indexOf("<tbody") < 0 )
|
|
tb = div.childNodes;
|
|
|
|
for ( var n = tb.length-1; n >= 0 ; --n )
|
|
if ( jQOld.nodeName(tb[n], "tbody") && !tb[n].childNodes.length )
|
|
tb[n].parentNode.removeChild(tb[n]);
|
|
|
|
}
|
|
|
|
arg = [];
|
|
for (var i=0, l=div.childNodes.length; i<l; i++)
|
|
arg.push(div.childNodes[i]);
|
|
}
|
|
|
|
if ( arg.length === 0 && !jQOld.nodeName(arg, "form") )
|
|
return;
|
|
|
|
if ( arg[0] == undefined || jQOld.nodeName(arg, "form") )
|
|
r.push( arg );
|
|
else
|
|
r = jQOld.merge( r, arg );
|
|
|
|
});
|
|
|
|
return r;
|
|
},
|
|
|
|
attr: function(elem, name, value){
|
|
var fix = jQOld.isXMLDoc(elem) ? {} : {
|
|
"for": "htmlFor",
|
|
"class": "className",
|
|
"float": jQOld.browser.msie ? "styleFloat" : "cssFloat",
|
|
cssFloat: jQOld.browser.msie ? "styleFloat" : "cssFloat",
|
|
innerHTML: "innerHTML",
|
|
className: "className",
|
|
value: "value",
|
|
disabled: "disabled",
|
|
checked: "checked",
|
|
readonly: "readOnly",
|
|
selected: "selected"
|
|
};
|
|
|
|
// IE actually uses filters for opacity ... elem is actually elem.style
|
|
if ( name == "opacity" && jQOld.browser.msie && value != undefined ) {
|
|
// IE has trouble with opacity if it does not have layout
|
|
// Force it by setting the zoom level
|
|
elem.zoom = 1;
|
|
|
|
// Set the alpha filter to set the opacity
|
|
return elem.filter = elem.filter.replace(/alpha\([^\)]*\)/gi,"") +
|
|
( value == 1 ? "" : "alpha(opacity=" + value * 100 + ")" );
|
|
|
|
} else if ( name == "opacity" && jQOld.browser.msie )
|
|
return elem.filter ?
|
|
parseFloat( elem.filter.match(/alpha\(opacity=(.*)\)/)[1] ) / 100 : 1;
|
|
|
|
// Mozilla doesn't play well with opacity 1
|
|
if ( name == "opacity" && jQOld.browser.mozilla && value == 1 )
|
|
value = 0.9999;
|
|
|
|
|
|
// Certain attributes only work when accessed via the old DOM 0 way
|
|
if ( fix[name] ) {
|
|
if ( value != undefined ) elem[fix[name]] = value;
|
|
return elem[fix[name]];
|
|
|
|
} else if ( value == undefined && jQOld.browser.msie && jQOld.nodeName(elem, "form") && (name == "action" || name == "method") )
|
|
return elem.getAttributeNode(name).nodeValue;
|
|
|
|
// IE elem.getAttribute passes even for style
|
|
else if ( elem.tagName ) {
|
|
if ( value != undefined ) elem.setAttribute( name, value );
|
|
if ( jQOld.browser.msie && /href|src/.test(name) && !jQOld.isXMLDoc(elem) )
|
|
return elem.getAttribute( name, 2 );
|
|
return elem.getAttribute( name );
|
|
|
|
// elem is actually elem.style ... set the style
|
|
} else {
|
|
name = name.replace(/-([a-z])/ig,function(z,b){return b.toUpperCase();});
|
|
if ( value != undefined ) elem[name] = value;
|
|
return elem[name];
|
|
}
|
|
},
|
|
trim: function(t){
|
|
return t.replace(/^\s+|\s+$/g, "");
|
|
},
|
|
|
|
makeArray: function( a ) {
|
|
var r = [];
|
|
|
|
if ( a.constructor != Array )
|
|
for ( var i = 0, al = a.length; i < al; i++ )
|
|
r.push( a[i] );
|
|
else
|
|
r = a.slice( 0 );
|
|
|
|
return r;
|
|
},
|
|
|
|
inArray: function( b, a ) {
|
|
for ( var i = 0, al = a.length; i < al; i++ )
|
|
if ( a[i] == b )
|
|
return i;
|
|
return -1;
|
|
},
|
|
merge: function(first, second) {
|
|
var r = [].slice.call( first, 0 );
|
|
|
|
// Now check for duplicates between the two arrays
|
|
// and only add the unique items
|
|
for ( var i = 0, sl = second.length; i < sl; i++ )
|
|
// Check for duplicates
|
|
if ( jQOld.inArray( second[i], r ) == -1 )
|
|
// The item is unique, add it
|
|
first.push( second[i] );
|
|
|
|
return first;
|
|
},
|
|
grep: function(elems, fn, inv) {
|
|
// If a string is passed in for the function, make a function
|
|
// for it (a handy shortcut)
|
|
if ( typeof fn == "string" )
|
|
fn = new Function("a","i","return " + fn);
|
|
|
|
var result = [];
|
|
|
|
// Go through the array, only saving the items
|
|
// that pass the validator function
|
|
for ( var i = 0, el = elems.length; i < el; i++ )
|
|
if ( !inv && fn(elems[i],i) || inv && !fn(elems[i],i) )
|
|
result.push( elems[i] );
|
|
|
|
return result;
|
|
},
|
|
map: function(elems, fn) {
|
|
// If a string is passed in for the function, make a function
|
|
// for it (a handy shortcut)
|
|
if ( typeof fn == "string" )
|
|
fn = new Function("a","return " + fn);
|
|
|
|
var result = [], r = [];
|
|
|
|
// Go through the array, translating each of the items to their
|
|
// new value (or values).
|
|
for ( var i = 0, el = elems.length; i < el; i++ ) {
|
|
var val = fn(elems[i],i);
|
|
|
|
if ( val !== null && val != undefined ) {
|
|
if ( val.constructor != Array ) val = [val];
|
|
result = result.concat( val );
|
|
}
|
|
}
|
|
|
|
var r = result.length ? [ result[0] ] : [];
|
|
|
|
check: for ( var i = 1, rl = result.length; i < rl; i++ ) {
|
|
for ( var j = 0; j < i; j++ )
|
|
if ( result[i] == r[j] )
|
|
continue check;
|
|
|
|
r.push( result[i] );
|
|
}
|
|
|
|
return r;
|
|
}
|
|
});
|
|
|
|
/*
|
|
* Whether the W3C compliant box model is being used.
|
|
*
|
|
* @property
|
|
* @name $.boxModel
|
|
* @type Boolean
|
|
* @cat JavaScript
|
|
*/
|
|
new function() {
|
|
var b = navigator.userAgent.toLowerCase();
|
|
|
|
// Figure out what browser is being used
|
|
jQOld.browser = {
|
|
safari: /webkit/.test(b),
|
|
opera: /opera/.test(b),
|
|
msie: /msie/.test(b) && !/opera/.test(b),
|
|
mozilla: /mozilla/.test(b) && !/(compatible|webkit)/.test(b)
|
|
};
|
|
|
|
// Check to see if the W3C box model is being used
|
|
jQOld.boxModel = !jQOld.browser.msie || document.compatMode == "CSS1Compat";
|
|
};
|
|
|
|
jQOld.each({
|
|
parent: "a.parentNode",
|
|
parents: "jQOld.parents(a)",
|
|
next: "jQOld.nth(a,2,'nextSibling')",
|
|
prev: "jQOld.nth(a,2,'previousSibling')",
|
|
siblings: "jQOld.sibling(a.parentNode.firstChild,a)",
|
|
children: "jQOld.sibling(a.firstChild)"
|
|
}, function(i,n){
|
|
jQOld.fn[ i ] = function(a) {
|
|
var ret = jQOld.map(this,n);
|
|
if ( a && typeof a == "string" )
|
|
ret = jQOld.multiFilter(a,ret);
|
|
return this.pushStack( ret );
|
|
};
|
|
});
|
|
|
|
jQOld.each({
|
|
appendTo: "append",
|
|
prependTo: "prepend",
|
|
insertBefore: "before",
|
|
insertAfter: "after"
|
|
}, function(i,n){
|
|
jQOld.fn[ i ] = function(){
|
|
var a = arguments;
|
|
return this.each(function(){
|
|
for ( var j = 0, al = a.length; j < al; j++ )
|
|
jQOld(a[j])[n]( this );
|
|
});
|
|
};
|
|
});
|
|
|
|
jQOld.each( {
|
|
removeAttr: function( key ) {
|
|
jQOld.attr( this, key, "" );
|
|
this.removeAttribute( key );
|
|
},
|
|
addClass: function(c){
|
|
jQOld.className.add(this,c);
|
|
},
|
|
removeClass: function(c){
|
|
jQOld.className.remove(this,c);
|
|
},
|
|
toggleClass: function( c ){
|
|
jQOld.className[ jQOld.className.has(this,c) ? "remove" : "add" ](this, c);
|
|
},
|
|
remove: function(a){
|
|
if ( !a || jQOld.filter( a, [this] ).r.length )
|
|
this.parentNode.removeChild( this );
|
|
},
|
|
empty: function() {
|
|
while ( this.firstChild )
|
|
this.removeChild( this.firstChild );
|
|
}
|
|
}, function(i,n){
|
|
jQOld.fn[ i ] = function() {
|
|
return this.each( n, arguments );
|
|
};
|
|
});
|
|
|
|
jQOld.each( [ "eq", "lt", "gt", "contains" ], function(i,n){
|
|
jQOld.fn[ n ] = function(num,fn) {
|
|
return this.filter( ":" + n + "(" + num + ")", fn );
|
|
};
|
|
});
|
|
|
|
jQOld.each( [ "height", "width" ], function(i,n){
|
|
jQOld.fn[ n ] = function(h) {
|
|
return h == undefined ?
|
|
( this.length ? jQOld.css( this[0], n ) : null ) :
|
|
this.css( n, h.constructor == String ? h : h + "px" );
|
|
};
|
|
});
|
|
jQOld.extend({
|
|
expr: {
|
|
"": "m[2]=='*'||jQOld.nodeName(a,m[2])",
|
|
"#": "a.getAttribute('id')==m[2]",
|
|
":": {
|
|
// Position Checks
|
|
lt: "i<m[3]-0",
|
|
gt: "i>m[3]-0",
|
|
nth: "m[3]-0==i",
|
|
eq: "m[3]-0==i",
|
|
first: "i==0",
|
|
last: "i==r.length-1",
|
|
even: "i%2==0",
|
|
odd: "i%2",
|
|
|
|
// Child Checks
|
|
"nth-child": "jQOld.nth(a.parentNode.firstChild,m[3],'nextSibling',a)==a",
|
|
"first-child": "jQOld.nth(a.parentNode.firstChild,1,'nextSibling')==a",
|
|
"last-child": "jQOld.nth(a.parentNode.lastChild,1,'previousSibling')==a",
|
|
"only-child": "jQOld.sibling(a.parentNode.firstChild).length==1",
|
|
|
|
// Parent Checks
|
|
parent: "a.firstChild",
|
|
empty: "!a.firstChild",
|
|
|
|
// Text Check
|
|
contains: "jQOld.fn.text.apply([a]).indexOf(m[3])>=0",
|
|
|
|
// Visibility
|
|
visible: 'a.type!="hidden"&&jQOld.css(a,"display")!="none"&&jQOld.css(a,"visibility")!="hidden"',
|
|
hidden: 'a.type=="hidden"||jQOld.css(a,"display")=="none"||jQOld.css(a,"visibility")=="hidden"',
|
|
|
|
// Form attributes
|
|
enabled: "!a.disabled",
|
|
disabled: "a.disabled",
|
|
checked: "a.checked",
|
|
selected: "a.selected||jQOld.attr(a,'selected')",
|
|
|
|
// Form elements
|
|
text: "a.type=='text'",
|
|
radio: "a.type=='radio'",
|
|
checkbox: "a.type=='checkbox'",
|
|
file: "a.type=='file'",
|
|
password: "a.type=='password'",
|
|
submit: "a.type=='submit'",
|
|
image: "a.type=='image'",
|
|
reset: "a.type=='reset'",
|
|
button: 'a.type=="button"||jQOld.nodeName(a,"button")',
|
|
input: "/input|select|textarea|button/i.test(a.nodeName)"
|
|
},
|
|
".": "jQOld.className.has(a,m[2])",
|
|
"@": {
|
|
"=": "z==m[4]",
|
|
"!=": "z!=m[4]",
|
|
"^=": "z&&!z.indexOf(m[4])",
|
|
"$=": "z&&z.substr(z.length - m[4].length,m[4].length)==m[4]",
|
|
"*=": "z&&z.indexOf(m[4])>=0",
|
|
"": "z",
|
|
_resort: function(m){
|
|
return ["", m[1], m[3], m[2], m[5]];
|
|
},
|
|
_prefix: "z=a[m[3]];if(!z||/href|src/.test(m[3]))z=jQOld.attr(a,m[3]);"
|
|
},
|
|
"[": "jQOld.find(m[2],a).length"
|
|
},
|
|
|
|
// The regular expressions that power the parsing engine
|
|
parse: [
|
|
// Match: [@value='test'], [@foo]
|
|
/^\[ *(@)([a-z0-9_-]*) *([!*$^=]*) *('?"?)(.*?)\4 *\]/i,
|
|
|
|
// Match: [div], [div p]
|
|
/^(\[)\s*(.*?(\[.*?\])?[^[]*?)\s*\]/,
|
|
|
|
// Match: :contains('foo')
|
|
/^(:)([a-z0-9_-]*)\("?'?(.*?(\(.*?\))?[^(]*?)"?'?\)/i,
|
|
|
|
// Match: :even, :last-chlid
|
|
/^([:.#]*)([a-z0-9_*-]*)/i
|
|
],
|
|
|
|
token: [
|
|
/^(\/?\.\.)/, "a.parentNode",
|
|
/^(>|\/)/, "jQOld.sibling(a.firstChild)",
|
|
/^(\+)/, "jQOld.nth(a,2,'nextSibling')",
|
|
/^(~)/, function(a){
|
|
var s = jQOld.sibling(a.parentNode.firstChild);
|
|
return s.slice(jQOld.inArray(a,s) + 1);
|
|
}
|
|
],
|
|
|
|
multiFilter: function( expr, elems, not ) {
|
|
var old, cur = [];
|
|
|
|
while ( expr && expr != old ) {
|
|
old = expr;
|
|
var f = jQOld.filter( expr, elems, not );
|
|
expr = f.t.replace(/^\s*,\s*/, "" );
|
|
cur = not ? elems = f.r : jQOld.merge( cur, f.r );
|
|
}
|
|
|
|
return cur;
|
|
},
|
|
find: function( t, context ) {
|
|
// Quickly handle non-string expressions
|
|
if ( typeof t != "string" )
|
|
return [ t ];
|
|
|
|
// Make sure that the context is a DOM Element
|
|
if ( context && !context.nodeType )
|
|
context = null;
|
|
|
|
// Set the correct context (if none is provided)
|
|
context = context || document;
|
|
|
|
// Handle the common XPath // expression
|
|
if ( !t.indexOf("//") ) {
|
|
context = context.documentElement;
|
|
t = t.substr(2,t.length);
|
|
|
|
// And the / root expression
|
|
} else if ( !t.indexOf("/") ) {
|
|
context = context.documentElement;
|
|
t = t.substr(1,t.length);
|
|
if ( t.indexOf("/") >= 1 )
|
|
t = t.substr(t.indexOf("/"),t.length);
|
|
}
|
|
|
|
// Initialize the search
|
|
var ret = [context], done = [], last = null;
|
|
|
|
// Continue while a selector expression exists, and while
|
|
// we're no longer looping upon ourselves
|
|
while ( t && last != t ) {
|
|
var r = [];
|
|
last = t;
|
|
|
|
t = jQOld.trim(t).replace( /^\/\//i, "" );
|
|
|
|
var foundToken = false;
|
|
|
|
// An attempt at speeding up child selectors that
|
|
// point to a specific element tag
|
|
var re = /^[\/>]\s*([a-z0-9*-]+)/i;
|
|
var m = re.exec(t);
|
|
|
|
if ( m ) {
|
|
// Perform our own iteration and filter
|
|
jQOld.each( ret, function(){
|
|
for ( var c = this.firstChild; c; c = c.nextSibling )
|
|
if ( c.nodeType == 1 && ( jQOld.nodeName(c, m[1]) || m[1] == "*" ) )
|
|
r.push( c );
|
|
});
|
|
|
|
ret = r;
|
|
t = t.replace( re, "" );
|
|
if ( t.indexOf(" ") == 0 ) continue;
|
|
foundToken = true;
|
|
} else {
|
|
// Look for pre-defined expression tokens
|
|
for ( var i = 0; i < jQOld.token.length; i += 2 ) {
|
|
// Attempt to match each, individual, token in
|
|
// the specified order
|
|
var re = jQOld.token[i];
|
|
var m = re.exec(t);
|
|
|
|
// If the token match was found
|
|
if ( m ) {
|
|
// Map it against the token's handler
|
|
r = ret = jQOld.map( ret, jQOld.isFunction( jQOld.token[i+1] ) ?
|
|
jQOld.token[i+1] :
|
|
function(a){ return eval(jQOld.token[i+1]); });
|
|
|
|
// And remove the token
|
|
t = jQOld.trim( t.replace( re, "" ) );
|
|
foundToken = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// See if there's still an expression, and that we haven't already
|
|
// matched a token
|
|
if ( t && !foundToken ) {
|
|
// Handle multiple expressions
|
|
if ( !t.indexOf(",") ) {
|
|
// Clean the result set
|
|
if ( ret[0] == context ) ret.shift();
|
|
|
|
// Merge the result sets
|
|
jQOld.merge( done, ret );
|
|
|
|
// Reset the context
|
|
r = ret = [context];
|
|
|
|
// Touch up the selector string
|
|
t = " " + t.substr(1,t.length);
|
|
|
|
} else {
|
|
// Optomize for the case nodeName#idName
|
|
var re2 = /^([a-z0-9_-]+)(#)([a-z0-9\\*_-]*)/i;
|
|
var m = re2.exec(t);
|
|
|
|
// Re-organize the results, so that they're consistent
|
|
if ( m ) {
|
|
m = [ 0, m[2], m[3], m[1] ];
|
|
|
|
} else {
|
|
// Otherwise, do a traditional filter check for
|
|
// ID, class, and element selectors
|
|
re2 = /^([#.]?)([a-z0-9\\*_-]*)/i;
|
|
m = re2.exec(t);
|
|
}
|
|
|
|
// Try to do a global search by ID, where we can
|
|
if ( m[1] == "#" && ret[ret.length-1].getElementById ) {
|
|
// Optimization for HTML document case
|
|
var oid = ret[ret.length-1].getElementById(m[2]);
|
|
|
|
// Do a quick check for the existence of the actual ID attribute
|
|
// to avoid selecting by the name attribute in IE
|
|
if ( jQOld.browser.msie && oid && oid.id != m[2] )
|
|
oid = jQOld('[@id="'+m[2]+'"]', ret[ret.length-1])[0];
|
|
|
|
// Do a quick check for node name (where applicable) so
|
|
// that div#foo searches will be really fast
|
|
ret = r = oid && (!m[3] || jQOld.nodeName(oid, m[3])) ? [oid] : [];
|
|
|
|
} else {
|
|
// Pre-compile a regular expression to handle class searches
|
|
if ( m[1] == "." )
|
|
var rec = new RegExp("(^|\\s)" + m[2] + "(\\s|$)");
|
|
|
|
// We need to find all descendant elements, it is more
|
|
// efficient to use getAll() when we are already further down
|
|
// the tree - we try to recognize that here
|
|
jQOld.each( ret, function(){
|
|
// Grab the tag name being searched for
|
|
var tag = m[1] != "" || m[0] == "" ? "*" : m[2];
|
|
|
|
// Handle IE7 being really dumb about <object>s
|
|
if ( jQOld.nodeName(this, "object") && tag == "*" )
|
|
tag = "param";
|
|
|
|
jQOld.merge( r,
|
|
m[1] != "" && ret.length != 1 ?
|
|
jQOld.getAll( this, [], m[1], m[2], rec ) :
|
|
this.getElementsByTagName( tag )
|
|
);
|
|
});
|
|
|
|
// It's faster to filter by class and be done with it
|
|
if ( m[1] == "." && ret.length == 1 )
|
|
r = jQOld.grep( r, function(e) {
|
|
return rec.test(e.className);
|
|
});
|
|
|
|
// Same with ID filtering
|
|
if ( m[1] == "#" && ret.length == 1 ) {
|
|
// Remember, then wipe out, the result set
|
|
var tmp = r;
|
|
r = [];
|
|
|
|
// Then try to find the element with the ID
|
|
jQOld.each( tmp, function(){
|
|
if ( this.getAttribute("id") == m[2] ) {
|
|
r = [ this ];
|
|
return false;
|
|
}
|
|
});
|
|
}
|
|
|
|
ret = r;
|
|
}
|
|
|
|
t = t.replace( re2, "" );
|
|
}
|
|
|
|
}
|
|
|
|
// If a selector string still exists
|
|
if ( t ) {
|
|
// Attempt to filter it
|
|
var val = jQOld.filter(t,r);
|
|
ret = r = val.r;
|
|
t = jQOld.trim(val.t);
|
|
}
|
|
}
|
|
|
|
// Remove the root context
|
|
if ( ret && ret[0] == context ) ret.shift();
|
|
|
|
// And combine the results
|
|
jQOld.merge( done, ret );
|
|
|
|
return done;
|
|
},
|
|
|
|
filter: function(t,r,not) {
|
|
// Look for common filter expressions
|
|
while ( t && /^[a-z[({<*:.#]/i.test(t) ) {
|
|
|
|
var p = jQOld.parse, m;
|
|
|
|
jQOld.each( p, function(i,re){
|
|
|
|
// Look for, and replace, string-like sequences
|
|
// and finally build a regexp out of it
|
|
m = re.exec( t );
|
|
|
|
if ( m ) {
|
|
// Remove what we just matched
|
|
t = t.substring( m[0].length );
|
|
|
|
// Re-organize the first match
|
|
if ( jQOld.expr[ m[1] ]._resort )
|
|
m = jQOld.expr[ m[1] ]._resort( m );
|
|
|
|
return false;
|
|
}
|
|
});
|
|
|
|
// :not() is a special case that can be optimized by
|
|
// keeping it out of the expression list
|
|
if ( m[1] == ":" && m[2] == "not" )
|
|
r = jQOld.filter(m[3], r, true).r;
|
|
|
|
// Handle classes as a special case (this will help to
|
|
// improve the speed, as the regexp will only be compiled once)
|
|
else if ( m[1] == "." ) {
|
|
|
|
var re = new RegExp("(^|\\s)" + m[2] + "(\\s|$)");
|
|
r = jQOld.grep( r, function(e){
|
|
return re.test(e.className || "");
|
|
}, not);
|
|
|
|
// Otherwise, find the expression to execute
|
|
} else {
|
|
var f = jQOld.expr[m[1]];
|
|
if ( typeof f != "string" )
|
|
f = jQOld.expr[m[1]][m[2]];
|
|
|
|
// Build a custom macro to enclose it
|
|
eval("f = function(a,i){" +
|
|
( jQOld.expr[ m[1] ]._prefix || "" ) +
|
|
"return " + f + "}");
|
|
|
|
// Execute it against the current filter
|
|
r = jQOld.grep( r, f, not );
|
|
}
|
|
}
|
|
|
|
// Return an array of filtered elements (r)
|
|
// and the modified expression string (t)
|
|
return { r: r, t: t };
|
|
},
|
|
|
|
getAll: function( o, r, token, name, re ) {
|
|
for ( var s = o.firstChild; s; s = s.nextSibling )
|
|
if ( s.nodeType == 1 ) {
|
|
var add = true;
|
|
|
|
if ( token == "." )
|
|
add = s.className && re.test(s.className);
|
|
else if ( token == "#" )
|
|
add = s.getAttribute("id") == name;
|
|
|
|
if ( add )
|
|
r.push( s );
|
|
|
|
if ( token == "#" && r.length ) break;
|
|
|
|
if ( s.firstChild )
|
|
jQOld.getAll( s, r, token, name, re );
|
|
}
|
|
|
|
return r;
|
|
},
|
|
parents: function( elem ){
|
|
var matched = [];
|
|
var cur = elem.parentNode;
|
|
while ( cur && cur != document ) {
|
|
matched.push( cur );
|
|
cur = cur.parentNode;
|
|
}
|
|
return matched;
|
|
},
|
|
nth: function(cur,result,dir,elem){
|
|
result = result || 1;
|
|
var num = 0;
|
|
for ( ; cur; cur = cur[dir] ) {
|
|
if ( cur.nodeType == 1 ) num++;
|
|
if ( num == result || result == "even" && num % 2 == 0 && num > 1 && cur == elem ||
|
|
result == "odd" && num % 2 == 1 && cur == elem ) return cur;
|
|
}
|
|
},
|
|
sibling: function( n, elem ) {
|
|
var r = [];
|
|
|
|
for ( ; n; n = n.nextSibling ) {
|
|
if ( n.nodeType == 1 && (!elem || n != elem) )
|
|
r.push( n );
|
|
}
|
|
|
|
return r;
|
|
}
|
|
});
|
|
/*
|
|
* A number of helper functions used for managing events.
|
|
* Many of the ideas behind this code orignated from
|
|
* Dean Edwards' addEvent library.
|
|
*/
|
|
jQOld.event = {
|
|
|
|
// Bind an event to an element
|
|
// Original by Dean Edwards
|
|
add: function(element, type, handler, data) {
|
|
// For whatever reason, IE has trouble passing the window object
|
|
// around, causing it to be cloned in the process
|
|
if ( jQOld.browser.msie && element.setInterval != undefined )
|
|
element = window;
|
|
|
|
// if data is passed, bind to handler
|
|
if( data )
|
|
handler.data = data;
|
|
|
|
// Make sure that the function being executed has a unique ID
|
|
if ( !handler.guid )
|
|
handler.guid = this.guid++;
|
|
|
|
// Init the element's event structure
|
|
if (!element.$events)
|
|
element.$events = {};
|
|
|
|
// Get the current list of functions bound to this event
|
|
var handlers = element.$events[type];
|
|
|
|
// If it hasn't been initialized yet
|
|
if (!handlers) {
|
|
// Init the event handler queue
|
|
handlers = element.$events[type] = {};
|
|
|
|
// Remember an existing handler, if it's already there
|
|
if (element["on" + type])
|
|
handlers[0] = element["on" + type];
|
|
}
|
|
|
|
// Add the function to the element's handler list
|
|
handlers[handler.guid] = handler;
|
|
|
|
// And bind the global event handler to the element
|
|
element["on" + type] = this.handle;
|
|
|
|
// Remember the function in a global list (for triggering)
|
|
if (!this.global[type])
|
|
this.global[type] = [];
|
|
this.global[type].push( element );
|
|
},
|
|
|
|
guid: 1,
|
|
global: {},
|
|
|
|
// Detach an event or set of events from an element
|
|
remove: function(element, type, handler) {
|
|
if (element.$events) {
|
|
var i,j,k;
|
|
if ( type && type.type ) { // type is actually an event object here
|
|
handler = type.handler;
|
|
type = type.type;
|
|
}
|
|
|
|
if (type && element.$events[type])
|
|
// remove the given handler for the given type
|
|
if ( handler )
|
|
delete element.$events[type][handler.guid];
|
|
|
|
// remove all handlers for the given type
|
|
else
|
|
for ( i in element.$events[type] )
|
|
delete element.$events[type][i];
|
|
|
|
// remove all handlers
|
|
else
|
|
for ( j in element.$events )
|
|
this.remove( element, j );
|
|
|
|
// remove event handler if no more handlers exist
|
|
for ( k in element.$events[type] )
|
|
if (k) {
|
|
k = true;
|
|
break;
|
|
}
|
|
if (!k) element["on" + type] = null;
|
|
}
|
|
},
|
|
|
|
trigger: function(type, data, element) {
|
|
// Clone the incoming data, if any
|
|
data = jQOld.makeArray(data || []);
|
|
|
|
// Handle a global trigger
|
|
if ( !element )
|
|
jQOld.each( this.global[type] || [], function(){
|
|
jQOld.event.trigger( type, data, this );
|
|
});
|
|
|
|
// Handle triggering a single element
|
|
else {
|
|
var handler = element["on" + type ], val,
|
|
fn = jQOld.isFunction( element[ type ] );
|
|
|
|
if ( handler ) {
|
|
// Pass along a fake event
|
|
data.unshift( this.fix({ type: type, target: element }) );
|
|
|
|
// Trigger the event
|
|
if ( (val = handler.apply( element, data )) !== false )
|
|
this.triggered = true;
|
|
}
|
|
|
|
if ( fn && val !== false )
|
|
element[ type ]();
|
|
|
|
this.triggered = false;
|
|
}
|
|
},
|
|
|
|
handle: function(event) {
|
|
// Handle the second event of a trigger and when
|
|
// an event is called after a page has unloaded
|
|
if ( typeof jQOld == "undefined" || jQOld.event.triggered ) return;
|
|
|
|
// Empty object is for triggered events with no data
|
|
event = jQOld.event.fix( event || window.event || {} );
|
|
|
|
// returned undefined or false
|
|
var returnValue;
|
|
|
|
var c = this.$events[event.type];
|
|
|
|
var args = [].slice.call( arguments, 1 );
|
|
args.unshift( event );
|
|
|
|
for ( var j in c ) {
|
|
// Pass in a reference to the handler function itself
|
|
// So that we can later remove it
|
|
args[0].handler = c[j];
|
|
args[0].data = c[j].data;
|
|
|
|
if ( c[j].apply( this, args ) === false ) {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
returnValue = false;
|
|
}
|
|
}
|
|
|
|
// Clean up added properties in IE to prevent memory leak
|
|
if (jQOld.browser.msie) event.target = event.preventDefault = event.stopPropagation = event.handler = event.data = null;
|
|
|
|
return returnValue;
|
|
},
|
|
|
|
fix: function(event) {
|
|
// Fix target property, if necessary
|
|
if ( !event.target && event.srcElement )
|
|
event.target = event.srcElement;
|
|
|
|
// Calculate pageX/Y if missing and clientX/Y available
|
|
if ( event.pageX == undefined && event.clientX != undefined ) {
|
|
var e = document.documentElement, b = document.body;
|
|
event.pageX = event.clientX + (e.scrollLeft || b.scrollLeft);
|
|
event.pageY = event.clientY + (e.scrollTop || b.scrollTop);
|
|
}
|
|
|
|
// check if target is a textnode (safari)
|
|
if (jQOld.browser.safari && event.target.nodeType == 3) {
|
|
// store a copy of the original event object
|
|
// and clone because target is read only
|
|
var originalEvent = event;
|
|
event = jQOld.extend({}, originalEvent);
|
|
|
|
// get parentnode from textnode
|
|
event.target = originalEvent.target.parentNode;
|
|
|
|
// add preventDefault and stopPropagation since
|
|
// they will not work on the clone
|
|
event.preventDefault = function() {
|
|
return originalEvent.preventDefault();
|
|
};
|
|
event.stopPropagation = function() {
|
|
return originalEvent.stopPropagation();
|
|
};
|
|
}
|
|
|
|
// fix preventDefault and stopPropagation
|
|
if (!event.preventDefault)
|
|
event.preventDefault = function() {
|
|
this.returnValue = false;
|
|
};
|
|
|
|
if (!event.stopPropagation)
|
|
event.stopPropagation = function() {
|
|
this.cancelBubble = true;
|
|
};
|
|
|
|
return event;
|
|
}
|
|
};
|
|
|
|
jQOld.fn.extend({
|
|
bind: function( type, data, fn ) {
|
|
return this.each(function(){
|
|
jQOld.event.add( this, type, fn || data, data );
|
|
});
|
|
},
|
|
one: function( type, data, fn ) {
|
|
return this.each(function(){
|
|
jQOld.event.add( this, type, function(event) {
|
|
jQOld(this).unbind(event);
|
|
return (fn || data).apply( this, arguments);
|
|
}, data);
|
|
});
|
|
},
|
|
unbind: function( type, fn ) {
|
|
return this.each(function(){
|
|
jQOld.event.remove( this, type, fn );
|
|
});
|
|
},
|
|
trigger: function( type, data ) {
|
|
return this.each(function(){
|
|
jQOld.event.trigger( type, data, this );
|
|
});
|
|
},
|
|
toggle: function() {
|
|
// Save reference to arguments for access in closure
|
|
var a = arguments;
|
|
|
|
return this.click(function(e) {
|
|
// Figure out which function to execute
|
|
this.lastToggle = this.lastToggle == 0 ? 1 : 0;
|
|
|
|
// Make sure that clicks stop
|
|
e.preventDefault();
|
|
|
|
// and execute the function
|
|
return a[this.lastToggle].apply( this, [e] ) || false;
|
|
});
|
|
},
|
|
hover: function(f,g) {
|
|
|
|
// A private function for handling mouse 'hovering'
|
|
function handleHover(e) {
|
|
// Check if mouse(over|out) are still within the same parent element
|
|
var p = (e.type == "mouseover" ? e.fromElement : e.toElement) || e.relatedTarget;
|
|
|
|
// Traverse up the tree
|
|
while ( p && p != this ) try { p = p.parentNode } catch(e) { p = this; };
|
|
|
|
// If we actually just moused on to a sub-element, ignore it
|
|
if ( p == this ) return false;
|
|
|
|
// Execute the right function
|
|
return (e.type == "mouseover" ? f : g).apply(this, [e]);
|
|
}
|
|
|
|
// Bind the function to the two event listeners
|
|
return this.mouseover(handleHover).mouseout(handleHover);
|
|
},
|
|
ready: function(f) {
|
|
// If the DOM is already ready
|
|
if ( jQOld.isReady )
|
|
// Execute the function immediately
|
|
f.apply( document, [jQOld] );
|
|
|
|
// Otherwise, remember the function for later
|
|
else {
|
|
// Add the function to the wait list
|
|
jQOld.readyList.push( function() { return f.apply(this, [jQOld]) } );
|
|
}
|
|
|
|
return this;
|
|
}
|
|
});
|
|
|
|
jQOld.extend({
|
|
/*
|
|
* All the code that makes DOM Ready work nicely.
|
|
*/
|
|
isReady: false,
|
|
readyList: [],
|
|
|
|
// Handle when the DOM is ready
|
|
ready: function() {
|
|
// Make sure that the DOM is not already loaded
|
|
if ( !jQOld.isReady ) {
|
|
// Remember that the DOM is ready
|
|
jQOld.isReady = true;
|
|
|
|
// If there are functions bound, to execute
|
|
if ( jQOld.readyList ) {
|
|
// Execute all of them
|
|
jQOld.each( jQOld.readyList, function(){
|
|
this.apply( document );
|
|
});
|
|
|
|
// Reset the list of functions
|
|
jQOld.readyList = null;
|
|
}
|
|
// Remove event lisenter to avoid memory leak
|
|
if ( jQOld.browser.mozilla || jQOld.browser.opera )
|
|
document.removeEventListener( "DOMContentLoaded", jQOld.ready, false );
|
|
}
|
|
}
|
|
});
|
|
|
|
new function(){
|
|
|
|
jQOld.each( ("blur,focus,load,resize,scroll,unload,click,dblclick," +
|
|
"mousedown,mouseup,mousemove,mouseover,mouseout,change,select," +
|
|
"submit,keydown,keypress,keyup,error").split(","), function(i,o){
|
|
|
|
// Handle event binding
|
|
jQOld.fn[o] = function(f){
|
|
return f ? this.bind(o, f) : this.trigger(o);
|
|
};
|
|
|
|
});
|
|
|
|
// If Mozilla is used
|
|
if ( jQOld.browser.mozilla || jQOld.browser.opera )
|
|
// Use the handy event callback
|
|
document.addEventListener( "DOMContentLoaded", jQOld.ready, false );
|
|
|
|
// If IE is used, use the excellent hack by Matthias Miller
|
|
// http://www.outofhanwell.com/blog/index.php?title=the_window_onload_problem_revisited
|
|
else if ( jQOld.browser.msie ) {
|
|
|
|
// Only works if you document.write() it
|
|
document.write("<scr" + "ipt id=__ie_init defer=true " +
|
|
"src=//:><\/script>");
|
|
|
|
// Use the defer script hack
|
|
var script = document.getElementById("__ie_init");
|
|
|
|
// script does not exist if jQOld is loaded dynamically
|
|
if ( script )
|
|
script.onreadystatechange = function() {
|
|
if ( this.readyState != "complete" ) return;
|
|
this.parentNode.removeChild( this );
|
|
jQOld.ready();
|
|
};
|
|
|
|
// Clear from memory
|
|
script = null;
|
|
|
|
// If Safari is used
|
|
} else if ( jQOld.browser.safari )
|
|
// Continually check to see if the document.readyState is valid
|
|
jQOld.safariTimer = setInterval(function(){
|
|
// loaded and complete are both valid states
|
|
if ( document.readyState == "loaded" ||
|
|
document.readyState == "complete" ) {
|
|
|
|
// If either one are found, remove the timer
|
|
clearInterval( jQOld.safariTimer );
|
|
jQOld.safariTimer = null;
|
|
|
|
// and execute any waiting functions
|
|
jQOld.ready();
|
|
}
|
|
}, 10);
|
|
|
|
// A fallback to window.onload, that will always work
|
|
jQOld.event.add( window, "load", jQOld.ready );
|
|
|
|
};
|
|
|
|
// Clean up after IE to avoid memory leaks
|
|
if (jQOld.browser.msie)
|
|
jQOld(window).one("unload", function() {
|
|
var global = jQOld.event.global;
|
|
for ( var type in global ) {
|
|
var els = global[type], i = els.length;
|
|
if ( i && type != 'unload' )
|
|
do
|
|
jQOld.event.remove(els[i-1], type);
|
|
while (--i);
|
|
}
|
|
});
|
|
jQOld.fn.extend({
|
|
loadIfModified: function( url, params, callback ) {
|
|
this.load( url, params, callback, 1 );
|
|
},
|
|
load: function( url, params, callback, ifModified ) {
|
|
if ( jQOld.isFunction( url ) )
|
|
return this.bind("load", url);
|
|
|
|
callback = callback || function(){};
|
|
|
|
// Default to a GET request
|
|
var type = "GET";
|
|
|
|
// If the second parameter was provided
|
|
if ( params )
|
|
// If it's a function
|
|
if ( jQOld.isFunction( params ) ) {
|
|
// We assume that it's the callback
|
|
callback = params;
|
|
params = null;
|
|
|
|
// Otherwise, build a param string
|
|
} else {
|
|
params = jQOld.param( params );
|
|
type = "POST";
|
|
}
|
|
|
|
var self = this;
|
|
|
|
// Request the remote document
|
|
jQOld.ajax({
|
|
url: url,
|
|
type: type,
|
|
data: params,
|
|
ifModified: ifModified,
|
|
complete: function(res, status){
|
|
if ( status == "success" || !ifModified && status == "notmodified" )
|
|
// Inject the HTML into all the matched elements
|
|
self.attr("innerHTML", res.responseText)
|
|
// Execute all the scripts inside of the newly-injected HTML
|
|
.evalScripts()
|
|
// Execute callback
|
|
.each( callback, [res.responseText, status, res] );
|
|
else
|
|
callback.apply( self, [res.responseText, status, res] );
|
|
}
|
|
});
|
|
return this;
|
|
},
|
|
serialize: function() {
|
|
return jQOld.param( this );
|
|
},
|
|
evalScripts: function() {
|
|
return this.find("script").each(function(){
|
|
if ( this.src )
|
|
jQOld.getScript( this.src );
|
|
else
|
|
jQOld.globalEval( this.text || this.textContent || this.innerHTML || "" );
|
|
}).end();
|
|
}
|
|
|
|
});
|
|
|
|
// If IE is used, create a wrapper for the XMLHttpRequest object
|
|
if ( !window.XMLHttpRequest )
|
|
XMLHttpRequest = function(){
|
|
return new ActiveXObject("Microsoft.XMLHTTP");
|
|
};
|
|
|
|
// Attach a bunch of functions for handling common AJAX events
|
|
|
|
jQOld.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){
|
|
jQOld.fn[o] = function(f){
|
|
return this.bind(o, f);
|
|
};
|
|
});
|
|
|
|
jQOld.extend({
|
|
get: function( url, data, callback, type, ifModified ) {
|
|
// shift arguments if data argument was ommited
|
|
if ( jQOld.isFunction( data ) ) {
|
|
callback = data;
|
|
data = null;
|
|
}
|
|
|
|
return jQOld.ajax({
|
|
url: url,
|
|
data: data,
|
|
success: callback,
|
|
dataType: type,
|
|
ifModified: ifModified
|
|
});
|
|
},
|
|
getIfModified: function( url, data, callback, type ) {
|
|
return jQOld.get(url, data, callback, type, 1);
|
|
},
|
|
getScript: function( url, callback ) {
|
|
return jQOld.get(url, null, callback, "script");
|
|
},
|
|
getJSON: function( url, data, callback ) {
|
|
return jQOld.get(url, data, callback, "json");
|
|
},
|
|
post: function( url, data, callback, type ) {
|
|
if ( jQOld.isFunction( data ) ) {
|
|
callback = data;
|
|
data = {};
|
|
}
|
|
|
|
return jQOld.ajax({
|
|
type: "POST",
|
|
url: url,
|
|
data: data,
|
|
success: callback,
|
|
dataType: type
|
|
});
|
|
},
|
|
|
|
// timeout (ms)
|
|
//timeout: 0,
|
|
ajaxTimeout: function( timeout ) {
|
|
jQOld.ajaxSettings.timeout = timeout;
|
|
},
|
|
ajaxSetup: function( settings ) {
|
|
jQOld.extend( jQOld.ajaxSettings, settings );
|
|
},
|
|
|
|
ajaxSettings: {
|
|
global: true,
|
|
type: "GET",
|
|
timeout: 0,
|
|
contentType: "application/x-www-form-urlencoded",
|
|
processData: true,
|
|
async: true,
|
|
data: null
|
|
},
|
|
|
|
// Last-Modified header cache for next request
|
|
lastModified: {},
|
|
ajax: function( s ) {
|
|
// TODO introduce global settings, allowing the client to modify them for all requests, not only timeout
|
|
s = jQOld.extend({}, jQOld.ajaxSettings, s);
|
|
|
|
// if data available
|
|
if ( s.data ) {
|
|
// convert data if not already a string
|
|
if (s.processData && typeof s.data != "string")
|
|
s.data = jQOld.param(s.data);
|
|
// append data to url for get requests
|
|
if( s.type.toLowerCase() == "get" ) {
|
|
// "?" + data or "&" + data (in case there are already params)
|
|
s.url += ((s.url.indexOf("?") > -1) ? "&" : "?") + s.data;
|
|
// IE likes to send both get and post data, prevent this
|
|
s.data = null;
|
|
}
|
|
}
|
|
|
|
// Watch for a new set of requests
|
|
if ( s.global && ! jQOld.active++ )
|
|
jQOld.event.trigger( "ajaxStart" );
|
|
|
|
var requestDone = false;
|
|
|
|
// Create the request object
|
|
var xml = new XMLHttpRequest();
|
|
|
|
// Open the socket
|
|
xml.open(s.type, s.url, s.async);
|
|
|
|
// Set the correct header, if data is being sent
|
|
if ( s.data )
|
|
xml.setRequestHeader("Content-Type", s.contentType);
|
|
|
|
// Set the If-Modified-Since header, if ifModified mode.
|
|
if ( s.ifModified )
|
|
xml.setRequestHeader("If-Modified-Since",
|
|
jQOld.lastModified[s.url] || "Thu, 01 Jan 1970 00:00:00 GMT" );
|
|
|
|
// Set header so the called script knows that it's an XMLHttpRequest
|
|
xml.setRequestHeader("X-Requested-With", "XMLHttpRequest");
|
|
|
|
// Make sure the browser sends the right content length
|
|
if ( xml.overrideMimeType )
|
|
xml.setRequestHeader("Connection", "close");
|
|
|
|
// Allow custom headers/mimetypes
|
|
if( s.beforeSend )
|
|
s.beforeSend(xml);
|
|
|
|
if ( s.global )
|
|
jQOld.event.trigger("ajaxSend", [xml, s]);
|
|
|
|
// Wait for a response to come back
|
|
var onreadystatechange = function(isTimeout){
|
|
// The transfer is complete and the data is available, or the request timed out
|
|
if ( xml && (xml.readyState == 4 || isTimeout == "timeout") ) {
|
|
requestDone = true;
|
|
|
|
// clear poll interval
|
|
if (ival) {
|
|
clearInterval(ival);
|
|
ival = null;
|
|
}
|
|
|
|
var status;
|
|
try {
|
|
status = jQOld.httpSuccess( xml ) && isTimeout != "timeout" ?
|
|
s.ifModified && jQOld.httpNotModified( xml, s.url ) ? "notmodified" : "success" : "error";
|
|
// Make sure that the request was successful or notmodified
|
|
if ( status != "error" ) {
|
|
// Cache Last-Modified header, if ifModified mode.
|
|
var modRes;
|
|
try {
|
|
modRes = xml.getResponseHeader("Last-Modified");
|
|
} catch(e) {} // swallow exception thrown by FF if header is not available
|
|
|
|
if ( s.ifModified && modRes )
|
|
jQOld.lastModified[s.url] = modRes;
|
|
|
|
// process the data (runs the xml through httpData regardless of callback)
|
|
var data = jQOld.httpData( xml, s.dataType );
|
|
|
|
// If a local callback was specified, fire it and pass it the data
|
|
if ( s.success )
|
|
s.success( data, status );
|
|
|
|
// Fire the global callback
|
|
if( s.global )
|
|
jQOld.event.trigger( "ajaxSuccess", [xml, s] );
|
|
} else
|
|
jQOld.handleError(s, xml, status);
|
|
} catch(e) {
|
|
status = "error";
|
|
jQOld.handleError(s, xml, status, e);
|
|
}
|
|
|
|
// The request was completed
|
|
if( s.global )
|
|
jQOld.event.trigger( "ajaxComplete", [xml, s] );
|
|
|
|
// Handle the global AJAX counter
|
|
if ( s.global && ! --jQOld.active )
|
|
jQOld.event.trigger( "ajaxStop" );
|
|
|
|
// Process result
|
|
if ( s.complete )
|
|
s.complete(xml, status);
|
|
|
|
// Stop memory leaks
|
|
if(s.async)
|
|
xml = null;
|
|
}
|
|
};
|
|
|
|
// don't attach the handler to the request, just poll it instead
|
|
var ival = setInterval(onreadystatechange, 13);
|
|
|
|
// Timeout checker
|
|
if ( s.timeout > 0 )
|
|
setTimeout(function(){
|
|
// Check to see if the request is still happening
|
|
if ( xml ) {
|
|
// Cancel the request
|
|
xml.abort();
|
|
|
|
if( !requestDone )
|
|
onreadystatechange( "timeout" );
|
|
}
|
|
}, s.timeout);
|
|
|
|
// Send the data
|
|
try {
|
|
xml.send(s.data);
|
|
} catch(e) {
|
|
jQOld.handleError(s, xml, null, e);
|
|
}
|
|
|
|
// firefox 1.5 doesn't fire statechange for sync requests
|
|
if ( !s.async )
|
|
onreadystatechange();
|
|
|
|
// return XMLHttpRequest to allow aborting the request etc.
|
|
return xml;
|
|
},
|
|
|
|
handleError: function( s, xml, status, e ) {
|
|
// If a local callback was specified, fire it
|
|
if ( s.error ) s.error( xml, status, e );
|
|
|
|
// Fire the global callback
|
|
if ( s.global )
|
|
jQOld.event.trigger( "ajaxError", [xml, s, e] );
|
|
},
|
|
|
|
// Counter for holding the number of active queries
|
|
active: 0,
|
|
|
|
// Determines if an XMLHttpRequest was successful or not
|
|
httpSuccess: function( r ) {
|
|
try {
|
|
return !r.status && location.protocol == "file:" ||
|
|
( r.status >= 200 && r.status < 300 ) || r.status == 304 ||
|
|
jQOld.browser.safari && r.status == undefined;
|
|
} catch(e){}
|
|
return false;
|
|
},
|
|
|
|
// Determines if an XMLHttpRequest returns NotModified
|
|
httpNotModified: function( xml, url ) {
|
|
try {
|
|
var xmlRes = xml.getResponseHeader("Last-Modified");
|
|
|
|
// Firefox always returns 200. check Last-Modified date
|
|
return xml.status == 304 || xmlRes == jQOld.lastModified[url] ||
|
|
jQOld.browser.safari && xml.status == undefined;
|
|
} catch(e){}
|
|
return false;
|
|
},
|
|
|
|
/* Get the data out of an XMLHttpRequest.
|
|
* Return parsed XML if content-type header is "xml" and type is "xml" or omitted,
|
|
* otherwise return plain text.
|
|
* (String) data - The type of data that you're expecting back,
|
|
* (e.g. "xml", "html", "script")
|
|
*/
|
|
httpData: function( r, type ) {
|
|
var ct = r.getResponseHeader("content-type");
|
|
var data = !type && ct && ct.indexOf("xml") >= 0;
|
|
data = type == "xml" || data ? r.responseXML : r.responseText;
|
|
|
|
// If the type is "script", eval it in global context
|
|
if ( type == "script" )
|
|
jQOld.globalEval( data );
|
|
|
|
// Get the JavaScript object, if JSON is used.
|
|
if ( type == "json" )
|
|
eval( "data = " + data );
|
|
|
|
// evaluate scripts within html
|
|
if ( type == "html" )
|
|
jQOld("<div>").html(data).evalScripts();
|
|
|
|
return data;
|
|
},
|
|
|
|
// Serialize an array of form elements or a set of
|
|
// key/values into a query string
|
|
param: function( a ) {
|
|
var s = [];
|
|
|
|
// If an array was passed in, assume that it is an array
|
|
// of form elements
|
|
if ( a.constructor == Array || a.jquery )
|
|
// Serialize the form elements
|
|
jQOld.each( a, function(){
|
|
s.push( encodeURIComponent(this.name) + "=" + encodeURIComponent( this.value ) );
|
|
});
|
|
|
|
// Otherwise, assume that it's an object of key/value pairs
|
|
else
|
|
// Serialize the key/values
|
|
for ( var j in a )
|
|
// If the value is an array then the key names need to be repeated
|
|
if ( a[j] && a[j].constructor == Array )
|
|
jQOld.each( a[j], function(){
|
|
s.push( encodeURIComponent(j) + "=" + encodeURIComponent( this ) );
|
|
});
|
|
else
|
|
s.push( encodeURIComponent(j) + "=" + encodeURIComponent( a[j] ) );
|
|
|
|
// Return the resulting serialization
|
|
return s.join("&");
|
|
},
|
|
|
|
// evalulates a script in global context
|
|
// not reliable for safari
|
|
globalEval: function( data ) {
|
|
if ( window.execScript )
|
|
window.execScript( data );
|
|
else if ( jQOld.browser.safari )
|
|
// safari doesn't provide a synchronous global eval
|
|
window.setTimeout( data, 0 );
|
|
else
|
|
eval.call( window, data );
|
|
}
|
|
|
|
});
|
|
jQOld.fn.extend({
|
|
|
|
show: function(speed,callback){
|
|
var hidden = this.filter(":hidden");
|
|
speed ?
|
|
hidden.animate({
|
|
height: "show", width: "show", opacity: "show"
|
|
}, speed, callback) :
|
|
|
|
hidden.each(function(){
|
|
this.style.display = this.oldblock ? this.oldblock : "";
|
|
if ( jQOld.css(this,"display") == "none" )
|
|
this.style.display = "block";
|
|
});
|
|
return this;
|
|
},
|
|
|
|
hide: function(speed,callback){
|
|
var visible = this.filter(":visible");
|
|
speed ?
|
|
visible.animate({
|
|
height: "hide", width: "hide", opacity: "hide"
|
|
}, speed, callback) :
|
|
|
|
visible.each(function(){
|
|
this.oldblock = this.oldblock || jQOld.css(this,"display");
|
|
if ( this.oldblock == "none" )
|
|
this.oldblock = "block";
|
|
this.style.display = "none";
|
|
});
|
|
return this;
|
|
},
|
|
|
|
// Save the old toggle function
|
|
_toggle: jQOld.fn.toggle,
|
|
toggle: function( fn, fn2 ){
|
|
var args = arguments;
|
|
return jQOld.isFunction(fn) && jQOld.isFunction(fn2) ?
|
|
this._toggle( fn, fn2 ) :
|
|
this.each(function(){
|
|
jQOld(this)[ jQOld(this).is(":hidden") ? "show" : "hide" ]
|
|
.apply( jQOld(this), args );
|
|
});
|
|
},
|
|
slideDown: function(speed,callback){
|
|
return this.animate({height: "show"}, speed, callback);
|
|
},
|
|
slideUp: function(speed,callback){
|
|
return this.animate({height: "hide"}, speed, callback);
|
|
},
|
|
slideToggle: function(speed, callback){
|
|
return this.each(function(){
|
|
var state = jQOld(this).is(":hidden") ? "show" : "hide";
|
|
jQOld(this).animate({height: state}, speed, callback);
|
|
});
|
|
},
|
|
fadeIn: function(speed, callback){
|
|
return this.animate({opacity: "show"}, speed, callback);
|
|
},
|
|
fadeOut: function(speed, callback){
|
|
return this.animate({opacity: "hide"}, speed, callback);
|
|
},
|
|
fadeTo: function(speed,to,callback){
|
|
return this.animate({opacity: to}, speed, callback);
|
|
},
|
|
animate: function( prop, speed, easing, callback ) {
|
|
return this.queue(function(){
|
|
|
|
this.curAnim = jQOld.extend({}, prop);
|
|
var opt = jQOld.speed(speed, easing, callback);
|
|
|
|
for ( var p in prop ) {
|
|
var e = new jQOld.fx( this, opt, p );
|
|
if ( prop[p].constructor == Number )
|
|
e.custom( e.cur(), prop[p] );
|
|
else
|
|
e[ prop[p] ]( prop );
|
|
}
|
|
|
|
});
|
|
},
|
|
queue: function(type,fn){
|
|
if ( !fn ) {
|
|
fn = type;
|
|
type = "fx";
|
|
}
|
|
|
|
return this.each(function(){
|
|
if ( !this.queue )
|
|
this.queue = {};
|
|
|
|
if ( !this.queue[type] )
|
|
this.queue[type] = [];
|
|
|
|
this.queue[type].push( fn );
|
|
|
|
if ( this.queue[type].length == 1 )
|
|
fn.apply(this);
|
|
});
|
|
}
|
|
|
|
});
|
|
|
|
jQOld.extend({
|
|
|
|
speed: function(speed, easing, fn) {
|
|
var opt = speed && speed.constructor == Object ? speed : {
|
|
complete: fn || !fn && easing ||
|
|
jQOld.isFunction( speed ) && speed,
|
|
duration: speed,
|
|
easing: fn && easing || easing && easing.constructor != Function && easing
|
|
};
|
|
|
|
opt.duration = (opt.duration && opt.duration.constructor == Number ?
|
|
opt.duration :
|
|
{ slow: 600, fast: 200 }[opt.duration]) || 400;
|
|
|
|
// Queueing
|
|
opt.old = opt.complete;
|
|
opt.complete = function(){
|
|
jQOld.dequeue(this, "fx");
|
|
if ( jQOld.isFunction( opt.old ) )
|
|
opt.old.apply( this );
|
|
};
|
|
|
|
return opt;
|
|
},
|
|
|
|
easing: {},
|
|
|
|
queue: {},
|
|
|
|
dequeue: function(elem,type){
|
|
type = type || "fx";
|
|
|
|
if ( elem.queue && elem.queue[type] ) {
|
|
// Remove self
|
|
elem.queue[type].shift();
|
|
|
|
// Get next function
|
|
var f = elem.queue[type][0];
|
|
|
|
if ( f ) f.apply( elem );
|
|
}
|
|
},
|
|
|
|
/*
|
|
* I originally wrote fx() as a clone of moo.fx and in the process
|
|
* of making it small in size the code became illegible to sane
|
|
* people. You've been warned.
|
|
*/
|
|
|
|
fx: function( elem, options, prop ){
|
|
|
|
var z = this;
|
|
|
|
// The styles
|
|
var y = elem.style;
|
|
|
|
// Store display property
|
|
var oldDisplay = jQOld.css(elem, "display");
|
|
|
|
// Make sure that nothing sneaks out
|
|
y.overflow = "hidden";
|
|
|
|
// Simple function for setting a style value
|
|
z.a = function(){
|
|
if ( options.step )
|
|
options.step.apply( elem, [ z.now ] );
|
|
|
|
if ( prop == "opacity" )
|
|
jQOld.attr(y, "opacity", z.now); // Let attr handle opacity
|
|
else if ( parseInt(z.now) ) // My hate for IE will never die
|
|
y[prop] = parseInt(z.now) + "px";
|
|
|
|
y.display = "block"; // Set display property to block for animation
|
|
};
|
|
|
|
// Figure out the maximum number to run to
|
|
z.max = function(){
|
|
return parseFloat( jQOld.css(elem,prop) );
|
|
};
|
|
|
|
// Get the current size
|
|
z.cur = function(){
|
|
var r = parseFloat( jQOld.curCSS(elem, prop) );
|
|
return r && r > -10000 ? r : z.max();
|
|
};
|
|
|
|
// Start an animation from one number to another
|
|
z.custom = function(from,to){
|
|
z.startTime = (new Date()).getTime();
|
|
z.now = from;
|
|
z.a();
|
|
|
|
z.timer = setInterval(function(){
|
|
z.step(from, to);
|
|
}, 13);
|
|
};
|
|
|
|
// Simple 'show' function
|
|
z.show = function(){
|
|
if ( !elem.orig ) elem.orig = {};
|
|
|
|
// Remember where we started, so that we can go back to it later
|
|
elem.orig[prop] = this.cur();
|
|
|
|
options.show = true;
|
|
|
|
// Begin the animation
|
|
z.custom(0, elem.orig[prop]);
|
|
|
|
// Stupid IE, look what you made me do
|
|
if ( prop != "opacity" )
|
|
y[prop] = "1px";
|
|
};
|
|
|
|
// Simple 'hide' function
|
|
z.hide = function(){
|
|
if ( !elem.orig ) elem.orig = {};
|
|
|
|
// Remember where we started, so that we can go back to it later
|
|
elem.orig[prop] = this.cur();
|
|
|
|
options.hide = true;
|
|
|
|
// Begin the animation
|
|
z.custom(elem.orig[prop], 0);
|
|
};
|
|
|
|
//Simple 'toggle' function
|
|
z.toggle = function() {
|
|
if ( !elem.orig ) elem.orig = {};
|
|
|
|
// Remember where we started, so that we can go back to it later
|
|
elem.orig[prop] = this.cur();
|
|
|
|
if(oldDisplay == "none") {
|
|
options.show = true;
|
|
|
|
// Stupid IE, look what you made me do
|
|
if ( prop != "opacity" )
|
|
y[prop] = "1px";
|
|
|
|
// Begin the animation
|
|
z.custom(0, elem.orig[prop]);
|
|
} else {
|
|
options.hide = true;
|
|
|
|
// Begin the animation
|
|
z.custom(elem.orig[prop], 0);
|
|
}
|
|
};
|
|
|
|
// Each step of an animation
|
|
z.step = function(firstNum, lastNum){
|
|
var t = (new Date()).getTime();
|
|
|
|
if (t > options.duration + z.startTime) {
|
|
// Stop the timer
|
|
clearInterval(z.timer);
|
|
z.timer = null;
|
|
|
|
z.now = lastNum;
|
|
z.a();
|
|
|
|
if (elem.curAnim) elem.curAnim[ prop ] = true;
|
|
|
|
var done = true;
|
|
for ( var i in elem.curAnim )
|
|
if ( elem.curAnim[i] !== true )
|
|
done = false;
|
|
|
|
if ( done ) {
|
|
// Reset the overflow
|
|
y.overflow = "";
|
|
|
|
// Reset the display
|
|
y.display = oldDisplay;
|
|
if (jQOld.css(elem, "display") == "none")
|
|
y.display = "block";
|
|
|
|
// Hide the element if the "hide" operation was done
|
|
if ( options.hide )
|
|
y.display = "none";
|
|
|
|
// Reset the properties, if the item has been hidden or shown
|
|
if ( options.hide || options.show )
|
|
for ( var p in elem.curAnim )
|
|
if (p == "opacity")
|
|
jQOld.attr(y, p, elem.orig[p]);
|
|
else
|
|
y[p] = "";
|
|
}
|
|
|
|
// If a callback was provided, execute it
|
|
if ( done && jQOld.isFunction( options.complete ) )
|
|
// Execute the complete function
|
|
options.complete.apply( elem );
|
|
} else {
|
|
var n = t - this.startTime;
|
|
// Figure out where in the animation we are and set the number
|
|
var p = n / options.duration;
|
|
|
|
// If the easing function exists, then use it
|
|
z.now = options.easing && jQOld.easing[options.easing] ?
|
|
jQOld.easing[options.easing](p, n, firstNum, (lastNum-firstNum), options.duration) :
|
|
// else use default linear easing
|
|
((-Math.cos(p*Math.PI)/2) + 0.5) * (lastNum-firstNum) + firstNum;
|
|
|
|
// Perform the next step of the animation
|
|
z.a();
|
|
}
|
|
};
|
|
|
|
}
|
|
});
|
|
}
|