Upgrade to ExtJS 3.3.1 - Released 11/30/2010
[extjs.git] / 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>