source: trunk/themes/default/js/ui/jquery.effects.core.js @ 9559

Last change on this file since 9559 was 9559, checked in by patdenice, 13 years ago

Update jQuery UI to 1.8.10.
Improve jquery ui management in template class.
File size: 22.5 KB
Line 
1/*
2 * jQuery UI Effects 1.8.10
3 *
4 * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
5 * Dual licensed under the MIT or GPL Version 2 licenses.
6 * http://jquery.org/license
7 *
8 * http://docs.jquery.com/UI/Effects/
9 */
10;jQuery.effects || (function($, undefined) {
11
12$.effects = {};
13
14
15
16/******************************************************************************/
17/****************************** COLOR ANIMATIONS ******************************/
18/******************************************************************************/
19
20// override the animation for color styles
21$.each(['backgroundColor', 'borderBottomColor', 'borderLeftColor',
22        'borderRightColor', 'borderTopColor', 'borderColor', 'color', 'outlineColor'],
23function(i, attr) {
24        $.fx.step[attr] = function(fx) {
25                if (!fx.colorInit) {
26                        fx.start = getColor(fx.elem, attr);
27                        fx.end = getRGB(fx.end);
28                        fx.colorInit = true;
29                }
30
31                fx.elem.style[attr] = 'rgb(' +
32                        Math.max(Math.min(parseInt((fx.pos * (fx.end[0] - fx.start[0])) + fx.start[0], 10), 255), 0) + ',' +
33                        Math.max(Math.min(parseInt((fx.pos * (fx.end[1] - fx.start[1])) + fx.start[1], 10), 255), 0) + ',' +
34                        Math.max(Math.min(parseInt((fx.pos * (fx.end[2] - fx.start[2])) + fx.start[2], 10), 255), 0) + ')';
35        };
36});
37
38// Color Conversion functions from highlightFade
39// By Blair Mitchelmore
40// http://jquery.offput.ca/highlightFade/
41
42// Parse strings looking for color tuples [255,255,255]
43function getRGB(color) {
44                var result;
45
46                // Check if we're already dealing with an array of colors
47                if ( color && color.constructor == Array && color.length == 3 )
48                                return color;
49
50                // Look for rgb(num,num,num)
51                if (result = /rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/.exec(color))
52                                return [parseInt(result[1],10), parseInt(result[2],10), parseInt(result[3],10)];
53
54                // Look for rgb(num%,num%,num%)
55                if (result = /rgb\(\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*\)/.exec(color))
56                                return [parseFloat(result[1])*2.55, parseFloat(result[2])*2.55, parseFloat(result[3])*2.55];
57
58                // Look for #a0b1c2
59                if (result = /#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/.exec(color))
60                                return [parseInt(result[1],16), parseInt(result[2],16), parseInt(result[3],16)];
61
62                // Look for #fff
63                if (result = /#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])/.exec(color))
64                                return [parseInt(result[1]+result[1],16), parseInt(result[2]+result[2],16), parseInt(result[3]+result[3],16)];
65
66                // Look for rgba(0, 0, 0, 0) == transparent in Safari 3
67                if (result = /rgba\(0, 0, 0, 0\)/.exec(color))
68                                return colors['transparent'];
69
70                // Otherwise, we're most likely dealing with a named color
71                return colors[$.trim(color).toLowerCase()];
72}
73
74function getColor(elem, attr) {
75                var color;
76
77                do {
78                                color = $.curCSS(elem, attr);
79
80                                // Keep going until we find an element that has color, or we hit the body
81                                if ( color != '' && color != 'transparent' || $.nodeName(elem, "body") )
82                                                break;
83
84                                attr = "backgroundColor";
85                } while ( elem = elem.parentNode );
86
87                return getRGB(color);
88};
89
90// Some named colors to work with
91// From Interface by Stefan Petre
92// http://interface.eyecon.ro/
93
94var colors = {
95        aqua:[0,255,255],
96        azure:[240,255,255],
97        beige:[245,245,220],
98        black:[0,0,0],
99        blue:[0,0,255],
100        brown:[165,42,42],
101        cyan:[0,255,255],
102        darkblue:[0,0,139],
103        darkcyan:[0,139,139],
104        darkgrey:[169,169,169],
105        darkgreen:[0,100,0],
106        darkkhaki:[189,183,107],
107        darkmagenta:[139,0,139],
108        darkolivegreen:[85,107,47],
109        darkorange:[255,140,0],
110        darkorchid:[153,50,204],
111        darkred:[139,0,0],
112        darksalmon:[233,150,122],
113        darkviolet:[148,0,211],
114        fuchsia:[255,0,255],
115        gold:[255,215,0],
116        green:[0,128,0],
117        indigo:[75,0,130],
118        khaki:[240,230,140],
119        lightblue:[173,216,230],
120        lightcyan:[224,255,255],
121        lightgreen:[144,238,144],
122        lightgrey:[211,211,211],
123        lightpink:[255,182,193],
124        lightyellow:[255,255,224],
125        lime:[0,255,0],
126        magenta:[255,0,255],
127        maroon:[128,0,0],
128        navy:[0,0,128],
129        olive:[128,128,0],
130        orange:[255,165,0],
131        pink:[255,192,203],
132        purple:[128,0,128],
133        violet:[128,0,128],
134        red:[255,0,0],
135        silver:[192,192,192],
136        white:[255,255,255],
137        yellow:[255,255,0],
138        transparent: [255,255,255]
139};
140
141
142
143/******************************************************************************/
144/****************************** CLASS ANIMATIONS ******************************/
145/******************************************************************************/
146
147var classAnimationActions = ['add', 'remove', 'toggle'],
148        shorthandStyles = {
149                border: 1,
150                borderBottom: 1,
151                borderColor: 1,
152                borderLeft: 1,
153                borderRight: 1,
154                borderTop: 1,
155                borderWidth: 1,
156                margin: 1,
157                padding: 1
158        };
159
160function getElementStyles() {
161        var style = document.defaultView
162                        ? document.defaultView.getComputedStyle(this, null)
163                        : this.currentStyle,
164                newStyle = {},
165                key,
166                camelCase;
167
168        // webkit enumerates style porperties
169        if (style && style.length && style[0] && style[style[0]]) {
170                var len = style.length;
171                while (len--) {
172                        key = style[len];
173                        if (typeof style[key] == 'string') {
174                                camelCase = key.replace(/\-(\w)/g, function(all, letter){
175                                        return letter.toUpperCase();
176                                });
177                                newStyle[camelCase] = style[key];
178                        }
179                }
180        } else {
181                for (key in style) {
182                        if (typeof style[key] === 'string') {
183                                newStyle[key] = style[key];
184                        }
185                }
186        }
187       
188        return newStyle;
189}
190
191function filterStyles(styles) {
192        var name, value;
193        for (name in styles) {
194                value = styles[name];
195                if (
196                        // ignore null and undefined values
197                        value == null ||
198                        // ignore functions (when does this occur?)
199                        $.isFunction(value) ||
200                        // shorthand styles that need to be expanded
201                        name in shorthandStyles ||
202                        // ignore scrollbars (break in IE)
203                        (/scrollbar/).test(name) ||
204
205                        // only colors or values that can be converted to numbers
206                        (!(/color/i).test(name) && isNaN(parseFloat(value)))
207                ) {
208                        delete styles[name];
209                }
210        }
211       
212        return styles;
213}
214
215function styleDifference(oldStyle, newStyle) {
216        var diff = { _: 0 }, // http://dev.jquery.com/ticket/5459
217                name;
218
219        for (name in newStyle) {
220                if (oldStyle[name] != newStyle[name]) {
221                        diff[name] = newStyle[name];
222                }
223        }
224
225        return diff;
226}
227
228$.effects.animateClass = function(value, duration, easing, callback) {
229        if ($.isFunction(easing)) {
230                callback = easing;
231                easing = null;
232        }
233
234        return this.queue('fx', function() {
235                var that = $(this),
236                        originalStyleAttr = that.attr('style') || ' ',
237                        originalStyle = filterStyles(getElementStyles.call(this)),
238                        newStyle,
239                        className = that.attr('className');
240
241                $.each(classAnimationActions, function(i, action) {
242                        if (value[action]) {
243                                that[action + 'Class'](value[action]);
244                        }
245                });
246                newStyle = filterStyles(getElementStyles.call(this));
247                that.attr('className', className);
248
249                that.animate(styleDifference(originalStyle, newStyle), duration, easing, function() {
250                        $.each(classAnimationActions, function(i, action) {
251                                if (value[action]) { that[action + 'Class'](value[action]); }
252                        });
253                        // work around bug in IE by clearing the cssText before setting it
254                        if (typeof that.attr('style') == 'object') {
255                                that.attr('style').cssText = '';
256                                that.attr('style').cssText = originalStyleAttr;
257                        } else {
258                                that.attr('style', originalStyleAttr);
259                        }
260                        if (callback) { callback.apply(this, arguments); }
261                });
262
263                // $.animate adds a function to the end of the queue
264                // but we want it at the front
265                var queue = $.queue(this),
266                        anim = queue.splice(queue.length - 1, 1)[0];
267                queue.splice(1, 0, anim);
268                $.dequeue(this);
269        });
270};
271
272$.fn.extend({
273        _addClass: $.fn.addClass,
274        addClass: function(classNames, speed, easing, callback) {
275                return speed ? $.effects.animateClass.apply(this, [{ add: classNames },speed,easing,callback]) : this._addClass(classNames);
276        },
277
278        _removeClass: $.fn.removeClass,
279        removeClass: function(classNames,speed,easing,callback) {
280                return speed ? $.effects.animateClass.apply(this, [{ remove: classNames },speed,easing,callback]) : this._removeClass(classNames);
281        },
282
283        _toggleClass: $.fn.toggleClass,
284        toggleClass: function(classNames, force, speed, easing, callback) {
285                if ( typeof force == "boolean" || force === undefined ) {
286                        if ( !speed ) {
287                                // without speed parameter;
288                                return this._toggleClass(classNames, force);
289                        } else {
290                                return $.effects.animateClass.apply(this, [(force?{add:classNames}:{remove:classNames}),speed,easing,callback]);
291                        }
292                } else {
293                        // without switch parameter;
294                        return $.effects.animateClass.apply(this, [{ toggle: classNames },force,speed,easing]);
295                }
296        },
297
298        switchClass: function(remove,add,speed,easing,callback) {
299                return $.effects.animateClass.apply(this, [{ add: add, remove: remove },speed,easing,callback]);
300        }
301});
302
303
304
305/******************************************************************************/
306/*********************************** EFFECTS **********************************/
307/******************************************************************************/
308
309$.extend($.effects, {
310        version: "1.8.10",
311
312        // Saves a set of properties in a data storage
313        save: function(element, set) {
314                for(var i=0; i < set.length; i++) {
315                        if(set[i] !== null) element.data("ec.storage."+set[i], element[0].style[set[i]]);
316                }
317        },
318
319        // Restores a set of previously saved properties from a data storage
320        restore: function(element, set) {
321                for(var i=0; i < set.length; i++) {
322                        if(set[i] !== null) element.css(set[i], element.data("ec.storage."+set[i]));
323                }
324        },
325
326        setMode: function(el, mode) {
327                if (mode == 'toggle') mode = el.is(':hidden') ? 'show' : 'hide'; // Set for toggle
328                return mode;
329        },
330
331        getBaseline: function(origin, original) { // Translates a [top,left] array into a baseline value
332                // this should be a little more flexible in the future to handle a string & hash
333                var y, x;
334                switch (origin[0]) {
335                        case 'top': y = 0; break;
336                        case 'middle': y = 0.5; break;
337                        case 'bottom': y = 1; break;
338                        default: y = origin[0] / original.height;
339                };
340                switch (origin[1]) {
341                        case 'left': x = 0; break;
342                        case 'center': x = 0.5; break;
343                        case 'right': x = 1; break;
344                        default: x = origin[1] / original.width;
345                };
346                return {x: x, y: y};
347        },
348
349        // Wraps the element around a wrapper that copies position properties
350        createWrapper: function(element) {
351
352                // if the element is already wrapped, return it
353                if (element.parent().is('.ui-effects-wrapper')) {
354                        return element.parent();
355                }
356
357                // wrap the element
358                var props = {
359                                width: element.outerWidth(true),
360                                height: element.outerHeight(true),
361                                'float': element.css('float')
362                        },
363                        wrapper = $('<div></div>')
364                                .addClass('ui-effects-wrapper')
365                                .css({
366                                        fontSize: '100%',
367                                        background: 'transparent',
368                                        border: 'none',
369                                        margin: 0,
370                                        padding: 0
371                                });
372
373                element.wrap(wrapper);
374                wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually loose the reference to the wrapped element
375
376                // transfer positioning properties to the wrapper
377                if (element.css('position') == 'static') {
378                        wrapper.css({ position: 'relative' });
379                        element.css({ position: 'relative' });
380                } else {
381                        $.extend(props, {
382                                position: element.css('position'),
383                                zIndex: element.css('z-index')
384                        });
385                        $.each(['top', 'left', 'bottom', 'right'], function(i, pos) {
386                                props[pos] = element.css(pos);
387                                if (isNaN(parseInt(props[pos], 10))) {
388                                        props[pos] = 'auto';
389                                }
390                        });
391                        element.css({position: 'relative', top: 0, left: 0, right: 'auto', bottom: 'auto' });
392                }
393
394                return wrapper.css(props).show();
395        },
396
397        removeWrapper: function(element) {
398                if (element.parent().is('.ui-effects-wrapper'))
399                        return element.parent().replaceWith(element);
400                return element;
401        },
402
403        setTransition: function(element, list, factor, value) {
404                value = value || {};
405                $.each(list, function(i, x){
406                        unit = element.cssUnit(x);
407                        if (unit[0] > 0) value[x] = unit[0] * factor + unit[1];
408                });
409                return value;
410        }
411});
412
413
414function _normalizeArguments(effect, options, speed, callback) {
415        // shift params for method overloading
416        if (typeof effect == 'object') {
417                callback = options;
418                speed = null;
419                options = effect;
420                effect = options.effect;
421        }
422        if ($.isFunction(options)) {
423                callback = options;
424                speed = null;
425                options = {};
426        }
427        if (typeof options == 'number' || $.fx.speeds[options]) {
428                callback = speed;
429                speed = options;
430                options = {};
431        }
432        if ($.isFunction(speed)) {
433                callback = speed;
434                speed = null;
435        }
436
437        options = options || {};
438
439        speed = speed || options.duration;
440        speed = $.fx.off ? 0 : typeof speed == 'number'
441                ? speed : speed in $.fx.speeds ? $.fx.speeds[speed] : $.fx.speeds._default;
442
443        callback = callback || options.complete;
444
445        return [effect, options, speed, callback];
446}
447
448function standardSpeed( speed ) {
449        // valid standard speeds
450        if ( !speed || typeof speed === "number" || $.fx.speeds[ speed ] ) {
451                return true;
452        }
453       
454        // invalid strings - treat as "normal" speed
455        if ( typeof speed === "string" && !$.effects[ speed ] ) {
456                return true;
457        }
458       
459        return false;
460}
461
462$.fn.extend({
463        effect: function(effect, options, speed, callback) {
464                var args = _normalizeArguments.apply(this, arguments),
465                        // TODO: make effects take actual parameters instead of a hash
466                        args2 = {
467                                options: args[1],
468                                duration: args[2],
469                                callback: args[3]
470                        },
471                        mode = args2.options.mode,
472                        effectMethod = $.effects[effect];
473               
474                if ( $.fx.off || !effectMethod ) {
475                        // delegate to the original method (e.g., .show()) if possible
476                        if ( mode ) {
477                                return this[ mode ]( args2.duration, args2.callback );
478                        } else {
479                                return this.each(function() {
480                                        if ( args2.callback ) {
481                                                args2.callback.call( this );
482                                        }
483                                });
484                        }
485                }
486               
487                return effectMethod.call(this, args2);
488        },
489
490        _show: $.fn.show,
491        show: function(speed) {
492                if ( standardSpeed( speed ) ) {
493                        return this._show.apply(this, arguments);
494                } else {
495                        var args = _normalizeArguments.apply(this, arguments);
496                        args[1].mode = 'show';
497                        return this.effect.apply(this, args);
498                }
499        },
500
501        _hide: $.fn.hide,
502        hide: function(speed) {
503                if ( standardSpeed( speed ) ) {
504                        return this._hide.apply(this, arguments);
505                } else {
506                        var args = _normalizeArguments.apply(this, arguments);
507                        args[1].mode = 'hide';
508                        return this.effect.apply(this, args);
509                }
510        },
511
512        // jQuery core overloads toggle and creates _toggle
513        __toggle: $.fn.toggle,
514        toggle: function(speed) {
515                if ( standardSpeed( speed ) || typeof speed === "boolean" || $.isFunction( speed ) ) {
516                        return this.__toggle.apply(this, arguments);
517                } else {
518                        var args = _normalizeArguments.apply(this, arguments);
519                        args[1].mode = 'toggle';
520                        return this.effect.apply(this, args);
521                }
522        },
523
524        // helper functions
525        cssUnit: function(key) {
526                var style = this.css(key), val = [];
527                $.each( ['em','px','%','pt'], function(i, unit){
528                        if(style.indexOf(unit) > 0)
529                                val = [parseFloat(style), unit];
530                });
531                return val;
532        }
533});
534
535
536
537/******************************************************************************/
538/*********************************** EASING ***********************************/
539/******************************************************************************/
540
541/*
542 * jQuery Easing v1.3 - http://gsgd.co.uk/sandbox/jquery/easing/
543 *
544 * Uses the built in easing capabilities added In jQuery 1.1
545 * to offer multiple easing options
546 *
547 * TERMS OF USE - jQuery Easing
548 *
549 * Open source under the BSD License.
550 *
551 * Copyright 2008 George McGinley Smith
552 * All rights reserved.
553 *
554 * Redistribution and use in source and binary forms, with or without modification,
555 * are permitted provided that the following conditions are met:
556 *
557 * Redistributions of source code must retain the above copyright notice, this list of
558 * conditions and the following disclaimer.
559 * Redistributions in binary form must reproduce the above copyright notice, this list
560 * of conditions and the following disclaimer in the documentation and/or other materials
561 * provided with the distribution.
562 *
563 * Neither the name of the author nor the names of contributors may be used to endorse
564 * or promote products derived from this software without specific prior written permission.
565 *
566 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
567 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
568 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
569 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
570 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
571 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
572 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
573 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
574 * OF THE POSSIBILITY OF SUCH DAMAGE.
575 *
576*/
577
578// t: current time, b: begInnIng value, c: change In value, d: duration
579$.easing.jswing = $.easing.swing;
580
581$.extend($.easing,
582{
583        def: 'easeOutQuad',
584        swing: function (x, t, b, c, d) {
585                //alert($.easing.default);
586                return $.easing[$.easing.def](x, t, b, c, d);
587        },
588        easeInQuad: function (x, t, b, c, d) {
589                return c*(t/=d)*t + b;
590        },
591        easeOutQuad: function (x, t, b, c, d) {
592                return -c *(t/=d)*(t-2) + b;
593        },
594        easeInOutQuad: function (x, t, b, c, d) {
595                if ((t/=d/2) < 1) return c/2*t*t + b;
596                return -c/2 * ((--t)*(t-2) - 1) + b;
597        },
598        easeInCubic: function (x, t, b, c, d) {
599                return c*(t/=d)*t*t + b;
600        },
601        easeOutCubic: function (x, t, b, c, d) {
602                return c*((t=t/d-1)*t*t + 1) + b;
603        },
604        easeInOutCubic: function (x, t, b, c, d) {
605                if ((t/=d/2) < 1) return c/2*t*t*t + b;
606                return c/2*((t-=2)*t*t + 2) + b;
607        },
608        easeInQuart: function (x, t, b, c, d) {
609                return c*(t/=d)*t*t*t + b;
610        },
611        easeOutQuart: function (x, t, b, c, d) {
612                return -c * ((t=t/d-1)*t*t*t - 1) + b;
613        },
614        easeInOutQuart: function (x, t, b, c, d) {
615                if ((t/=d/2) < 1) return c/2*t*t*t*t + b;
616                return -c/2 * ((t-=2)*t*t*t - 2) + b;
617        },
618        easeInQuint: function (x, t, b, c, d) {
619                return c*(t/=d)*t*t*t*t + b;
620        },
621        easeOutQuint: function (x, t, b, c, d) {
622                return c*((t=t/d-1)*t*t*t*t + 1) + b;
623        },
624        easeInOutQuint: function (x, t, b, c, d) {
625                if ((t/=d/2) < 1) return c/2*t*t*t*t*t + b;
626                return c/2*((t-=2)*t*t*t*t + 2) + b;
627        },
628        easeInSine: function (x, t, b, c, d) {
629                return -c * Math.cos(t/d * (Math.PI/2)) + c + b;
630        },
631        easeOutSine: function (x, t, b, c, d) {
632                return c * Math.sin(t/d * (Math.PI/2)) + b;
633        },
634        easeInOutSine: function (x, t, b, c, d) {
635                return -c/2 * (Math.cos(Math.PI*t/d) - 1) + b;
636        },
637        easeInExpo: function (x, t, b, c, d) {
638                return (t==0) ? b : c * Math.pow(2, 10 * (t/d - 1)) + b;
639        },
640        easeOutExpo: function (x, t, b, c, d) {
641                return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b;
642        },
643        easeInOutExpo: function (x, t, b, c, d) {
644                if (t==0) return b;
645                if (t==d) return b+c;
646                if ((t/=d/2) < 1) return c/2 * Math.pow(2, 10 * (t - 1)) + b;
647                return c/2 * (-Math.pow(2, -10 * --t) + 2) + b;
648        },
649        easeInCirc: function (x, t, b, c, d) {
650                return -c * (Math.sqrt(1 - (t/=d)*t) - 1) + b;
651        },
652        easeOutCirc: function (x, t, b, c, d) {
653                return c * Math.sqrt(1 - (t=t/d-1)*t) + b;
654        },
655        easeInOutCirc: function (x, t, b, c, d) {
656                if ((t/=d/2) < 1) return -c/2 * (Math.sqrt(1 - t*t) - 1) + b;
657                return c/2 * (Math.sqrt(1 - (t-=2)*t) + 1) + b;
658        },
659        easeInElastic: function (x, t, b, c, d) {
660                var s=1.70158;var p=0;var a=c;
661                if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
662                if (a < Math.abs(c)) { a=c; var s=p/4; }
663                else var s = p/(2*Math.PI) * Math.asin (c/a);
664                return -(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
665        },
666        easeOutElastic: function (x, t, b, c, d) {
667                var s=1.70158;var p=0;var a=c;
668                if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
669                if (a < Math.abs(c)) { a=c; var s=p/4; }
670                else var s = p/(2*Math.PI) * Math.asin (c/a);
671                return a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/p ) + c + b;
672        },
673        easeInOutElastic: function (x, t, b, c, d) {
674                var s=1.70158;var p=0;var a=c;
675                if (t==0) return b;  if ((t/=d/2)==2) return b+c;  if (!p) p=d*(.3*1.5);
676                if (a < Math.abs(c)) { a=c; var s=p/4; }
677                else var s = p/(2*Math.PI) * Math.asin (c/a);
678                if (t < 1) return -.5*(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
679                return a*Math.pow(2,-10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )*.5 + c + b;
680        },
681        easeInBack: function (x, t, b, c, d, s) {
682                if (s == undefined) s = 1.70158;
683                return c*(t/=d)*t*((s+1)*t - s) + b;
684        },
685        easeOutBack: function (x, t, b, c, d, s) {
686                if (s == undefined) s = 1.70158;
687                return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
688        },
689        easeInOutBack: function (x, t, b, c, d, s) {
690                if (s == undefined) s = 1.70158;
691                if ((t/=d/2) < 1) return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b;
692                return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b;
693        },
694        easeInBounce: function (x, t, b, c, d) {
695                return c - $.easing.easeOutBounce (x, d-t, 0, c, d) + b;
696        },
697        easeOutBounce: function (x, t, b, c, d) {
698                if ((t/=d) < (1/2.75)) {
699                        return c*(7.5625*t*t) + b;
700                } else if (t < (2/2.75)) {
701                        return c*(7.5625*(t-=(1.5/2.75))*t + .75) + b;
702                } else if (t < (2.5/2.75)) {
703                        return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b;
704                } else {
705                        return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b;
706                }
707        },
708        easeInOutBounce: function (x, t, b, c, d) {
709                if (t < d/2) return $.easing.easeInBounce (x, t*2, 0, c, d) * .5 + b;
710                return $.easing.easeOutBounce (x, t*2-d, 0, c, d) * .5 + c*.5 + b;
711        }
712});
713
714/*
715 *
716 * TERMS OF USE - EASING EQUATIONS
717 *
718 * Open source under the BSD License.
719 *
720 * Copyright 2001 Robert Penner
721 * All rights reserved.
722 *
723 * Redistribution and use in source and binary forms, with or without modification,
724 * are permitted provided that the following conditions are met:
725 *
726 * Redistributions of source code must retain the above copyright notice, this list of
727 * conditions and the following disclaimer.
728 * Redistributions in binary form must reproduce the above copyright notice, this list
729 * of conditions and the following disclaimer in the documentation and/or other materials
730 * provided with the distribution.
731 *
732 * Neither the name of the author nor the names of contributors may be used to endorse
733 * or promote products derived from this software without specific prior written permission.
734 *
735 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
736 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
737 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
738 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
739 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
740 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
741 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
742 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
743 * OF THE POSSIBILITY OF SUCH DAMAGE.
744 *
745 */
746
747})(jQuery);
Note: See TracBrowser for help on using the repository browser.