// Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us) 
// 
// Parts (c) 2005 Justin Palmer (http://encytemedia.com/) 
// Parts (c) 2005 Mark Pilgrim (http://diveintomark.org/) 
//  
// Permission is hereby granted, free of charge, to any person obtaining 
// a copy of this software and associated documentation files (the 
// "Software"), to deal in the Software without restriction, including 
// without limitation the rights to use, copy, modify, merge, publish, 
// distribute, sublicense, and/or sell copies of the Software, and to 
// permit persons to whom the Software is furnished to do so, subject to 
// the following conditions: 
//  
// The above copyright notice and this permission notice shall be 
// included in all copies or substantial portions of the Software. 
//  
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
 
 
Effect = {} 
Effect2 = Effect; // deprecated 
 
/* ------------- transitions ------------- */ 
 
Effect.Transitions = {} 
 
Effect.Transitions.linear = function(pos) { 
  return pos; 
} 
Effect.Transitions.sinoidal = function(pos) { 
  return (-Math.cos(pos*Math.PI)/2) + 0.5; 
} 
Effect.Transitions.reverse  = function(pos) { 
  return 1-pos; 
} 
Effect.Transitions.flicker = function(pos) { 
  return ((-Math.cos(pos*Math.PI)/4) + 0.75) + Math.random(0.25); 
} 
Effect.Transitions.wobble = function(pos) { 
  return (-Math.cos(pos*Math.PI*(9*pos))/2) + 0.5; 
} 
Effect.Transitions.pulse = function(pos) { 
  return (Math.floor(pos*10) % 2 == 0 ?  
    (pos*10-Math.floor(pos*10)) : 1-(pos*10-Math.floor(pos*10))); 
} 
Effect.Transitions.none = function(pos) { 
  return 0; 
} 
Effect.Transitions.full = function(pos) { 
  return 1; 
} 
 
/* ------------- element ext -------------- */ 
 
Element.makePositioned = function(element) { 
  element = $(element); 
  if(element.style.position == "") 
    element.style.position = "relative"; 
} 
 
Element.makeClipping = function(element) { 
  element = $(element); 
  element._overflow = element.style.overflow || 'visible'; 
  if(element._overflow!='hidden') element.style.overflow = 'hidden'; 
} 
 
Element.undoClipping = function(element) { 
  element = $(element); 
  if(element._overflow!='hidden') element.style.overflow = element._overflow; 
} 
 
/* ------------- core effects ------------- */ 
 
Effect.Base = function() {}; 
Effect.Base.prototype = { 
  setOptions: function(options) { 
    this.options = Object.extend({ 
      transition: Effect.Transitions.sinoidal, 
      duration:   1.0,   // seconds 
      fps:        25.0,  // max. 100fps 
      sync:       false, // true for combining 
      from:       0.0, 
      to:         1.0 
    }, options || {}); 
  }, 
  start: function(options) { 
    this.setOptions(options || {}); 
    this.currentFrame = 0; 
    this.startOn      = new Date().getTime(); 
    this.finishOn     = this.startOn + (this.options.duration*1000); 
    if(this.options.beforeStart) this.options.beforeStart(this); 
    if(!this.options.sync) this.loop();   
  }, 
  loop: function() { 
    var timePos = new Date().getTime(); 
    if(timePos >= this.finishOn) { 
      this.render(this.options.to); 
      if(this.finish) this.finish();  
      if(this.options.afterFinish) this.options.afterFinish(this); 
      return;   
    } 
    var pos   = (timePos - this.startOn) / (this.finishOn - this.startOn); 
    var frame = Math.round(pos * this.options.fps * this.options.duration); 
    if(frame > this.currentFrame) { 
      this.render(pos); 
      this.currentFrame = frame; 
    } 
    this.timeout = setTimeout(this.loop.bind(this), 10); 
  }, 
  render: function(pos) { 
    if(this.options.transition) pos = this.options.transition(pos); 
    pos *= (this.options.to-this.options.from); 
    pos += this.options.from;  
    if(this.options.beforeUpdate) this.options.beforeUpdate(this); 
    if(this.update) this.update(pos); 
    if(this.options.afterUpdate) this.options.afterUpdate(this);   
  }, 
  cancel: function() { 
    if(this.timeout) clearTimeout(this.timeout); 
  } 
} 
 
Effect.Parallel = Class.create(); 
Object.extend(Object.extend(Effect.Parallel.prototype, Effect.Base.prototype), { 
  initialize: function(effects) { 
    this.effects = effects || []; 
    this.start(arguments[1]); 
  }, 
  update: function(position) { 
    for (var i = 0; i < this.effects.length; i++) 
      this.effects[i].render(position);   
  }, 
  finish: function(position) { 
    for (var i = 0; i < this.effects.length; i++) 
      if(this.effects[i].finish) this.effects[i].finish(position); 
  } 
}); 
 
// Internet Explorer caveat: works only on elements the have 
// a 'layout', meaning having a given width or height.  
// There is no way to safely set this automatically. 
Effect.Opacity = Class.create(); 
Object.extend(Object.extend(Effect.Opacity.prototype, Effect.Base.prototype), { 
  initialize: function(element) { 
    this.element = $(element); 
    options = Object.extend({ 
      from: 0.0, 
      to:   1.0 
    }, arguments[1] || {}); 
    this.start(options); 
  }, 
  update: function(position) { 
    this.setOpacity(position); 
  },  
  setOpacity: function(opacity) { 
    opacity = (opacity == 1) ? 0.99999 : opacity; 
    this.element.style.opacity = opacity; 
    this.element.style.filter = "alpha(opacity:"+opacity*100+")"; 
  } 
}); 
 
Effect.MoveBy = Class.create(); 
Object.extend(Object.extend(Effect.MoveBy.prototype, Effect.Base.prototype), { 
  initialize: function(element, toTop, toLeft) { 
    this.element      = $(element); 
    this.originalTop  = parseFloat(this.element.style.top || '0'); 
    this.originalLeft = parseFloat(this.element.style.left || '0'); 
    this.toTop        = toTop; 
    this.toLeft       = toLeft; 
    Element.makePositioned(this.element); 
    this.start(arguments[3]); 
  }, 
  update: function(position) { 
    topd  = this.toTop  * position + this.originalTop; 
    leftd = this.toLeft * position + this.originalLeft; 
    this.setPosition(topd, leftd); 
  }, 
  setPosition: function(topd, leftd) { 
    this.element.style.top  = topd  + "px"; 
    this.element.style.left = leftd + "px"; 
  } 
}); 
 
Effect.Scale = Class.create(); 
Object.extend(Object.extend(Effect.Scale.prototype, Effect.Base.prototype), { 
  initialize: function(element, percent) { 
    this.element = $(element) 
    options = Object.extend({ 
      scaleX: true, 
      scaleY: true, 
      scaleContent: true, 
      scaleFromCenter: false, 
      scaleMode: 'box',        // 'box' or 'contents' or {} with provided values 
      scaleFrom: 100.0 
    }, arguments[2] || {}); 
    this.originalTop    = this.element.offsetTop; 
    this.originalLeft   = this.element.offsetLeft; 
    if(this.element.style.fontSize=="") this.sizeEm = 1.0; 
    if(this.element.style.fontSize && this.element.style.fontSize.indexOf("em")>0) 
      this.sizeEm      = parseFloat(this.element.style.fontSize); 
    this.factor = (percent/100.0) - (options.scaleFrom/100.0); 
    if(options.scaleMode=='box') { 
      this.originalHeight = this.element.clientHeight; 
      this.originalWidth  = this.element.clientWidth;  
    } else  
    if(options.scaleMode=='contents') { 
      this.originalHeight = this.element.scrollHeight; 
      this.originalWidth  = this.element.scrollWidth; 
    } else { 
      this.originalHeight = options.scaleMode.originalHeight; 
      this.originalWidth  = options.scaleMode.originalWidth; 
    } 
    this.start(options); 
  }, 
 
  update: function(position) { 
    currentScale = (this.options.scaleFrom/100.0) + (this.factor * position); 
    if(this.options.scaleContent && this.sizeEm)  
      this.element.style.fontSize = this.sizeEm*currentScale + "em"; 
    this.setDimensions( 
      this.originalWidth * currentScale,  
      this.originalHeight * currentScale); 
  }, 
 
  setDimensions: function(width, height) { 
    if(this.options.scaleX) this.element.style.width = width + 'px'; 
    if(this.options.scaleY) this.element.style.height = height + 'px'; 
    if(this.options.scaleFromCenter) { 
      topd  = (height - this.originalHeight)/2; 
      leftd = (width  - this.originalWidth)/2; 
      if(this.element.style.position=='absolute') { 
        if(this.options.scaleY) this.element.style.top = this.originalTop-topd + "px"; 
        if(this.options.scaleX) this.element.style.left = this.originalLeft-leftd + "px"; 
      } else { 
        if(this.options.scaleY) this.element.style.top = -topd + "px"; 
        if(this.options.scaleX) this.element.style.left = -leftd + "px"; 
      } 
    } 
  } 
}); 
 
Effect.Highlight = Class.create(); 
Object.extend(Object.extend(Effect.Highlight.prototype, Effect.Base.prototype), { 
  initialize: function(element) { 
    this.element = $(element); 
     
    // try to parse current background color as default for endcolor 
    // browser stores this as: "rgb(255, 255, 255)", convert to "#ffffff" format 
    var endcolor = "#ffffff"; 
    var current = this.element.style.backgroundColor; 
    if(current && current.slice(0,4) == "rgb(") { 
      endcolor = "#"; 
      var cols = current.slice(4,current.length-1).split(','); 
      var i=0; do { endcolor += parseInt(cols[i]).toColorPart() } while (++i<3); } 
       
    var options = Object.extend({ 
      startcolor:   "#ffff99", 
      endcolor:     endcolor, 
      restorecolor: current  
    }, arguments[1] || {}); 
     
    // init color calculations 
    this.colors_base = [ 
      parseInt(options.startcolor.slice(1,3),16), 
      parseInt(options.startcolor.slice(3,5),16), 
      parseInt(options.startcolor.slice(5),16) ]; 
    this.colors_delta = [ 
      parseInt(options.endcolor.slice(1,3),16)-this.colors_base[0], 
      parseInt(options.endcolor.slice(3,5),16)-this.colors_base[1], 
      parseInt(options.endcolor.slice(5),16)-this.colors_base[2] ]; 
 
    this.start(options); 
  }, 
  update: function(position) { 
    var colors = [ 
      Math.round(this.colors_base[0]+(this.colors_delta[0]*position)), 
      Math.round(this.colors_base[1]+(this.colors_delta[1]*position)), 
      Math.round(this.colors_base[2]+(this.colors_delta[2]*position)) ]; 
    this.element.style.backgroundColor = "#" + 
      colors[0].toColorPart() + colors[1].toColorPart() + colors[2].toColorPart(); 
  }, 
  finish: function() { 
    this.element.style.backgroundColor = this.options.restorecolor; 
  } 
}); 
 
Effect.ScrollTo = Class.create(); 
Object.extend(Object.extend(Effect.ScrollTo.prototype, Effect.Base.prototype), { 
  initialize: function(element) { 
    this.element = $(element); 
    Position.prepare(); 
    var offsets = Position.cumulativeOffset(this.element); 
    var max = window.innerHeight ?  
      window.height - window.innerHeight : 
      document.body.scrollHeight -  
        (document.documentElement.clientHeight ?  
          document.documentElement.clientHeight : document.body.clientHeight); 
    this.scrollStart = Position.deltaY; 
    this.delta  = (offsets[1] > max ? max : offsets[1]) - this.scrollStart; 
    this.start(arguments[1] || {}); 
  }, 
  update: function(position) { 
    Position.prepare(); 
    window.scrollTo(Position.deltaX,  
      this.scrollStart + (position*this.delta)); 
  } 
}); 
 
/* ------------- prepackaged effects ------------- */ 
 
Effect.Fade = function(element) { 
  options = Object.extend({ 
  from: 1.0, 
  to:   0.0, 
  afterFinish: function(effect)  
    { Element.hide(effect.element); 
      effect.setOpacity(1); }  
  }, arguments[1] || {}); 
  new Effect.Opacity(element,options); 
} 
 
Effect.Appear = function(element) { 
  options = Object.extend({ 
  from: 0.0, 
  to:   1.0, 
  beforeStart: function(effect)   
    { effect.setOpacity(0); 
      Element.show(effect.element); }, 
  afterUpdate: function(effect)   
    { Element.show(effect.element); } 
  }, arguments[1] || {}); 
  new Effect.Opacity(element,options); 
} 
 
Effect.Puff = function(element) { 
  new Effect.Parallel( 
   [ new Effect.Scale(element, 200, { sync: true, scaleFromCenter: true }),  
     new Effect.Opacity(element, { sync: true, to: 0.0, from: 1.0 } ) ],  
     { duration: 1.0,  
      afterUpdate: function(effect)  
       { effect.effects[0].element.style.position = 'absolute'; }, 
      afterFinish: function(effect) 
       { Element.hide(effect.effects[0].element); } 
     } 
   ); 
} 
 
Effect.BlindUp = function(element) { 
  Element.makeClipping(element); 
  new Effect.Scale(element, 0,  
    Object.extend({ scaleContent: false,  
      scaleX: false,  
      afterFinish: function(effect)  
        {  
          Element.hide(effect.element); 
          Element.undoClipping(effect.element); 
        }  
    }, arguments[1] || {}) 
  ); 
} 
 
Effect.BlindDown = function(element) { 
  $(element).style.height   = '0px'; 
  Element.makeClipping(element); 
  Element.show(element); 
  new Effect.Scale(element, 100,  
    Object.extend({ scaleContent: false,  
      scaleX: false,  
      scaleMode: 'contents', 
      scaleFrom: 0, 
      afterFinish: function(effect) { 
        Element.undoClipping(effect.element); 
      } 
    }, arguments[1] || {}) 
  ); 
} 
 
Effect.SwitchOff = function(element) { 
  new Effect.Appear(element, 
    { duration: 0.4, 
     transition: Effect.Transitions.flicker, 
     afterFinish: function(effect) 
      { effect.element.style.overflow = 'hidden'; 
        new Effect.Scale(effect.element, 1,  
         { duration: 0.3, scaleFromCenter: true, 
          scaleX: false, scaleContent: false, 
          afterUpdate: function(effect) {  
           if(effect.element.style.position=="") 
             effect.element.style.position = 'relative'; }, 
          afterFinish: function(effect) { Element.hide(effect.element); } 
         } ) 
      } 
    } ); 
} 
 
Effect.DropOut = function(element) { 
  new Effect.Parallel( 
    [ new Effect.MoveBy(element, 100, 0, { sync: true }),  
      new Effect.Opacity(element, { sync: true, to: 0.0, from: 1.0 } ) ],  
    { duration: 0.5,  
     afterFinish: function(effect) 
       { Element.hide(effect.effects[0].element); }  
    }); 
} 
 
Effect.Shake = function(element) { 
  new Effect.MoveBy(element, 0, 20,  
    { duration: 0.05, afterFinish: function(effect) { 
  new Effect.MoveBy(effect.element, 0, -40,  
    { duration: 0.1, afterFinish: function(effect) {  
  new Effect.MoveBy(effect.element, 0, 40,  
    { duration: 0.1, afterFinish: function(effect) {   
  new Effect.MoveBy(effect.element, 0, -40,  
    { duration: 0.1, afterFinish: function(effect) {   
  new Effect.MoveBy(effect.element, 0, 40,  
    { duration: 0.1, afterFinish: function(effect) {   
  new Effect.MoveBy(effect.element, 0, -20,  
    { duration: 0.05, afterFinish: function(effect) {   
  }}) }}) }}) }}) }}) }}); 
} 
 
Effect.SlideDown = function(element) { 
  element = $(element); 
  element.style.height   = '0px'; 
  Element.makeClipping(element); 
  Element.cleanWhitespace(element); 
  Element.makePositioned(element.firstChild); 
  Element.show(element); 
  new Effect.Scale(element, 100,  
   Object.extend({ scaleContent: false,  
    scaleX: false,  
    scaleMode: 'contents', 
    scaleFrom: 0, 
    afterUpdate: function(effect)  
      { effect.element.firstChild.style.bottom =  
          (effect.originalHeight - effect.element.clientHeight) + 'px'; }, 
    afterFinish: function(effect)  
      {  Element.undoClipping(effect.element); } 
    }, arguments[1] || {}) 
  ); 
} 
   
Effect.SlideUp = function(element) { 
  element = $(element); 
  Element.makeClipping(element); 
  Element.cleanWhitespace(element); 
  Element.makePositioned(element.firstChild); 
  Element.show(element); 
  new Effect.Scale(element, 0,  
   Object.extend({ scaleContent: false,  
    scaleX: false,  
    afterUpdate: function(effect)  
      { effect.element.firstChild.style.bottom =  
          (effect.originalHeight - effect.element.clientHeight) + 'px'; }, 
    afterFinish: function(effect) 
      {  
        Element.hide(effect.element); 
        Element.undoClipping(effect.element); 
      } 
   }, arguments[1] || {}) 
  ); 
} 
 
Effect.Squish = function(element) { 
 new Effect.Scale(element, 0,  
   { afterFinish: function(effect) { Element.hide(effect.element); } }); 
} 
 
Effect.Grow = function(element) { 
  element = $(element); 
  var options = arguments[1] || {}; 
   
  var originalWidth = element.clientWidth; 
  var originalHeight = element.clientHeight; 
  element.style.overflow = 'hidden'; 
  Element.show(element); 
   
  var direction = options.direction || 'center'; 
  var moveTransition = options.moveTransition || Effect.Transitions.sinoidal; 
  var scaleTransition = options.scaleTransition || Effect.Transitions.sinoidal; 
  var opacityTransition = options.opacityTransition || Effect.Transitions.full; 
   
  var initialMoveX, initialMoveY; 
  var moveX, moveY; 
   
  switch (direction) { 
    case 'top-left': 
      initialMoveX = initialMoveY = moveX = moveY = 0;  
      break; 
    case 'top-right': 
      initialMoveX = originalWidth; 
      initialMoveY = moveY = 0; 
      moveX = -originalWidth; 
      break; 
    case 'bottom-left': 
      initialMoveX = moveX = 0; 
      initialMoveY = originalHeight; 
      moveY = -originalHeight; 
      break; 
    case 'bottom-right': 
      initialMoveX = originalWidth; 
      initialMoveY = originalHeight; 
      moveX = -originalWidth; 
      moveY = -originalHeight; 
      break; 
    case 'center': 
      initialMoveX = originalWidth / 2; 
      initialMoveY = originalHeight / 2; 
      moveX = -originalWidth / 2; 
      moveY = -originalHeight / 2; 
      break; 
  } 
   
  new Effect.MoveBy(element, initialMoveY, initialMoveX, {  
    duration: 0.01,  
    beforeUpdate: function(effect) { $(element).style.height = '0px'; }, 
    afterFinish: function(effect) { 
      new Effect.Parallel( 
        [ new Effect.Opacity(element, { sync: true, to: 1.0, from: 0.0, transition: opacityTransition }), 
          new Effect.MoveBy(element, moveY, moveX, { sync: true, transition: moveTransition }), 
          new Effect.Scale(element, 100, {  
            scaleMode: { originalHeight: originalHeight, originalWidth: originalWidth },  
            sync: true, scaleFrom: 0, scaleTo: 100, transition: scaleTransition })], 
        options); } 
    }); 
} 
 
Effect.Shrink = function(element) { 
  element = $(element); 
  var options = arguments[1] || {}; 
   
  var originalWidth = element.clientWidth; 
  var originalHeight = element.clientHeight; 
  element.style.overflow = 'hidden'; 
  Element.show(element); 
 
  var direction = options.direction || 'center'; 
  var moveTransition = options.moveTransition || Effect.Transitions.sinoidal; 
  var scaleTransition = options.scaleTransition || Effect.Transitions.sinoidal; 
  var opacityTransition = options.opacityTransition || Effect.Transitions.none; 
   
  var moveX, moveY; 
   
  switch (direction) { 
    case 'top-left': 
      moveX = moveY = 0; 
      break; 
    case 'top-right': 
      moveX = originalWidth; 
      moveY = 0; 
      break; 
    case 'bottom-left': 
      moveX = 0; 
      moveY = originalHeight; 
      break; 
    case 'bottom-right': 
      moveX = originalWidth; 
      moveY = originalHeight; 
      break; 
    case 'center':   
      moveX = originalWidth / 2; 
      moveY = originalHeight / 2; 
      break; 
  } 
   
  new Effect.Parallel( 
    [ new Effect.Opacity(element, { sync: true, to: 0.0, from: 1.0, transition: opacityTransition }), 
      new Effect.Scale(element, 0, { sync: true, transition: moveTransition }), 
      new Effect.MoveBy(element, moveY, moveX, { sync: true, transition: scaleTransition }) ], 
    options); 
} 
 
Effect.Pulsate = function(element) { 
  var options    = arguments[1] || {}; 
  var transition = options.transition || Effect.Transitions.sinoidal; 
  var reverser   = function(pos){ return transition(1-Effect.Transitions.pulse(pos)) }; 
  reverser.bind(transition); 
  new Effect.Opacity(element,  
    Object.extend(Object.extend({  duration: 3.0, 
       afterFinish: function(effect) { Element.show(effect.element); } 
    }, options), {transition: reverser})); 
} 
 
Effect.Fold = function(element) { 
 $(element).style.overflow = 'hidden'; 
 new Effect.Scale(element, 5, Object.extend({    
   scaleContent: false, 
   scaleTo: 100, 
   scaleX: false, 
   afterFinish: function(effect) { 
   new Effect.Scale(element, 1, {  
     scaleContent: false,  
     scaleTo: 0, 
     scaleY: false, 
     afterFinish: function(effect) { Element.hide(effect.element) } }); 
 }}, arguments[1] || {})); 
} 
 
// old: new Effect.ContentZoom(element, percent) 
// new: Element.setContentZoom(element, percent)  
 
Element.setContentZoom = function(element, percent) { 
  var element = $(element); 
  element.style.fontSize = (percent/100) + "em";   
  if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0); 
}