CLICK HERE TO BUY IT TODAY! OR GET IT FREE VIA TRIALPAY  

PHP Demo Application - Source Code

/Framework/Model/Vendor/jquery-ui/development-bundle/ui/jquery.effects.core.js



/*
 * jQuery UI Effects 1.8.4
 *
 * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Effects/
 */
;
jQuery.effects || (function($, undefined) {
	$.effects {};
	/******************************************************************************/
	/****************************** COLOR ANIMATIONS ******************************/
	/******************************************************************************/
	// override the animation for color styles
	$.each(['backgroundColor''borderBottomColor''borderLeftColor',
	    'borderRightColor''borderTopColor''color''outlineColor'],
	function(iattr) {
		    $.fx.step[attr] = function(fx) {
			        if (!fx.colorInit) {
				            fx.start getColor(fx.elemattr);
				            fx.end getRGB(fx.end);
				            fx.colorInit true;
				        }
			        fx.elem.style[attr] = 'rgb(' +
			            Math.max(Math.min(parseInt((fx.pos * (fx.end[0] - fx.start[0])) + fx.start[0], 10), 255), 0) + ',' +
			            Math.max(Math.min(parseInt((fx.pos * (fx.end[1] - fx.start[1])) + fx.start[1], 10), 255), 0) + ',' +
			            Math.max(Math.min(parseInt((fx.pos * (fx.end[2] - fx.start[2])) + fx.start[2], 10), 255), 0) + ')';
			    };
		});
	// Color Conversion functions from highlightFade
	// By Blair Mitchelmore
	// http://jquery.offput.ca/highlightFade/
	// Parse strings looking for color tuples [255,255,255]
	function getRGB(color) {
		        var result;
		        // Check if we're already dealing with an array of colors
		        if ( color && color.constructor == Array && color.length == )
		                return color;
		        // Look for rgb(num,num,num)
		        if (result = /rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/.exec(color))
		                return [parseInt(result[1],10), parseInt(result[2],10), parseInt(result[3],10)];
		        // Look for rgb(num%,num%,num%)
		        if (result = /rgb\(\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*\)/.exec(color))
		                return [parseFloat(result[1])*2.55parseFloat(result[2])*2.55parseFloat(result[3])*2.55];
		        // Look for #a0b1c2
		        if (result = /#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/.exec(color))
		                return [parseInt(result[1],16), parseInt(result[2],16), parseInt(result[3],16)];
		        // Look for #fff
		        if (result = /#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])/.exec(color))
		                return [parseInt(result[1]+result[1],16), parseInt(result[2]+result[2],16), parseInt(result[3]+result[3],16)];
		        // Look for rgba(0, 0, 0, 0) == transparent in Safari 3
		        if (result = /rgba\(0000\)/.exec(color))
		                return colors['transparent'];
		        // Otherwise, we're most likely dealing with a named color
		        return colors[$.trim(color).toLowerCase()];
		}
	function getColor(elemattr) {
		        var color;
		        do {
			                color = $.curCSS(elemattr);
			                // Keep going until we find an element that has color, or we hit the body
			                if ( color != '' && color != 'transparent' || $.nodeName(elem"body") )
			                        break;
			                attr "backgroundColor";
			        } while ( elem elem.parentNode );
		        return getRGB(color);
		};
	// Some named colors to work with
	// From Interface by Stefan Petre
	// http://interface.eyecon.ro/
	var colors = {
		    aqua:[0,255,255],
		    azure:[240,255,255],
		    beige:[245,245,220],
		    black:[0,0,0],
		    blue:[0,0,255],
		    brown:[165,42,42],
		    cyan:[0,255,255],
		    darkblue:[0,0,139],
		    darkcyan:[0,139,139],
		    darkgrey:[169,169,169],
		    darkgreen:[0,100,0],
		    darkkhaki:[189,183,107],
		    darkmagenta:[139,0,139],
		    darkolivegreen:[85,107,47],
		    darkorange:[255,140,0],
		    darkorchid:[153,50,204],
		    darkred:[139,0,0],
		    darksalmon:[233,150,122],
		    darkviolet:[148,0,211],
		    fuchsia:[255,0,255],
		    gold:[255,215,0],
		    green:[0,128,0],
		    indigo:[75,0,130],
		    khaki:[240,230,140],
		    lightblue:[173,216,230],
		    lightcyan:[224,255,255],
		    lightgreen:[144,238,144],
		    lightgrey:[211,211,211],
		    lightpink:[255,182,193],
		    lightyellow:[255,255,224],
		    lime:[0,255,0],
		    magenta:[255,0,255],
		    maroon:[128,0,0],
		    navy:[0,0,128],
		    olive:[128,128,0],
		    orange:[255,165,0],
		    pink:[255,192,203],
		    purple:[128,0,128],
		    violet:[128,0,128],
		    red:[255,0,0],
		    silver:[192,192,192],
		    white:[255,255,255],
		    yellow:[255,255,0],
		    transparent: [255,255,255]
		};
	/******************************************************************************/
	/****************************** CLASS ANIMATIONS ******************************/
	/******************************************************************************/
	var classAnimationActions = ['add''remove''toggle'],
	    shorthandStyles = {
		        border1,
		        borderBottom1,
		        borderColor1,
		        borderLeft1,
		        borderRight1,
		        borderTop1,
		        borderWidth1,
		        margin1,
		        padding1
		    };
	function getElementStyles() {
		    var style document.defaultView
		            document.defaultView.getComputedStyle(thisnull)
		            : this.currentStyle,
		        newStyle {},
		        key,
		        camelCase;
		    // webkit enumerates style porperties
		    if (style && style.length && style[0] && style[style[0]]) {
			        var len style.length;
			        while (len--) {
				            key style[len];
				            if (typeof style[key] == 'string') {
					                camelCase key.replace(/\-(\w)/g, function(allletter){
						                    return letter.toUpperCase();
						                });
					                newStyle[camelCase] = style[key];
					            }
				        }
			    } else {
			        for (key in style) {
				            if (typeof style[key] === 'string') {
					                newStyle[key] = style[key];
					            }
				        }
			    }
		    return newStyle;
		}
	function filterStyles(styles) {
		    var namevalue;
		    for (name in styles) {
			        value styles[name];
			        if (
			            // ignore null and undefined values
			            value == null ||
			            // ignore functions (when does this occur?)
			            $.isFunction(value) ||
			            // shorthand styles that need to be expanded
			            name in shorthandStyles ||
			            // ignore scrollbars (break in IE)
			            (/scrollbar/).test(name) ||
			            // only colors or values that can be converted to numbers
			            (!(/color/i).test(name) && isNaN(parseFloat(value)))
			        ) {
				            delete styles[name];
				        }
			    }
		    return styles;
		}
	function styleDifference(oldStylenewStyle) {
		    var diff = { _0
			}, // http://dev.jquery.com/ticket/5459
		        name;
		    for (name in newStyle) {
			        if (oldStyle[name] != newStyle[name]) {
				            diff[name] = newStyle[name];
				        }
			    }
		    return diff;
		}
	$.effects.animateClass = function(valuedurationeasingcallback) {
		    if ($.isFunction(easing)) {
			        callback easing;
			        easing null;
			    }
		    return this.each(function() {
			        var that = $(this),
			            originalStyleAttr that.attr('style') || ' ',
			            originalStyle filterStyles(getElementStyles.call(this)),
			            newStyle,
			            className that.attr('className');
			        $.each(classAnimationActions, function(iaction) {
				            if (value[action]) {
					                that[action 'Class'](value[action]);
					            }
				        });
			        newStyle filterStyles(getElementStyles.call(this));
			        that.attr('className'className);
			        that.animate(styleDifference(originalStylenewStyle), durationeasing, function() {
				            $.each(classAnimationActions, function(iaction) {
					                if (value[action]) {
						that[action 'Class'](value[action]);
						}
					            });
				            // work around bug in IE by clearing the cssText before setting it
				            if (typeof that.attr('style') == 'object') {
					                that.attr('style').cssText '';
					                that.attr('style').cssText originalStyleAttr;
					            } else {
					                that.attr('style'originalStyleAttr);
					            }
				            if (callback) {
					callback.apply(thisarguments);
					}
				        });
			    });
		};
	$.fn.extend({
		    _addClass: $.fn.addClass,
		    addClass: function(classNamesspeedeasingcallback) {
			        return speed ? $.effects.animateClass.apply(this, [{ addclassNames
				},speed,easing,callback]) : this._addClass(classNames);
			    },
		    _removeClass: $.fn.removeClass,
		    removeClass: function(classNames,speed,easing,callback) {
			        return speed ? $.effects.animateClass.apply(this, [{ removeclassNames
				},speed,easing,callback]) : this._removeClass(classNames);
			    },
		    _toggleClass: $.fn.toggleClass,
		    toggleClass: function(classNamesforcespeedeasingcallback) {
			        if ( typeof force == "boolean" || force === undefined ) {
				            if ( !speed ) {
					                // without speed parameter;
					                return this._toggleClass(classNamesforce);
					            } else {
					                return $.effects.animateClass.apply(this, [(force?{add:classNames}:{remove:classNames}),speed,easing,callback]);
					            }
				        } else {
				            // without switch parameter;
				            return $.effects.animateClass.apply(this, [{ toggleclassNames
					},force,speed,easing]);
				        }
			    },
		    switchClass: function(remove,add,speed,easing,callback) {
			        return $.effects.animateClass.apply(this, [{ addaddremoveremove
				},speed,easing,callback]);
			    }
		});
	/******************************************************************************/
	/*********************************** EFFECTS **********************************/
	/******************************************************************************/
	$.extend($.effects, {
		    version"1.8.4",
		    // Saves a set of properties in a data storage
		    save: function(elementset) {
			        for(var i=0;
			 set.length;
			 i++) {
				            if(set[i] !== nullelement.data("ec.storage."+set[i], element[0].style[set[i]]);
				        }
			    },
		    // Restores a set of previously saved properties from a data storage
		    restore: function(elementset) {
			        for(var i=0;
			 set.length;
			 i++) {
				            if(set[i] !== nullelement.css(set[i], element.data("ec.storage."+set[i]));
				        }
			    },
		    setMode: function(elmode) {
			        if (mode == 'toggle'mode el.is(':hidden') ? 'show' 'hide';
			 // Set for toggle
			        return mode;
			    },
		    getBaseline: function(originoriginal) {
			// Translates a [top,left] array into a baseline value
			        // this should be a little more flexible in the future to handle a string & hash
			        var yx;
			        switch (origin[0]) {
				            case 'top'0;
				 break;
				            case 'middle'0.5;
				 break;
				            case 'bottom'1;
				 break;
				            default: origin[0] / original.height;
				        };
			        switch (origin[1]) {
				            case 'left'0;
				 break;
				            case 'center'0.5;
				 break;
				            case 'right'1;
				 break;
				            default: origin[1] / original.width;
				        };
			        return {xxyy};
			    },
		    // Wraps the element around a wrapper that copies position properties
		    createWrapper: function(element) {
			        // if the element is already wrapped, return it
			        if (element.parent().is('.ui-effects-wrapper')) {
				            return element.parent();
				        }
			        // wrap the element
			        var props = {
				                widthelement.outerWidth(true),
				                heightelement.outerHeight(true),
				                'float'element.css('float')
				            },
			            wrapper = $('<div></div>')
			                .addClass('ui-effects-wrapper')
			                .css({
				                    fontSize'100%',
				                    background'transparent',
				                    border'none',
				                    margin0,
				                    padding0
				                });
			        element.wrap(wrapper);
			        wrapper element.parent();
			 //Hotfix for jQuery 1.4 since some change in wrap() seems to actually loose the reference to the wrapped element
			        // transfer positioning properties to the wrapper
			        if (element.css('position') == 'static') {
				            wrapper.css({ position'relative'
					});
				            element.css({ position'relative'
					});
				        } else {
				            $.extend(props, {
					                positionelement.css('position'),
					                zIndexelement.css('z-index')
					            });
				            $.each(['top''left''bottom''right'], function(ipos) {
					                props[pos] = element.css(pos);
					                if (isNaN(parseInt(props[pos], 10))) {
						                    props[pos] = 'auto';
						                }
					            });
				            element.css({position'relative'top0left0
					});
				        }
			        return wrapper.css(props).show();
			    },
		    removeWrapper: function(element) {
			        if (element.parent().is('.ui-effects-wrapper'))
			            return element.parent().replaceWith(element);
			        return element;
			    },
		    setTransition: function(element, list, factorvalue) {
			        value value || {};
			        $.each(list, function(ix){
				            unit element.cssUnit(x);
				            if (unit[0] > 0value[x] = unit[0] * factor unit[1];
				        });
			        return value;
			    }
		});
	function _normalizeArguments(effectoptionsspeedcallback) {
		    // shift params for method overloading
		    if (typeof effect == 'object') {
			        callback options;
			        speed null;
			        options effect;
			        effect options.effect;
			    }
		    if ($.isFunction(options)) {
			        callback options;
			        speed null;
			        options {};
			    }
		        if (typeof options == 'number' || $.fx.speeds[options]) {
			        callback speed;
			        speed options;
			        options {};
			    }
		    if ($.isFunction(speed)) {
			        callback speed;
			        speed null;
			    }
		    options options || {};
		    speed speed || options.duration;
		    speed = $.fx.off typeof speed == 'number'
		        speed : $.fx.speeds[speed] || $.fx.speeds._default;
		    callback callback || options.complete;
		    return [effectoptionsspeedcallback];
		}
	$.fn.extend({
		    effect: function(effectoptionsspeedcallback) {
			        var args _normalizeArguments.apply(thisarguments),
			            // TODO: make effects takes actual parameters instead of a hash
			            args2 = {
				                optionsargs[1],
				                durationargs[2],
				                callbackargs[3]
				            },
			            effectMethod = $.effects[effect];
			        return effectMethod && !$.fx.off effectMethod.call(thisargs2) : this;
			    },
		    _show: $.fn.show,
		    show: function(speed) {
			        if (!speed || typeof speed == 'number' || $.fx.speeds[speed]) {
				            return this._show.apply(thisarguments);
				        } else {
				            var args _normalizeArguments.apply(thisarguments);
				            args[1].mode 'show';
				            return this.effect.apply(thisargs);
				        }
			    },
		    _hide: $.fn.hide,
		    hide: function(speed) {
			        if (!speed || typeof speed == 'number' || $.fx.speeds[speed]) {
				            return this._hide.apply(thisarguments);
				        } else {
				            var args _normalizeArguments.apply(thisarguments);
				            args[1].mode 'hide';
				            return this.effect.apply(thisargs);
				        }
			    },
		    // jQuery core overloads toggle and create _toggle
		    __toggle: $.fn.toggle,
		    toggle: function(speed) {
			        if (!speed || typeof speed == 'number' || $.fx.speeds[speed] ||
			            typeof speed == 'boolean' || $.isFunction(speed)) {
				            return this.__toggle.apply(thisarguments);
				        } else {
				            var args _normalizeArguments.apply(thisarguments);
				            args[1].mode 'toggle';
				            return this.effect.apply(thisargs);
				        }
			    },
		    // helper functions
		    cssUnit: function(key) {
			        var style this.css(key), val [];
			        $.each( ['em','px','%','pt'], function(iunit){
				            if(style.indexOf(unit) > 0)
				                val = [parseFloat(style), unit];
				        });
			        return val;
			    }
		});
	/******************************************************************************/
	/*********************************** EASING ***********************************/
	/******************************************************************************/
	/*
	 * jQuery Easing v1.3 - http://gsgd.co.uk/sandbox/jquery/easing/
	 *
	 * Uses the built in easing capabilities added In jQuery 1.1
	 * to offer multiple easing options
	 *
	 * TERMS OF USE - jQuery Easing
	 *
	 * Open source under the BSD License.
	 *
	 * Copyright 2008 George McGinley Smith
	 * All rights reserved.
	 *
	 * Redistribution and use in source and binary forms, with or without modification,
	 * are permitted provided that the following conditions are met:
	 *
	 * Redistributions of source code must retain the above copyright notice, this list of
	 * conditions and the following disclaimer.
	 * Redistributions in binary form must reproduce the above copyright notice, this list
	 * of conditions and the following disclaimer in the documentation and/or other materials
	 * provided with the distribution.
	 *
	 * Neither the name of the author nor the names of contributors may be used to endorse
	 * or promote products derived from this software without specific prior written permission.
	 *
	 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
	 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
	 * GOODS OR SERVICES;
	 LOSS OF USE, DATA, OR PROFITS;
	 OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
	 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
	 * OF THE POSSIBILITY OF SUCH DAMAGE.
	 *
	*/
	// t: current time, b: begInnIng value, c: change In value, d: duration
	$.easing.jswing = $.easing.swing;
	$.extend($.easing,
	{
		    def'easeOutQuad',
		    swing: function (xtbcd) {
			        //alert($.easing.default);
			        return $.easing[$.easing.def](xtbcd);
			    },
		    easeInQuad: function (xtbcd) {
			        return c*(t/=d)*b;
			    },
		    easeOutQuad: function (xtbcd) {
			        return -*(t/=d)*(t-2) + b;
			    },
		    easeInOutQuad: function (xtbcd) {
			        if ((t/=d/2) < 1) return c/2*t*b;
			        return -c/* ((--t)*(t-2) - 1) + b;
			    },
		    easeInCubic: function (xtbcd) {
			        return c*(t/=d)*t*b;
			    },
		    easeOutCubic: function (xtbcd) {
			        return c*((t=t/d-1)*t*1) + b;
			    },
		    easeInOutCubic: function (xtbcd) {
			        if ((t/=d/2) < 1) return c/2*t*t*b;
			        return c/2*((t-=2)*t*2) + b;
			    },
		    easeInQuart: function (xtbcd) {
			        return c*(t/=d)*t*t*b;
			    },
		    easeOutQuart: function (xtbcd) {
			        return -* ((t=t/d-1)*t*t*1) + b;
			    },
		    easeInOutQuart: function (xtbcd) {
			        if ((t/=d/2) < 1) return c/2*t*t*t*b;
			        return -c/* ((t-=2)*t*t*2) + b;
			    },
		    easeInQuint: function (xtbcd) {
			        return c*(t/=d)*t*t*t*b;
			    },
		    easeOutQuint: function (xtbcd) {
			        return c*((t=t/d-1)*t*t*t*1) + b;
			    },
		    easeInOutQuint: function (xtbcd) {
			        if ((t/=d/2) < 1) return c/2*t*t*t*t*b;
			        return c/2*((t-=2)*t*t*t*2) + b;
			    },
		    easeInSine: function (xtbcd) {
			        return -Math.cos(t/* (Math.PI/2)) + b;
			    },
		    easeOutSine: function (xtbcd) {
			        return Math.sin(t/* (Math.PI/2)) + b;
			    },
		    easeInOutSine: function (xtbcd) {
			        return -c/* (Math.cos(Math.PI*t/d) - 1) + b;
			    },
		    easeInExpo: function (xtbcd) {
			        return (t==0) ? Math.pow(210 * (t/1)) + b;
			    },
		    easeOutExpo: function (xtbcd) {
			        return (t==d) ? b+* (-Math.pow(2, -10 t/d) + 1) + b;
			    },
		    easeInOutExpo: function (xtbcd) {
			        if (t==0) return b;
			        if (t==d) return b+c;
			        if ((t/=d/2) < 1) return c/Math.pow(210 * (1)) + b;
			        return c/* (-Math.pow(2, -10 * --t) + 2) + b;
			    },
		    easeInCirc: function (xtbcd) {
			        return -* (Math.sqrt(- (t/=d)*t) - 1) + b;
			    },
		    easeOutCirc: function (xtbcd) {
			        return Math.sqrt(- (t=t/d-1)*t) + b;
			    },
		    easeInOutCirc: function (xtbcd) {
			        if ((t/=d/2) < 1) return -c/* (Math.sqrt(t*t) - 1) + b;
			        return c/* (Math.sqrt(- (t-=2)*t) + 1) + b;
			    },
		    easeInElastic: function (xtbcd) {
			        var s=1.70158;
			var p=0;
			var a=c;
			        if (t==0) return b;
			  if ((t/=d)==1) return b+c;
			  if (!pp=d*.3;
			        if (Math.abs(c)) {
				a=c;
				 var s=p/4;
				}
			        else var p/(2*Math.PI) * Math.asin (c/a);
			        return -(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/)) + b;
			    },
		    easeOutElastic: function (xtbcd) {
			        var s=1.70158;
			var p=0;
			var a=c;
			        if (t==0) return b;
			  if ((t/=d)==1) return b+c;
			  if (!pp=d*.3;
			        if (Math.abs(c)) {
				a=c;
				 var s=p/4;
				}
			        else var p/(2*Math.PI) * Math.asin (c/a);
			        return a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/) + b;
			    },
		    easeInOutElastic: function (xtbcd) {
			        var s=1.70158;
			var p=0;
			var a=c;
			        if (t==0) return b;
			  if ((t/=d/2)==2) return b+c;
			  if (!pp=d*(.3*1.5);
			        if (Math.abs(c)) {
				a=c;
				 var s=p/4;
				}
			        else var p/(2*Math.PI) * Math.asin (c/a);
			        if (1) return -.5*(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/)) + b;
			        return a*Math.pow(2,-10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/)*.5 b;
			    },
		    easeInBack: function (xtbcds) {
			        if (== undefined1.70158;
			        return c*(t/=d)*t*((s+1)*s) + b;
			    },
		    easeOutBack: function (xtbcds) {
			        if (== undefined1.70158;
			        return c*((t=t/d-1)*t*((s+1)*s) + 1) + b;
			    },
		    easeInOutBack: function (xtbcds) {
			        if (== undefined1.70158;
			        if ((t/=d/2) < 1) return c/2*(t*t*(((s*=(1.525))+1)*s)) + b;
			        return c/2*((t-=2)*t*(((s*=(1.525))+1)*s) + 2) + b;
			    },
		    easeInBounce: function (xtbcd) {
			        return - $.easing.easeOutBounce (xd-t0cd) + b;
			    },
		    easeOutBounce: function (xtbcd) {
			        if ((t/=d) < (1/2.75)) {
				            return c*(7.5625*t*t) + b;
				        } else if (< (2/2.75)) {
				            return c*(7.5625*(t-=(1.5/2.75))*.75) + b;
				        } else if (< (2.5/2.75)) {
				            return c*(7.5625*(t-=(2.25/2.75))*.9375) + b;
				        } else {
				            return c*(7.5625*(t-=(2.625/2.75))*.984375) + b;
				        }
			    },
		    easeInOutBounce: function (xtbcd) {
			        if (d/2) return $.easing.easeInBounce (xt*20cd) * .5 b;
			        return $.easing.easeOutBounce (xt*2-d0cd) * .5 c*.5 b;
			    }
		});
	/*
	 *
	 * TERMS OF USE - EASING EQUATIONS
	 *
	 * Open source under the BSD License.
	 *
	 * Copyright 2001 Robert Penner
	 * All rights reserved.
	 *
	 * Redistribution and use in source and binary forms, with or without modification,
	 * are permitted provided that the following conditions are met:
	 *
	 * Redistributions of source code must retain the above copyright notice, this list of
	 * conditions and the following disclaimer.
	 * Redistributions in binary form must reproduce the above copyright notice, this list
	 * of conditions and the following disclaimer in the documentation and/or other materials
	 * provided with the distribution.
	 *
	 * Neither the name of the author nor the names of contributors may be used to endorse
	 * or promote products derived from this software without specific prior written permission.
	 *
	 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
	 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
	 * GOODS OR SERVICES;
	 LOSS OF USE, DATA, OR PROFITS;
	 OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
	 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
	 * OF THE POSSIBILITY OF SUCH DAMAGE.
	 *
	 */
	})(jQuery);





PHP Demo Source Code Index