// Contributors:

//  Justin Palmer (http://encytemedia.com/)

//  Mark Pilgrim (http://diveintomark.org/)

//  Martin Bialasinki

// script.aculo.us is freely distributable under the terms of an MIT-style license.

  var color = '#';

};

/*--------------------------------------------------------------------------*/

  return $A($(element).childNodes).collect( function(node) {

      (node.hasChildNodes() ? Element.collectTextNodes(node) : ''));

  }).flatten().join('');

};

  return $A($(element).childNodes).collect( function(node) {

        Element.collectTextNodesIgnoreClass(node, className) : ''));

  }).flatten().join('');

};

Element.setContentZoom = function(element, percent) {

  if (Prototype.Browser.WebKit) window.scrollBy(0,0);

  return element;

};

Element.getInlineOpacity = function(element){

  return $(element).style.opacity || '';

};

Element.forceRerendering = function(element) {

  try {

    element = $(element);

    var n = document.createTextNode(' ');

    element.appendChild(n);

    element.removeChild(n);

  } catch(e) { }

};

/*--------------------------------------------------------------------------*/

var Effect = {

  _elementDoesNotExistError: {

    name: 'ElementDoesNotExistError',

    message: 'The specified DOM element does not exist, but is required for this effect to operate'

  },

  Transitions: {

    linear: Prototype.K,

    sinoidal: function(pos) {

    },

    reverse: function(pos) {

      return 1-pos;

    },

    flicker: function(pos) {

      return pos > 1 ? 1 : pos;

    },

    wobble: function(pos) {

    },

    },

    },

    none: function(pos) {

      return 0;

    },

    full: function(pos) {

      return 1;

    }

  },

  DefaultOptions: {

    duration:   1.0,   // seconds

    fps:        100,   // 100= assume 66fps max.

    sync:       false, // true for combining

    from:       0.0,

    to:         1.0,

    delay:      0.0,

    queue:      'parallel'

  },

  tagifyText: function(element) {

    var tagifyStyle = 'position:relative';

    if (Prototype.Browser.IE) tagifyStyle += ';zoom:1';

    element = $(element);

    $A(element.childNodes).each( function(child) {

      if (child.nodeType==3) {

        child.nodeValue.toArray().each( function(character) {

          element.insertBefore(

            new Element('span', {style: tagifyStyle}).update(

              child);

        });

        Element.remove(child);

      }

    });

  },

  multiple: function(element, effect) {

    var elements;

       (element.length))

      elements = element;

    else

      elements = $(element).childNodes;

    var options = Object.extend({

      speed: 0.1,

      delay: 0.0

    }, arguments[2] || { });

    var masterDelay = options.delay;

    $A(elements).each( function(element, index) {

      new effect(element, Object.extend(options, { delay: index * options.speed + masterDelay }));

    });

  },

  PAIRS: {

    'slide':  ['SlideDown','SlideUp'],

    'blind':  ['BlindDown','BlindUp'],

    'appear': ['Appear','Fade']

  },

    element = $(element);

      queue: { position:'end', scope:(element.id || 'global'), limit: 1 }

  }

};

Effect.DefaultOptions.transition = Effect.Transitions.sinoidal;

/* ------------- core effects ------------- */

Effect.ScopedQueue = Class.create(Enumerable, {

  initialize: function() {

    this.effects  = [];

  },

  _each: function(iterator) {

    this.effects._each(iterator);

  },

  add: function(effect) {

    var timestamp = new Date().getTime();

      effect.options.queue : effect.options.queue.position;

    switch(position) {

      case 'front':

        this.effects.findAll(function(e){ return e.state=='idle' }).each( function(e) {

            e.startOn  += effect.finishOn;

            e.finishOn += effect.finishOn;

          });

        break;

      case 'with-last':

        timestamp = this.effects.pluck('startOn').max() || timestamp;

        break;

      case 'end':

        // start effect after last queued effect has finished

        timestamp = this.effects.pluck('finishOn').max() || timestamp;

        break;

    }

    effect.startOn  += timestamp;

    effect.finishOn += timestamp;

    if (!effect.options.queue.limit || (this.effects.length < effect.options.queue.limit))

      this.effects.push(effect);

    if (!this.interval)

      this.interval = setInterval(this.loop.bind(this), 15);

  },

  remove: function(effect) {

    this.effects = this.effects.reject(function(e) { return e==effect });

    if (this.effects.length == 0) {

      clearInterval(this.interval);

      this.interval = null;

    }

  },

  loop: function() {

    var timePos = new Date().getTime();

      this.effects[i] && this.effects[i].loop(timePos);

  }

});

Effect.Queues = {

  instances: $H(),

  get: function(queueName) {

    if (!Object.isString(queueName)) return queueName;

    return this.instances.get(queueName) ||

      this.instances.set(queueName, new Effect.ScopedQueue());

  }

};

Effect.Queue = Effect.Queues.get('global');

Effect.Base = Class.create({

  position: null,

  start: function(options) {

    if (options && options.transition === false) options.transition = Effect.Transitions.linear;

    this.options      = Object.extend(Object.extend({ },Effect.DefaultOptions), options || { });

    this.currentFrame = 0;

    this.state        = 'idle';

    this.startOn      = this.options.delay*1000;

    this.finishOn     = this.startOn+(this.options.duration*1000);

    this.fromToDelta  = this.options.to-this.options.from;

    this.totalTime    = this.finishOn-this.startOn;

    this.totalFrames  = this.options.fps*this.options.duration;

    this.event('beforeStart');

    if (!this.options.sync)

        'global' : this.options.queue.scope).add(this);

  },

  loop: function(timePos) {

    if (timePos >= this.startOn) {

      if (timePos >= this.finishOn) {

        this.render(1.0);

        this.cancel();

        this.event('beforeFinish');

        this.event('afterFinish');

      }

      var pos   = (timePos - this.startOn) / this.totalTime,

          frame = (pos * this.totalFrames).round();

      if (frame > this.currentFrame) {

        this.render(pos);

        this.currentFrame = frame;

      }

    }

  },

  cancel: function() {

    if (!this.options.sync)

        'global' : this.options.queue.scope).remove(this);

    this.state = 'finished';

  },

  event: function(eventName) {

    if (this.options[eventName + 'Internal']) this.options[eventName + 'Internal'](this);

    if (this.options[eventName]) this.options[eventName](this);

  },

  inspect: function() {

    var data = $H();

    for(property in this)

      if (!Object.isFunction(this[property])) data.set(property, this[property]);

    return '#<Effect:' + data.inspect() + ',options:' + $H(this.options).inspect() + '>';

  }

});

Effect.Parallel = Class.create(Effect.Base, {

  initialize: function(effects) {

    this.effects = effects || [];

    this.start(arguments[1]);

  },

  update: function(position) {

    this.effects.invoke('render', position);

  },

  finish: function(position) {

    this.effects.each( function(effect) {

      effect.render(1.0);

      effect.cancel();

      effect.event('beforeFinish');

      if (effect.finish) effect.finish(position);