docs/source/ext-base-anim-extra.html

   1 <html>
   2 <head>
   3   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   4   <title>The source code</title>
   5     <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
   6     <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
   7 </head>
   8 <body  onload="prettyPrint();">
   9     <pre class="prettyprint lang-js">/*!
  10  * Ext JS Library 3.3.1
  11  * Copyright(c) 2006-2010 Sencha Inc.
  12  * licensing@sencha.com
  13  * http://www.sencha.com/license
  14  */
  15 // Easing functions
  16 (function(){
  17     // shortcuts to aid compression
  18     var abs = Math.abs,
  19         pi = Math.PI,
  20         asin = Math.asin,
  21         pow = Math.pow,
  22         sin = Math.sin,
  23         EXTLIB = Ext.lib;
  24
  25     Ext.apply(EXTLIB.Easing, {
  26
  27         easeBoth: function (t, b, c, d) {
  28             return ((t /= d / 2) < 1)  ?  c / 2 * t * t + b  :  -c / 2 * ((--t) * (t - 2) - 1) + b;
  29         },
  30
  31         easeInStrong: function (t, b, c, d) {
  32             return c * (t /= d) * t * t * t + b;
  33         },
  34
  35         easeOutStrong: function (t, b, c, d) {
  36             return -c * ((t = t / d - 1) * t * t * t - 1) + b;
  37         },
  38
  39         easeBothStrong: function (t, b, c, d) {
  40             return ((t /= d / 2) < 1)  ?  c / 2 * t * t * t * t + b  :  -c / 2 * ((t -= 2) * t * t * t - 2) + b;
  41         },
  42
  43         elasticIn: function (t, b, c, d, a, p) {
  44             if (t == 0 || (t /= d) == 1) {
  45                 return t == 0 ? b : b + c;
  46             }
  47             p = p || (d * .3);
  48
  49             var s;
  50             if (a >= abs(c)) {
  51                 s = p / (2 * pi) * asin(c / a);
  52             } else {
  53                 a = c;
  54                 s = p / 4;
  55             }
  56
  57             return -(a * pow(2, 10 * (t -= 1)) * sin((t * d - s) * (2 * pi) / p)) + b;
  58
  59         },
  60
  61         elasticOut: function (t, b, c, d, a, p) {
  62             if (t == 0 || (t /= d) == 1) {
  63                 return t == 0 ? b : b + c;
  64             }
  65             p = p || (d * .3);
  66
  67             var s;
  68             if (a >= abs(c)) {
  69                 s = p / (2 * pi) * asin(c / a);
  70             } else {
  71                 a = c;
  72                 s = p / 4;
  73             }
  74
  75             return a * pow(2, -10 * t) * sin((t * d - s) * (2 * pi) / p) + c + b;
  76         },
  77
  78         elasticBoth: function (t, b, c, d, a, p) {
  79             if (t == 0 || (t /= d / 2) == 2) {
  80                 return t == 0 ? b : b + c;
  81             }
  82
  83             p = p || (d * (.3 * 1.5));
  84
  85             var s;
  86             if (a >= abs(c)) {
  87                 s = p / (2 * pi) * asin(c / a);
  88             } else {
  89                 a = c;
  90                 s = p / 4;
  91             }
  92
  93             return t < 1 ?
  94                     -.5 * (a * pow(2, 10 * (t -= 1)) * sin((t * d - s) * (2 * pi) / p)) + b :
  95                     a * pow(2, -10 * (t -= 1)) * sin((t * d - s) * (2 * pi) / p) * .5 + c + b;
  96         },
  97
  98         backIn: function (t, b, c, d, s) {
  99             s = s ||  1.70158;
 100             return c * (t /= d) * t * ((s + 1) * t - s) + b;
 101         },
 102
 103
 104         backOut: function (t, b, c, d, s) {
 105             if (!s) {
 106                 s = 1.70158;
 107             }
 108             return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;
 109         },
 110
 111
 112         backBoth: function (t, b, c, d, s) {
 113             s = s || 1.70158;
 114
 115             return ((t /= d / 2 ) < 1) ?
 116                     c / 2 * (t * t * (((s *= (1.525)) + 1) * t - s)) + b :
 117                     c / 2 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2) + b;
 118         },
 119
 120
 121         bounceIn: function (t, b, c, d) {
 122             return c - EXTLIB.Easing.bounceOut(d - t, 0, c, d) + b;
 123         },
 124
 125
 126         bounceOut: function (t, b, c, d) {
 127         if ((t /= d) < (1 / 2.75)) {
 128                 return c * (7.5625 * t * t) + b;
 129             } else if (t < (2 / 2.75)) {
 130                 return c * (7.5625 * (t -= (1.5 / 2.75)) * t + .75) + b;
 131             } else if (t < (2.5 / 2.75)) {
 132                 return c * (7.5625 * (t -= (2.25 / 2.75)) * t + .9375) + b;
 133             }
 134             return c * (7.5625 * (t -= (2.625 / 2.75)) * t + .984375) + b;
 135         },
 136
 137
 138         bounceBoth: function (t, b, c, d) {
 139             return (t < d / 2) ?
 140                     EXTLIB.Easing.bounceIn(t * 2, 0, c, d) * .5 + b :
 141                     EXTLIB.Easing.bounceOut(t * 2 - d, 0, c, d) * .5 + c * .5 + b;
 142         }
 143     });
 144 })();
 145
 146 (function() {
 147     var EXTLIB = Ext.lib;
 148     // Color Animation
 149     EXTLIB.Anim.color = function(el, args, duration, easing, cb, scope) {
 150         return EXTLIB.Anim.run(el, args, duration, easing, cb, scope, EXTLIB.ColorAnim);
 151     };
 152
 153     EXTLIB.ColorAnim = function(el, attributes, duration, method) {
 154         EXTLIB.ColorAnim.superclass.constructor.call(this, el, attributes, duration, method);
 155     };
 156
 157     Ext.extend(EXTLIB.ColorAnim, EXTLIB.AnimBase);
 158
 159     var superclass = EXTLIB.ColorAnim.superclass,
 160         colorRE = /color$/i,
 161         transparentRE = /^transparent|rgba\(0, 0, 0, 0\)$/,
 162         rgbRE = /^rgb\(([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\)$/i,
 163         hexRE= /^#?([0-9A-F]{2})([0-9A-F]{2})([0-9A-F]{2})$/i,
 164         hex3RE = /^#?([0-9A-F]{1})([0-9A-F]{1})([0-9A-F]{1})$/i,
 165         isset = function(v){
 166             return typeof v !== 'undefined';
 167         };
 168
 169     // private
 170     function parseColor(s) {
 171         var pi = parseInt,
 172             base,
 173             out = null,
 174             c;
 175
 176         if (s.length == 3) {
 177             return s;
 178         }
 179
 180         Ext.each([hexRE, rgbRE, hex3RE], function(re, idx){
 181             base = (idx % 2 == 0) ? 16 : 10;
 182             c = re.exec(s);
 183             if(c && c.length == 4){
 184                 out = [pi(c[1], base), pi(c[2], base), pi(c[3], base)];
 185                 return false;
 186             }
 187         });
 188         return out;
 189     }
 190
 191     Ext.apply(EXTLIB.ColorAnim.prototype, {
 192         getAttr : function(attr) {
 193             var me = this,
 194                 el = me.el,
 195                 val;
 196             if(colorRE.test(attr)){
 197                 while(el && transparentRE.test(val = Ext.fly(el).getStyle(attr))){
 198                     el = el.parentNode;
 199                     val = "fff";
 200                 }
 201             }else{
 202                 val = superclass.getAttr.call(me, attr);
 203             }
 204             return val;
 205         },
 206
 207         doMethod : function(attr, start, end) {
 208             var me = this,
 209                 val,
 210                 floor = Math.floor,
 211                 i,
 212                 len,
 213                 v;
 214
 215             if(colorRE.test(attr)){
 216                 val = [];
 217                 end = end || [];
 218
 219                 for(i = 0, len = start.length; i < len; i++) {
 220                     v = start[i];
 221                     val[i] = superclass.doMethod.call(me, attr, v, end[i]);
 222                 }
 223                 val = 'rgb(' + floor(val[0]) + ',' + floor(val[1]) + ',' + floor(val[2]) + ')';
 224             }else{
 225                 val = superclass.doMethod.call(me, attr, start, end);
 226             }
 227             return val;
 228         },
 229
 230         setRunAttr : function(attr) {
 231             var me = this,
 232                 a = me.attributes[attr],
 233                 to = a.to,
 234                 by = a.by,
 235                 ra;
 236
 237             superclass.setRunAttr.call(me, attr);
 238             ra = me.runAttrs[attr];
 239             if(colorRE.test(attr)){
 240                 var start = parseColor(ra.start),
 241                     end = parseColor(ra.end);
 242
 243                 if(!isset(to) && isset(by)){
 244                     end = parseColor(by);
 245                     for(var i=0,len=start.length; i<len; i++) {
 246                         end[i] = start[i] + end[i];
 247                     }
 248                 }
 249                 ra.start = start;
 250                 ra.end = end;
 251             }
 252         }
 253     });
 254 })();
 255
 256
 257 (function() {
 258     // Scroll Animation
 259     var EXTLIB = Ext.lib;
 260     EXTLIB.Anim.scroll = function(el, args, duration, easing, cb, scope) {
 261         return EXTLIB.Anim.run(el, args, duration, easing, cb, scope, EXTLIB.Scroll);
 262     };
 263
 264     EXTLIB.Scroll = function(el, attributes, duration, method) {
 265         if(el){
 266             EXTLIB.Scroll.superclass.constructor.call(this, el, attributes, duration, method);
 267         }
 268     };
 269
 270     Ext.extend(EXTLIB.Scroll, EXTLIB.ColorAnim);
 271
 272     var superclass = EXTLIB.Scroll.superclass,
 273         SCROLL = 'scroll';
 274
 275     Ext.apply(EXTLIB.Scroll.prototype, {
 276
 277         doMethod : function(attr, start, end) {
 278             var val,
 279                 me = this,
 280                 curFrame = me.curFrame,
 281                 totalFrames = me.totalFrames;
 282
 283             if(attr == SCROLL){
 284                 val = [me.method(curFrame, start[0], end[0] - start[0], totalFrames),
 285                        me.method(curFrame, start[1], end[1] - start[1], totalFrames)];
 286             }else{
 287                 val = superclass.doMethod.call(me, attr, start, end);
 288             }
 289             return val;
 290         },
 291
 292         getAttr : function(attr) {
 293             var me = this;
 294
 295             if (attr == SCROLL) {
 296                 return [me.el.scrollLeft, me.el.scrollTop];
 297             }else{
 298                 return superclass.getAttr.call(me, attr);
 299             }
 300         },
 301
 302         setAttr : function(attr, val, unit) {
 303             var me = this;
 304
 305             if(attr == SCROLL){
 306                 me.el.scrollLeft = val[0];
 307                 me.el.scrollTop = val[1];
 308             }else{
 309                 superclass.setAttr.call(me, attr, val, unit);
 310             }
 311         }
 312     });
 313 })();</pre>
 314 </body>
 315 </html>