Fixed the document.ready addEventListener issue.
[jquery.git] / fx / fx.js
1 // overwrite the old show method
2 jQuery.prototype._show = jQuery.prototype.show;
3
4 /**
5  * The effects module overloads the show method to now allow 
6  * for a speed to the show operation. What actually happens is 
7  * that the height, width, and opacity to the matched elements 
8  * are changed dynamically. The only three current speeds are 
9  * "slow", "normal", and "fast". For example:
10  *   $("p").show("slow");
11  * Note: You should not run the show method on things 
12  * that are already shown. This can be circumvented by doing this:
13  *   $("p:hidden").show("slow");
14  */
15 jQuery.prototype.show = function(speed,callback){
16         return speed ? this.animate({
17                 height: "show", width: "show", opacity: "show"
18         }, speed, callback) : this._show();
19 };
20
21 // We're overwriting the old hide method
22 jQuery.prototype._hide = jQuery.prototype.hide;
23
24
25 /**
26  * The hide function behaves very similary to the show function, 
27  * but is just the opposite.
28  *   $("p:visible").hide("slow");
29  */
30 jQuery.prototype.hide = function(speed,callback){
31         return speed ? this.animate({
32                 height: "hide",
33                 width: "hide",
34                 opacity: "hide"
35         }, speed, callback) : this._hide();
36 };
37
38 /**
39  * This function increases the height and opacity for all matched 
40  * elements. This is very similar to 'show', but does not change 
41  * the width - creating a neat sliding effect.
42  *   $("p:hidden").slideDown("slow");
43  */
44 jQuery.prototype.slideDown = function(speed,callback){
45         return this.animate({height: "show"}, speed, callback);
46 };
47
48 /**
49  * Just like slideDown, only it hides all matched elements.
50  *   $("p:visible").slideUp("slow");
51  */
52 jQuery.prototype.slideUp = function(speed,callback){
53         return this.animate({height: "hide"}, speed, callback);
54 };
55
56 /**
57  * Adjusts the opacity of all matched elements from a hidden, 
58  * to a fully visible, state.
59  *   $("p:hidden").fadeIn("slow");
60  */
61 jQuery.prototype.fadeIn = function(speed,callback){
62         return this.animate({opacity: "show"}, speed, callback);
63 };
64
65 /**
66  * Same as fadeIn, but transitions from a visible, to a hidden state.
67  *   $("p:visible").fadeOut("slow");
68  */
69 jQuery.prototype.fadeOut = function(speed,callback){
70         return this.animate({opacity: "hide"}, speed, callback);
71 };
72
73 /**
74  * ...
75  */
76 jQuery.prototype.fadeTo = function(speed,to,callback){
77         return this.animate({opacity: to}, speed, callback);
78 };
79
80 /**
81  *
82  */
83 jQuery.prototype.animate = function(prop,speed,callback) {
84         return this.queue(function(){
85                 var i = 0;
86                 for ( var p in prop ) {
87                         var e = new jQuery.fx( this, jQuery.speed(speed,callback,i++), p );
88                         if ( prop[p].constructor == Number )
89                                 e.custom( e.cur(), prop[p] );
90                         else
91                                 e[ prop[p] ]();
92                 }
93         });
94 };
95
96 jQuery.speed = function(s,o,i) {
97         o = o || {};
98         
99         if ( o.constructor == Function )
100                 o = { complete: o };
101         
102         var ss = {"slow":600,"fast":200};
103         o.duration = (s && s.constructor == Number ? s : ss[s]) || 400;
104
105         // Queueing
106         o.oldComplete = o.complete;
107         o.complete = function(){
108                 jQuery.dequeue(this, "fx");
109                 if ( o.oldComplete && o.oldComplete.constructor == Function )
110                         o.oldComplete.apply( this );
111         };
112         
113         if ( i > 0 )
114                 o.complete = null;
115
116         return o;
117 };
118
119 jQuery.queue = {};
120
121 jQuery.dequeue = function(elem,type){
122         type = type || "fx";
123
124         if ( elem.queue && elem.queue[type] ) {
125                 // Remove self
126                 elem.queue[type].shift();
127
128                 // Get next function
129                 var f = elem.queue[type][0];
130         
131                 if ( f )
132                         f.apply( elem );
133         }
134 };
135
136 jQuery.prototype.queue = function(type,fn){
137         if ( !fn ) {
138                 fn = type;
139                 type = "fx";
140         }
141
142         return this.each(function(){
143                 if ( !this.queue )
144                         this.queue = {};
145
146                 if ( !this.queue[type] )
147                         this.queue[type] = [];
148
149                 this.queue[type].push( fn );
150         
151                 if ( this.queue[type].length == 1 )
152                         fn.apply(this);
153         });
154 };
155
156 jQuery.setAuto = function(e,p) {
157         var a = e.style[p];
158         var o = jQuery.css(e,p);
159         e.style[p] = "auto";
160         var n = jQuery.css(e,p);
161         if ( o != n )
162                 e.style[p] = a;
163 };
164
165 /*
166  * I originally wrote fx() as a clone of moo.fx and in the process
167  * of making it small in size the code became illegible to sane
168  * people. You've been warned.
169  */
170
171 jQuery.fx = function( elem, options, prop ){
172
173         var z = this;
174
175         // The users options
176         z.o = {
177                 duration: options.duration || 400,
178                 complete: options.complete
179         };
180
181         // The element
182         z.el = elem;
183
184         // The styles
185         var y = z.el.style;
186
187         // Simple function for setting a style value
188         z.a = function(){
189                 if ( prop == "opacity" ) {
190                         if (z.now == 1) z.now = 0.9999;
191                         if (window.ActiveXObject)
192                                 y.filter = "alpha(opacity=" + z.now*100 + ")";
193                         y.opacity = z.now;
194                 } else
195                         y[prop] = z.now+"px";
196         };
197
198         // Figure out the maximum number to run to
199         z.max = function(){
200                 return z.el["orig"+prop] || z.cur();
201         };
202
203         // Get the current size
204         z.cur = function(){
205                 return parseFloat( jQuery.css(z.el,prop) );
206         };
207
208         // Start an animation from one number to another
209         z.custom = function(from,to){
210                 z.startTime = (new Date()).getTime();
211                 z.now = from;
212                 z.a();
213
214                 z.timer = setInterval(function(){
215                         z.step(from, to);
216                 }, 13);
217         };
218
219         // Simple 'show' function
220         z.show = function(){
221                 y.display = "block";
222                 z.o.auto = true;
223                 z.custom(0,z.max());
224         };
225
226         // Simple 'hide' function
227         z.hide = function(){
228                 // Remember where we started, so that we can go back to it later
229                 z.el["orig"+prop] = this.cur();
230
231                 // Begin the animation
232                 z.custom(z.cur(),0);
233         };
234
235         // IE has trouble with opacity if it doesn't have layout
236         if ( jQuery.browser == "msie" && !z.el.currentStyle.hasLayout )
237                 y.zoom = 1;
238
239         // Remember  the overflow of the element
240         z.oldOverflow = y.overflow;
241
242         // Make sure that nothing sneaks out
243         y.overflow = "hidden";
244
245         // Each step of an animation
246         z.step = function(firstNum, lastNum){
247                 var t = (new Date()).getTime();
248
249                 if (t > z.o.duration + z.startTime) {
250                         // Stop the timer
251                         clearInterval(z.timer);
252                         z.timer = null;
253
254                         z.now = lastNum;
255                         z.a();
256
257                         // Reset the overflow
258                         y.overflow = z.oldOverflow;
259
260                         // If the element was shown, and not using a custom number,
261                         // set its height and/or width to auto
262                         if ( (prop == "height" || prop == "width") && z.o.auto )
263                                 jQuery.setAuto( z.el, prop );
264
265                         // If a callback was provided, execute it
266                         if( z.o.complete && z.o.complete.constructor == Function ) {
267
268                                 // Yes, this is a weird place for this, but it needs to be executed
269                                 // only once per cluster of effects.
270                                 // If the element is, effectively, hidden - hide it
271                                 if ( y.height == "0px" || y.width == "0px" )
272                                         y.display = "none";
273
274                                 // Execute the complete function
275                                 z.o.complete.apply( z.el );
276                         }
277                 } else {
278                         // Figure out where in the animation we are and set the number
279                         var p = (t - this.startTime) / z.o.duration;
280                         z.now = ((-Math.cos(p*Math.PI)/2) + 0.5) * (lastNum-firstNum) + firstNum;
281
282                         // Perform the next step of the animation
283                         z.a();
284                 }
285         };
286
287 };