]> git.openstreetmap.org Git - rails.git/blob - public/javascripts/effects.js
Remove NearMap from Potlatch options
[rails.git] / public / javascripts / effects.js
1 // Copyright (c) 2005-2008 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
2 // Contributors:
3 //  Justin Palmer (http://encytemedia.com/)
4 //  Mark Pilgrim (http://diveintomark.org/)
5 //  Martin Bialasinki
6 //
7 // script.aculo.us is freely distributable under the terms of an MIT-style license.
8 // For details, see the script.aculo.us web site: http://script.aculo.us/
9
10 // converts rgb() and #xxx to #xxxxxx format,
11 // returns self (or first argument) if not convertable
12 String.prototype.parseColor = function() {
13   var color = '#';
14   if (this.slice(0,4) == 'rgb(') {
15     var cols = this.slice(4,this.length-1).split(',');
16     var i=0; do { color += parseInt(cols[i]).toColorPart() } while (++i<3);
17   } else {
18     if (this.slice(0,1) == '#') {
19       if (this.length==4) for(var i=1;i<4;i++) color += (this.charAt(i) + this.charAt(i)).toLowerCase();
20       if (this.length==7) color = this.toLowerCase();
21     }
22   }
23   return (color.length==7 ? color : (arguments[0] || this));
24 };
25
26 /*--------------------------------------------------------------------------*/
27
28 Element.collectTextNodes = function(element) {
29   return $A($(element).childNodes).collect( function(node) {
30     return (node.nodeType==3 ? node.nodeValue :
31       (node.hasChildNodes() ? Element.collectTextNodes(node) : ''));
32   }).flatten().join('');
33 };
34
35 Element.collectTextNodesIgnoreClass = function(element, className) {
36   return $A($(element).childNodes).collect( function(node) {
37     return (node.nodeType==3 ? node.nodeValue :
38       ((node.hasChildNodes() && !Element.hasClassName(node,className)) ?
39         Element.collectTextNodesIgnoreClass(node, className) : ''));
40   }).flatten().join('');
41 };
42
43 Element.setContentZoom = function(element, percent) {
44   element = $(element);
45   element.setStyle({fontSize: (percent/100) + 'em'});
46   if (Prototype.Browser.WebKit) window.scrollBy(0,0);
47   return element;
48 };
49
50 Element.getInlineOpacity = function(element){
51   return $(element).style.opacity || '';
52 };
53
54 Element.forceRerendering = function(element) {
55   try {
56     element = $(element);
57     var n = document.createTextNode(' ');
58     element.appendChild(n);
59     element.removeChild(n);
60   } catch(e) { }
61 };
62
63 /*--------------------------------------------------------------------------*/
64
65 var Effect = {
66   _elementDoesNotExistError: {
67     name: 'ElementDoesNotExistError',
68     message: 'The specified DOM element does not exist, but is required for this effect to operate'
69   },
70   Transitions: {
71     linear: Prototype.K,
72     sinoidal: function(pos) {
73       return (-Math.cos(pos*Math.PI)/2) + .5;
74     },
75     reverse: function(pos) {
76       return 1-pos;
77     },
78     flicker: function(pos) {
79       var pos = ((-Math.cos(pos*Math.PI)/4) + .75) + Math.random()/4;
80       return pos > 1 ? 1 : pos;
81     },
82     wobble: function(pos) {
83       return (-Math.cos(pos*Math.PI*(9*pos))/2) + .5;
84     },
85     pulse: function(pos, pulses) {
86       return (-Math.cos((pos*((pulses||5)-.5)*2)*Math.PI)/2) + .5;
87     },
88     spring: function(pos) {
89       return 1 - (Math.cos(pos * 4.5 * Math.PI) * Math.exp(-pos * 6));
90     },
91     none: function(pos) {
92       return 0;
93     },
94     full: function(pos) {
95       return 1;
96     }
97   },
98   DefaultOptions: {
99     duration:   1.0,   // seconds
100     fps:        100,   // 100= assume 66fps max.
101     sync:       false, // true for combining
102     from:       0.0,
103     to:         1.0,
104     delay:      0.0,
105     queue:      'parallel'
106   },
107   tagifyText: function(element) {
108     var tagifyStyle = 'position:relative';
109     if (Prototype.Browser.IE) tagifyStyle += ';zoom:1';
110
111     element = $(element);
112     $A(element.childNodes).each( function(child) {
113       if (child.nodeType==3) {
114         child.nodeValue.toArray().each( function(character) {
115           element.insertBefore(
116             new Element('span', {style: tagifyStyle}).update(
117               character == ' ' ? String.fromCharCode(160) : character),
118               child);
119         });
120         Element.remove(child);
121       }
122     });
123   },
124   multiple: function(element, effect) {
125     var elements;
126     if (((typeof element == 'object') ||
127         Object.isFunction(element)) &&
128        (element.length))
129       elements = element;
130     else
131       elements = $(element).childNodes;
132
133     var options = Object.extend({
134       speed: 0.1,
135       delay: 0.0
136     }, arguments[2] || { });
137     var masterDelay = options.delay;
138
139     $A(elements).each( function(element, index) {
140       new effect(element, Object.extend(options, { delay: index * options.speed + masterDelay }));
141     });
142   },
143   PAIRS: {
144     'slide':  ['SlideDown','SlideUp'],
145     'blind':  ['BlindDown','BlindUp'],
146     'appear': ['Appear','Fade']
147   },
148   toggle: function(element, effect) {
149     element = $(element);
150     effect = (effect || 'appear').toLowerCase();
151     var options = Object.extend({
152       queue: { position:'end', scope:(element.id || 'global'), limit: 1 }
153     }, arguments[2] || { });
154     Effect[element.visible() ?
155       Effect.PAIRS[effect][1] : Effect.PAIRS[effect][0]](element, options);
156   }
157 };
158
159 Effect.DefaultOptions.transition = Effect.Transitions.sinoidal;
160
161 /* ------------- core effects ------------- */
162
163 Effect.ScopedQueue = Class.create(Enumerable, {
164   initialize: function() {
165     this.effects  = [];
166     this.interval = null;
167   },
168   _each: function(iterator) {
169     this.effects._each(iterator);
170   },
171   add: function(effect) {
172     var timestamp = new Date().getTime();
173
174     var position = Object.isString(effect.options.queue) ?
175       effect.options.queue : effect.options.queue.position;
176
177     switch(position) {
178       case 'front':
179         // move unstarted effects after this effect
180         this.effects.findAll(function(e){ return e.state=='idle' }).each( function(e) {
181             e.startOn  += effect.finishOn;
182             e.finishOn += effect.finishOn;
183           });
184         break;
185       case 'with-last':
186         timestamp = this.effects.pluck('startOn').max() || timestamp;
187         break;
188       case 'end':
189         // start effect after last queued effect has finished
190         timestamp = this.effects.pluck('finishOn').max() || timestamp;
191         break;
192     }
193
194     effect.startOn  += timestamp;
195     effect.finishOn += timestamp;
196
197     if (!effect.options.queue.limit || (this.effects.length < effect.options.queue.limit))
198       this.effects.push(effect);
199
200     if (!this.interval)
201       this.interval = setInterval(this.loop.bind(this), 15);
202   },
203   remove: function(effect) {
204     this.effects = this.effects.reject(function(e) { return e==effect });
205     if (this.effects.length == 0) {
206       clearInterval(this.interval);
207       this.interval = null;
208     }
209   },
210   loop: function() {
211     var timePos = new Date().getTime();
212     for(var i=0, len=this.effects.length;i<len;i++)
213       this.effects[i] && this.effects[i].loop(timePos);
214   }
215 });
216
217 Effect.Queues = {
218   instances: $H(),
219   get: function(queueName) {
220     if (!Object.isString(queueName)) return queueName;
221
222     return this.instances.get(queueName) ||
223       this.instances.set(queueName, new Effect.ScopedQueue());
224   }
225 };
226 Effect.Queue = Effect.Queues.get('global');
227
228 Effect.Base = Class.create({
229   position: null,
230   start: function(options) {
231     function codeForEvent(options,eventName){
232       return (
233         (options[eventName+'Internal'] ? 'this.options.'+eventName+'Internal(this);' : '') +
234         (options[eventName] ? 'this.options.'+eventName+'(this);' : '')
235       );
236     }
237     if (options && options.transition === false) options.transition = Effect.Transitions.linear;
238     this.options      = Object.extend(Object.extend({ },Effect.DefaultOptions), options || { });
239     this.currentFrame = 0;
240     this.state        = 'idle';
241     this.startOn      = this.options.delay*1000;
242     this.finishOn     = this.startOn+(this.options.duration*1000);
243     this.fromToDelta  = this.options.to-this.options.from;
244     this.totalTime    = this.finishOn-this.startOn;
245     this.totalFrames  = this.options.fps*this.options.duration;
246
247     this.render = (function() {
248       function dispatch(effect, eventName) {
249         if (effect.options[eventName + 'Internal'])
250           effect.options[eventName + 'Internal'](effect);
251         if (effect.options[eventName])
252           effect.options[eventName](effect);
253       }
254
255       return function(pos) {
256         if (this.state === "idle") {
257           this.state = "running";
258           dispatch(this, 'beforeSetup');
259           if (this.setup) this.setup();
260           dispatch(this, 'afterSetup');
261         }
262         if (this.state === "running") {
263           pos = (this.options.transition(pos) * this.fromToDelta) + this.options.from;
264           this.position = pos;
265           dispatch(this, 'beforeUpdate');
266           if (this.update) this.update(pos);
267           dispatch(this, 'afterUpdate');
268         }
269       };
270     })();
271
272     this.event('beforeStart');
273     if (!this.options.sync)
274       Effect.Queues.get(Object.isString(this.options.queue) ?
275         'global' : this.options.queue.scope).add(this);
276   },
277   loop: function(timePos) {
278     if (timePos >= this.startOn) {
279       if (timePos >= this.finishOn) {
280         this.render(1.0);
281         this.cancel();
282         this.event('beforeFinish');
283         if (this.finish) this.finish();
284         this.event('afterFinish');
285         return;
286       }
287       var pos   = (timePos - this.startOn) / this.totalTime,
288           frame = (pos * this.totalFrames).round();
289       if (frame > this.currentFrame) {
290         this.render(pos);
291         this.currentFrame = frame;
292       }
293     }
294   },
295   cancel: function() {
296     if (!this.options.sync)
297       Effect.Queues.get(Object.isString(this.options.queue) ?
298         'global' : this.options.queue.scope).remove(this);
299     this.state = 'finished';
300   },
301   event: function(eventName) {
302     if (this.options[eventName + 'Internal']) this.options[eventName + 'Internal'](this);
303     if (this.options[eventName]) this.options[eventName](this);
304   },
305   inspect: function() {
306     var data = $H();
307     for(property in this)
308       if (!Object.isFunction(this[property])) data.set(property, this[property]);
309     return '#<Effect:' + data.inspect() + ',options:' + $H(this.options).inspect() + '>';
310   }
311 });
312
313 Effect.Parallel = Class.create(Effect.Base, {
314   initialize: function(effects) {
315     this.effects = effects || [];
316     this.start(arguments[1]);
317   },
318   update: function(position) {
319     this.effects.invoke('render', position);
320   },
321   finish: function(position) {
322     this.effects.each( function(effect) {
323       effect.render(1.0);
324       effect.cancel();
325       effect.event('beforeFinish');
326       if (effect.finish) effect.finish(position);
327       effect.event('afterFinish');
328     });
329   }
330 });
331
332 Effect.Tween = Class.create(Effect.Base, {
333   initialize: function(object, from, to) {
334     object = Object.isString(object) ? $(object) : object;
335     var args = $A(arguments), method = args.last(),
336       options = args.length == 5 ? args[3] : null;
337     this.method = Object.isFunction(method) ? method.bind(object) :
338       Object.isFunction(object[method]) ? object[method].bind(object) :
339       function(value) { object[method] = value };
340     this.start(Object.extend({ from: from, to: to }, options || { }));
341   },
342   update: function(position) {
343     this.method(position);
344   }
345 });
346
347 Effect.Event = Class.create(Effect.Base, {
348   initialize: function() {
349     this.start(Object.extend({ duration: 0 }, arguments[0] || { }));
350   },
351   update: Prototype.emptyFunction
352 });
353
354 Effect.Opacity = Class.create(Effect.Base, {
355   initialize: function(element) {
356     this.element = $(element);
357     if (!this.element) throw(Effect._elementDoesNotExistError);
358     // make this work on IE on elements without 'layout'
359     if (Prototype.Browser.IE && (!this.element.currentStyle.hasLayout))
360       this.element.setStyle({zoom: 1});
361     var options = Object.extend({
362       from: this.element.getOpacity() || 0.0,
363       to:   1.0
364     }, arguments[1] || { });
365     this.start(options);
366   },
367   update: function(position) {
368     this.element.setOpacity(position);
369   }
370 });
371
372 Effect.Move = Class.create(Effect.Base, {
373   initialize: function(element) {
374     this.element = $(element);
375     if (!this.element) throw(Effect._elementDoesNotExistError);
376     var options = Object.extend({
377       x:    0,
378       y:    0,
379       mode: 'relative'
380     }, arguments[1] || { });
381     this.start(options);
382   },
383   setup: function() {
384     this.element.makePositioned();
385     this.originalLeft = parseFloat(this.element.getStyle('left') || '0');
386     this.originalTop  = parseFloat(this.element.getStyle('top')  || '0');
387     if (this.options.mode == 'absolute') {
388       this.options.x = this.options.x - this.originalLeft;
389       this.options.y = this.options.y - this.originalTop;
390     }
391   },
392   update: function(position) {
393     this.element.setStyle({
394       left: (this.options.x  * position + this.originalLeft).round() + 'px',
395       top:  (this.options.y  * position + this.originalTop).round()  + 'px'
396     });
397   }
398 });
399
400 // for backwards compatibility
401 Effect.MoveBy = function(element, toTop, toLeft) {
402   return new Effect.Move(element,
403     Object.extend({ x: toLeft, y: toTop }, arguments[3] || { }));
404 };
405
406 Effect.Scale = Class.create(Effect.Base, {
407   initialize: function(element, percent) {
408     this.element = $(element);
409     if (!this.element) throw(Effect._elementDoesNotExistError);
410     var options = Object.extend({
411       scaleX: true,
412       scaleY: true,
413       scaleContent: true,
414       scaleFromCenter: false,
415       scaleMode: 'box',        // 'box' or 'contents' or { } with provided values
416       scaleFrom: 100.0,
417       scaleTo:   percent
418     }, arguments[2] || { });
419     this.start(options);
420   },
421   setup: function() {
422     this.restoreAfterFinish = this.options.restoreAfterFinish || false;
423     this.elementPositioning = this.element.getStyle('position');
424
425     this.originalStyle = { };
426     ['top','left','width','height','fontSize'].each( function(k) {
427       this.originalStyle[k] = this.element.style[k];
428     }.bind(this));
429
430     this.originalTop  = this.element.offsetTop;
431     this.originalLeft = this.element.offsetLeft;
432
433     var fontSize = this.element.getStyle('font-size') || '100%';
434     ['em','px','%','pt'].each( function(fontSizeType) {
435       if (fontSize.indexOf(fontSizeType)>0) {
436         this.fontSize     = parseFloat(fontSize);
437         this.fontSizeType = fontSizeType;
438       }
439     }.bind(this));
440
441     this.factor = (this.options.scaleTo - this.options.scaleFrom)/100;
442
443     this.dims = null;
444     if (this.options.scaleMode=='box')
445       this.dims = [this.element.offsetHeight, this.element.offsetWidth];
446     if (/^content/.test(this.options.scaleMode))
447       this.dims = [this.element.scrollHeight, this.element.scrollWidth];
448     if (!this.dims)
449       this.dims = [this.options.scaleMode.originalHeight,
450                    this.options.scaleMode.originalWidth];
451   },
452   update: function(position) {
453     var currentScale = (this.options.scaleFrom/100.0) + (this.factor * position);
454     if (this.options.scaleContent && this.fontSize)
455       this.element.setStyle({fontSize: this.fontSize * currentScale + this.fontSizeType });
456     this.setDimensions(this.dims[0] * currentScale, this.dims[1] * currentScale);
457   },
458   finish: function(position) {
459     if (this.restoreAfterFinish) this.element.setStyle(this.originalStyle);
460   },
461   setDimensions: function(height, width) {
462     var d = { };
463     if (this.options.scaleX) d.width = width.round() + 'px';
464     if (this.options.scaleY) d.height = height.round() + 'px';
465     if (this.options.scaleFromCenter) {
466       var topd  = (height - this.dims[0])/2;
467       var leftd = (width  - this.dims[1])/2;
468       if (this.elementPositioning == 'absolute') {
469         if (this.options.scaleY) d.top = this.originalTop-topd + 'px';
470         if (this.options.scaleX) d.left = this.originalLeft-leftd + 'px';
471       } else {
472         if (this.options.scaleY) d.top = -topd + 'px';
473         if (this.options.scaleX) d.left = -leftd + 'px';
474       }
475     }
476     this.element.setStyle(d);
477   }
478 });
479
480 Effect.Highlight = Class.create(Effect.Base, {
481   initialize: function(element) {
482     this.element = $(element);
483     if (!this.element) throw(Effect._elementDoesNotExistError);
484     var options = Object.extend({ startcolor: '#ffff99' }, arguments[1] || { });
485     this.start(options);
486   },
487   setup: function() {
488     // Prevent executing on elements not in the layout flow
489     if (this.element.getStyle('display')=='none') { this.cancel(); return; }
490     // Disable background image during the effect
491     this.oldStyle = { };
492     if (!this.options.keepBackgroundImage) {
493       this.oldStyle.backgroundImage = this.element.getStyle('background-image');
494       this.element.setStyle({backgroundImage: 'none'});
495     }
496     if (!this.options.endcolor)
497       this.options.endcolor = this.element.getStyle('background-color').parseColor('#ffffff');
498     if (!this.options.restorecolor)
499       this.options.restorecolor = this.element.getStyle('background-color');
500     // init color calculations
501     this._base  = $R(0,2).map(function(i){ return parseInt(this.options.startcolor.slice(i*2+1,i*2+3),16) }.bind(this));
502     this._delta = $R(0,2).map(function(i){ return parseInt(this.options.endcolor.slice(i*2+1,i*2+3),16)-this._base[i] }.bind(this));
503   },
504   update: function(position) {
505     this.element.setStyle({backgroundColor: $R(0,2).inject('#',function(m,v,i){
506       return m+((this._base[i]+(this._delta[i]*position)).round().toColorPart()); }.bind(this)) });
507   },
508   finish: function() {
509     this.element.setStyle(Object.extend(this.oldStyle, {
510       backgroundColor: this.options.restorecolor
511     }));
512   }
513 });
514
515 Effect.ScrollTo = function(element) {
516   var options = arguments[1] || { },
517   scrollOffsets = document.viewport.getScrollOffsets(),
518   elementOffsets = $(element).cumulativeOffset();
519
520   if (options.offset) elementOffsets[1] += options.offset;
521
522   return new Effect.Tween(null,
523     scrollOffsets.top,
524     elementOffsets[1],
525     options,
526     function(p){ scrollTo(scrollOffsets.left, p.round()); }
527   );
528 };
529
530 /* ------------- combination effects ------------- */
531
532 Effect.Fade = function(element) {
533   element = $(element);
534   var oldOpacity = element.getInlineOpacity();
535   var options = Object.extend({
536     from: element.getOpacity() || 1.0,
537     to:   0.0,
538     afterFinishInternal: function(effect) {
539       if (effect.options.to!=0) return;
540       effect.element.hide().setStyle({opacity: oldOpacity});
541     }
542   }, arguments[1] || { });
543   return new Effect.Opacity(element,options);
544 };
545
546 Effect.Appear = function(element) {
547   element = $(element);
548   var options = Object.extend({
549   from: (element.getStyle('display') == 'none' ? 0.0 : element.getOpacity() || 0.0),
550   to:   1.0,
551   // force Safari to render floated elements properly
552   afterFinishInternal: function(effect) {
553     effect.element.forceRerendering();
554   },
555   beforeSetup: function(effect) {
556     effect.element.setOpacity(effect.options.from).show();
557   }}, arguments[1] || { });
558   return new Effect.Opacity(element,options);
559 };
560
561 Effect.Puff = function(element) {
562   element = $(element);
563   var oldStyle = {
564     opacity: element.getInlineOpacity(),
565     position: element.getStyle('position'),
566     top:  element.style.top,
567     left: element.style.left,
568     width: element.style.width,
569     height: element.style.height
570   };
571   return new Effect.Parallel(
572    [ new Effect.Scale(element, 200,
573       { sync: true, scaleFromCenter: true, scaleContent: true, restoreAfterFinish: true }),
574      new Effect.Opacity(element, { sync: true, to: 0.0 } ) ],
575      Object.extend({ duration: 1.0,
576       beforeSetupInternal: function(effect) {
577         Position.absolutize(effect.effects[0].element);
578       },
579       afterFinishInternal: function(effect) {
580          effect.effects[0].element.hide().setStyle(oldStyle); }
581      }, arguments[1] || { })
582    );
583 };
584
585 Effect.BlindUp = function(element) {
586   element = $(element);
587   element.makeClipping();
588   return new Effect.Scale(element, 0,
589     Object.extend({ scaleContent: false,
590       scaleX: false,
591       restoreAfterFinish: true,
592       afterFinishInternal: function(effect) {
593         effect.element.hide().undoClipping();
594       }
595     }, arguments[1] || { })
596   );
597 };
598
599 Effect.BlindDown = function(element) {
600   element = $(element);
601   var elementDimensions = element.getDimensions();
602   return new Effect.Scale(element, 100, Object.extend({
603     scaleContent: false,
604     scaleX: false,
605     scaleFrom: 0,
606     scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
607     restoreAfterFinish: true,
608     afterSetup: function(effect) {
609       effect.element.makeClipping().setStyle({height: '0px'}).show();
610     },
611     afterFinishInternal: function(effect) {
612       effect.element.undoClipping();
613     }
614   }, arguments[1] || { }));
615 };
616
617 Effect.SwitchOff = function(element) {
618   element = $(element);
619   var oldOpacity = element.getInlineOpacity();
620   return new Effect.Appear(element, Object.extend({
621     duration: 0.4,
622     from: 0,
623     transition: Effect.Transitions.flicker,
624     afterFinishInternal: function(effect) {
625       new Effect.Scale(effect.element, 1, {
626         duration: 0.3, scaleFromCenter: true,
627         scaleX: false, scaleContent: false, restoreAfterFinish: true,
628         beforeSetup: function(effect) {
629           effect.element.makePositioned().makeClipping();
630         },
631         afterFinishInternal: function(effect) {
632           effect.element.hide().undoClipping().undoPositioned().setStyle({opacity: oldOpacity});
633         }
634       });
635     }
636   }, arguments[1] || { }));
637 };
638
639 Effect.DropOut = function(element) {
640   element = $(element);
641   var oldStyle = {
642     top: element.getStyle('top'),
643     left: element.getStyle('left'),
644     opacity: element.getInlineOpacity() };
645   return new Effect.Parallel(
646     [ new Effect.Move(element, {x: 0, y: 100, sync: true }),
647       new Effect.Opacity(element, { sync: true, to: 0.0 }) ],
648     Object.extend(
649       { duration: 0.5,
650         beforeSetup: function(effect) {
651           effect.effects[0].element.makePositioned();
652         },
653         afterFinishInternal: function(effect) {
654           effect.effects[0].element.hide().undoPositioned().setStyle(oldStyle);
655         }
656       }, arguments[1] || { }));
657 };
658
659 Effect.Shake = function(element) {
660   element = $(element);
661   var options = Object.extend({
662     distance: 20,
663     duration: 0.5
664   }, arguments[1] || {});
665   var distance = parseFloat(options.distance);
666   var split = parseFloat(options.duration) / 10.0;
667   var oldStyle = {
668     top: element.getStyle('top'),
669     left: element.getStyle('left') };
670     return new Effect.Move(element,
671       { x:  distance, y: 0, duration: split, afterFinishInternal: function(effect) {
672     new Effect.Move(effect.element,
673       { x: -distance*2, y: 0, duration: split*2,  afterFinishInternal: function(effect) {
674     new Effect.Move(effect.element,
675       { x:  distance*2, y: 0, duration: split*2,  afterFinishInternal: function(effect) {
676     new Effect.Move(effect.element,
677       { x: -distance*2, y: 0, duration: split*2,  afterFinishInternal: function(effect) {
678     new Effect.Move(effect.element,
679       { x:  distance*2, y: 0, duration: split*2,  afterFinishInternal: function(effect) {
680     new Effect.Move(effect.element,
681       { x: -distance, y: 0, duration: split, afterFinishInternal: function(effect) {
682         effect.element.undoPositioned().setStyle(oldStyle);
683   }}); }}); }}); }}); }}); }});
684 };
685
686 Effect.SlideDown = function(element) {
687   element = $(element).cleanWhitespace();
688   // SlideDown need to have the content of the element wrapped in a container element with fixed height!
689   var oldInnerBottom = element.down().getStyle('bottom');
690   var elementDimensions = element.getDimensions();
691   return new Effect.Scale(element, 100, Object.extend({
692     scaleContent: false,
693     scaleX: false,
694     scaleFrom: window.opera ? 0 : 1,
695     scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
696     restoreAfterFinish: true,
697     afterSetup: function(effect) {
698       effect.element.makePositioned();
699       effect.element.down().makePositioned();
700       if (window.opera) effect.element.setStyle({top: ''});
701       effect.element.makeClipping().setStyle({height: '0px'}).show();
702     },
703     afterUpdateInternal: function(effect) {
704       effect.element.down().setStyle({bottom:
705         (effect.dims[0] - effect.element.clientHeight) + 'px' });
706     },
707     afterFinishInternal: function(effect) {
708       effect.element.undoClipping().undoPositioned();
709       effect.element.down().undoPositioned().setStyle({bottom: oldInnerBottom}); }
710     }, arguments[1] || { })
711   );
712 };
713
714 Effect.SlideUp = function(element) {
715   element = $(element).cleanWhitespace();
716   var oldInnerBottom = element.down().getStyle('bottom');
717   var elementDimensions = element.getDimensions();
718   return new Effect.Scale(element, window.opera ? 0 : 1,
719    Object.extend({ scaleContent: false,
720     scaleX: false,
721     scaleMode: 'box',
722     scaleFrom: 100,
723     scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
724     restoreAfterFinish: true,
725     afterSetup: function(effect) {
726       effect.element.makePositioned();
727       effect.element.down().makePositioned();
728       if (window.opera) effect.element.setStyle({top: ''});
729       effect.element.makeClipping().show();
730     },
731     afterUpdateInternal: function(effect) {
732       effect.element.down().setStyle({bottom:
733         (effect.dims[0] - effect.element.clientHeight) + 'px' });
734     },
735     afterFinishInternal: function(effect) {
736       effect.element.hide().undoClipping().undoPositioned();
737       effect.element.down().undoPositioned().setStyle({bottom: oldInnerBottom});
738     }
739    }, arguments[1] || { })
740   );
741 };
742
743 // Bug in opera makes the TD containing this element expand for a instance after finish
744 Effect.Squish = function(element) {
745   return new Effect.Scale(element, window.opera ? 1 : 0, {
746     restoreAfterFinish: true,
747     beforeSetup: function(effect) {
748       effect.element.makeClipping();
749     },
750     afterFinishInternal: function(effect) {
751       effect.element.hide().undoClipping();
752     }
753   });
754 };
755
756 Effect.Grow = function(element) {
757   element = $(element);
758   var options = Object.extend({
759     direction: 'center',
760     moveTransition: Effect.Transitions.sinoidal,
761     scaleTransition: Effect.Transitions.sinoidal,
762     opacityTransition: Effect.Transitions.full
763   }, arguments[1] || { });
764   var oldStyle = {
765     top: element.style.top,
766     left: element.style.left,
767     height: element.style.height,
768     width: element.style.width,
769     opacity: element.getInlineOpacity() };
770
771   var dims = element.getDimensions();
772   var initialMoveX, initialMoveY;
773   var moveX, moveY;
774
775   switch (options.direction) {
776     case 'top-left':
777       initialMoveX = initialMoveY = moveX = moveY = 0;
778       break;
779     case 'top-right':
780       initialMoveX = dims.width;
781       initialMoveY = moveY = 0;
782       moveX = -dims.width;
783       break;
784     case 'bottom-left':
785       initialMoveX = moveX = 0;
786       initialMoveY = dims.height;
787       moveY = -dims.height;
788       break;
789     case 'bottom-right':
790       initialMoveX = dims.width;
791       initialMoveY = dims.height;
792       moveX = -dims.width;
793       moveY = -dims.height;
794       break;
795     case 'center':
796       initialMoveX = dims.width / 2;
797       initialMoveY = dims.height / 2;
798       moveX = -dims.width / 2;
799       moveY = -dims.height / 2;
800       break;
801   }
802
803   return new Effect.Move(element, {
804     x: initialMoveX,
805     y: initialMoveY,
806     duration: 0.01,
807     beforeSetup: function(effect) {
808       effect.element.hide().makeClipping().makePositioned();
809     },
810     afterFinishInternal: function(effect) {
811       new Effect.Parallel(
812         [ new Effect.Opacity(effect.element, { sync: true, to: 1.0, from: 0.0, transition: options.opacityTransition }),
813           new Effect.Move(effect.element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition }),
814           new Effect.Scale(effect.element, 100, {
815             scaleMode: { originalHeight: dims.height, originalWidth: dims.width },
816             sync: true, scaleFrom: window.opera ? 1 : 0, transition: options.scaleTransition, restoreAfterFinish: true})
817         ], Object.extend({
818              beforeSetup: function(effect) {
819                effect.effects[0].element.setStyle({height: '0px'}).show();
820              },
821              afterFinishInternal: function(effect) {
822                effect.effects[0].element.undoClipping().undoPositioned().setStyle(oldStyle);
823              }
824            }, options)
825       );
826     }
827   });
828 };
829
830 Effect.Shrink = function(element) {
831   element = $(element);
832   var options = Object.extend({
833     direction: 'center',
834     moveTransition: Effect.Transitions.sinoidal,
835     scaleTransition: Effect.Transitions.sinoidal,
836     opacityTransition: Effect.Transitions.none
837   }, arguments[1] || { });
838   var oldStyle = {
839     top: element.style.top,
840     left: element.style.left,
841     height: element.style.height,
842     width: element.style.width,
843     opacity: element.getInlineOpacity() };
844
845   var dims = element.getDimensions();
846   var moveX, moveY;
847
848   switch (options.direction) {
849     case 'top-left':
850       moveX = moveY = 0;
851       break;
852     case 'top-right':
853       moveX = dims.width;
854       moveY = 0;
855       break;
856     case 'bottom-left':
857       moveX = 0;
858       moveY = dims.height;
859       break;
860     case 'bottom-right':
861       moveX = dims.width;
862       moveY = dims.height;
863       break;
864     case 'center':
865       moveX = dims.width / 2;
866       moveY = dims.height / 2;
867       break;
868   }
869
870   return new Effect.Parallel(
871     [ new Effect.Opacity(element, { sync: true, to: 0.0, from: 1.0, transition: options.opacityTransition }),
872       new Effect.Scale(element, window.opera ? 1 : 0, { sync: true, transition: options.scaleTransition, restoreAfterFinish: true}),
873       new Effect.Move(element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition })
874     ], Object.extend({
875          beforeStartInternal: function(effect) {
876            effect.effects[0].element.makePositioned().makeClipping();
877          },
878          afterFinishInternal: function(effect) {
879            effect.effects[0].element.hide().undoClipping().undoPositioned().setStyle(oldStyle); }
880        }, options)
881   );
882 };
883
884 Effect.Pulsate = function(element) {
885   element = $(element);
886   var options    = arguments[1] || { },
887     oldOpacity = element.getInlineOpacity(),
888     transition = options.transition || Effect.Transitions.linear,
889     reverser   = function(pos){
890       return 1 - transition((-Math.cos((pos*(options.pulses||5)*2)*Math.PI)/2) + .5);
891     };
892
893   return new Effect.Opacity(element,
894     Object.extend(Object.extend({  duration: 2.0, from: 0,
895       afterFinishInternal: function(effect) { effect.element.setStyle({opacity: oldOpacity}); }
896     }, options), {transition: reverser}));
897 };
898
899 Effect.Fold = function(element) {
900   element = $(element);
901   var oldStyle = {
902     top: element.style.top,
903     left: element.style.left,
904     width: element.style.width,
905     height: element.style.height };
906   element.makeClipping();
907   return new Effect.Scale(element, 5, Object.extend({
908     scaleContent: false,
909     scaleX: false,
910     afterFinishInternal: function(effect) {
911     new Effect.Scale(element, 1, {
912       scaleContent: false,
913       scaleY: false,
914       afterFinishInternal: function(effect) {
915         effect.element.hide().undoClipping().setStyle(oldStyle);
916       } });
917   }}, arguments[1] || { }));
918 };
919
920 Effect.Morph = Class.create(Effect.Base, {
921   initialize: function(element) {
922     this.element = $(element);
923     if (!this.element) throw(Effect._elementDoesNotExistError);
924     var options = Object.extend({
925       style: { }
926     }, arguments[1] || { });
927
928     if (!Object.isString(options.style)) this.style = $H(options.style);
929     else {
930       if (options.style.include(':'))
931         this.style = options.style.parseStyle();
932       else {
933         this.element.addClassName(options.style);
934         this.style = $H(this.element.getStyles());
935         this.element.removeClassName(options.style);
936         var css = this.element.getStyles();
937         this.style = this.style.reject(function(style) {
938           return style.value == css[style.key];
939         });
940         options.afterFinishInternal = function(effect) {
941           effect.element.addClassName(effect.options.style);
942           effect.transforms.each(function(transform) {
943             effect.element.style[transform.style] = '';
944           });
945         };
946       }
947     }
948     this.start(options);
949   },
950
951   setup: function(){
952     function parseColor(color){
953       if (!color || ['rgba(0, 0, 0, 0)','transparent'].include(color)) color = '#ffffff';
954       color = color.parseColor();
955       return $R(0,2).map(function(i){
956         return parseInt( color.slice(i*2+1,i*2+3), 16 );
957       });
958     }
959     this.transforms = this.style.map(function(pair){
960       var property = pair[0], value = pair[1], unit = null;
961
962       if (value.parseColor('#zzzzzz') != '#zzzzzz') {
963         value = value.parseColor();
964         unit  = 'color';
965       } else if (property == 'opacity') {
966         value = parseFloat(value);
967         if (Prototype.Browser.IE && (!this.element.currentStyle.hasLayout))
968           this.element.setStyle({zoom: 1});
969       } else if (Element.CSS_LENGTH.test(value)) {
970           var components = value.match(/^([\+\-]?[0-9\.]+)(.*)$/);
971           value = parseFloat(components[1]);
972           unit = (components.length == 3) ? components[2] : null;
973       }
974
975       var originalValue = this.element.getStyle(property);
976       return {
977         style: property.camelize(),
978         originalValue: unit=='color' ? parseColor(originalValue) : parseFloat(originalValue || 0),
979         targetValue: unit=='color' ? parseColor(value) : value,
980         unit: unit
981       };
982     }.bind(this)).reject(function(transform){
983       return (
984         (transform.originalValue == transform.targetValue) ||
985         (
986           transform.unit != 'color' &&
987           (isNaN(transform.originalValue) || isNaN(transform.targetValue))
988         )
989       );
990     });
991   },
992   update: function(position) {
993     var style = { }, transform, i = this.transforms.length;
994     while(i--)
995       style[(transform = this.transforms[i]).style] =
996         transform.unit=='color' ? '#'+
997           (Math.round(transform.originalValue[0]+
998             (transform.targetValue[0]-transform.originalValue[0])*position)).toColorPart() +
999           (Math.round(transform.originalValue[1]+
1000             (transform.targetValue[1]-transform.originalValue[1])*position)).toColorPart() +
1001           (Math.round(transform.originalValue[2]+
1002             (transform.targetValue[2]-transform.originalValue[2])*position)).toColorPart() :
1003         (transform.originalValue +
1004           (transform.targetValue - transform.originalValue) * position).toFixed(3) +
1005             (transform.unit === null ? '' : transform.unit);
1006     this.element.setStyle(style, true);
1007   }
1008 });
1009
1010 Effect.Transform = Class.create({
1011   initialize: function(tracks){
1012     this.tracks  = [];
1013     this.options = arguments[1] || { };
1014     this.addTracks(tracks);
1015   },
1016   addTracks: function(tracks){
1017     tracks.each(function(track){
1018       track = $H(track);
1019       var data = track.values().first();
1020       this.tracks.push($H({
1021         ids:     track.keys().first(),
1022         effect:  Effect.Morph,
1023         options: { style: data }
1024       }));
1025     }.bind(this));
1026     return this;
1027   },
1028   play: function(){
1029     return new Effect.Parallel(
1030       this.tracks.map(function(track){
1031         var ids = track.get('ids'), effect = track.get('effect'), options = track.get('options');
1032         var elements = [$(ids) || $$(ids)].flatten();
1033         return elements.map(function(e){ return new effect(e, Object.extend({ sync:true }, options)) });
1034       }).flatten(),
1035       this.options
1036     );
1037   }
1038 });
1039
1040 Element.CSS_PROPERTIES = $w(
1041   'backgroundColor backgroundPosition borderBottomColor borderBottomStyle ' +
1042   'borderBottomWidth borderLeftColor borderLeftStyle borderLeftWidth ' +
1043   'borderRightColor borderRightStyle borderRightWidth borderSpacing ' +
1044   'borderTopColor borderTopStyle borderTopWidth bottom clip color ' +
1045   'fontSize fontWeight height left letterSpacing lineHeight ' +
1046   'marginBottom marginLeft marginRight marginTop markerOffset maxHeight '+
1047   'maxWidth minHeight minWidth opacity outlineColor outlineOffset ' +
1048   'outlineWidth paddingBottom paddingLeft paddingRight paddingTop ' +
1049   'right textIndent top width wordSpacing zIndex');
1050
1051 Element.CSS_LENGTH = /^(([\+\-]?[0-9\.]+)(em|ex|px|in|cm|mm|pt|pc|\%))|0$/;
1052
1053 String.__parseStyleElement = document.createElement('div');
1054 String.prototype.parseStyle = function(){
1055   var style, styleRules = $H();
1056   if (Prototype.Browser.WebKit)
1057     style = new Element('div',{style:this}).style;
1058   else {
1059     String.__parseStyleElement.innerHTML = '<div style="' + this + '"></div>';
1060     style = String.__parseStyleElement.childNodes[0].style;
1061   }
1062
1063   Element.CSS_PROPERTIES.each(function(property){
1064     if (style[property]) styleRules.set(property, style[property]);
1065   });
1066
1067   if (Prototype.Browser.IE && this.include('opacity'))
1068     styleRules.set('opacity', this.match(/opacity:\s*((?:0|1)?(?:\.\d*)?)/)[1]);
1069
1070   return styleRules;
1071 };
1072
1073 if (document.defaultView && document.defaultView.getComputedStyle) {
1074   Element.getStyles = function(element) {
1075     var css = document.defaultView.getComputedStyle($(element), null);
1076     return Element.CSS_PROPERTIES.inject({ }, function(styles, property) {
1077       styles[property] = css[property];
1078       return styles;
1079     });
1080   };
1081 } else {
1082   Element.getStyles = function(element) {
1083     element = $(element);
1084     var css = element.currentStyle, styles;
1085     styles = Element.CSS_PROPERTIES.inject({ }, function(results, property) {
1086       results[property] = css[property];
1087       return results;
1088     });
1089     if (!styles.opacity) styles.opacity = element.getOpacity();
1090     return styles;
1091   };
1092 }
1093
1094 Effect.Methods = {
1095   morph: function(element, style) {
1096     element = $(element);
1097     new Effect.Morph(element, Object.extend({ style: style }, arguments[2] || { }));
1098     return element;
1099   },
1100   visualEffect: function(element, effect, options) {
1101     element = $(element);
1102     var s = effect.dasherize().camelize(), klass = s.charAt(0).toUpperCase() + s.substring(1);
1103     new Effect[klass](element, options);
1104     return element;
1105   },
1106   highlight: function(element, options) {
1107     element = $(element);
1108     new Effect.Highlight(element, options);
1109     return element;
1110   }
1111 };
1112
1113 $w('fade appear grow shrink fold blindUp blindDown slideUp slideDown '+
1114   'pulsate shake puff squish switchOff dropOut').each(
1115   function(effect) {
1116     Effect.Methods[effect] = function(element, options){
1117       element = $(element);
1118       Effect[effect.charAt(0).toUpperCase() + effect.substring(1)](element, options);
1119       return element;
1120     };
1121   }
1122 );
1123
1124 $w('getInlineOpacity forceRerendering setContentZoom collectTextNodes collectTextNodesIgnoreClass getStyles').each(
1125   function(f) { Effect.Methods[f] = Element[f]; }
1126 );
1127
1128 Element.addMethods(Effect.Methods);